2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
13 * This is an example demonstrating how to implement a multi-layer VP8
14 * encoding scheme based on temporal scalability for video applications
15 * that benefit from a scalable bitstream.
21 #define VPX_CODEC_DISABLE_COMPAT 1
22 #include "vpx/vpx_encoder.h"
23 #include "vpx/vp8cx.h"
24 #define interface (vpx_codec_vp8_cx())
25 #define fourcc 0x30385056
27 #define IVF_FILE_HDR_SZ (32)
28 #define IVF_FRAME_HDR_SZ (12)
30 static void mem_put_le16(char *mem, unsigned int val) {
35 static void mem_put_le32(char *mem, unsigned int val) {
42 static void die(const char *fmt, ...) {
47 if(fmt[strlen(fmt)-1] != '\n')
52 static void die_codec(vpx_codec_ctx_t *ctx, const char *s) {
53 const char *detail = vpx_codec_error_detail(ctx);
55 printf("%s: %s\n", s, vpx_codec_error(ctx));
57 printf(" %s\n",detail);
61 static int read_frame(FILE *f, vpx_image_t *img) {
62 size_t nbytes, to_read;
65 to_read = img->w*img->h*3/2;
66 nbytes = fread(img->planes[0], 1, to_read, f);
67 if(nbytes != to_read) {
70 printf("Warning: Read partial frame. Check your width & height!\n");
75 static void write_ivf_file_header(FILE *outfile,
76 const vpx_codec_enc_cfg_t *cfg,
80 if(cfg->g_pass != VPX_RC_ONE_PASS && cfg->g_pass != VPX_RC_LAST_PASS)
86 mem_put_le16(header+4, 0); /* version */
87 mem_put_le16(header+6, 32); /* headersize */
88 mem_put_le32(header+8, fourcc); /* headersize */
89 mem_put_le16(header+12, cfg->g_w); /* width */
90 mem_put_le16(header+14, cfg->g_h); /* height */
91 mem_put_le32(header+16, cfg->g_timebase.den); /* rate */
92 mem_put_le32(header+20, cfg->g_timebase.num); /* scale */
93 mem_put_le32(header+24, frame_cnt); /* length */
94 mem_put_le32(header+28, 0); /* unused */
96 if(fwrite(header, 1, 32, outfile));
100 static void write_ivf_frame_header(FILE *outfile,
101 const vpx_codec_cx_pkt_t *pkt)
106 if(pkt->kind != VPX_CODEC_CX_FRAME_PKT)
109 pts = pkt->data.frame.pts;
110 mem_put_le32(header, pkt->data.frame.sz);
111 mem_put_le32(header+4, pts&0xFFFFFFFF);
112 mem_put_le32(header+8, pts >> 32);
114 if(fwrite(header, 1, 12, outfile));
117 static int mode_to_num_layers[7] = {2, 2, 3, 3, 3, 3, 5};
119 int main(int argc, char **argv) {
120 FILE *infile, *outfile[MAX_LAYERS];
121 vpx_codec_ctx_t codec;
122 vpx_codec_enc_cfg_t cfg;
133 int layering_mode = 0;
134 int frames_in_layer[MAX_LAYERS] = {0};
135 int layer_flags[MAX_PERIODICITY] = {0};
137 // Check usage and arguments
139 die("Usage: %s <infile> <outfile> <width> <height> <mode> "
140 "<Rate_0> ... <Rate_nlayers-1>\n", argv[0]);
142 width = strtol (argv[3], NULL, 0);
143 height = strtol (argv[4], NULL, 0);
144 if (width < 16 || width%2 || height <16 || height%2)
145 die ("Invalid resolution: %d x %d", width, height);
147 if (!sscanf(argv[5], "%d", &layering_mode))
148 die ("Invalid mode %s", argv[5]);
149 if (layering_mode<0 || layering_mode>6)
150 die ("Invalid mode (0..6) %s", argv[5]);
152 if (argc != 6+mode_to_num_layers[layering_mode])
153 die ("Invalid number of arguments");
155 if (!vpx_img_alloc (&raw, VPX_IMG_FMT_I420, width, height, 1))
156 die ("Failed to allocate image", width, height);
158 printf("Using %s\n",vpx_codec_iface_name(interface));
160 // Populate encoder configuration
161 res = vpx_codec_enc_config_default(interface, &cfg, 0);
163 printf("Failed to get config: %s\n", vpx_codec_err_to_string(res));
167 // Update the default configuration with our settings
171 for (i=6; i<6+mode_to_num_layers[layering_mode]; i++)
172 if (!sscanf(argv[i], "%d", &cfg.ts_target_bitrate[i-6]))
173 die ("Invalid data rate %s", argv[i]);
175 // Real time parameters
176 cfg.rc_dropframe_thresh = 0;
177 cfg.rc_end_usage = VPX_CBR;
178 cfg.rc_resize_allowed = 0;
179 cfg.rc_min_quantizer = 4;
180 cfg.rc_max_quantizer = 63;
181 cfg.rc_undershoot_pct = 98;
182 cfg.rc_overshoot_pct = 100;
183 cfg.rc_buf_initial_sz = 500;
184 cfg.rc_buf_optimal_sz = 600;
185 cfg.rc_buf_sz = 1000;
187 // Enable error resilient mode
188 cfg.g_error_resilient = 1;
189 cfg.g_lag_in_frames = 0;
190 cfg.kf_mode = VPX_KF_DISABLED;
192 // Disable automatic keyframe placement
193 cfg.kf_min_dist = cfg.kf_max_dist = 1000;
195 // Temporal scaling parameters:
196 // NOTE: The 3 prediction frames cannot be used interchangebly due to
197 // differences in the way they are handled throughout the code. The
198 // frames should be allocated to layers in the order LAST, GF, ARF.
199 // Other combinations work, but may produce slightly inferior results.
200 switch (layering_mode)
205 // 2-layers, 2-frame period
207 cfg.ts_number_layers = 2;
208 cfg.ts_periodicity = 2;
209 cfg.ts_rate_decimator[0] = 2;
210 cfg.ts_rate_decimator[1] = 1;
211 memcpy(cfg.ts_layer_id, ids, sizeof(ids));
213 // 0=L, 1=GF, Intra-layer prediction enabled
214 layer_flags[0] = VPX_EFLAG_FORCE_KF |
215 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
216 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF;
217 layer_flags[1] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
218 VP8_EFLAG_NO_REF_ARF;
220 // 0=L, 1=GF, Intra-layer 1 prediction disabled
221 layer_flags[0] = VPX_EFLAG_FORCE_KF |
222 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
223 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF;
224 layer_flags[1] = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST |
225 VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_LAST;
232 // 2-layers, 3-frame period
233 int ids[3] = {0,1,1};
234 cfg.ts_number_layers = 2;
235 cfg.ts_periodicity = 3;
236 cfg.ts_rate_decimator[0] = 3;
237 cfg.ts_rate_decimator[1] = 1;
238 memcpy(cfg.ts_layer_id, ids, sizeof(ids));
240 // 0=L, 1=GF, Intra-layer prediction enabled
241 layer_flags[0] = VPX_EFLAG_FORCE_KF |
242 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
243 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
245 layer_flags[2] = VP8_EFLAG_NO_REF_GF |
246 VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_ARF |
247 VP8_EFLAG_NO_UPD_LAST;
253 // 3-layers, 6-frame period
254 int ids[6] = {0,2,2,1,2,2};
255 cfg.ts_number_layers = 3;
256 cfg.ts_periodicity = 6;
257 cfg.ts_rate_decimator[0] = 6;
258 cfg.ts_rate_decimator[1] = 3;
259 cfg.ts_rate_decimator[2] = 1;
260 memcpy(cfg.ts_layer_id, ids, sizeof(ids));
262 // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled
263 layer_flags[0] = VPX_EFLAG_FORCE_KF |
264 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
265 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
266 layer_flags[3] = VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_ARF |
267 VP8_EFLAG_NO_UPD_LAST;
271 layer_flags[5] = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_LAST;
277 // 3-layers, 4-frame period
278 int ids[6] = {0,2,1,2};
279 cfg.ts_number_layers = 3;
280 cfg.ts_periodicity = 4;
281 cfg.ts_rate_decimator[0] = 4;
282 cfg.ts_rate_decimator[1] = 2;
283 cfg.ts_rate_decimator[2] = 1;
284 memcpy(cfg.ts_layer_id, ids, sizeof(ids));
286 // 0=L, 1=GF, 2=ARF, Intra-layer prediction disabled
287 layer_flags[0] = VPX_EFLAG_FORCE_KF |
288 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
289 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
290 layer_flags[2] = VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
291 VP8_EFLAG_NO_UPD_ARF |
292 VP8_EFLAG_NO_UPD_LAST;
294 layer_flags[3] = VP8_EFLAG_NO_REF_ARF |
295 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
296 VP8_EFLAG_NO_UPD_ARF;
298 cfg.ts_rate_decimator[2] = 1;
303 // 3-layers, 4-frame period
304 int ids[6] = {0,2,1,2};
305 cfg.ts_number_layers = 3;
306 cfg.ts_periodicity = 4;
307 cfg.ts_rate_decimator[0] = 4;
308 cfg.ts_rate_decimator[1] = 2;
309 cfg.ts_rate_decimator[2] = 1;
310 memcpy(cfg.ts_layer_id, ids, sizeof(ids));
312 // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled in layer 1,
313 // disabled in layer 2
314 layer_flags[0] = VPX_EFLAG_FORCE_KF |
315 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
316 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
317 layer_flags[2] = VP8_EFLAG_NO_REF_ARF |
318 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
320 layer_flags[3] = VP8_EFLAG_NO_REF_ARF |
321 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
322 VP8_EFLAG_NO_UPD_ARF;
328 // 3-layers, 4-frame period
329 int ids[6] = {0,2,1,2};
330 cfg.ts_number_layers = 3;
331 cfg.ts_periodicity = 4;
332 cfg.ts_rate_decimator[0] = 4;
333 cfg.ts_rate_decimator[1] = 2;
334 cfg.ts_rate_decimator[2] = 1;
335 memcpy(cfg.ts_layer_id, ids, sizeof(ids));
337 // 0=L, 1=GF, 2=ARF, Intra-layer prediction enabled
338 layer_flags[0] = VPX_EFLAG_FORCE_KF |
339 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
340 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
341 layer_flags[2] = VP8_EFLAG_NO_REF_ARF |
342 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF;
344 layer_flags[3] = VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
350 // NOTE: Probably of academic interest only
352 // 5-layers, 16-frame period
353 int ids[16] = {0,4,3,4,2,4,3,4,1,4,3,4,2,4,3,4};
354 cfg.ts_number_layers = 5;
355 cfg.ts_periodicity = 16;
356 cfg.ts_rate_decimator[0] = 16;
357 cfg.ts_rate_decimator[1] = 8;
358 cfg.ts_rate_decimator[2] = 4;
359 cfg.ts_rate_decimator[3] = 2;
360 cfg.ts_rate_decimator[4] = 1;
361 memcpy(cfg.ts_layer_id, ids, sizeof(ids));
363 layer_flags[0] = VPX_EFLAG_FORCE_KF;
371 layer_flags[15] = VP8_EFLAG_NO_UPD_LAST |
372 VP8_EFLAG_NO_UPD_GF |
373 VP8_EFLAG_NO_UPD_ARF |
374 VP8_EFLAG_NO_UPD_ENTROPY;
380 layer_flags[12] = VP8_EFLAG_NO_REF_LAST;
381 layer_flags[8] = VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF |
382 VP8_EFLAG_NO_UPD_ENTROPY;
391 if(!(infile = fopen(argv[1], "rb")))
392 die("Failed to open %s for reading", argv[1]);
394 // Open an output file for each stream
395 for (i=0; i<cfg.ts_number_layers; i++)
398 sprintf (file_name, "%s_%d.ivf", argv[2], i);
399 if (!(outfile[i] = fopen(file_name, "wb")))
400 die("Failed to open %s for writing", file_name);
401 write_ivf_file_header(outfile[i], &cfg, 0);
405 if (vpx_codec_enc_init (&codec, interface, &cfg, 0))
406 die_codec (&codec, "Failed to initialize encoder");
408 // Cap CPU & first I-frame size
409 vpx_codec_control (&codec, VP8E_SET_CPUUSED, -6);
410 vpx_codec_control (&codec, VP8E_SET_MAX_INTRA_BITRATE_PCT, 600);
413 while (frame_avail || got_data) {
414 vpx_codec_iter_t iter = NULL;
415 const vpx_codec_cx_pkt_t *pkt;
417 flags = layer_flags[frame_cnt % cfg.ts_periodicity];
419 frame_avail = read_frame(infile, &raw);
420 if (vpx_codec_encode(&codec, frame_avail? &raw : NULL, frame_cnt,
421 1, flags, VPX_DL_REALTIME))
422 die_codec(&codec, "Failed to encode frame");
425 layer_flags[0] &= ~VPX_EFLAG_FORCE_KF;
428 while ( (pkt = vpx_codec_get_cx_data(&codec, &iter)) ) {
431 case VPX_CODEC_CX_FRAME_PKT:
432 for (i=cfg.ts_layer_id[frame_cnt % cfg.ts_periodicity];
433 i<cfg.ts_number_layers; i++)
435 write_ivf_frame_header(outfile[i], pkt);
436 if (fwrite(pkt->data.frame.buf, 1, pkt->data.frame.sz,
438 frames_in_layer[i]++;
444 printf (pkt->kind == VPX_CODEC_CX_FRAME_PKT
445 && (pkt->data.frame.flags & VPX_FRAME_IS_KEY)? "K":".");
453 printf ("Processed %d frames.\n",frame_cnt-1);
454 if (vpx_codec_destroy(&codec))
455 die_codec (&codec, "Failed to destroy codec");
457 // Try to rewrite the output file headers with the actual frame count
458 for (i=0; i<cfg.ts_number_layers; i++)
460 if (!fseek(outfile[i], 0, SEEK_SET))
461 write_ivf_file_header (outfile[i], &cfg, frames_in_layer[i]);