generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

examples: apply clang-format

Browse Source 
Change-Id: Icc3bbb07c99a31a70030baec7e51b881902a7b5e
This commit is contained in:
clang-format 2016-07-18 19:04:56 -07:00 committed by James Zern
parent c69cc4ce1f
commit ef45540927
14 changed files with 1038 additions and 1238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
examples/decode_to_md5.c
View File

@ -65,8 +65,7 @@ static void get_image_md5(const vpx_image_t *img, unsigned char digest[16]) {
static void print_md5(FILE *stream, unsigned char digest[16]) { static void print_md5(FILE *stream, unsigned char digest[16]) {
int i; int i;
for (i = 0; i < 16; ++i) for (i = 0; i < 16; ++i) fprintf(stream, "%02x", digest[i]);
fprintf(stream, "%02x", digest[i]);
} }
static const char *exec_name; static const char *exec_name;
@ -86,12 +85,10 @@ int main(int argc, char **argv) {
exec_name = argv[0]; exec_name = argv[0];
if (argc != 3) if (argc != 3) die("Invalid number of arguments.");
die("Invalid number of arguments.");
reader = vpx_video_reader_open(argv[1]); reader = vpx_video_reader_open(argv[1]);
if (!reader) if (!reader) die("Failed to open %s for reading.", argv[1]);
die("Failed to open %s for reading.", argv[1]);
if (!(outfile = fopen(argv[2], "wb"))) if (!(outfile = fopen(argv[2], "wb")))
die("Failed to open %s for writing.", argv[2]); die("Failed to open %s for writing.", argv[2]);
@ -99,8 +96,7 @@ int main(int argc, char **argv) {
info = vpx_video_reader_get_info(reader); info = vpx_video_reader_get_info(reader);
decoder = get_vpx_decoder_by_fourcc(info->codec_fourcc); decoder = get_vpx_decoder_by_fourcc(info->codec_fourcc);
if (!decoder) if (!decoder) die("Unknown input codec.");
die("Unknown input codec.");
printf("Using %s\n", vpx_codec_iface_name(decoder->codec_interface())); printf("Using %s\n", vpx_codec_iface_name(decoder->codec_interface()));
@ -111,8 +107,8 @@ int main(int argc, char **argv) {
vpx_codec_iter_t iter = NULL; vpx_codec_iter_t iter = NULL;
vpx_image_t *img = NULL; vpx_image_t *img = NULL;
size_t frame_size = 0; size_t frame_size = 0;
const unsigned char *frame = vpx_video_reader_get_frame(reader, const unsigned char *frame =
&frame_size); vpx_video_reader_get_frame(reader, &frame_size);
if (vpx_codec_decode(&codec, frame, (unsigned int)frame_size, NULL, 0)) if (vpx_codec_decode(&codec, frame, (unsigned int)frame_size, NULL, 0))
die_codec(&codec, "Failed to decode frame"); die_codec(&codec, "Failed to decode frame");
@ -121,14 +117,13 @@ int main(int argc, char **argv) {
get_image_md5(img, digest); get_image_md5(img, digest);
print_md5(outfile, digest); print_md5(outfile, digest);
fprintf(outfile, " img-%dx%d-%04d.i420\n", fprintf(outfile, " img-%dx%d-%04d.i420\n", img->d_w, img->d_h,
img->d_w, img->d_h, ++frame_cnt); ++frame_cnt);
} }
} }
printf("Processed %d frames.\n", frame_cnt); printf("Processed %d frames.\n", frame_cnt);
if (vpx_codec_destroy(&codec)) if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec.");
die_codec(&codec, "Failed to destroy codec.");
vpx_video_reader_close(reader); vpx_video_reader_close(reader);

16
examples/decode_with_drops.c
View File

@ -84,12 +84,10 @@ int main(int argc, char **argv) {
exec_name = argv[0]; exec_name = argv[0];
if (argc != 4) if (argc != 4) die("Invalid number of arguments.");
die("Invalid number of arguments.");
reader = vpx_video_reader_open(argv[1]); reader = vpx_video_reader_open(argv[1]);
if (!reader) if (!reader) die("Failed to open %s for reading.", argv[1]);
die("Failed to open %s for reading.", argv[1]);
if (!(outfile = fopen(argv[2], "wb"))) if (!(outfile = fopen(argv[2], "wb")))
die("Failed to open %s for writing.", argv[2]); die("Failed to open %s for writing.", argv[2]);
@ -103,8 +101,7 @@ int main(int argc, char **argv) {
info = vpx_video_reader_get_info(reader); info = vpx_video_reader_get_info(reader);
decoder = get_vpx_decoder_by_fourcc(info->codec_fourcc); decoder = get_vpx_decoder_by_fourcc(info->codec_fourcc);
if (!decoder) if (!decoder) die("Unknown input codec.");
die("Unknown input codec.");
printf("Using %s\n", vpx_codec_iface_name(decoder->codec_interface())); printf("Using %s\n", vpx_codec_iface_name(decoder->codec_interface()));
@ -116,8 +113,8 @@ int main(int argc, char **argv) {
vpx_image_t *img = NULL; vpx_image_t *img = NULL;
size_t frame_size = 0; size_t frame_size = 0;
int skip; int skip;
const unsigned char *frame = vpx_video_reader_get_frame(reader, const unsigned char *frame =
&frame_size); vpx_video_reader_get_frame(reader, &frame_size);
if (vpx_codec_decode(&codec, frame, (unsigned int)frame_size, NULL, 0)) if (vpx_codec_decode(&codec, frame, (unsigned int)frame_size, NULL, 0))
die_codec(&codec, "Failed to decode frame."); die_codec(&codec, "Failed to decode frame.");
@ -139,8 +136,7 @@ int main(int argc, char **argv) {
} }
printf("Processed %d frames.\n", frame_cnt); printf("Processed %d frames.\n", frame_cnt);
if (vpx_codec_destroy(&codec)) if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec.");
die_codec(&codec, "Failed to destroy codec.");
printf("Play: ffplay -f rawvideo -pix_fmt yuv420p -s %dx%d %s\n", printf("Play: ffplay -f rawvideo -pix_fmt yuv420p -s %dx%d %s\n",
info->frame_width, info->frame_height, argv[2]); info->frame_width, info->frame_height, argv[2]);

29
examples/postproc.c
View File

@ -68,12 +68,10 @@ int main(int argc, char **argv) {
exec_name = argv[0]; exec_name = argv[0];
if (argc != 3) if (argc != 3) die("Invalid number of arguments.");
die("Invalid number of arguments.");
reader = vpx_video_reader_open(argv[1]); reader = vpx_video_reader_open(argv[1]);
if (!reader) if (!reader) die("Failed to open %s for reading.", argv[1]);
die("Failed to open %s for reading.", argv[1]);
if (!(outfile = fopen(argv[2], "wb"))) if (!(outfile = fopen(argv[2], "wb")))
die("Failed to open %s for writing", argv[2]); die("Failed to open %s for writing", argv[2]);
@ -81,8 +79,7 @@ int main(int argc, char **argv) {
info = vpx_video_reader_get_info(reader); info = vpx_video_reader_get_info(reader);
decoder = get_vpx_decoder_by_fourcc(info->codec_fourcc); decoder = get_vpx_decoder_by_fourcc(info->codec_fourcc);
if (!decoder) if (!decoder) die("Unknown input codec.");
die("Unknown input codec.");
printf("Using %s\n", vpx_codec_iface_name(decoder->codec_interface())); printf("Using %s\n", vpx_codec_iface_name(decoder->codec_interface()));
@ -91,26 +88,25 @@ int main(int argc, char **argv) {
if (res == VPX_CODEC_INCAPABLE) if (res == VPX_CODEC_INCAPABLE)
die_codec(&codec, "Postproc not supported by this decoder."); die_codec(&codec, "Postproc not supported by this decoder.");
if (res) if (res) die_codec(&codec, "Failed to initialize decoder.");
die_codec(&codec, "Failed to initialize decoder.");
while (vpx_video_reader_read_frame(reader)) { while (vpx_video_reader_read_frame(reader)) {
vpx_codec_iter_t iter = NULL; vpx_codec_iter_t iter = NULL;
vpx_image_t *img = NULL; vpx_image_t *img = NULL;
size_t frame_size = 0; size_t frame_size = 0;
const unsigned char *frame = vpx_video_reader_get_frame(reader, const unsigned char *frame =
&frame_size); vpx_video_reader_get_frame(reader, &frame_size);
++frame_cnt; ++frame_cnt;
if (frame_cnt % 30 == 1) { if (frame_cnt % 30 == 1) {
vp8_postproc_cfg_t pp = {0, 0, 0}; vp8_postproc_cfg_t pp = { 0, 0, 0 };
if (vpx_codec_control(&codec, VP8_SET_POSTPROC, &pp)) if (vpx_codec_control(&codec, VP8_SET_POSTPROC, &pp))
die_codec(&codec, "Failed to turn off postproc."); die_codec(&codec, "Failed to turn off postproc.");
} else if (frame_cnt % 30 == 16) { } else if (frame_cnt % 30 == 16) {
vp8_postproc_cfg_t pp = {VP8_DEBLOCK | VP8_DEMACROBLOCK | VP8_MFQE, vp8_postproc_cfg_t pp = { VP8_DEBLOCK | VP8_DEMACROBLOCK | VP8_MFQE, 4,
4, 0}; 0 };
if (vpx_codec_control(&codec, VP8_SET_POSTPROC, &pp)) if (vpx_codec_control(&codec, VP8_SET_POSTPROC, &pp))
die_codec(&codec, "Failed to turn on postproc."); die_codec(&codec, "Failed to turn on postproc.");
}; };
@ -125,8 +121,7 @@ int main(int argc, char **argv) {
} }
printf("Processed %d frames.\n", frame_cnt); printf("Processed %d frames.\n", frame_cnt);
if (vpx_codec_destroy(&codec)) if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec");
die_codec(&codec, "Failed to destroy codec");
printf("Play: ffplay -f rawvideo -pix_fmt yuv420p -s %dx%d %s\n", printf("Play: ffplay -f rawvideo -pix_fmt yuv420p -s %dx%d %s\n",
info->frame_width, info->frame_height, argv[2]); info->frame_width, info->frame_height, argv[2]);

27
examples/resize_util.c
View File

@ -34,10 +34,8 @@ void usage_exit(void) {
static int parse_dim(char *v, int *width, int *height) { static int parse_dim(char *v, int *width, int *height) {
char *x = strchr(v, 'x'); char *x = strchr(v, 'x');
if (x == NULL) if (x == NULL) x = strchr(v, 'X');
x = strchr(v, 'X'); if (x == NULL) return 0;
if (x == NULL)
return 0;
*width = atoi(v); *width = atoi(v);
*height = atoi(&x[1]); *height = atoi(&x[1]);
if (*width <= 0 || *height <= 0) if (*width <= 0 || *height <= 0)
@ -93,30 +91,25 @@ int main(int argc, char *argv[]) {
else else
frames = INT_MAX; frames = INT_MAX;
printf("Input size: %dx%d\n", printf("Input size: %dx%d\n", width, height);
width, height); printf("Target size: %dx%d, Frames: ", target_width, target_height);
printf("Target size: %dx%d, Frames: ",
target_width, target_height);
if (frames == INT_MAX) if (frames == INT_MAX)
printf("All\n"); printf("All\n");
else else
printf("%d\n", frames); printf("%d\n", frames);
inbuf = (uint8_t*)malloc(width * height * 3 / 2); inbuf = (uint8_t *)malloc(width * height * 3 / 2);
outbuf = (uint8_t*)malloc(target_width * target_height * 3 / 2); outbuf = (uint8_t *)malloc(target_width * target_height * 3 / 2);
inbuf_u = inbuf + width * height; inbuf_u = inbuf + width * height;
inbuf_v = inbuf_u + width * height / 4; inbuf_v = inbuf_u + width * height / 4;
outbuf_u = outbuf + target_width * target_height; outbuf_u = outbuf + target_width * target_height;
outbuf_v = outbuf_u + target_width * target_height / 4; outbuf_v = outbuf_u + target_width * target_height / 4;
f = 0; f = 0;
while (f < frames) { while (f < frames) {
if (fread(inbuf, width * height * 3 / 2, 1, fpin) != 1) if (fread(inbuf, width * height * 3 / 2, 1, fpin) != 1) break;
break; vp9_resize_frame420(inbuf, width, inbuf_u, inbuf_v, width / 2, height,
vp9_resize_frame420(inbuf, width, inbuf_u, inbuf_v, width / 2, width, outbuf, target_width, outbuf_u, outbuf_v,
height, width, target_width / 2, target_height, target_width);
outbuf, target_width, outbuf_u, outbuf_v,
target_width / 2,
target_height, target_width);
fwrite(outbuf, target_width * target_height * 3 / 2, 1, fpout); fwrite(outbuf, target_width * target_height * 3 / 2, 1, fpout);
f++; f++;
} }

56
examples/set_maps.c
View File

@ -8,7 +8,6 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
// VP8 Set Active and ROI Maps // VP8 Set Active and ROI Maps
// =========================== // ===========================
// //
@ -86,8 +85,7 @@ static void set_roi_map(const vpx_codec_enc_cfg_t *cfg,
roi.static_threshold[3] = 0; roi.static_threshold[3] = 0;
roi.roi_map = (uint8_t *)malloc(roi.rows * roi.cols); roi.roi_map = (uint8_t *)malloc(roi.rows * roi.cols);
for (i = 0; i < roi.rows * roi.cols; ++i) for (i = 0; i < roi.rows * roi.cols; ++i) roi.roi_map[i] = i % 4;
roi.roi_map[i] = i % 4;
if (vpx_codec_control(codec, VP8E_SET_ROI_MAP, &roi)) if (vpx_codec_control(codec, VP8E_SET_ROI_MAP, &roi))
die_codec(codec, "Failed to set ROI map"); die_codec(codec, "Failed to set ROI map");
@ -98,14 +96,13 @@ static void set_roi_map(const vpx_codec_enc_cfg_t *cfg,
static void set_active_map(const vpx_codec_enc_cfg_t *cfg, static void set_active_map(const vpx_codec_enc_cfg_t *cfg,
vpx_codec_ctx_t *codec) { vpx_codec_ctx_t *codec) {
unsigned int i; unsigned int i;
vpx_active_map_t map = {0, 0, 0}; vpx_active_map_t map = { 0, 0, 0 };
map.rows = (cfg->g_h + 15) / 16; map.rows = (cfg->g_h + 15) / 16;
map.cols = (cfg->g_w + 15) / 16; map.cols = (cfg->g_w + 15) / 16;
map.active_map = (uint8_t *)malloc(map.rows * map.cols); map.active_map = (uint8_t *)malloc(map.rows * map.cols);
for (i = 0; i < map.rows * map.cols; ++i) for (i = 0; i < map.rows * map.cols; ++i) map.active_map[i] = i % 2;
map.active_map[i] = i % 2;
if (vpx_codec_control(codec, VP8E_SET_ACTIVEMAP, &map)) if (vpx_codec_control(codec, VP8E_SET_ACTIVEMAP, &map))
die_codec(codec, "Failed to set active map"); die_codec(codec, "Failed to set active map");
@ -115,7 +112,7 @@ static void set_active_map(const vpx_codec_enc_cfg_t *cfg,
static void unset_active_map(const vpx_codec_enc_cfg_t *cfg, static void unset_active_map(const vpx_codec_enc_cfg_t *cfg,
vpx_codec_ctx_t *codec) { vpx_codec_ctx_t *codec) {
vpx_active_map_t map = {0, 0, 0}; vpx_active_map_t map = { 0, 0, 0 };
map.rows = (cfg->g_h + 15) / 16; map.rows = (cfg->g_h + 15) / 16;
map.cols = (cfg->g_w + 15) / 16; map.cols = (cfg->g_w + 15) / 16;
@ -125,25 +122,21 @@ static void unset_active_map(const vpx_codec_enc_cfg_t *cfg,
die_codec(codec, "Failed to set active map"); die_codec(codec, "Failed to set active map");
} }
static int encode_frame(vpx_codec_ctx_t *codec, static int encode_frame(vpx_codec_ctx_t *codec, vpx_image_t *img,
vpx_image_t *img, int frame_index, VpxVideoWriter *writer) {
int frame_index,
VpxVideoWriter *writer) {
int got_pkts = 0; int got_pkts = 0;
vpx_codec_iter_t iter = NULL; vpx_codec_iter_t iter = NULL;
const vpx_codec_cx_pkt_t *pkt = NULL; const vpx_codec_cx_pkt_t *pkt = NULL;
const vpx_codec_err_t res = vpx_codec_encode(codec, img, frame_index, 1, 0, const vpx_codec_err_t res =
VPX_DL_GOOD_QUALITY); vpx_codec_encode(codec, img, frame_index, 1, 0, VPX_DL_GOOD_QUALITY);
if (res != VPX_CODEC_OK) if (res != VPX_CODEC_OK) die_codec(codec, "Failed to encode frame");
die_codec(codec, "Failed to encode frame");
while ((pkt = vpx_codec_get_cx_data(codec, &iter)) != NULL) { while ((pkt = vpx_codec_get_cx_data(codec, &iter)) != NULL) {
got_pkts = 1; got_pkts = 1;
if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) { if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) {
const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0; const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0;
if (!vpx_video_writer_write_frame(writer, if (!vpx_video_writer_write_frame(writer, pkt->data.frame.buf,
pkt->data.frame.buf,
pkt->data.frame.sz, pkt->data.frame.sz,
pkt->data.frame.pts)) { pkt->data.frame.pts)) {
die_codec(codec, "Failed to write compressed frame"); die_codec(codec, "Failed to write compressed frame");
@ -167,12 +160,11 @@ int main(int argc, char **argv) {
VpxVideoInfo info; VpxVideoInfo info;
VpxVideoWriter *writer = NULL; VpxVideoWriter *writer = NULL;
const VpxInterface *encoder = NULL; const VpxInterface *encoder = NULL;
const int fps = 2; // TODO(dkovalev) add command line argument const int fps = 2; // TODO(dkovalev) add command line argument
const double bits_per_pixel_per_frame = 0.067; const double bits_per_pixel_per_frame = 0.067;
exec_name = argv[0]; exec_name = argv[0];
if (argc != 6) if (argc != 6) die("Invalid number of arguments");
die("Invalid number of arguments");
memset(&info, 0, sizeof(info)); memset(&info, 0, sizeof(info));
@ -187,35 +179,31 @@ int main(int argc, char **argv) {
info.time_base.numerator = 1; info.time_base.numerator = 1;
info.time_base.denominator = fps; info.time_base.denominator = fps;
if (info.frame_width <= 0 || if (info.frame_width <= 0 || info.frame_height <= 0 ||
info.frame_height <= 0 || (info.frame_width % 2) != 0 || (info.frame_height % 2) != 0) {
(info.frame_width % 2) != 0 ||
(info.frame_height % 2) != 0) {
die("Invalid frame size: %dx%d", info.frame_width, info.frame_height); die("Invalid frame size: %dx%d", info.frame_width, info.frame_height);
} }
if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, info.frame_width, if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, info.frame_width,
info.frame_height, 1)) { info.frame_height, 1)) {
die("Failed to allocate image."); die("Failed to allocate image.");
} }
printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface())); printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface()));
res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0); res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0);
if (res) if (res) die_codec(&codec, "Failed to get default codec config.");
die_codec(&codec, "Failed to get default codec config.");
cfg.g_w = info.frame_width; cfg.g_w = info.frame_width;
cfg.g_h = info.frame_height; cfg.g_h = info.frame_height;
cfg.g_timebase.num = info.time_base.numerator; cfg.g_timebase.num = info.time_base.numerator;
cfg.g_timebase.den = info.time_base.denominator; cfg.g_timebase.den = info.time_base.denominator;
cfg.rc_target_bitrate = (unsigned int)(bits_per_pixel_per_frame * cfg.g_w * cfg.rc_target_bitrate =
cfg.g_h * fps / 1000); (unsigned int)(bits_per_pixel_per_frame * cfg.g_w * cfg.g_h * fps / 1000);
cfg.g_lag_in_frames = 0; cfg.g_lag_in_frames = 0;
writer = vpx_video_writer_open(argv[5], kContainerIVF, &info); writer = vpx_video_writer_open(argv[5], kContainerIVF, &info);
if (!writer) if (!writer) die("Failed to open %s for writing.", argv[5]);
die("Failed to open %s for writing.", argv[5]);
if (!(infile = fopen(argv[4], "rb"))) if (!(infile = fopen(argv[4], "rb")))
die("Failed to open %s for reading.", argv[4]); die("Failed to open %s for reading.", argv[4]);
@ -239,15 +227,15 @@ int main(int argc, char **argv) {
} }
// Flush encoder. // Flush encoder.
while (encode_frame(&codec, NULL, -1, writer)) {} while (encode_frame(&codec, NULL, -1, writer)) {
}
printf("\n"); printf("\n");
fclose(infile); fclose(infile);
printf("Processed %d frames.\n", frame_count); printf("Processed %d frames.\n", frame_count);
vpx_img_free(&raw); vpx_img_free(&raw);
if (vpx_codec_destroy(&codec)) if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec.");
die_codec(&codec, "Failed to destroy codec.");
vpx_video_writer_close(writer); vpx_video_writer_close(writer);

17
examples/simple_decoder.c
View File

@ -8,7 +8,6 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
// Simple Decoder // Simple Decoder
// ============== // ==============
// //
@ -103,12 +102,10 @@ int main(int argc, char **argv) {
exec_name = argv[0]; exec_name = argv[0];
if (argc != 3) if (argc != 3) die("Invalid number of arguments.");
die("Invalid number of arguments.");
reader = vpx_video_reader_open(argv[1]); reader = vpx_video_reader_open(argv[1]);
if (!reader) if (!reader) die("Failed to open %s for reading.", argv[1]);
die("Failed to open %s for reading.", argv[1]);
if (!(outfile = fopen(argv[2], "wb"))) if (!(outfile = fopen(argv[2], "wb")))
die("Failed to open %s for writing.", argv[2]); die("Failed to open %s for writing.", argv[2]);
@ -116,8 +113,7 @@ int main(int argc, char **argv) {
info = vpx_video_reader_get_info(reader); info = vpx_video_reader_get_info(reader);
decoder = get_vpx_decoder_by_fourcc(info->codec_fourcc); decoder = get_vpx_decoder_by_fourcc(info->codec_fourcc);
if (!decoder) if (!decoder) die("Unknown input codec.");
die("Unknown input codec.");
printf("Using %s\n", vpx_codec_iface_name(decoder->codec_interface())); printf("Using %s\n", vpx_codec_iface_name(decoder->codec_interface()));
@ -128,8 +124,8 @@ int main(int argc, char **argv) {
vpx_codec_iter_t iter = NULL; vpx_codec_iter_t iter = NULL;
vpx_image_t *img = NULL; vpx_image_t *img = NULL;
size_t frame_size = 0; size_t frame_size = 0;
const unsigned char *frame = vpx_video_reader_get_frame(reader, const unsigned char *frame =
&frame_size); vpx_video_reader_get_frame(reader, &frame_size);
if (vpx_codec_decode(&codec, frame, (unsigned int)frame_size, NULL, 0)) if (vpx_codec_decode(&codec, frame, (unsigned int)frame_size, NULL, 0))
die_codec(&codec, "Failed to decode frame."); die_codec(&codec, "Failed to decode frame.");
@ -140,8 +136,7 @@ int main(int argc, char **argv) {
} }
printf("Processed %d frames.\n", frame_cnt); printf("Processed %d frames.\n", frame_cnt);
if (vpx_codec_destroy(&codec)) if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec");
die_codec(&codec, "Failed to destroy codec");
printf("Play: ffplay -f rawvideo -pix_fmt yuv420p -s %dx%d %s\n", printf("Play: ffplay -f rawvideo -pix_fmt yuv420p -s %dx%d %s\n",
info->frame_width, info->frame_height, argv[2]); info->frame_width, info->frame_height, argv[2]);

55
examples/simple_encoder.c
View File

@ -109,32 +109,27 @@ static const char *exec_name;
void usage_exit(void) { void usage_exit(void) {
fprintf(stderr, fprintf(stderr,
"Usage: %s <codec> <width> <height> <infile> <outfile> " "Usage: %s <codec> <width> <height> <infile> <outfile> "
"<keyframe-interval> <error-resilient> <frames to encode>\n" "<keyframe-interval> <error-resilient> <frames to encode>\n"
"See comments in simple_encoder.c for more information.\n", "See comments in simple_encoder.c for more information.\n",
exec_name); exec_name);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
static int encode_frame(vpx_codec_ctx_t *codec, static int encode_frame(vpx_codec_ctx_t *codec, vpx_image_t *img,
vpx_image_t *img, int frame_index, int flags, VpxVideoWriter *writer) {
int frame_index,
int flags,
VpxVideoWriter *writer) {
int got_pkts = 0; int got_pkts = 0;
vpx_codec_iter_t iter = NULL; vpx_codec_iter_t iter = NULL;
const vpx_codec_cx_pkt_t *pkt = NULL; const vpx_codec_cx_pkt_t *pkt = NULL;
const vpx_codec_err_t res = vpx_codec_encode(codec, img, frame_index, 1, const vpx_codec_err_t res =
flags, VPX_DL_GOOD_QUALITY); vpx_codec_encode(codec, img, frame_index, 1, flags, VPX_DL_GOOD_QUALITY);
if (res != VPX_CODEC_OK) if (res != VPX_CODEC_OK) die_codec(codec, "Failed to encode frame");
die_codec(codec, "Failed to encode frame");
while ((pkt = vpx_codec_get_cx_data(codec, &iter)) != NULL) { while ((pkt = vpx_codec_get_cx_data(codec, &iter)) != NULL) {
got_pkts = 1; got_pkts = 1;
if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) { if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) {
const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0; const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0;
if (!vpx_video_writer_write_frame(writer, if (!vpx_video_writer_write_frame(writer, pkt->data.frame.buf,
pkt->data.frame.buf,
pkt->data.frame.sz, pkt->data.frame.sz,
pkt->data.frame.pts)) { pkt->data.frame.pts)) {
die_codec(codec, "Failed to write compressed frame"); die_codec(codec, "Failed to write compressed frame");
@ -155,7 +150,7 @@ int main(int argc, char **argv) {
int frame_count = 0; int frame_count = 0;
vpx_image_t raw; vpx_image_t raw;
vpx_codec_err_t res; vpx_codec_err_t res;
VpxVideoInfo info = {0}; VpxVideoInfo info = { 0 };
VpxVideoWriter *writer = NULL; VpxVideoWriter *writer = NULL;
const VpxInterface *encoder = NULL; const VpxInterface *encoder = NULL;
const int fps = 30; const int fps = 30;
@ -172,8 +167,7 @@ int main(int argc, char **argv) {
exec_name = argv[0]; exec_name = argv[0];
if (argc != 9) if (argc != 9) die("Invalid number of arguments");
die("Invalid number of arguments");
codec_arg = argv[1]; codec_arg = argv[1];
width_arg = argv[2]; width_arg = argv[2];
@ -184,8 +178,7 @@ int main(int argc, char **argv) {
max_frames = strtol(argv[8], NULL, 0); max_frames = strtol(argv[8], NULL, 0);
encoder = get_vpx_encoder_by_name(codec_arg); encoder = get_vpx_encoder_by_name(codec_arg);
if (!encoder) if (!encoder) die("Unsupported codec.");
die("Unsupported codec.");
info.codec_fourcc = encoder->fourcc; info.codec_fourcc = encoder->fourcc;
info.frame_width = strtol(width_arg, NULL, 0); info.frame_width = strtol(width_arg, NULL, 0);
@ -193,27 +186,23 @@ int main(int argc, char **argv) {
info.time_base.numerator = 1; info.time_base.numerator = 1;
info.time_base.denominator = fps; info.time_base.denominator = fps;
if (info.frame_width <= 0 || if (info.frame_width <= 0 || info.frame_height <= 0 ||
info.frame_height <= 0 || (info.frame_width % 2) != 0 || (info.frame_height % 2) != 0) {
(info.frame_width % 2) != 0 ||
(info.frame_height % 2) != 0) {
die("Invalid frame size: %dx%d", info.frame_width, info.frame_height); die("Invalid frame size: %dx%d", info.frame_width, info.frame_height);
} }
if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, info.frame_width, if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, info.frame_width,
info.frame_height, 1)) { info.frame_height, 1)) {
die("Failed to allocate image."); die("Failed to allocate image.");
} }
keyframe_interval = strtol(keyframe_interval_arg, NULL, 0); keyframe_interval = strtol(keyframe_interval_arg, NULL, 0);
if (keyframe_interval < 0) if (keyframe_interval < 0) die("Invalid keyframe interval value.");
die("Invalid keyframe interval value.");
printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface())); printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface()));
res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0); res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0);
if (res) if (res) die_codec(&codec, "Failed to get default codec config.");
die_codec(&codec, "Failed to get default codec config.");
cfg.g_w = info.frame_width; cfg.g_w = info.frame_width;
cfg.g_h = info.frame_height; cfg.g_h = info.frame_height;
@ -223,8 +212,7 @@ int main(int argc, char **argv) {
cfg.g_error_resilient = strtol(argv[7], NULL, 0); cfg.g_error_resilient = strtol(argv[7], NULL, 0);
writer = vpx_video_writer_open(outfile_arg, kContainerIVF, &info); writer = vpx_video_writer_open(outfile_arg, kContainerIVF, &info);
if (!writer) if (!writer) die("Failed to open %s for writing.", outfile_arg);
die("Failed to open %s for writing.", outfile_arg);
if (!(infile = fopen(infile_arg, "rb"))) if (!(infile = fopen(infile_arg, "rb")))
die("Failed to open %s for reading.", infile_arg); die("Failed to open %s for reading.", infile_arg);
@ -239,20 +227,19 @@ int main(int argc, char **argv) {
flags |= VPX_EFLAG_FORCE_KF; flags |= VPX_EFLAG_FORCE_KF;
encode_frame(&codec, &raw, frame_count++, flags, writer); encode_frame(&codec, &raw, frame_count++, flags, writer);
frames_encoded++; frames_encoded++;
if (max_frames > 0 && frames_encoded >= max_frames) if (max_frames > 0 && frames_encoded >= max_frames) break;
break;
} }
// Flush encoder. // Flush encoder.
while (encode_frame(&codec, NULL, -1, 0, writer)) {}; while (encode_frame(&codec, NULL, -1, 0, writer)) {
}
printf("\n"); printf("\n");
fclose(infile); fclose(infile);
printf("Processed %d frames.\n", frame_count); printf("Processed %d frames.\n", frame_count);
vpx_img_free(&raw); vpx_img_free(&raw);
if (vpx_codec_destroy(&codec)) if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec.");
die_codec(&codec, "Failed to destroy codec.");
vpx_video_writer_close(writer); vpx_video_writer_close(writer);

101
examples/twopass_encoder.c
View File

@ -61,25 +61,21 @@ static const char *exec_name;
void usage_exit(void) { void usage_exit(void) {
fprintf(stderr, fprintf(stderr,
"Usage: %s <codec> <width> <height> <infile> <outfile> " "Usage: %s <codec> <width> <height> <infile> <outfile> "
"<frame limit>\n", "<frame limit>\n",
exec_name); exec_name);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
static int get_frame_stats(vpx_codec_ctx_t *ctx, static int get_frame_stats(vpx_codec_ctx_t *ctx, const vpx_image_t *img,
const vpx_image_t *img, vpx_codec_pts_t pts, unsigned int duration,
vpx_codec_pts_t pts, vpx_enc_frame_flags_t flags, unsigned int deadline,
unsigned int duration,
vpx_enc_frame_flags_t flags,
unsigned int deadline,
vpx_fixed_buf_t *stats) { vpx_fixed_buf_t *stats) {
int got_pkts = 0; int got_pkts = 0;
vpx_codec_iter_t iter = NULL; vpx_codec_iter_t iter = NULL;
const vpx_codec_cx_pkt_t *pkt = NULL; const vpx_codec_cx_pkt_t *pkt = NULL;
const vpx_codec_err_t res = vpx_codec_encode(ctx, img, pts, duration, flags, const vpx_codec_err_t res =
deadline); vpx_codec_encode(ctx, img, pts, duration, flags, deadline);
if (res != VPX_CODEC_OK) if (res != VPX_CODEC_OK) die_codec(ctx, "Failed to get frame stats.");
die_codec(ctx, "Failed to get frame stats.");
while ((pkt = vpx_codec_get_cx_data(ctx, &iter)) != NULL) { while ((pkt = vpx_codec_get_cx_data(ctx, &iter)) != NULL) {
got_pkts = 1; got_pkts = 1;
@ -96,20 +92,16 @@ static int get_frame_stats(vpx_codec_ctx_t *ctx,
return got_pkts; return got_pkts;
} }
static int encode_frame(vpx_codec_ctx_t *ctx, static int encode_frame(vpx_codec_ctx_t *ctx, const vpx_image_t *img,
const vpx_image_t *img, vpx_codec_pts_t pts, unsigned int duration,
vpx_codec_pts_t pts, vpx_enc_frame_flags_t flags, unsigned int deadline,
unsigned int duration,
vpx_enc_frame_flags_t flags,
unsigned int deadline,
VpxVideoWriter *writer) { VpxVideoWriter *writer) {
int got_pkts = 0; int got_pkts = 0;
vpx_codec_iter_t iter = NULL; vpx_codec_iter_t iter = NULL;
const vpx_codec_cx_pkt_t *pkt = NULL; const vpx_codec_cx_pkt_t *pkt = NULL;
const vpx_codec_err_t res = vpx_codec_encode(ctx, img, pts, duration, flags, const vpx_codec_err_t res =
deadline); vpx_codec_encode(ctx, img, pts, duration, flags, deadline);
if (res != VPX_CODEC_OK) if (res != VPX_CODEC_OK) die_codec(ctx, "Failed to encode frame.");
die_codec(ctx, "Failed to encode frame.");
while ((pkt = vpx_codec_get_cx_data(ctx, &iter)) != NULL) { while ((pkt = vpx_codec_get_cx_data(ctx, &iter)) != NULL) {
got_pkts = 1; got_pkts = 1;
@ -117,8 +109,8 @@ static int encode_frame(vpx_codec_ctx_t *ctx,
const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0; const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0;
if (!vpx_video_writer_write_frame(writer, pkt->data.frame.buf, if (!vpx_video_writer_write_frame(writer, pkt->data.frame.buf,
pkt->data.frame.sz, pkt->data.frame.sz,
pkt->data.frame.pts)) pkt->data.frame.pts))
die_codec(ctx, "Failed to write compressed frame."); die_codec(ctx, "Failed to write compressed frame.");
printf(keyframe ? "K" : "."); printf(keyframe ? "K" : ".");
fflush(stdout); fflush(stdout);
@ -128,14 +120,12 @@ static int encode_frame(vpx_codec_ctx_t *ctx,
return got_pkts; return got_pkts;
} }
static vpx_fixed_buf_t pass0(vpx_image_t *raw, static vpx_fixed_buf_t pass0(vpx_image_t *raw, FILE *infile,
FILE *infile,
const VpxInterface *encoder, const VpxInterface *encoder,
const vpx_codec_enc_cfg_t *cfg, const vpx_codec_enc_cfg_t *cfg, int max_frames) {
int max_frames) {
vpx_codec_ctx_t codec; vpx_codec_ctx_t codec;
int frame_count = 0; int frame_count = 0;
vpx_fixed_buf_t stats = {NULL, 0}; vpx_fixed_buf_t stats = { NULL, 0 };
if (vpx_codec_enc_init(&codec, encoder->codec_interface(), cfg, 0)) if (vpx_codec_enc_init(&codec, encoder->codec_interface(), cfg, 0))
die_codec(&codec, "Failed to initialize encoder"); die_codec(&codec, "Failed to initialize encoder");
@ -145,40 +135,33 @@ static vpx_fixed_buf_t pass0(vpx_image_t *raw,
++frame_count; ++frame_count;
get_frame_stats(&codec, raw, frame_count, 1, 0, VPX_DL_GOOD_QUALITY, get_frame_stats(&codec, raw, frame_count, 1, 0, VPX_DL_GOOD_QUALITY,
&stats); &stats);
if (max_frames > 0 && frame_count >= max_frames) if (max_frames > 0 && frame_count >= max_frames) break;
break;
} }
// Flush encoder. // Flush encoder.
while (get_frame_stats(&codec, NULL, frame_count, 1, 0, while (get_frame_stats(&codec, NULL, frame_count, 1, 0, VPX_DL_GOOD_QUALITY,
VPX_DL_GOOD_QUALITY, &stats)) {} &stats)) {
}
printf("Pass 0 complete. Processed %d frames.\n", frame_count); printf("Pass 0 complete. Processed %d frames.\n", frame_count);
if (vpx_codec_destroy(&codec)) if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec.");
die_codec(&codec, "Failed to destroy codec.");
return stats; return stats;
} }
static void pass1(vpx_image_t *raw, static void pass1(vpx_image_t *raw, FILE *infile, const char *outfile_name,
FILE *infile, const VpxInterface *encoder, const vpx_codec_enc_cfg_t *cfg,
const char *outfile_name,
const VpxInterface *encoder,
const vpx_codec_enc_cfg_t *cfg,
int max_frames) { int max_frames) {
VpxVideoInfo info = { VpxVideoInfo info = { encoder->fourcc,
encoder->fourcc, cfg->g_w,
cfg->g_w, cfg->g_h,
cfg->g_h, { cfg->g_timebase.num, cfg->g_timebase.den } };
{cfg->g_timebase.num, cfg->g_timebase.den}
};
VpxVideoWriter *writer = NULL; VpxVideoWriter *writer = NULL;
vpx_codec_ctx_t codec; vpx_codec_ctx_t codec;
int frame_count = 0; int frame_count = 0;
writer = vpx_video_writer_open(outfile_name, kContainerIVF, &info); writer = vpx_video_writer_open(outfile_name, kContainerIVF, &info);
if (!writer) if (!writer) die("Failed to open %s for writing", outfile_name);
die("Failed to open %s for writing", outfile_name);
if (vpx_codec_enc_init(&codec, encoder->codec_interface(), cfg, 0)) if (vpx_codec_enc_init(&codec, encoder->codec_interface(), cfg, 0))
die_codec(&codec, "Failed to initialize encoder"); die_codec(&codec, "Failed to initialize encoder");
@ -188,17 +171,16 @@ static void pass1(vpx_image_t *raw,
++frame_count; ++frame_count;
encode_frame(&codec, raw, frame_count, 1, 0, VPX_DL_GOOD_QUALITY, writer); encode_frame(&codec, raw, frame_count, 1, 0, VPX_DL_GOOD_QUALITY, writer);
if (max_frames > 0 && frame_count >= max_frames) if (max_frames > 0 && frame_count >= max_frames) break;
break;
} }
// Flush encoder. // Flush encoder.
while (encode_frame(&codec, NULL, -1, 1, 0, VPX_DL_GOOD_QUALITY, writer)) {} while (encode_frame(&codec, NULL, -1, 1, 0, VPX_DL_GOOD_QUALITY, writer)) {
}
printf("\n"); printf("\n");
if (vpx_codec_destroy(&codec)) if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec.");
die_codec(&codec, "Failed to destroy codec.");
vpx_video_writer_close(writer); vpx_video_writer_close(writer);
@ -215,8 +197,8 @@ int main(int argc, char **argv) {
vpx_fixed_buf_t stats; vpx_fixed_buf_t stats;
const VpxInterface *encoder = NULL; const VpxInterface *encoder = NULL;
const int fps = 30; // TODO(dkovalev) add command line argument const int fps = 30; // TODO(dkovalev) add command line argument
const int bitrate = 200; // kbit/s TODO(dkovalev) add command line argument const int bitrate = 200; // kbit/s TODO(dkovalev) add command line argument
const char *const codec_arg = argv[1]; const char *const codec_arg = argv[1];
const char *const width_arg = argv[2]; const char *const width_arg = argv[2];
const char *const height_arg = argv[3]; const char *const height_arg = argv[3];
@ -225,19 +207,17 @@ int main(int argc, char **argv) {
int max_frames = 0; int max_frames = 0;
exec_name = argv[0]; exec_name = argv[0];
if (argc != 7) if (argc != 7) die("Invalid number of arguments.");
die("Invalid number of arguments.");
max_frames = strtol(argv[6], NULL, 0); max_frames = strtol(argv[6], NULL, 0);
encoder = get_vpx_encoder_by_name(codec_arg); encoder = get_vpx_encoder_by_name(codec_arg);
if (!encoder) if (!encoder) die("Unsupported codec.");
die("Unsupported codec.");
w = strtol(width_arg, NULL, 0); w = strtol(width_arg, NULL, 0);
h = strtol(height_arg, NULL, 0); h = strtol(height_arg, NULL, 0);
if (w <= 0 || h <= 0 || (w % 2) != 0 || (h % 2) != 0) if (w <= 0 || h <= 0 || (w % 2) != 0 || (h % 2) != 0)
die("Invalid frame size: %dx%d", w, h); die("Invalid frame size: %dx%d", w, h);
if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, w, h, 1)) if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, w, h, 1))
@ -247,8 +227,7 @@ int main(int argc, char **argv) {
// Configuration // Configuration
res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0); res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0);
if (res) if (res) die_codec(&codec, "Failed to get default codec config.");
die_codec(&codec, "Failed to get default codec config.");
cfg.g_w = w; cfg.g_w = w;
cfg.g_h = h; cfg.g_h = h;

1109
examples/vp8_multi_resolution_encoder.c
View File

File diff suppressed because it is too large Load Diff

56
examples/vp8cx_set_ref.c
View File

@ -8,7 +8,6 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
// VP8 Set Reference Frame // VP8 Set Reference Frame
// ======================= // =======================
// //
@ -64,25 +63,21 @@ void usage_exit(void) {
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
static int encode_frame(vpx_codec_ctx_t *codec, static int encode_frame(vpx_codec_ctx_t *codec, vpx_image_t *img,
vpx_image_t *img, int frame_index, VpxVideoWriter *writer) {
int frame_index,
VpxVideoWriter *writer) {
int got_pkts = 0; int got_pkts = 0;
vpx_codec_iter_t iter = NULL; vpx_codec_iter_t iter = NULL;
const vpx_codec_cx_pkt_t *pkt = NULL; const vpx_codec_cx_pkt_t *pkt = NULL;
const vpx_codec_err_t res = vpx_codec_encode(codec, img, frame_index, 1, 0, const vpx_codec_err_t res =
VPX_DL_GOOD_QUALITY); vpx_codec_encode(codec, img, frame_index, 1, 0, VPX_DL_GOOD_QUALITY);
if (res != VPX_CODEC_OK) if (res != VPX_CODEC_OK) die_codec(codec, "Failed to encode frame");
die_codec(codec, "Failed to encode frame");
while ((pkt = vpx_codec_get_cx_data(codec, &iter)) != NULL) { while ((pkt = vpx_codec_get_cx_data(codec, &iter)) != NULL) {
got_pkts = 1; got_pkts = 1;
if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) { if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) {
const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0; const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0;
if (!vpx_video_writer_write_frame(writer, if (!vpx_video_writer_write_frame(writer, pkt->data.frame.buf,
pkt->data.frame.buf,
pkt->data.frame.sz, pkt->data.frame.sz,
pkt->data.frame.pts)) { pkt->data.frame.pts)) {
die_codec(codec, "Failed to write compressed frame"); die_codec(codec, "Failed to write compressed frame");
@ -98,31 +93,28 @@ static int encode_frame(vpx_codec_ctx_t *codec,
int main(int argc, char **argv) { int main(int argc, char **argv) {
FILE *infile = NULL; FILE *infile = NULL;
vpx_codec_ctx_t codec = {0}; vpx_codec_ctx_t codec = { 0 };
vpx_codec_enc_cfg_t cfg = {0}; vpx_codec_enc_cfg_t cfg = { 0 };
int frame_count = 0; int frame_count = 0;
vpx_image_t raw; vpx_image_t raw;
vpx_codec_err_t res; vpx_codec_err_t res;
VpxVideoInfo info = {0}; VpxVideoInfo info = { 0 };
VpxVideoWriter *writer = NULL; VpxVideoWriter *writer = NULL;
const VpxInterface *encoder = NULL; const VpxInterface *encoder = NULL;
int update_frame_num = 0; int update_frame_num = 0;
const int fps = 30; // TODO(dkovalev) add command line argument const int fps = 30; // TODO(dkovalev) add command line argument
const int bitrate = 200; // kbit/s TODO(dkovalev) add command line argument const int bitrate = 200; // kbit/s TODO(dkovalev) add command line argument
exec_name = argv[0]; exec_name = argv[0];
if (argc != 6) if (argc != 6) die("Invalid number of arguments");
die("Invalid number of arguments");
// TODO(dkovalev): add vp9 support and rename the file accordingly // TODO(dkovalev): add vp9 support and rename the file accordingly
encoder = get_vpx_encoder_by_name("vp8"); encoder = get_vpx_encoder_by_name("vp8");
if (!encoder) if (!encoder) die("Unsupported codec.");
die("Unsupported codec.");
update_frame_num = atoi(argv[5]); update_frame_num = atoi(argv[5]);
if (!update_frame_num) if (!update_frame_num) die("Couldn't parse frame number '%s'\n", argv[5]);
die("Couldn't parse frame number '%s'\n", argv[5]);
info.codec_fourcc = encoder->fourcc; info.codec_fourcc = encoder->fourcc;
info.frame_width = strtol(argv[1], NULL, 0); info.frame_width = strtol(argv[1], NULL, 0);
@ -130,23 +122,20 @@ int main(int argc, char **argv) {
info.time_base.numerator = 1; info.time_base.numerator = 1;
info.time_base.denominator = fps; info.time_base.denominator = fps;
if (info.frame_width <= 0 || if (info.frame_width <= 0 || info.frame_height <= 0 ||
info.frame_height <= 0 || (info.frame_width % 2) != 0 || (info.frame_height % 2) != 0) {
(info.frame_width % 2) != 0 ||
(info.frame_height % 2) != 0) {
die("Invalid frame size: %dx%d", info.frame_width, info.frame_height); die("Invalid frame size: %dx%d", info.frame_width, info.frame_height);
} }
if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, info.frame_width, if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, info.frame_width,
info.frame_height, 1)) { info.frame_height, 1)) {
die("Failed to allocate image."); die("Failed to allocate image.");
} }
printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface())); printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface()));
res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0); res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0);
if (res) if (res) die_codec(&codec, "Failed to get default codec config.");
die_codec(&codec, "Failed to get default codec config.");
cfg.g_w = info.frame_width; cfg.g_w = info.frame_width;
cfg.g_h = info.frame_height; cfg.g_h = info.frame_height;
@ -155,8 +144,7 @@ int main(int argc, char **argv) {
cfg.rc_target_bitrate = bitrate; cfg.rc_target_bitrate = bitrate;
writer = vpx_video_writer_open(argv[4], kContainerIVF, &info); writer = vpx_video_writer_open(argv[4], kContainerIVF, &info);
if (!writer) if (!writer) die("Failed to open %s for writing.", argv[4]);
die("Failed to open %s for writing.", argv[4]);
if (!(infile = fopen(argv[3], "rb"))) if (!(infile = fopen(argv[3], "rb")))
die("Failed to open %s for reading.", argv[3]); die("Failed to open %s for reading.", argv[3]);
@ -178,15 +166,15 @@ int main(int argc, char **argv) {
} }
// Flush encoder. // Flush encoder.
while (encode_frame(&codec, NULL, -1, writer)) {} while (encode_frame(&codec, NULL, -1, writer)) {
}
printf("\n"); printf("\n");
fclose(infile); fclose(infile);
printf("Processed %d frames.\n", frame_count); printf("Processed %d frames.\n", frame_count);
vpx_img_free(&raw); vpx_img_free(&raw);
if (vpx_codec_destroy(&codec)) if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec.");
die_codec(&codec, "Failed to destroy codec.");
vpx_video_writer_close(writer); vpx_video_writer_close(writer);

50
examples/vp9_lossless_encoder.c
View File

@ -21,32 +21,28 @@
static const char *exec_name; static const char *exec_name;
void usage_exit(void) { void usage_exit(void) {
fprintf(stderr, "vp9_lossless_encoder: Example demonstrating VP9 lossless " fprintf(stderr,
"encoding feature. Supports raw input only.\n"); "vp9_lossless_encoder: Example demonstrating VP9 lossless "
"encoding feature. Supports raw input only.\n");
fprintf(stderr, "Usage: %s <width> <height> <infile> <outfile>\n", exec_name); fprintf(stderr, "Usage: %s <width> <height> <infile> <outfile>\n", exec_name);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
static int encode_frame(vpx_codec_ctx_t *codec, static int encode_frame(vpx_codec_ctx_t *codec, vpx_image_t *img,
vpx_image_t *img, int frame_index, int flags, VpxVideoWriter *writer) {
int frame_index,
int flags,
VpxVideoWriter *writer) {
int got_pkts = 0; int got_pkts = 0;
vpx_codec_iter_t iter = NULL; vpx_codec_iter_t iter = NULL;
const vpx_codec_cx_pkt_t *pkt = NULL; const vpx_codec_cx_pkt_t *pkt = NULL;
const vpx_codec_err_t res = vpx_codec_encode(codec, img, frame_index, 1, const vpx_codec_err_t res =
flags, VPX_DL_GOOD_QUALITY); vpx_codec_encode(codec, img, frame_index, 1, flags, VPX_DL_GOOD_QUALITY);
if (res != VPX_CODEC_OK) if (res != VPX_CODEC_OK) die_codec(codec, "Failed to encode frame");
die_codec(codec, "Failed to encode frame");
while ((pkt = vpx_codec_get_cx_data(codec, &iter)) != NULL) { while ((pkt = vpx_codec_get_cx_data(codec, &iter)) != NULL) {
got_pkts = 1; got_pkts = 1;
if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) { if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) {
const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0; const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0;
if (!vpx_video_writer_write_frame(writer, if (!vpx_video_writer_write_frame(writer, pkt->data.frame.buf,
pkt->data.frame.buf,
pkt->data.frame.sz, pkt->data.frame.sz,
pkt->data.frame.pts)) { pkt->data.frame.pts)) {
die_codec(codec, "Failed to write compressed frame"); die_codec(codec, "Failed to write compressed frame");
@ -66,19 +62,17 @@ int main(int argc, char **argv) {
int frame_count = 0; int frame_count = 0;
vpx_image_t raw; vpx_image_t raw;
vpx_codec_err_t res; vpx_codec_err_t res;
VpxVideoInfo info = {0}; VpxVideoInfo info = { 0 };
VpxVideoWriter *writer = NULL; VpxVideoWriter *writer = NULL;
const VpxInterface *encoder = NULL; const VpxInterface *encoder = NULL;
const int fps = 30; const int fps = 30;
exec_name = argv[0]; exec_name = argv[0];
if (argc < 5) if (argc < 5) die("Invalid number of arguments");
die("Invalid number of arguments");
encoder = get_vpx_encoder_by_name("vp9"); encoder = get_vpx_encoder_by_name("vp9");
if (!encoder) if (!encoder) die("Unsupported codec.");
die("Unsupported codec.");
info.codec_fourcc = encoder->fourcc; info.codec_fourcc = encoder->fourcc;
info.frame_width = strtol(argv[1], NULL, 0); info.frame_width = strtol(argv[1], NULL, 0);
@ -86,23 +80,20 @@ int main(int argc, char **argv) {
info.time_base.numerator = 1; info.time_base.numerator = 1;
info.time_base.denominator = fps; info.time_base.denominator = fps;
if (info.frame_width <= 0 || if (info.frame_width <= 0 || info.frame_height <= 0 ||
info.frame_height <= 0 || (info.frame_width % 2) != 0 || (info.frame_height % 2) != 0) {
(info.frame_width % 2) != 0 ||
(info.frame_height % 2) != 0) {
die("Invalid frame size: %dx%d", info.frame_width, info.frame_height); die("Invalid frame size: %dx%d", info.frame_width, info.frame_height);
} }
if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, info.frame_width, if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, info.frame_width,
info.frame_height, 1)) { info.frame_height, 1)) {
die("Failed to allocate image."); die("Failed to allocate image.");
} }
printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface())); printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface()));
res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0); res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0);
if (res) if (res) die_codec(&codec, "Failed to get default codec config.");
die_codec(&codec, "Failed to get default codec config.");
cfg.g_w = info.frame_width; cfg.g_w = info.frame_width;
cfg.g_h = info.frame_height; cfg.g_h = info.frame_height;
@ -110,8 +101,7 @@ int main(int argc, char **argv) {
cfg.g_timebase.den = info.time_base.denominator; cfg.g_timebase.den = info.time_base.denominator;
writer = vpx_video_writer_open(argv[4], kContainerIVF, &info); writer = vpx_video_writer_open(argv[4], kContainerIVF, &info);
if (!writer) if (!writer) die("Failed to open %s for writing.", argv[4]);
die("Failed to open %s for writing.", argv[4]);
if (!(infile = fopen(argv[3], "rb"))) if (!(infile = fopen(argv[3], "rb")))
die("Failed to open %s for reading.", argv[3]); die("Failed to open %s for reading.", argv[3]);
@ -128,15 +118,15 @@ int main(int argc, char **argv) {
} }
// Flush encoder. // Flush encoder.
while (encode_frame(&codec, NULL, -1, 0, writer)) {} while (encode_frame(&codec, NULL, -1, 0, writer)) {
}
printf("\n"); printf("\n");
fclose(infile); fclose(infile);
printf("Processed %d frames.\n", frame_count); printf("Processed %d frames.\n", frame_count);
vpx_img_free(&raw); vpx_img_free(&raw);
if (vpx_codec_destroy(&codec)) if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec.");
die_codec(&codec, "Failed to destroy codec.");
vpx_video_writer_close(writer); vpx_video_writer_close(writer);

276
examples/vp9_spatial_svc_encoder.c
View File

@ -20,7 +20,6 @@
#include <string.h> #include <string.h>
#include <time.h> #include <time.h>
#include "../args.h" #include "../args.h"
#include "../tools_common.h" #include "../tools_common.h"
#include "../video_writer.h" #include "../video_writer.h"
@ -54,8 +53,9 @@ static const arg_def_t spatial_layers_arg =
static const arg_def_t temporal_layers_arg = static const arg_def_t temporal_layers_arg =
ARG_DEF("tl", "temporal-layers", 1, "number of temporal SVC layers"); ARG_DEF("tl", "temporal-layers", 1, "number of temporal SVC layers");
static const arg_def_t temporal_layering_mode_arg = static const arg_def_t temporal_layering_mode_arg =
ARG_DEF("tlm", "temporal-layering-mode", 1, "temporal layering scheme." ARG_DEF("tlm", "temporal-layering-mode", 1,
"VP9E_TEMPORAL_LAYERING_MODE"); "temporal layering scheme."
"VP9E_TEMPORAL_LAYERING_MODE");
static const arg_def_t kf_dist_arg = static const arg_def_t kf_dist_arg =
ARG_DEF("k", "kf-dist", 1, "number of frames between keyframes"); ARG_DEF("k", "kf-dist", 1, "number of frames between keyframes");
static const arg_def_t scale_factors_arg = static const arg_def_t scale_factors_arg =
@ -75,8 +75,9 @@ static const arg_def_t min_bitrate_arg =
static const arg_def_t max_bitrate_arg = static const arg_def_t max_bitrate_arg =
ARG_DEF(NULL, "max-bitrate", 1, "Maximum bitrate"); ARG_DEF(NULL, "max-bitrate", 1, "Maximum bitrate");
static const arg_def_t lag_in_frame_arg = static const arg_def_t lag_in_frame_arg =
ARG_DEF(NULL, "lag-in-frames", 1, "Number of frame to input before " ARG_DEF(NULL, "lag-in-frames", 1,
"generating any outputs"); "Number of frame to input before "
"generating any outputs");
static const arg_def_t rc_end_usage_arg = static const arg_def_t rc_end_usage_arg =
ARG_DEF(NULL, "rc-end-usage", 1, "0 - 3: VBR, CBR, CQ, Q"); ARG_DEF(NULL, "rc-end-usage", 1, "0 - 3: VBR, CBR, CQ, Q");
static const arg_def_t speed_arg = static const arg_def_t speed_arg =
@ -86,35 +87,44 @@ static const arg_def_t aqmode_arg =
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
static const struct arg_enum_list bitdepth_enum[] = { static const struct arg_enum_list bitdepth_enum[] = {
{"8", VPX_BITS_8}, { "8", VPX_BITS_8 }, { "10", VPX_BITS_10 }, { "12", VPX_BITS_12 }, { NULL, 0 }
{"10", VPX_BITS_10},
{"12", VPX_BITS_12},
{NULL, 0}
}; };
static const arg_def_t bitdepth_arg = static const arg_def_t bitdepth_arg = ARG_DEF_ENUM(
ARG_DEF_ENUM("d", "bit-depth", 1, "Bit depth for codec 8, 10 or 12. ", "d", "bit-depth", 1, "Bit depth for codec 8, 10 or 12. ", bitdepth_enum);
bitdepth_enum);
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
static const arg_def_t *svc_args[] = { &frames_arg,
static const arg_def_t *svc_args[] = { &width_arg,
&frames_arg, &width_arg, &height_arg, &height_arg,
&timebase_arg, &bitrate_arg, &skip_frames_arg, &spatial_layers_arg, &timebase_arg,
&kf_dist_arg, &scale_factors_arg, &passes_arg, &pass_arg, &bitrate_arg,
&fpf_name_arg, &min_q_arg, &max_q_arg, &min_bitrate_arg, &skip_frames_arg,
&max_bitrate_arg, &temporal_layers_arg, &temporal_layering_mode_arg, &spatial_layers_arg,
&lag_in_frame_arg, &threads_arg, &aqmode_arg, &kf_dist_arg,
&scale_factors_arg,
&passes_arg,
&pass_arg,
&fpf_name_arg,
&min_q_arg,
&max_q_arg,
&min_bitrate_arg,
&max_bitrate_arg,
&temporal_layers_arg,
&temporal_layering_mode_arg,
&lag_in_frame_arg,
&threads_arg,
&aqmode_arg,
#if OUTPUT_RC_STATS #if OUTPUT_RC_STATS
&output_rc_stats_arg, &output_rc_stats_arg,
#endif #endif
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
&bitdepth_arg, &bitdepth_arg,
#endif #endif
&speed_arg, &speed_arg,
&rc_end_usage_arg, NULL &rc_end_usage_arg,
}; NULL };
static const uint32_t default_frames_to_skip = 0; static const uint32_t default_frames_to_skip = 0;
static const uint32_t default_frames_to_code = 60 * 60; static const uint32_t default_frames_to_code = 60 * 60;
@ -128,7 +138,7 @@ static const uint32_t default_temporal_layers = 1;
static const uint32_t default_kf_dist = 100; static const uint32_t default_kf_dist = 100;
static const uint32_t default_temporal_layering_mode = 0; static const uint32_t default_temporal_layering_mode = 0;
static const uint32_t default_output_rc_stats = 0; static const uint32_t default_output_rc_stats = 0;
static const int32_t default_speed = -1; // -1 means use library default. static const int32_t default_speed = -1; // -1 means use library default.
static const uint32_t default_threads = 0; // zero means use library default. static const uint32_t default_threads = 0; // zero means use library default.
typedef struct { typedef struct {
@ -155,7 +165,7 @@ void usage_exit(void) {
static void parse_command_line(int argc, const char **argv_, static void parse_command_line(int argc, const char **argv_,
AppInput *app_input, SvcContext *svc_ctx, AppInput *app_input, SvcContext *svc_ctx,
vpx_codec_enc_cfg_t *enc_cfg) { vpx_codec_enc_cfg_t *enc_cfg) {
struct arg arg = {0}; struct arg arg = { 0 };
char **argv = NULL; char **argv = NULL;
char **argi = NULL; char **argi = NULL;
char **argj = NULL; char **argj = NULL;
@ -165,7 +175,7 @@ static void parse_command_line(int argc, const char **argv_,
const char *fpf_file_name = NULL; const char *fpf_file_name = NULL;
unsigned int min_bitrate = 0; unsigned int min_bitrate = 0;
unsigned int max_bitrate = 0; unsigned int max_bitrate = 0;
char string_options[1024] = {0}; char string_options[1024] = { 0 };
// initialize SvcContext with parameters that will be passed to vpx_svc_init // initialize SvcContext with parameters that will be passed to vpx_svc_init
svc_ctx->log_level = SVC_LOG_DEBUG; svc_ctx->log_level = SVC_LOG_DEBUG;
@ -229,8 +239,8 @@ static void parse_command_line(int argc, const char **argv_,
} else if (arg_match(&arg, &threads_arg, argi)) { } else if (arg_match(&arg, &threads_arg, argi)) {
svc_ctx->threads = arg_parse_uint(&arg); svc_ctx->threads = arg_parse_uint(&arg);
} else if (arg_match(&arg, &temporal_layering_mode_arg, argi)) { } else if (arg_match(&arg, &temporal_layering_mode_arg, argi)) {
svc_ctx->temporal_layering_mode = svc_ctx->temporal_layering_mode = enc_cfg->temporal_layering_mode =
enc_cfg->temporal_layering_mode = arg_parse_int(&arg); arg_parse_int(&arg);
if (svc_ctx->temporal_layering_mode) { if (svc_ctx->temporal_layering_mode) {
enc_cfg->g_error_resilient = 1; enc_cfg->g_error_resilient = 1;
} }
@ -278,7 +288,7 @@ static void parse_command_line(int argc, const char **argv_,
enc_cfg->g_input_bit_depth = 10; enc_cfg->g_input_bit_depth = 10;
enc_cfg->g_profile = 2; enc_cfg->g_profile = 2;
break; break;
case VPX_BITS_12: case VPX_BITS_12:
enc_cfg->g_input_bit_depth = 12; enc_cfg->g_input_bit_depth = 12;
enc_cfg->g_profile = 2; enc_cfg->g_profile = 2;
break; break;
@ -360,9 +370,8 @@ static void parse_command_line(int argc, const char **argv_,
"num: %d, den: %d, bitrate: %d,\n" "num: %d, den: %d, bitrate: %d,\n"
"gop size: %d\n", "gop size: %d\n",
vpx_codec_iface_name(vpx_codec_vp9_cx()), app_input->frames_to_code, vpx_codec_iface_name(vpx_codec_vp9_cx()), app_input->frames_to_code,
app_input->frames_to_skip, app_input->frames_to_skip, svc_ctx->spatial_layers, enc_cfg->g_w,
svc_ctx->spatial_layers, enc_cfg->g_w, enc_cfg->g_h, enc_cfg->g_h, enc_cfg->g_timebase.num, enc_cfg->g_timebase.den,
enc_cfg->g_timebase.num, enc_cfg->g_timebase.den,
enc_cfg->rc_target_bitrate, enc_cfg->kf_max_dist); enc_cfg->rc_target_bitrate, enc_cfg->kf_max_dist);
} }
@ -399,7 +408,7 @@ struct RateControlStats {
// Note: these rate control stats assume only 1 key frame in the // Note: these rate control stats assume only 1 key frame in the
// sequence (i.e., first frame only). // sequence (i.e., first frame only).
static void set_rate_control_stats(struct RateControlStats *rc, static void set_rate_control_stats(struct RateControlStats *rc,
vpx_codec_enc_cfg_t *cfg) { vpx_codec_enc_cfg_t *cfg) {
unsigned int sl, tl; unsigned int sl, tl;
// Set the layer (cumulative) framerate and the target layer (non-cumulative) // Set the layer (cumulative) framerate and the target layer (non-cumulative)
// per-frame-bandwidth, for the rate control encoding stats below. // per-frame-bandwidth, for the rate control encoding stats below.
@ -412,18 +421,15 @@ static void set_rate_control_stats(struct RateControlStats *rc,
if (cfg->ts_number_layers == 1) if (cfg->ts_number_layers == 1)
rc->layer_framerate[layer] = framerate; rc->layer_framerate[layer] = framerate;
else else
rc->layer_framerate[layer] = rc->layer_framerate[layer] = framerate / cfg->ts_rate_decimator[tl];
framerate / cfg->ts_rate_decimator[tl];
if (tl > 0) { if (tl > 0) {
rc->layer_pfb[layer] = 1000.0 * rc->layer_pfb[layer] =
(cfg->layer_target_bitrate[layer] - 1000.0 * (cfg->layer_target_bitrate[layer] -
cfg->layer_target_bitrate[layer - 1]) / cfg->layer_target_bitrate[layer - 1]) /
(rc->layer_framerate[layer] - (rc->layer_framerate[layer] - rc->layer_framerate[layer - 1]);
rc->layer_framerate[layer - 1]);
} else { } else {
rc->layer_pfb[tlayer0] = 1000.0 * rc->layer_pfb[tlayer0] = 1000.0 * cfg->layer_target_bitrate[tlayer0] /
cfg->layer_target_bitrate[tlayer0] / rc->layer_framerate[tlayer0];
rc->layer_framerate[tlayer0];
} }
rc->layer_input_frames[layer] = 0; rc->layer_input_frames[layer] = 0;
rc->layer_enc_frames[layer] = 0; rc->layer_enc_frames[layer] = 0;
@ -447,31 +453,33 @@ static void printout_rate_control_summary(struct RateControlStats *rc,
double perc_fluctuation = 0.0; double perc_fluctuation = 0.0;
printf("Total number of processed frames: %d\n\n", frame_cnt - 1); printf("Total number of processed frames: %d\n\n", frame_cnt - 1);
printf("Rate control layer stats for sl%d tl%d layer(s):\n\n", printf("Rate control layer stats for sl%d tl%d layer(s):\n\n",
cfg->ss_number_layers, cfg->ts_number_layers); cfg->ss_number_layers, cfg->ts_number_layers);
for (sl = 0; sl < cfg->ss_number_layers; ++sl) { for (sl = 0; sl < cfg->ss_number_layers; ++sl) {
for (tl = 0; tl < cfg->ts_number_layers; ++tl) { for (tl = 0; tl < cfg->ts_number_layers; ++tl) {
const int layer = sl * cfg->ts_number_layers + tl; const int layer = sl * cfg->ts_number_layers + tl;
const int num_dropped = (tl > 0) ? const int num_dropped =
(rc->layer_input_frames[layer] - rc->layer_enc_frames[layer]) : (tl > 0)
(rc->layer_input_frames[layer] - rc->layer_enc_frames[layer] - 1); ? (rc->layer_input_frames[layer] - rc->layer_enc_frames[layer])
if (!sl) : (rc->layer_input_frames[layer] - rc->layer_enc_frames[layer] -
tot_num_frames += rc->layer_input_frames[layer]; 1);
if (!sl) tot_num_frames += rc->layer_input_frames[layer];
rc->layer_encoding_bitrate[layer] = 0.001 * rc->layer_framerate[layer] * rc->layer_encoding_bitrate[layer] = 0.001 * rc->layer_framerate[layer] *
rc->layer_encoding_bitrate[layer] / tot_num_frames; rc->layer_encoding_bitrate[layer] /
rc->layer_avg_frame_size[layer] = rc->layer_avg_frame_size[layer] / tot_num_frames;
rc->layer_enc_frames[layer]; rc->layer_avg_frame_size[layer] =
rc->layer_avg_rate_mismatch[layer] = rc->layer_avg_frame_size[layer] / rc->layer_enc_frames[layer];
100.0 * rc->layer_avg_rate_mismatch[layer] / rc->layer_avg_rate_mismatch[layer] = 100.0 *
rc->layer_enc_frames[layer]; rc->layer_avg_rate_mismatch[layer] /
rc->layer_enc_frames[layer];
printf("For layer#: sl%d tl%d \n", sl, tl); printf("For layer#: sl%d tl%d \n", sl, tl);
printf("Bitrate (target vs actual): %d %f.0 kbps\n", printf("Bitrate (target vs actual): %d %f.0 kbps\n",
cfg->layer_target_bitrate[layer], cfg->layer_target_bitrate[layer],
rc->layer_encoding_bitrate[layer]); rc->layer_encoding_bitrate[layer]);
printf("Average frame size (target vs actual): %f %f bits\n", printf("Average frame size (target vs actual): %f %f bits\n",
rc->layer_pfb[layer], rc->layer_avg_frame_size[layer]); rc->layer_pfb[layer], rc->layer_avg_frame_size[layer]);
printf("Average rate_mismatch: %f\n", printf("Average rate_mismatch: %f\n", rc->layer_avg_rate_mismatch[layer]);
rc->layer_avg_rate_mismatch[layer]); printf(
printf("Number of input frames, encoded (non-key) frames, " "Number of input frames, encoded (non-key) frames, "
"and percent dropped frames: %d %d %f.0 \n", "and percent dropped frames: %d %d %f.0 \n",
rc->layer_input_frames[layer], rc->layer_enc_frames[layer], rc->layer_input_frames[layer], rc->layer_enc_frames[layer],
100.0 * num_dropped / rc->layer_input_frames[layer]); 100.0 * num_dropped / rc->layer_input_frames[layer]);
@ -483,19 +491,19 @@ static void printout_rate_control_summary(struct RateControlStats *rc,
rc->variance_st_encoding_bitrate / rc->window_count - rc->variance_st_encoding_bitrate / rc->window_count -
(rc->avg_st_encoding_bitrate * rc->avg_st_encoding_bitrate); (rc->avg_st_encoding_bitrate * rc->avg_st_encoding_bitrate);
perc_fluctuation = 100.0 * sqrt(rc->variance_st_encoding_bitrate) / perc_fluctuation = 100.0 * sqrt(rc->variance_st_encoding_bitrate) /
rc->avg_st_encoding_bitrate; rc->avg_st_encoding_bitrate;
printf("Short-time stats, for window of %d frames: \n", rc->window_size); printf("Short-time stats, for window of %d frames: \n", rc->window_size);
printf("Average, rms-variance, and percent-fluct: %f %f %f \n", printf("Average, rms-variance, and percent-fluct: %f %f %f \n",
rc->avg_st_encoding_bitrate, rc->avg_st_encoding_bitrate, sqrt(rc->variance_st_encoding_bitrate),
sqrt(rc->variance_st_encoding_bitrate),
perc_fluctuation); perc_fluctuation);
if (frame_cnt != tot_num_frames) if (frame_cnt != tot_num_frames)
die("Error: Number of input frames not equal to output encoded frames != " die(
"%d tot_num_frames = %d\n", frame_cnt, tot_num_frames); "Error: Number of input frames not equal to output encoded frames != "
"%d tot_num_frames = %d\n",
frame_cnt, tot_num_frames);
} }
vpx_codec_err_t parse_superframe_index(const uint8_t *data, vpx_codec_err_t parse_superframe_index(const uint8_t *data, size_t data_sz,
size_t data_sz,
uint32_t sizes[8], int *count) { uint32_t sizes[8], int *count) {
// A chunk ending with a byte matching 0xc0 is an invalid chunk unless // A chunk ending with a byte matching 0xc0 is an invalid chunk unless
// it is a super frame index. If the last byte of real video compression // it is a super frame index. If the last byte of real video compression
@ -508,7 +516,6 @@ vpx_codec_err_t parse_superframe_index(const uint8_t *data,
marker = *(data + data_sz - 1); marker = *(data + data_sz - 1);
*count = 0; *count = 0;
if ((marker & 0xe0) == 0xc0) { if ((marker & 0xe0) == 0xc0) {
const uint32_t frames = (marker & 0x7) + 1; const uint32_t frames = (marker & 0x7) + 1;
const uint32_t mag = ((marker >> 3) & 0x3) + 1; const uint32_t mag = ((marker >> 3) & 0x3) + 1;
@ -516,8 +523,7 @@ vpx_codec_err_t parse_superframe_index(const uint8_t *data,
// This chunk is marked as having a superframe index but doesn't have // This chunk is marked as having a superframe index but doesn't have
// enough data for it, thus it's an invalid superframe index. // enough data for it, thus it's an invalid superframe index.
if (data_sz < index_sz) if (data_sz < index_sz) return VPX_CODEC_CORRUPT_FRAME;
return VPX_CODEC_CORRUPT_FRAME;
{ {
const uint8_t marker2 = *(data + data_sz - index_sz); const uint8_t marker2 = *(data + data_sz - index_sz);
@ -525,8 +531,7 @@ vpx_codec_err_t parse_superframe_index(const uint8_t *data,
// This chunk is marked as having a superframe index but doesn't have // This chunk is marked as having a superframe index but doesn't have
// the matching marker byte at the front of the index therefore it's an // the matching marker byte at the front of the index therefore it's an
// invalid chunk. // invalid chunk.
if (marker != marker2) if (marker != marker2) return VPX_CODEC_CORRUPT_FRAME;
return VPX_CODEC_CORRUPT_FRAME;
} }
{ {
@ -537,8 +542,7 @@ vpx_codec_err_t parse_superframe_index(const uint8_t *data,
for (i = 0; i < frames; ++i) { for (i = 0; i < frames; ++i) {
uint32_t this_sz = 0; uint32_t this_sz = 0;
for (j = 0; j < mag; ++j) for (j = 0; j < mag; ++j) this_sz |= (*x++) << (j * 8);
this_sz |= (*x++) << (j * 8);
sizes[i] = this_sz; sizes[i] = this_sz;
} }
*count = frames; *count = frames;
@ -558,32 +562,27 @@ void set_frame_flags_bypass_mode(int sl, int tl, int num_spatial_layers,
for (sl = 0; sl < num_spatial_layers; ++sl) { for (sl = 0; sl < num_spatial_layers; ++sl) {
if (!tl) { if (!tl) {
if (!sl) { if (!sl) {
ref_frame_config->frame_flags[sl] = VP8_EFLAG_NO_REF_GF | ref_frame_config->frame_flags[sl] =
VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
VP8_EFLAG_NO_UPD_ARF;
} else { } else {
if (is_key_frame) { if (is_key_frame) {
ref_frame_config->frame_flags[sl] = VP8_EFLAG_NO_REF_LAST | ref_frame_config->frame_flags[sl] =
VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_ARF |
VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
VP8_EFLAG_NO_UPD_ARF;
} else { } else {
ref_frame_config->frame_flags[sl] = VP8_EFLAG_NO_REF_ARF | ref_frame_config->frame_flags[sl] =
VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
VP8_EFLAG_NO_UPD_ARF;
} }
} }
} else if (tl == 1) { } else if (tl == 1) {
if (!sl) { if (!sl) {
ref_frame_config->frame_flags[sl] = VP8_EFLAG_NO_REF_GF | ref_frame_config->frame_flags[sl] =
VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST |
VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
VP8_EFLAG_NO_UPD_GF;
} else { } else {
ref_frame_config->frame_flags[sl] = VP8_EFLAG_NO_REF_ARF | ref_frame_config->frame_flags[sl] =
VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
VP8_EFLAG_NO_UPD_GF;
} }
} }
if (tl == 0) { if (tl == 0) {
@ -602,9 +601,9 @@ void set_frame_flags_bypass_mode(int sl, int tl, int num_spatial_layers,
} }
int main(int argc, const char **argv) { int main(int argc, const char **argv) {
AppInput app_input = {0}; AppInput app_input = { 0 };
VpxVideoWriter *writer = NULL; VpxVideoWriter *writer = NULL;
VpxVideoInfo info = {0}; VpxVideoInfo info = { 0 };
vpx_codec_ctx_t codec; vpx_codec_ctx_t codec;
vpx_codec_enc_cfg_t enc_cfg; vpx_codec_enc_cfg_t enc_cfg;
SvcContext svc_ctx; SvcContext svc_ctx;
@ -618,14 +617,14 @@ int main(int argc, const char **argv) {
int end_of_stream = 0; int end_of_stream = 0;
int frames_received = 0; int frames_received = 0;
#if OUTPUT_RC_STATS #if OUTPUT_RC_STATS
VpxVideoWriter *outfile[VPX_TS_MAX_LAYERS] = {NULL}; VpxVideoWriter *outfile[VPX_TS_MAX_LAYERS] = { NULL };
struct RateControlStats rc; struct RateControlStats rc;
vpx_svc_layer_id_t layer_id; vpx_svc_layer_id_t layer_id;
vpx_svc_ref_frame_config_t ref_frame_config; vpx_svc_ref_frame_config_t ref_frame_config;
int sl, tl; int sl, tl;
double sum_bitrate = 0.0; double sum_bitrate = 0.0;
double sum_bitrate2 = 0.0; double sum_bitrate2 = 0.0;
double framerate = 30.0; double framerate = 30.0;
#endif #endif
struct vpx_usec_timer timer; struct vpx_usec_timer timer;
int64_t cx_time = 0; int64_t cx_time = 0;
@ -634,10 +633,10 @@ int main(int argc, const char **argv) {
exec_name = argv[0]; exec_name = argv[0];
parse_command_line(argc, argv, &app_input, &svc_ctx, &enc_cfg); parse_command_line(argc, argv, &app_input, &svc_ctx, &enc_cfg);
// Allocate image buffer // Allocate image buffer
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
if (!vpx_img_alloc(&raw, enc_cfg.g_input_bit_depth == 8 ? if (!vpx_img_alloc(&raw, enc_cfg.g_input_bit_depth == 8 ? VPX_IMG_FMT_I420
VPX_IMG_FMT_I420 : VPX_IMG_FMT_I42016, : VPX_IMG_FMT_I42016,
enc_cfg.g_w, enc_cfg.g_h, 32)) { enc_cfg.g_w, enc_cfg.g_h, 32)) {
die("Failed to allocate image %dx%d\n", enc_cfg.g_w, enc_cfg.g_h); die("Failed to allocate image %dx%d\n", enc_cfg.g_w, enc_cfg.g_h);
} }
@ -668,8 +667,8 @@ int main(int argc, const char **argv) {
if (!(app_input.passes == 2 && app_input.pass == 1)) { if (!(app_input.passes == 2 && app_input.pass == 1)) {
// We don't save the bitstream for the 1st pass on two pass rate control // We don't save the bitstream for the 1st pass on two pass rate control
writer = vpx_video_writer_open(app_input.output_filename, kContainerIVF, writer =
&info); vpx_video_writer_open(app_input.output_filename, kContainerIVF, &info);
if (!writer) if (!writer)
die("Failed to open %s for writing\n", app_input.output_filename); die("Failed to open %s for writing\n", app_input.output_filename);
} }
@ -683,15 +682,13 @@ int main(int argc, const char **argv) {
snprintf(file_name, sizeof(file_name), "%s_t%d.ivf", snprintf(file_name, sizeof(file_name), "%s_t%d.ivf",
app_input.output_filename, tl); app_input.output_filename, tl);
outfile[tl] = vpx_video_writer_open(file_name, kContainerIVF, &info); outfile[tl] = vpx_video_writer_open(file_name, kContainerIVF, &info);
if (!outfile[tl]) if (!outfile[tl]) die("Failed to open %s for writing", file_name);
die("Failed to open %s for writing", file_name);
} }
} }
#endif #endif
// skip initial frames // skip initial frames
for (i = 0; i < app_input.frames_to_skip; ++i) for (i = 0; i < app_input.frames_to_skip; ++i) vpx_img_read(&raw, infile);
vpx_img_read(&raw, infile);
if (svc_ctx.speed != -1) if (svc_ctx.speed != -1)
vpx_codec_control(&codec, VP8E_SET_CPUUSED, svc_ctx.speed); vpx_codec_control(&codec, VP8E_SET_CPUUSED, svc_ctx.speed);
@ -700,7 +697,6 @@ int main(int argc, const char **argv) {
if (svc_ctx.speed >= 5 && svc_ctx.aqmode == 1) if (svc_ctx.speed >= 5 && svc_ctx.aqmode == 1)
vpx_codec_control(&codec, VP9E_SET_AQ_MODE, 3); vpx_codec_control(&codec, VP9E_SET_AQ_MODE, 3);
// Encode frames // Encode frames
while (!end_of_stream) { while (!end_of_stream) {
vpx_codec_iter_t iter = NULL; vpx_codec_iter_t iter = NULL;
@ -729,8 +725,7 @@ int main(int argc, const char **argv) {
// over all the spatial layers for the current superframe. // over all the spatial layers for the current superframe.
vpx_codec_control(&codec, VP9E_SET_SVC_LAYER_ID, &layer_id); vpx_codec_control(&codec, VP9E_SET_SVC_LAYER_ID, &layer_id);
set_frame_flags_bypass_mode(sl, layer_id.temporal_layer_id, set_frame_flags_bypass_mode(sl, layer_id.temporal_layer_id,
svc_ctx.spatial_layers, svc_ctx.spatial_layers, frame_cnt == 0,
frame_cnt == 0,
&ref_frame_config); &ref_frame_config);
vpx_codec_control(&codec, VP9E_SET_SVC_REF_FRAME_CONFIG, vpx_codec_control(&codec, VP9E_SET_SVC_REF_FRAME_CONFIG,
&ref_frame_config); &ref_frame_config);
@ -743,9 +738,9 @@ int main(int argc, const char **argv) {
} }
vpx_usec_timer_start(&timer); vpx_usec_timer_start(&timer);
res = vpx_svc_encode(&svc_ctx, &codec, (end_of_stream ? NULL : &raw), res = vpx_svc_encode(
pts, frame_duration, svc_ctx.speed >= 5 ? &svc_ctx, &codec, (end_of_stream ? NULL : &raw), pts, frame_duration,
VPX_DL_REALTIME : VPX_DL_GOOD_QUALITY); svc_ctx.speed >= 5 ? VPX_DL_REALTIME : VPX_DL_GOOD_QUALITY);
vpx_usec_timer_mark(&timer); vpx_usec_timer_mark(&timer);
cx_time += vpx_usec_timer_elapsed(&timer); cx_time += vpx_usec_timer_elapsed(&timer);
@ -764,8 +759,7 @@ int main(int argc, const char **argv) {
uint32_t sizes[8]; uint32_t sizes[8];
int count = 0; int count = 0;
#endif #endif
vpx_video_writer_write_frame(writer, vpx_video_writer_write_frame(writer, cx_pkt->data.frame.buf,
cx_pkt->data.frame.buf,
cx_pkt->data.frame.sz, cx_pkt->data.frame.sz,
cx_pkt->data.frame.pts); cx_pkt->data.frame.pts);
#if OUTPUT_RC_STATS #if OUTPUT_RC_STATS
@ -782,20 +776,19 @@ int main(int argc, const char **argv) {
VP9E_TEMPORAL_LAYERING_MODE_BYPASS) { VP9E_TEMPORAL_LAYERING_MODE_BYPASS) {
for (sl = 0; sl < enc_cfg.ss_number_layers; ++sl) { for (sl = 0; sl < enc_cfg.ss_number_layers; ++sl) {
++rc.layer_input_frames[sl * enc_cfg.ts_number_layers + ++rc.layer_input_frames[sl * enc_cfg.ts_number_layers +
layer_id.temporal_layer_id]; layer_id.temporal_layer_id];
} }
} }
for (tl = layer_id.temporal_layer_id; for (tl = layer_id.temporal_layer_id;
tl < enc_cfg.ts_number_layers; ++tl) { tl < enc_cfg.ts_number_layers; ++tl) {
vpx_video_writer_write_frame(outfile[tl], vpx_video_writer_write_frame(
cx_pkt->data.frame.buf, outfile[tl], cx_pkt->data.frame.buf, cx_pkt->data.frame.sz,
cx_pkt->data.frame.sz, cx_pkt->data.frame.pts);
cx_pkt->data.frame.pts);
} }
for (sl = 0; sl < enc_cfg.ss_number_layers; ++sl) { for (sl = 0; sl < enc_cfg.ss_number_layers; ++sl) {
for (tl = layer_id.temporal_layer_id; for (tl = layer_id.temporal_layer_id;
tl < enc_cfg.ts_number_layers; ++tl) { tl < enc_cfg.ts_number_layers; ++tl) {
const int layer = sl * enc_cfg.ts_number_layers + tl; const int layer = sl * enc_cfg.ts_number_layers + tl;
++rc.layer_tot_enc_frames[layer]; ++rc.layer_tot_enc_frames[layer];
rc.layer_encoding_bitrate[layer] += 8.0 * sizes[sl]; rc.layer_encoding_bitrate[layer] += 8.0 * sizes[sl];
@ -832,20 +825,20 @@ int main(int argc, const char **argv) {
// Second shifted window. // Second shifted window.
if (frame_cnt > rc.window_size + rc.window_size / 2) { if (frame_cnt > rc.window_size + rc.window_size / 2) {
tl = layer_id.temporal_layer_id; tl = layer_id.temporal_layer_id;
for (sl = 0; sl < enc_cfg.ss_number_layers; ++sl) { for (sl = 0; sl < enc_cfg.ss_number_layers; ++sl) {
sum_bitrate2 += 0.001 * 8.0 * sizes[sl] * framerate; sum_bitrate2 += 0.001 * 8.0 * sizes[sl] * framerate;
} }
if (frame_cnt > 2 * rc.window_size && if (frame_cnt > 2 * rc.window_size &&
frame_cnt % rc.window_size == 0) { frame_cnt % rc.window_size == 0) {
rc.window_count += 1; rc.window_count += 1;
rc.avg_st_encoding_bitrate += sum_bitrate2 / rc.window_size; rc.avg_st_encoding_bitrate += sum_bitrate2 / rc.window_size;
rc.variance_st_encoding_bitrate += rc.variance_st_encoding_bitrate +=
(sum_bitrate2 / rc.window_size) * (sum_bitrate2 / rc.window_size) *
(sum_bitrate2 / rc.window_size); (sum_bitrate2 / rc.window_size);
sum_bitrate2 = 0.0; sum_bitrate2 = 0.0;
} }
} }
} }
#endif #endif
@ -860,14 +853,11 @@ int main(int argc, const char **argv) {
break; break;
} }
case VPX_CODEC_STATS_PKT: { case VPX_CODEC_STATS_PKT: {
stats_write(&app_input.rc_stats, stats_write(&app_input.rc_stats, cx_pkt->data.twopass_stats.buf,
cx_pkt->data.twopass_stats.buf,
cx_pkt->data.twopass_stats.sz); cx_pkt->data.twopass_stats.sz);
break; break;
} }
default: { default: { break; }
break;
}
} }
} }
@ -880,8 +870,8 @@ int main(int argc, const char **argv) {
// Compensate for the extra frame count for the bypass mode. // Compensate for the extra frame count for the bypass mode.
if (svc_ctx.temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS) { if (svc_ctx.temporal_layering_mode == VP9E_TEMPORAL_LAYERING_MODE_BYPASS) {
for (sl = 0; sl < enc_cfg.ss_number_layers; ++sl) { for (sl = 0; sl < enc_cfg.ss_number_layers; ++sl) {
const int layer = sl * enc_cfg.ts_number_layers + const int layer =
layer_id.temporal_layer_id; sl * enc_cfg.ts_number_layers + layer_id.temporal_layer_id;
--rc.layer_input_frames[layer]; --rc.layer_input_frames[layer];
} }
} }
@ -895,8 +885,7 @@ int main(int argc, const char **argv) {
} }
#endif #endif
if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec"); if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec");
if (app_input.passes == 2) if (app_input.passes == 2) stats_close(&app_input.rc_stats, 1);
stats_close(&app_input.rc_stats, 1);
if (writer) { if (writer) {
vpx_video_writer_close(writer); vpx_video_writer_close(writer);
} }
@ -908,8 +897,7 @@ int main(int argc, const char **argv) {
} }
#endif #endif
printf("Frame cnt and encoding time/FPS stats for encoding: %d %f %f \n", printf("Frame cnt and encoding time/FPS stats for encoding: %d %f %f \n",
frame_cnt, frame_cnt, 1000 * (float)cx_time / (double)(frame_cnt * 1000000),
1000 * (float)cx_time / (double)(frame_cnt * 1000000),
1000000 * (double)frame_cnt / (double)cx_time); 1000000 * (double)frame_cnt / (double)cx_time);
vpx_img_free(&raw); vpx_img_free(&raw);
// display average size, psnr // display average size, psnr

113
examples/vp9cx_set_ref.c
View File

@ -8,7 +8,6 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
// VP9 Set Reference Frame // VP9 Set Reference Frame
// ============================ // ============================
// //
@ -61,7 +60,8 @@
static const char *exec_name; static const char *exec_name;
void usage_exit() { void usage_exit() {
fprintf(stderr, "Usage: %s <width> <height> <infile> <outfile> " fprintf(stderr,
"Usage: %s <width> <height> <infile> <outfile> "
"<frame> <limit(optional)>\n", "<frame> <limit(optional)>\n",
exec_name); exec_name);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
@ -70,8 +70,7 @@ void usage_exit() {
static int compare_img(const vpx_image_t *const img1, static int compare_img(const vpx_image_t *const img1,
const vpx_image_t *const img2) { const vpx_image_t *const img2) {
uint32_t l_w = img1->d_w; uint32_t l_w = img1->d_w;
uint32_t c_w = uint32_t c_w = (img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
(img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
const uint32_t c_h = const uint32_t c_h =
(img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift; (img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift;
uint32_t i; uint32_t i;
@ -99,10 +98,10 @@ static int compare_img(const vpx_image_t *const img1,
return match; return match;
} }
#define mmin(a, b) ((a) < (b) ? (a) : (b)) #define mmin(a, b) ((a) < (b) ? (a) : (b))
static void find_mismatch(const vpx_image_t *const img1, static void find_mismatch(const vpx_image_t *const img1,
const vpx_image_t *const img2, const vpx_image_t *const img2, int yloc[4],
int yloc[4], int uloc[4], int vloc[4]) { int uloc[4], int vloc[4]) {
const uint32_t bsize = 64; const uint32_t bsize = 64;
const uint32_t bsizey = bsize >> img1->y_chroma_shift; const uint32_t bsizey = bsize >> img1->y_chroma_shift;
const uint32_t bsizex = bsize >> img1->x_chroma_shift; const uint32_t bsizex = bsize >> img1->x_chroma_shift;
@ -190,21 +189,18 @@ static void find_mismatch(const vpx_image_t *const img1,
} }
} }
static void testing_decode(vpx_codec_ctx_t *encoder, static void testing_decode(vpx_codec_ctx_t *encoder, vpx_codec_ctx_t *decoder,
vpx_codec_ctx_t *decoder, vpx_codec_enc_cfg_t *cfg, unsigned int frame_out,
vpx_codec_enc_cfg_t *cfg,
unsigned int frame_out,
int *mismatch_seen) { int *mismatch_seen) {
vpx_image_t enc_img, dec_img; vpx_image_t enc_img, dec_img;
struct vp9_ref_frame ref_enc, ref_dec; struct vp9_ref_frame ref_enc, ref_dec;
if (*mismatch_seen) if (*mismatch_seen) return;
return;
ref_enc.idx = 0; ref_enc.idx = 0;
ref_dec.idx = 0; ref_dec.idx = 0;
if (vpx_codec_control(encoder, VP9_GET_REFERENCE, &ref_enc)) if (vpx_codec_control(encoder, VP9_GET_REFERENCE, &ref_enc))
die_codec(encoder, "Failed to get encoder reference frame"); die_codec(encoder, "Failed to get encoder reference frame");
enc_img = ref_enc.img; enc_img = ref_enc.img;
if (vpx_codec_control(decoder, VP9_GET_REFERENCE, &ref_dec)) if (vpx_codec_control(decoder, VP9_GET_REFERENCE, &ref_dec))
die_codec(decoder, "Failed to get decoder reference frame"); die_codec(decoder, "Failed to get decoder reference frame");
@ -216,37 +212,31 @@ static void testing_decode(vpx_codec_ctx_t *encoder,
*mismatch_seen = 1; *mismatch_seen = 1;
find_mismatch(&enc_img, &dec_img, y, u, v); find_mismatch(&enc_img, &dec_img, y, u, v);
printf("Encode/decode mismatch on frame %d at" printf(
" Y[%d, %d] {%d/%d}," "Encode/decode mismatch on frame %d at"
" U[%d, %d] {%d/%d}," " Y[%d, %d] {%d/%d},"
" V[%d, %d] {%d/%d}", " U[%d, %d] {%d/%d},"
frame_out, " V[%d, %d] {%d/%d}",
y[0], y[1], y[2], y[3], frame_out, y[0], y[1], y[2], y[3], u[0], u[1], u[2], u[3], v[0], v[1],
u[0], u[1], u[2], u[3], v[2], v[3]);
v[0], v[1], v[2], v[3]);
} }
vpx_img_free(&enc_img); vpx_img_free(&enc_img);
vpx_img_free(&dec_img); vpx_img_free(&dec_img);
} }
static int encode_frame(vpx_codec_ctx_t *ecodec, static int encode_frame(vpx_codec_ctx_t *ecodec, vpx_codec_enc_cfg_t *cfg,
vpx_codec_enc_cfg_t *cfg, vpx_image_t *img, unsigned int frame_in,
vpx_image_t *img, VpxVideoWriter *writer, int test_decode,
unsigned int frame_in, vpx_codec_ctx_t *dcodec, unsigned int *frame_out,
VpxVideoWriter *writer,
int test_decode,
vpx_codec_ctx_t *dcodec,
unsigned int *frame_out,
int *mismatch_seen) { int *mismatch_seen) {
int got_pkts = 0; int got_pkts = 0;
vpx_codec_iter_t iter = NULL; vpx_codec_iter_t iter = NULL;
const vpx_codec_cx_pkt_t *pkt = NULL; const vpx_codec_cx_pkt_t *pkt = NULL;
int got_data; int got_data;
const vpx_codec_err_t res = vpx_codec_encode(ecodec, img, frame_in, 1, const vpx_codec_err_t res =
0, VPX_DL_GOOD_QUALITY); vpx_codec_encode(ecodec, img, frame_in, 1, 0, VPX_DL_GOOD_QUALITY);
if (res != VPX_CODEC_OK) if (res != VPX_CODEC_OK) die_codec(ecodec, "Failed to encode frame");
die_codec(ecodec, "Failed to encode frame");
got_data = 0; got_data = 0;
@ -257,11 +247,10 @@ static int encode_frame(vpx_codec_ctx_t *ecodec,
const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0; const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0;
if (!(pkt->data.frame.flags & VPX_FRAME_IS_FRAGMENT)) { if (!(pkt->data.frame.flags & VPX_FRAME_IS_FRAGMENT)) {
*frame_out += 1; *frame_out += 1;
} }
if (!vpx_video_writer_write_frame(writer, if (!vpx_video_writer_write_frame(writer, pkt->data.frame.buf,
pkt->data.frame.buf,
pkt->data.frame.sz, pkt->data.frame.sz,
pkt->data.frame.pts)) { pkt->data.frame.pts)) {
die_codec(ecodec, "Failed to write compressed frame"); die_codec(ecodec, "Failed to write compressed frame");
@ -290,12 +279,12 @@ static int encode_frame(vpx_codec_ctx_t *ecodec,
int main(int argc, char **argv) { int main(int argc, char **argv) {
FILE *infile = NULL; FILE *infile = NULL;
// Encoder // Encoder
vpx_codec_ctx_t ecodec = {0}; vpx_codec_ctx_t ecodec = { 0 };
vpx_codec_enc_cfg_t cfg = {0}; vpx_codec_enc_cfg_t cfg = { 0 };
unsigned int frame_in = 0; unsigned int frame_in = 0;
vpx_image_t raw; vpx_image_t raw;
vpx_codec_err_t res; vpx_codec_err_t res;
VpxVideoInfo info = {0}; VpxVideoInfo info = { 0 };
VpxVideoWriter *writer = NULL; VpxVideoWriter *writer = NULL;
const VpxInterface *encoder = NULL; const VpxInterface *encoder = NULL;
@ -319,8 +308,7 @@ int main(int argc, char **argv) {
unsigned int limit = 0; unsigned int limit = 0;
exec_name = argv[0]; exec_name = argv[0];
if (argc < 6) if (argc < 6) die("Invalid number of arguments");
die("Invalid number of arguments");
width_arg = argv[1]; width_arg = argv[1];
height_arg = argv[2]; height_arg = argv[2];
@ -328,15 +316,13 @@ int main(int argc, char **argv) {
outfile_arg = argv[4]; outfile_arg = argv[4];
encoder = get_vpx_encoder_by_name("vp9"); encoder = get_vpx_encoder_by_name("vp9");
if (!encoder) if (!encoder) die("Unsupported codec.");
die("Unsupported codec.");
update_frame_num = atoi(argv[5]); update_frame_num = atoi(argv[5]);
// In VP9, the reference buffers (cm->buffer_pool->frame_bufs[i].buf) are // In VP9, the reference buffers (cm->buffer_pool->frame_bufs[i].buf) are
// allocated while calling vpx_codec_encode(), thus, setting reference for // allocated while calling vpx_codec_encode(), thus, setting reference for
// 1st frame isn't supported. // 1st frame isn't supported.
if (update_frame_num <= 1) if (update_frame_num <= 1) die("Couldn't parse frame number '%s'\n", argv[5]);
die("Couldn't parse frame number '%s'\n", argv[5]);
if (argc > 6) { if (argc > 6) {
limit = atoi(argv[6]); limit = atoi(argv[6]);
@ -350,23 +336,20 @@ int main(int argc, char **argv) {
info.time_base.numerator = 1; info.time_base.numerator = 1;
info.time_base.denominator = fps; info.time_base.denominator = fps;
if (info.frame_width <= 0 || if (info.frame_width <= 0 || info.frame_height <= 0 ||
info.frame_height <= 0 || (info.frame_width % 2) != 0 || (info.frame_height % 2) != 0) {
(info.frame_width % 2) != 0 ||
(info.frame_height % 2) != 0) {
die("Invalid frame size: %dx%d", info.frame_width, info.frame_height); die("Invalid frame size: %dx%d", info.frame_width, info.frame_height);
} }
if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, info.frame_width, if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, info.frame_width,
info.frame_height, 1)) { info.frame_height, 1)) {
die("Failed to allocate image."); die("Failed to allocate image.");
} }
printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface())); printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface()));
res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0); res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0);
if (res) if (res) die_codec(&ecodec, "Failed to get default codec config.");
die_codec(&ecodec, "Failed to get default codec config.");
cfg.g_w = info.frame_width; cfg.g_w = info.frame_width;
cfg.g_h = info.frame_height; cfg.g_h = info.frame_height;
@ -376,8 +359,7 @@ int main(int argc, char **argv) {
cfg.g_lag_in_frames = 3; cfg.g_lag_in_frames = 3;
writer = vpx_video_writer_open(outfile_arg, kContainerIVF, &info); writer = vpx_video_writer_open(outfile_arg, kContainerIVF, &info);
if (!writer) if (!writer) die("Failed to open %s for writing.", outfile_arg);
die("Failed to open %s for writing.", outfile_arg);
if (!(infile = fopen(infile_arg, "rb"))) if (!(infile = fopen(infile_arg, "rb")))
die("Failed to open %s for reading.", infile_arg); die("Failed to open %s for reading.", infile_arg);
@ -390,15 +372,14 @@ int main(int argc, char **argv) {
die_codec(&ecodec, "Failed to set enable auto alt ref"); die_codec(&ecodec, "Failed to set enable auto alt ref");
if (test_decode) { if (test_decode) {
const VpxInterface *decoder = get_vpx_decoder_by_name("vp9"); const VpxInterface *decoder = get_vpx_decoder_by_name("vp9");
if (vpx_codec_dec_init(&dcodec, decoder->codec_interface(), NULL, 0)) if (vpx_codec_dec_init(&dcodec, decoder->codec_interface(), NULL, 0))
die_codec(&dcodec, "Failed to initialize decoder."); die_codec(&dcodec, "Failed to initialize decoder.");
} }
// Encode frames. // Encode frames.
while (vpx_img_read(&raw, infile)) { while (vpx_img_read(&raw, infile)) {
if (limit && frame_in >= limit) if (limit && frame_in >= limit) break;
break;
if (update_frame_num > 1 && frame_out + 1 == update_frame_num) { if (update_frame_num > 1 && frame_out + 1 == update_frame_num) {
vpx_ref_frame_t ref; vpx_ref_frame_t ref;
ref.frame_type = VP8_LAST_FRAME; ref.frame_type = VP8_LAST_FRAME;
@ -416,17 +397,17 @@ int main(int argc, char **argv) {
} }
} }
encode_frame(&ecodec, &cfg, &raw, frame_in, writer, test_decode, encode_frame(&ecodec, &cfg, &raw, frame_in, writer, test_decode, &dcodec,
&dcodec, &frame_out, &mismatch_seen); &frame_out, &mismatch_seen);
frame_in++; frame_in++;
if (mismatch_seen) if (mismatch_seen) break;
break;
} }
// Flush encoder. // Flush encoder.
if (!mismatch_seen) if (!mismatch_seen)
while (encode_frame(&ecodec, &cfg, NULL, frame_in, writer, test_decode, while (encode_frame(&ecodec, &cfg, NULL, frame_in, writer, test_decode,
&dcodec, &frame_out, &mismatch_seen)) {} &dcodec, &frame_out, &mismatch_seen)) {
}
printf("\n"); printf("\n");
fclose(infile); fclose(infile);

348
examples/vpx_temporal_svc_encoder.c
View File

@ -28,9 +28,7 @@
static const char *exec_name; static const char *exec_name;
void usage_exit(void) { void usage_exit(void) { exit(EXIT_FAILURE); }
exit(EXIT_FAILURE);
}
// Denoiser states, for temporal denoising. // Denoiser states, for temporal denoising.
enum denoiserState { enum denoiserState {
@ -41,7 +39,7 @@ enum denoiserState {
kDenoiserOnAdaptive kDenoiserOnAdaptive
}; };
static int mode_to_num_layers[13] = {1, 2, 2, 3, 3, 3, 3, 5, 2, 3, 3, 3, 3}; static int mode_to_num_layers[13] = { 1, 2, 2, 3, 3, 3, 3, 5, 2, 3, 3, 3, 3 };
// For rate control encoding stats. // For rate control encoding stats.
struct RateControlMetrics { struct RateControlMetrics {
@ -86,14 +84,14 @@ static void set_rate_control_metrics(struct RateControlMetrics *rc,
// per-frame-bandwidth, for the rate control encoding stats below. // per-frame-bandwidth, for the rate control encoding stats below.
const double framerate = cfg->g_timebase.den / cfg->g_timebase.num; const double framerate = cfg->g_timebase.den / cfg->g_timebase.num;
rc->layer_framerate[0] = framerate / cfg->ts_rate_decimator[0]; rc->layer_framerate[0] = framerate / cfg->ts_rate_decimator[0];
rc->layer_pfb[0] = 1000.0 * rc->layer_target_bitrate[0] / rc->layer_pfb[0] =
rc->layer_framerate[0]; 1000.0 * rc->layer_target_bitrate[0] / rc->layer_framerate[0];
for (i = 0; i < cfg->ts_number_layers; ++i) { for (i = 0; i < cfg->ts_number_layers; ++i) {
if (i > 0) { if (i > 0) {
rc->layer_framerate[i] = framerate / cfg->ts_rate_decimator[i]; rc->layer_framerate[i] = framerate / cfg->ts_rate_decimator[i];
rc->layer_pfb[i] = 1000.0 * rc->layer_pfb[i] = 1000.0 * (rc->layer_target_bitrate[i] -
(rc->layer_target_bitrate[i] - rc->layer_target_bitrate[i - 1]) / rc->layer_target_bitrate[i - 1]) /
(rc->layer_framerate[i] - rc->layer_framerate[i - 1]); (rc->layer_framerate[i] - rc->layer_framerate[i - 1]);
} }
rc->layer_input_frames[i] = 0; rc->layer_input_frames[i] = 0;
rc->layer_enc_frames[i] = 0; rc->layer_enc_frames[i] = 0;
@ -114,29 +112,31 @@ static void printout_rate_control_summary(struct RateControlMetrics *rc,
unsigned int i = 0; unsigned int i = 0;
int tot_num_frames = 0; int tot_num_frames = 0;
double perc_fluctuation = 0.0; double perc_fluctuation = 0.0;
printf("Total number of processed frames: %d\n\n", frame_cnt -1); printf("Total number of processed frames: %d\n\n", frame_cnt - 1);
printf("Rate control layer stats for %d layer(s):\n\n", printf("Rate control layer stats for %d layer(s):\n\n",
cfg->ts_number_layers); cfg->ts_number_layers);
for (i = 0; i < cfg->ts_number_layers; ++i) { for (i = 0; i < cfg->ts_number_layers; ++i) {
const int num_dropped = (i > 0) ? const int num_dropped =
(rc->layer_input_frames[i] - rc->layer_enc_frames[i]) : (i > 0) ? (rc->layer_input_frames[i] - rc->layer_enc_frames[i])
(rc->layer_input_frames[i] - rc->layer_enc_frames[i] - 1); : (rc->layer_input_frames[i] - rc->layer_enc_frames[i] - 1);
tot_num_frames += rc->layer_input_frames[i]; tot_num_frames += rc->layer_input_frames[i];
rc->layer_encoding_bitrate[i] = 0.001 * rc->layer_framerate[i] * rc->layer_encoding_bitrate[i] = 0.001 * rc->layer_framerate[i] *
rc->layer_encoding_bitrate[i] / tot_num_frames; rc->layer_encoding_bitrate[i] /
rc->layer_avg_frame_size[i] = rc->layer_avg_frame_size[i] / tot_num_frames;
rc->layer_enc_frames[i]; rc->layer_avg_frame_size[i] =
rc->layer_avg_rate_mismatch[i] = 100.0 * rc->layer_avg_rate_mismatch[i] / rc->layer_avg_frame_size[i] / rc->layer_enc_frames[i];
rc->layer_enc_frames[i]; rc->layer_avg_rate_mismatch[i] =
100.0 * rc->layer_avg_rate_mismatch[i] / rc->layer_enc_frames[i];
printf("For layer#: %d \n", i); printf("For layer#: %d \n", i);
printf("Bitrate (target vs actual): %d %f \n", rc->layer_target_bitrate[i], printf("Bitrate (target vs actual): %d %f \n", rc->layer_target_bitrate[i],
rc->layer_encoding_bitrate[i]); rc->layer_encoding_bitrate[i]);
printf("Average frame size (target vs actual): %f %f \n", rc->layer_pfb[i], printf("Average frame size (target vs actual): %f %f \n", rc->layer_pfb[i],
rc->layer_avg_frame_size[i]); rc->layer_avg_frame_size[i]);
printf("Average rate_mismatch: %f \n", rc->layer_avg_rate_mismatch[i]); printf("Average rate_mismatch: %f \n", rc->layer_avg_rate_mismatch[i]);
printf("Number of input frames, encoded (non-key) frames, " printf(
"and perc dropped frames: %d %d %f \n", rc->layer_input_frames[i], "Number of input frames, encoded (non-key) frames, "
rc->layer_enc_frames[i], "and perc dropped frames: %d %d %f \n",
rc->layer_input_frames[i], rc->layer_enc_frames[i],
100.0 * num_dropped / rc->layer_input_frames[i]); 100.0 * num_dropped / rc->layer_input_frames[i]);
printf("\n"); printf("\n");
} }
@ -145,11 +145,10 @@ static void printout_rate_control_summary(struct RateControlMetrics *rc,
rc->variance_st_encoding_bitrate / rc->window_count - rc->variance_st_encoding_bitrate / rc->window_count -
(rc->avg_st_encoding_bitrate * rc->avg_st_encoding_bitrate); (rc->avg_st_encoding_bitrate * rc->avg_st_encoding_bitrate);
perc_fluctuation = 100.0 * sqrt(rc->variance_st_encoding_bitrate) / perc_fluctuation = 100.0 * sqrt(rc->variance_st_encoding_bitrate) /
rc->avg_st_encoding_bitrate; rc->avg_st_encoding_bitrate;
printf("Short-time stats, for window of %d frames: \n",rc->window_size); printf("Short-time stats, for window of %d frames: \n", rc->window_size);
printf("Average, rms-variance, and percent-fluct: %f %f %f \n", printf("Average, rms-variance, and percent-fluct: %f %f %f \n",
rc->avg_st_encoding_bitrate, rc->avg_st_encoding_bitrate, sqrt(rc->variance_st_encoding_bitrate),
sqrt(rc->variance_st_encoding_bitrate),
perc_fluctuation); perc_fluctuation);
if ((frame_cnt - 1) != tot_num_frames) if ((frame_cnt - 1) != tot_num_frames)
die("Error: Number of input frames not equal to output! \n"); die("Error: Number of input frames not equal to output! \n");
@ -167,20 +166,20 @@ static void set_temporal_layer_pattern(int layering_mode,
switch (layering_mode) { switch (layering_mode) {
case 0: { case 0: {
// 1-layer. // 1-layer.
int ids[1] = {0}; int ids[1] = { 0 };
cfg->ts_periodicity = 1; cfg->ts_periodicity = 1;
*flag_periodicity = 1; *flag_periodicity = 1;
cfg->ts_number_layers = 1; cfg->ts_number_layers = 1;
cfg->ts_rate_decimator[0] = 1; cfg->ts_rate_decimator[0] = 1;
memcpy(cfg->ts_layer_id, ids, sizeof(ids)); memcpy(cfg->ts_layer_id, ids, sizeof(ids));
// Update L only. // Update L only.
layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF | layer_flags[0] =
VP8_EFLAG_NO_UPD_ARF; VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
break; break;
} }
case 1: { case 1: {
// 2-layers, 2-frame period. // 2-layers, 2-frame period.
int ids[2] = {0, 1}; int ids[2] = { 0, 1 };
cfg->ts_periodicity = 2; cfg->ts_periodicity = 2;
*flag_periodicity = 2; *flag_periodicity = 2;
cfg->ts_number_layers = 2; cfg->ts_number_layers = 2;
@ -189,22 +188,24 @@ static void set_temporal_layer_pattern(int layering_mode,
memcpy(cfg->ts_layer_id, ids, sizeof(ids)); memcpy(cfg->ts_layer_id, ids, sizeof(ids));
#if 1 #if 1
// 0=L, 1=GF, Intra-layer prediction enabled. // 0=L, 1=GF, Intra-layer prediction enabled.
layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF | layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF |
VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF; VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF |
layer_flags[1] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_REF_ARF;
VP8_EFLAG_NO_REF_ARF; layer_flags[1] =
VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_REF_ARF;
#else #else
// 0=L, 1=GF, Intra-layer prediction disabled. // 0=L, 1=GF, Intra-layer prediction disabled.
layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF | layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_GF |
VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF; VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF |
VP8_EFLAG_NO_REF_ARF;
layer_flags[1] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST | layer_flags[1] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_LAST; VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_LAST;
#endif #endif
break; break;
} }
case 2: { case 2: {
// 2-layers, 3-frame period. // 2-layers, 3-frame period.
int ids[3] = {0, 1, 1}; int ids[3] = { 0, 1, 1 };
cfg->ts_periodicity = 3; cfg->ts_periodicity = 3;
*flag_periodicity = 3; *flag_periodicity = 3;
cfg->ts_number_layers = 2; cfg->ts_number_layers = 2;
@ -212,16 +213,17 @@ static void set_temporal_layer_pattern(int layering_mode,
cfg->ts_rate_decimator[1] = 1; cfg->ts_rate_decimator[1] = 1;
memcpy(cfg->ts_layer_id, ids, sizeof(ids)); memcpy(cfg->ts_layer_id, ids, sizeof(ids));
// 0=L, 1=GF, Intra-layer prediction enabled. // 0=L, 1=GF, Intra-layer prediction enabled.
layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF | layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
layer_flags[1] = VP8_EFLAG_NO_UPD_ARF;
layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF | layer_flags[1] = layer_flags[2] =
VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST; VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_ARF |
VP8_EFLAG_NO_UPD_LAST;
break; break;
} }
case 3: { case 3: {
// 3-layers, 6-frame period. // 3-layers, 6-frame period.
int ids[6] = {0, 2, 2, 1, 2, 2}; int ids[6] = { 0, 2, 2, 1, 2, 2 };
cfg->ts_periodicity = 6; cfg->ts_periodicity = 6;
*flag_periodicity = 6; *flag_periodicity = 6;
cfg->ts_number_layers = 3; cfg->ts_number_layers = 3;
@ -230,19 +232,18 @@ static void set_temporal_layer_pattern(int layering_mode,
cfg->ts_rate_decimator[2] = 1; cfg->ts_rate_decimator[2] = 1;
memcpy(cfg->ts_layer_id, ids, sizeof(ids)); memcpy(cfg->ts_layer_id, ids, sizeof(ids));
// 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled. // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled.
layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF | layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
layer_flags[3] = VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_ARF;
VP8_EFLAG_NO_UPD_LAST; layer_flags[3] =
layer_flags[1] = VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
layer_flags[2] = layer_flags[1] = layer_flags[2] = layer_flags[4] = layer_flags[5] =
layer_flags[4] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_LAST;
layer_flags[5] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_LAST;
break; break;
} }
case 4: { case 4: {
// 3-layers, 4-frame period. // 3-layers, 4-frame period.
int ids[4] = {0, 2, 1, 2}; int ids[4] = { 0, 2, 1, 2 };
cfg->ts_periodicity = 4; cfg->ts_periodicity = 4;
*flag_periodicity = 4; *flag_periodicity = 4;
cfg->ts_number_layers = 3; cfg->ts_number_layers = 3;
@ -251,39 +252,41 @@ static void set_temporal_layer_pattern(int layering_mode,
cfg->ts_rate_decimator[2] = 1; cfg->ts_rate_decimator[2] = 1;
memcpy(cfg->ts_layer_id, ids, sizeof(ids)); memcpy(cfg->ts_layer_id, ids, sizeof(ids));
// 0=L, 1=GF, 2=ARF, Intra-layer prediction disabled. // 0=L, 1=GF, 2=ARF, Intra-layer prediction disabled.
layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF | layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
VP8_EFLAG_NO_UPD_ARF;
layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF | layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST; VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
layer_flags[1] = layer_flags[1] = layer_flags[3] =
layer_flags[3] = VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_UPD_ARF;
break; break;
} }
case 5: { case 5: {
// 3-layers, 4-frame period. // 3-layers, 4-frame period.
int ids[4] = {0, 2, 1, 2}; int ids[4] = { 0, 2, 1, 2 };
cfg->ts_periodicity = 4; cfg->ts_periodicity = 4;
*flag_periodicity = 4; *flag_periodicity = 4;
cfg->ts_number_layers = 3; cfg->ts_number_layers = 3;
cfg->ts_rate_decimator[0] = 4; cfg->ts_rate_decimator[0] = 4;
cfg->ts_rate_decimator[1] = 2; cfg->ts_rate_decimator[1] = 2;
cfg->ts_rate_decimator[2] = 1; cfg->ts_rate_decimator[2] = 1;
memcpy(cfg->ts_layer_id, ids, sizeof(ids)); memcpy(cfg->ts_layer_id, ids, sizeof(ids));
// 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled in layer 1, disabled // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled in layer 1, disabled
// in layer 2. // in layer 2.
layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF | layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
layer_flags[2] = VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
layer_flags[2] =
VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
layer_flags[1] = layer_flags[3] =
VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_UPD_ARF;
layer_flags[1] =
layer_flags[3] = VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST |
VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
break; break;
} }
case 6: { case 6: {
// 3-layers, 4-frame period. // 3-layers, 4-frame period.
int ids[4] = {0, 2, 1, 2}; int ids[4] = { 0, 2, 1, 2 };
cfg->ts_periodicity = 4; cfg->ts_periodicity = 4;
*flag_periodicity = 4; *flag_periodicity = 4;
cfg->ts_number_layers = 3; cfg->ts_number_layers = 3;
@ -292,18 +295,19 @@ static void set_temporal_layer_pattern(int layering_mode,
cfg->ts_rate_decimator[2] = 1; cfg->ts_rate_decimator[2] = 1;
memcpy(cfg->ts_layer_id, ids, sizeof(ids)); memcpy(cfg->ts_layer_id, ids, sizeof(ids));
// 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled. // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled.
layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF | layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
layer_flags[2] = VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
VP8_EFLAG_NO_UPD_ARF; layer_flags[2] =
layer_flags[1] = VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
layer_flags[3] = VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF; layer_flags[1] = layer_flags[3] =
VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
break; break;
} }
case 7: { case 7: {
// NOTE: Probably of academic interest only. // NOTE: Probably of academic interest only.
// 5-layers, 16-frame period. // 5-layers, 16-frame period.
int ids[16] = {0, 4, 3, 4, 2, 4, 3, 4, 1, 4, 3, 4, 2, 4, 3, 4}; int ids[16] = { 0, 4, 3, 4, 2, 4, 3, 4, 1, 4, 3, 4, 2, 4, 3, 4 };
cfg->ts_periodicity = 16; cfg->ts_periodicity = 16;
*flag_periodicity = 16; *flag_periodicity = 16;
cfg->ts_number_layers = 5; cfg->ts_number_layers = 5;
@ -313,28 +317,21 @@ static void set_temporal_layer_pattern(int layering_mode,
cfg->ts_rate_decimator[3] = 2; cfg->ts_rate_decimator[3] = 2;
cfg->ts_rate_decimator[4] = 1; cfg->ts_rate_decimator[4] = 1;
memcpy(cfg->ts_layer_id, ids, sizeof(ids)); memcpy(cfg->ts_layer_id, ids, sizeof(ids));
layer_flags[0] = VPX_EFLAG_FORCE_KF; layer_flags[0] = VPX_EFLAG_FORCE_KF;
layer_flags[1] = layer_flags[1] = layer_flags[3] = layer_flags[5] = layer_flags[7] =
layer_flags[3] = layer_flags[9] = layer_flags[11] = layer_flags[13] = layer_flags[15] =
layer_flags[5] = VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
layer_flags[7] = VP8_EFLAG_NO_UPD_ARF;
layer_flags[9] = layer_flags[2] = layer_flags[6] = layer_flags[10] = layer_flags[14] =
layer_flags[11] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_GF;
layer_flags[13] = layer_flags[4] = layer_flags[12] =
layer_flags[15] = VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_UPD_ARF;
VP8_EFLAG_NO_UPD_ARF; layer_flags[8] = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF;
layer_flags[2] =
layer_flags[6] =
layer_flags[10] =
layer_flags[14] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_GF;
layer_flags[4] =
layer_flags[12] = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_UPD_ARF;
layer_flags[8] = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF;
break; break;
} }
case 8: { case 8: {
// 2-layers, with sync point at first frame of layer 1. // 2-layers, with sync point at first frame of layer 1.
int ids[2] = {0, 1}; int ids[2] = { 0, 1 };
cfg->ts_periodicity = 2; cfg->ts_periodicity = 2;
*flag_periodicity = 8; *flag_periodicity = 8;
cfg->ts_number_layers = 2; cfg->ts_number_layers = 2;
@ -346,17 +343,17 @@ static void set_temporal_layer_pattern(int layering_mode,
// key frame. Sync point every 8 frames. // key frame. Sync point every 8 frames.
// Layer 0: predict from L and ARF, update L and G. // Layer 0: predict from L and ARF, update L and G.
layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF | layer_flags[0] =
VP8_EFLAG_NO_UPD_ARF; VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_ARF;
// Layer 1: sync point: predict from L and ARF, and update G. // Layer 1: sync point: predict from L and ARF, and update G.
layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_LAST | layer_flags[1] =
VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
// Layer 0, predict from L and ARF, update L. // Layer 0, predict from L and ARF, update L.
layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | layer_flags[2] =
VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
// Layer 1: predict from L, G and ARF, and update G. // Layer 1: predict from L, G and ARF, and update G.
layer_flags[3] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST | layer_flags[3] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
VP8_EFLAG_NO_UPD_ENTROPY; VP8_EFLAG_NO_UPD_ENTROPY;
// Layer 0. // Layer 0.
layer_flags[4] = layer_flags[2]; layer_flags[4] = layer_flags[2];
// Layer 1. // Layer 1.
@ -365,11 +362,11 @@ static void set_temporal_layer_pattern(int layering_mode,
layer_flags[6] = layer_flags[4]; layer_flags[6] = layer_flags[4];
// Layer 1. // Layer 1.
layer_flags[7] = layer_flags[5]; layer_flags[7] = layer_flags[5];
break; break;
} }
case 9: { case 9: {
// 3-layers: Sync points for layer 1 and 2 every 8 frames. // 3-layers: Sync points for layer 1 and 2 every 8 frames.
int ids[4] = {0, 2, 1, 2}; int ids[4] = { 0, 2, 1, 2 };
cfg->ts_periodicity = 4; cfg->ts_periodicity = 4;
*flag_periodicity = 8; *flag_periodicity = 8;
cfg->ts_number_layers = 3; cfg->ts_number_layers = 3;
@ -378,20 +375,21 @@ static void set_temporal_layer_pattern(int layering_mode,
cfg->ts_rate_decimator[2] = 1; cfg->ts_rate_decimator[2] = 1;
memcpy(cfg->ts_layer_id, ids, sizeof(ids)); memcpy(cfg->ts_layer_id, ids, sizeof(ids));
// 0=L, 1=GF, 2=ARF. // 0=L, 1=GF, 2=ARF.
layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF | layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_REF_GF |
VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_GF |
VP8_EFLAG_NO_UPD_ARF;
layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF | layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
layer_flags[3] = layer_flags[5] =
VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF; VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
layer_flags[3] =
layer_flags[5] = VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
layer_flags[4] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF | layer_flags[4] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
layer_flags[6] = VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | layer_flags[6] =
VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
layer_flags[7] = VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | layer_flags[7] = VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_ENTROPY; VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_ENTROPY;
break; break;
} }
case 10: { case 10: {
@ -399,7 +397,7 @@ static void set_temporal_layer_pattern(int layering_mode,
// and is only updated on key frame. // and is only updated on key frame.
// Sync points for layer 1 and 2 every 8 frames. // Sync points for layer 1 and 2 every 8 frames.
int ids[4] = {0, 2, 1, 2}; int ids[4] = { 0, 2, 1, 2 };
cfg->ts_periodicity = 4; cfg->ts_periodicity = 4;
*flag_periodicity = 8; *flag_periodicity = 8;
cfg->ts_number_layers = 3; cfg->ts_number_layers = 3;
@ -409,21 +407,21 @@ static void set_temporal_layer_pattern(int layering_mode,
memcpy(cfg->ts_layer_id, ids, sizeof(ids)); memcpy(cfg->ts_layer_id, ids, sizeof(ids));
// 0=L, 1=GF, 2=ARF. // 0=L, 1=GF, 2=ARF.
// Layer 0: predict from L and ARF; update L and G. // Layer 0: predict from L and ARF; update L and G.
layer_flags[0] = VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_ARF | layer_flags[0] =
VP8_EFLAG_NO_REF_GF; VPX_EFLAG_FORCE_KF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF;
// Layer 2: sync point: predict from L and ARF; update none. // Layer 2: sync point: predict from L and ARF; update none.
layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF |
VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
VP8_EFLAG_NO_UPD_ENTROPY; VP8_EFLAG_NO_UPD_ENTROPY;
// Layer 1: sync point: predict from L and ARF; update G. // Layer 1: sync point: predict from L and ARF; update G.
layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_ARF | layer_flags[2] =
VP8_EFLAG_NO_UPD_LAST; VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
// Layer 2: predict from L, G, ARF; update none. // Layer 2: predict from L, G, ARF; update none.
layer_flags[3] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | layer_flags[3] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ENTROPY; VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ENTROPY;
// Layer 0: predict from L and ARF; update L. // Layer 0: predict from L and ARF; update L.
layer_flags[4] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | layer_flags[4] =
VP8_EFLAG_NO_REF_GF; VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF;
// Layer 2: predict from L, G, ARF; update none. // Layer 2: predict from L, G, ARF; update none.
layer_flags[5] = layer_flags[3]; layer_flags[5] = layer_flags[3];
// Layer 1: predict from L, G, ARF; update G. // Layer 1: predict from L, G, ARF; update G.
@ -438,7 +436,7 @@ static void set_temporal_layer_pattern(int layering_mode,
// This was added to compare with vp9_spatial_svc_encoder. // This was added to compare with vp9_spatial_svc_encoder.
// 3-layers, 4-frame period. // 3-layers, 4-frame period.
int ids[4] = {0, 2, 1, 2}; int ids[4] = { 0, 2, 1, 2 };
cfg->ts_periodicity = 4; cfg->ts_periodicity = 4;
*flag_periodicity = 4; *flag_periodicity = 4;
cfg->ts_number_layers = 3; cfg->ts_number_layers = 3;
@ -448,20 +446,20 @@ static void set_temporal_layer_pattern(int layering_mode,
memcpy(cfg->ts_layer_id, ids, sizeof(ids)); memcpy(cfg->ts_layer_id, ids, sizeof(ids));
// 0=L, 1=GF, 2=ARF, Intra-layer prediction disabled. // 0=L, 1=GF, 2=ARF, Intra-layer prediction disabled.
layer_flags[0] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF | layer_flags[0] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF; VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF | layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST; VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF | layer_flags[1] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF; VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
layer_flags[3] = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_ARF | layer_flags[3] = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_ARF |
VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF; VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
break; break;
} }
case 12: case 12:
default: { default: {
// 3-layers structure as in case 10, but no sync/refresh points for // 3-layers structure as in case 10, but no sync/refresh points for
// layer 1 and 2. // layer 1 and 2.
int ids[4] = {0, 2, 1, 2}; int ids[4] = { 0, 2, 1, 2 };
cfg->ts_periodicity = 4; cfg->ts_periodicity = 4;
*flag_periodicity = 8; *flag_periodicity = 8;
cfg->ts_number_layers = 3; cfg->ts_number_layers = 3;
@ -471,15 +469,15 @@ static void set_temporal_layer_pattern(int layering_mode,
memcpy(cfg->ts_layer_id, ids, sizeof(ids)); memcpy(cfg->ts_layer_id, ids, sizeof(ids));
// 0=L, 1=GF, 2=ARF. // 0=L, 1=GF, 2=ARF.
// Layer 0: predict from L and ARF; update L. // Layer 0: predict from L and ARF; update L.
layer_flags[0] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | layer_flags[0] =
VP8_EFLAG_NO_REF_GF; VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF;
layer_flags[4] = layer_flags[0]; layer_flags[4] = layer_flags[0];
// Layer 1: predict from L, G, ARF; update G. // Layer 1: predict from L, G, ARF; update G.
layer_flags[2] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST; layer_flags[2] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
layer_flags[6] = layer_flags[2]; layer_flags[6] = layer_flags[2];
// Layer 2: predict from L, G, ARF; update none. // Layer 2: predict from L, G, ARF; update none.
layer_flags[1] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | layer_flags[1] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ENTROPY; VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ENTROPY;
layer_flags[3] = layer_flags[1]; layer_flags[3] = layer_flags[1];
layer_flags[5] = layer_flags[1]; layer_flags[5] = layer_flags[1];
layer_flags[7] = layer_flags[1]; layer_flags[7] = layer_flags[1];
@ -489,7 +487,7 @@ static void set_temporal_layer_pattern(int layering_mode,
} }
int main(int argc, char **argv) { int main(int argc, char **argv) {
VpxVideoWriter *outfile[VPX_TS_MAX_LAYERS] = {NULL}; VpxVideoWriter *outfile[VPX_TS_MAX_LAYERS] = { NULL };
vpx_codec_ctx_t codec; vpx_codec_ctx_t codec;
vpx_codec_enc_cfg_t cfg; vpx_codec_enc_cfg_t cfg;
int frame_cnt = 0; int frame_cnt = 0;
@ -502,15 +500,15 @@ int main(int argc, char **argv) {
int got_data; int got_data;
int flags = 0; int flags = 0;
unsigned int i; unsigned int i;
int pts = 0; // PTS starts at 0. int pts = 0; // PTS starts at 0.
int frame_duration = 1; // 1 timebase tick per frame. int frame_duration = 1; // 1 timebase tick per frame.
int layering_mode = 0; int layering_mode = 0;
int layer_flags[VPX_TS_MAX_PERIODICITY] = {0}; int layer_flags[VPX_TS_MAX_PERIODICITY] = { 0 };
int flag_periodicity = 1; int flag_periodicity = 1;
#if VPX_ENCODER_ABI_VERSION > (4 + VPX_CODEC_ABI_VERSION) #if VPX_ENCODER_ABI_VERSION > (4 + VPX_CODEC_ABI_VERSION)
vpx_svc_layer_id_t layer_id = {0, 0}; vpx_svc_layer_id_t layer_id = { 0, 0 };
#else #else
vpx_svc_layer_id_t layer_id = {0}; vpx_svc_layer_id_t layer_id = { 0 };
#endif #endif
const VpxInterface *encoder = NULL; const VpxInterface *encoder = NULL;
FILE *infile = NULL; FILE *infile = NULL;
@ -526,25 +524,28 @@ int main(int argc, char **argv) {
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
double sum_bitrate = 0.0; double sum_bitrate = 0.0;
double sum_bitrate2 = 0.0; double sum_bitrate2 = 0.0;
double framerate = 30.0; double framerate = 30.0;
exec_name = argv[0]; exec_name = argv[0];
// Check usage and arguments. // Check usage and arguments.
if (argc < min_args) { if (argc < min_args) {
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
die("Usage: %s <infile> <outfile> <codec_type(vp8/vp9)> <width> <height> " die(
"Usage: %s <infile> <outfile> <codec_type(vp8/vp9)> <width> <height> "
"<rate_num> <rate_den> <speed> <frame_drop_threshold> <mode> " "<rate_num> <rate_den> <speed> <frame_drop_threshold> <mode> "
"<Rate_0> ... <Rate_nlayers-1> <bit-depth> \n", argv[0]); "<Rate_0> ... <Rate_nlayers-1> <bit-depth> \n",
argv[0]);
#else #else
die("Usage: %s <infile> <outfile> <codec_type(vp8/vp9)> <width> <height> " die(
"Usage: %s <infile> <outfile> <codec_type(vp8/vp9)> <width> <height> "
"<rate_num> <rate_den> <speed> <frame_drop_threshold> <mode> " "<rate_num> <rate_den> <speed> <frame_drop_threshold> <mode> "
"<Rate_0> ... <Rate_nlayers-1> \n", argv[0]); "<Rate_0> ... <Rate_nlayers-1> \n",
argv[0]);
#endif // CONFIG_VP9_HIGHBITDEPTH #endif // CONFIG_VP9_HIGHBITDEPTH
} }
encoder = get_vpx_encoder_by_name(argv[3]); encoder = get_vpx_encoder_by_name(argv[3]);
if (!encoder) if (!encoder) die("Unsupported codec.");
die("Unsupported codec.");
printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface())); printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface()));
@ -564,7 +565,7 @@ int main(int argc, char **argv) {
} }
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
switch (strtol(argv[argc-1], NULL, 0)) { switch (strtol(argv[argc - 1], NULL, 0)) {
case 8: case 8:
bit_depth = VPX_BITS_8; bit_depth = VPX_BITS_8;
input_bit_depth = 8; input_bit_depth = 8;
@ -577,13 +578,11 @@ int main(int argc, char **argv) {
bit_depth = VPX_BITS_12; bit_depth = VPX_BITS_12;
input_bit_depth = 12; input_bit_depth = 12;
break; break;
default: default: die("Invalid bit depth (8, 10, 12) %s", argv[argc - 1]);
die("Invalid bit depth (8, 10, 12) %s", argv[argc-1]);
} }
if (!vpx_img_alloc(&raw, if (!vpx_img_alloc(
bit_depth == VPX_BITS_8 ? VPX_IMG_FMT_I420 : &raw, bit_depth == VPX_BITS_8 ? VPX_IMG_FMT_I420 : VPX_IMG_FMT_I42016,
VPX_IMG_FMT_I42016, width, height, 32)) {
width, height, 32)) {
die("Failed to allocate image", width, height); die("Failed to allocate image", width, height);
} }
#else #else
@ -621,8 +620,7 @@ int main(int argc, char **argv) {
} }
for (i = min_args_base; for (i = min_args_base;
(int)i < min_args_base + mode_to_num_layers[layering_mode]; (int)i < min_args_base + mode_to_num_layers[layering_mode]; ++i) {
++i) {
rc.layer_target_bitrate[i - 11] = strtol(argv[i], NULL, 0); rc.layer_target_bitrate[i - 11] = strtol(argv[i], NULL, 0);
if (strncmp(encoder->name, "vp8", 3) == 0) if (strncmp(encoder->name, "vp8", 3) == 0)
cfg.ts_target_bitrate[i - 11] = rc.layer_target_bitrate[i - 11]; cfg.ts_target_bitrate[i - 11] = rc.layer_target_bitrate[i - 11];
@ -635,8 +633,7 @@ int main(int argc, char **argv) {
cfg.rc_end_usage = VPX_CBR; cfg.rc_end_usage = VPX_CBR;
cfg.rc_min_quantizer = 2; cfg.rc_min_quantizer = 2;
cfg.rc_max_quantizer = 56; cfg.rc_max_quantizer = 56;
if (strncmp(encoder->name, "vp9", 3) == 0) if (strncmp(encoder->name, "vp9", 3) == 0) cfg.rc_max_quantizer = 52;
cfg.rc_max_quantizer = 52;
cfg.rc_undershoot_pct = 50; cfg.rc_undershoot_pct = 50;
cfg.rc_overshoot_pct = 50; cfg.rc_overshoot_pct = 50;
cfg.rc_buf_initial_sz = 500; cfg.rc_buf_initial_sz = 500;
@ -651,7 +648,7 @@ int main(int argc, char **argv) {
// Enable error resilient mode. // Enable error resilient mode.
cfg.g_error_resilient = 1; cfg.g_error_resilient = 1;
cfg.g_lag_in_frames = 0; cfg.g_lag_in_frames = 0;
cfg.kf_mode = VPX_KF_AUTO; cfg.kf_mode = VPX_KF_AUTO;
// Disable automatic keyframe placement. // Disable automatic keyframe placement.
@ -659,9 +656,7 @@ int main(int argc, char **argv) {
cfg.temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS; cfg.temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS;
set_temporal_layer_pattern(layering_mode, set_temporal_layer_pattern(layering_mode, &cfg, layer_flags,
&cfg,
layer_flags,
&flag_periodicity); &flag_periodicity);
set_rate_control_metrics(&rc, &cfg); set_rate_control_metrics(&rc, &cfg);
@ -688,15 +683,14 @@ int main(int argc, char **argv) {
snprintf(file_name, sizeof(file_name), "%s_%d.ivf", argv[2], i); snprintf(file_name, sizeof(file_name), "%s_%d.ivf", argv[2], i);
outfile[i] = vpx_video_writer_open(file_name, kContainerIVF, &info); outfile[i] = vpx_video_writer_open(file_name, kContainerIVF, &info);
if (!outfile[i]) if (!outfile[i]) die("Failed to open %s for writing", file_name);
die("Failed to open %s for writing", file_name);
assert(outfile[i] != NULL); assert(outfile[i] != NULL);
} }
// No spatial layers in this encoder. // No spatial layers in this encoder.
cfg.ss_number_layers = 1; cfg.ss_number_layers = 1;
// Initialize codec. // Initialize codec.
#if CONFIG_VP9_HIGHBITDEPTH #if CONFIG_VP9_HIGHBITDEPTH
if (vpx_codec_enc_init( if (vpx_codec_enc_init(
&codec, encoder->codec_interface(), &cfg, &codec, encoder->codec_interface(), &cfg,
@ -719,7 +713,7 @@ int main(int argc, char **argv) {
vpx_codec_control(&codec, VP8E_SET_STATIC_THRESHOLD, 1); vpx_codec_control(&codec, VP8E_SET_STATIC_THRESHOLD, 1);
vpx_codec_control(&codec, VP9E_SET_TUNE_CONTENT, 0); vpx_codec_control(&codec, VP9E_SET_TUNE_CONTENT, 0);
vpx_codec_control(&codec, VP9E_SET_TILE_COLUMNS, (cfg.g_threads >> 1)); vpx_codec_control(&codec, VP9E_SET_TILE_COLUMNS, (cfg.g_threads >> 1));
if (vpx_codec_control(&codec, VP9E_SET_SVC, layering_mode > 0 ? 1: 0)) if (vpx_codec_control(&codec, VP9E_SET_SVC, layering_mode > 0 ? 1 : 0))
die_codec(&codec, "Failed to set SVC"); die_codec(&codec, "Failed to set SVC");
for (i = 0; i < cfg.ts_number_layers; ++i) { for (i = 0; i < cfg.ts_number_layers; ++i) {
svc_params.max_quantizers[i] = cfg.rc_max_quantizer; svc_params.max_quantizers[i] = cfg.rc_max_quantizer;
@ -760,14 +754,12 @@ int main(int argc, char **argv) {
layer_id.temporal_layer_id); layer_id.temporal_layer_id);
} }
flags = layer_flags[frame_cnt % flag_periodicity]; flags = layer_flags[frame_cnt % flag_periodicity];
if (layering_mode == 0) if (layering_mode == 0) flags = 0;
flags = 0;
frame_avail = vpx_img_read(&raw, infile); frame_avail = vpx_img_read(&raw, infile);
if (frame_avail) if (frame_avail) ++rc.layer_input_frames[layer_id.temporal_layer_id];
++rc.layer_input_frames[layer_id.temporal_layer_id];
vpx_usec_timer_start(&timer); vpx_usec_timer_start(&timer);
if (vpx_codec_encode(&codec, frame_avail? &raw : NULL, pts, 1, flags, if (vpx_codec_encode(&codec, frame_avail ? &raw : NULL, pts, 1, flags,
VPX_DL_REALTIME)) { VPX_DL_REALTIME)) {
die_codec(&codec, "Failed to encode frame"); die_codec(&codec, "Failed to encode frame");
} }
vpx_usec_timer_mark(&timer); vpx_usec_timer_mark(&timer);
@ -777,12 +769,12 @@ int main(int argc, char **argv) {
layer_flags[0] &= ~VPX_EFLAG_FORCE_KF; layer_flags[0] &= ~VPX_EFLAG_FORCE_KF;
} }
got_data = 0; got_data = 0;
while ( (pkt = vpx_codec_get_cx_data(&codec, &iter)) ) { while ((pkt = vpx_codec_get_cx_data(&codec, &iter))) {
got_data = 1; got_data = 1;
switch (pkt->kind) { switch (pkt->kind) {
case VPX_CODEC_CX_FRAME_PKT: case VPX_CODEC_CX_FRAME_PKT:
for (i = cfg.ts_layer_id[frame_cnt % cfg.ts_periodicity]; for (i = cfg.ts_layer_id[frame_cnt % cfg.ts_periodicity];
i < cfg.ts_number_layers; ++i) { i < cfg.ts_number_layers; ++i) {
vpx_video_writer_write_frame(outfile[i], pkt->data.frame.buf, vpx_video_writer_write_frame(outfile[i], pkt->data.frame.buf,
pkt->data.frame.sz, pts); pkt->data.frame.sz, pts);
++rc.layer_tot_enc_frames[i]; ++rc.layer_tot_enc_frames[i];
@ -825,8 +817,7 @@ int main(int argc, char **argv) {
} }
} }
break; break;
default: default: break;
break;
} }
} }
++frame_cnt; ++frame_cnt;
@ -836,16 +827,13 @@ int main(int argc, char **argv) {
printout_rate_control_summary(&rc, &cfg, frame_cnt); printout_rate_control_summary(&rc, &cfg, frame_cnt);
printf("\n"); printf("\n");
printf("Frame cnt and encoding time/FPS stats for encoding: %d %f %f \n", printf("Frame cnt and encoding time/FPS stats for encoding: %d %f %f \n",
frame_cnt, frame_cnt, 1000 * (float)cx_time / (double)(frame_cnt * 1000000),
1000 * (float)cx_time / (double)(frame_cnt * 1000000), 1000000 * (double)frame_cnt / (double)cx_time);
1000000 * (double)frame_cnt / (double)cx_time);
if (vpx_codec_destroy(&codec)) if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec");
die_codec(&codec, "Failed to destroy codec");
// Try to rewrite the output file headers with the actual frame count. // Try to rewrite the output file headers with the actual frame count.
for (i = 0; i < cfg.ts_number_layers; ++i) for (i = 0; i < cfg.ts_number_layers; ++i) vpx_video_writer_close(outfile[i]);
vpx_video_writer_close(outfile[i]);
vpx_img_free(&raw); vpx_img_free(&raw);
return EXIT_SUCCESS; return EXIT_SUCCESS;