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.
18 #include "third_party/libyuv/include/libyuv/scale.h"
23 #define VPX_CODEC_DISABLE_COMPAT 1
24 #include "./vpx_config.h"
25 #include "vpx/vpx_decoder.h"
26 #include "vpx_ports/mem_ops.h"
27 #include "vpx_ports/vpx_timer.h"
29 #if CONFIG_VP8_DECODER || CONFIG_VP9_DECODER
30 #include "vpx/vp8dx.h"
33 #include "./md5_utils.h"
35 #include "./tools_common.h"
36 #include "./webmdec.h"
39 static const char *exec_name
;
41 struct VpxDecInputContext
{
42 struct VpxInputContext
*vpx_input_ctx
;
43 struct WebmInputContext
*webm_ctx
;
46 static const arg_def_t looparg
= ARG_DEF(NULL
, "loops", 1,
47 "Number of times to decode the file");
48 static const arg_def_t codecarg
= ARG_DEF(NULL
, "codec", 1,
50 static const arg_def_t use_yv12
= ARG_DEF(NULL
, "yv12", 0,
51 "Output raw YV12 frames");
52 static const arg_def_t use_i420
= ARG_DEF(NULL
, "i420", 0,
53 "Output raw I420 frames");
54 static const arg_def_t flipuvarg
= ARG_DEF(NULL
, "flipuv", 0,
55 "Flip the chroma planes in the output");
56 static const arg_def_t noblitarg
= ARG_DEF(NULL
, "noblit", 0,
57 "Don't process the decoded frames");
58 static const arg_def_t progressarg
= ARG_DEF(NULL
, "progress", 0,
59 "Show progress after each frame decodes");
60 static const arg_def_t limitarg
= ARG_DEF(NULL
, "limit", 1,
61 "Stop decoding after n frames");
62 static const arg_def_t skiparg
= ARG_DEF(NULL
, "skip", 1,
63 "Skip the first n input frames");
64 static const arg_def_t postprocarg
= ARG_DEF(NULL
, "postproc", 0,
65 "Postprocess decoded frames");
66 static const arg_def_t summaryarg
= ARG_DEF(NULL
, "summary", 0,
67 "Show timing summary");
68 static const arg_def_t outputfile
= ARG_DEF("o", "output", 1,
69 "Output file name pattern (see below)");
70 static const arg_def_t threadsarg
= ARG_DEF("t", "threads", 1,
71 "Max threads to use");
72 static const arg_def_t verbosearg
= ARG_DEF("v", "verbose", 0,
73 "Show version string");
74 static const arg_def_t error_concealment
= ARG_DEF(NULL
, "error-concealment", 0,
75 "Enable decoder error-concealment");
76 static const arg_def_t scalearg
= ARG_DEF("S", "scale", 0,
77 "Scale output frames uniformly");
79 static const arg_def_t fb_arg
=
80 ARG_DEF(NULL
, "frame-buffers", 1, "Number of frame buffers to use");
82 static const arg_def_t md5arg
= ARG_DEF(NULL
, "md5", 0,
83 "Compute the MD5 sum of the decoded frame");
85 static const arg_def_t
*all_args
[] = {
86 &codecarg
, &use_yv12
, &use_i420
, &flipuvarg
, &noblitarg
,
87 &progressarg
, &limitarg
, &skiparg
, &postprocarg
, &summaryarg
, &outputfile
,
88 &threadsarg
, &verbosearg
, &scalearg
, &fb_arg
,
94 #if CONFIG_VP8_DECODER
95 static const arg_def_t addnoise_level
= ARG_DEF(NULL
, "noise-level", 1,
96 "Enable VP8 postproc add noise");
97 static const arg_def_t deblock
= ARG_DEF(NULL
, "deblock", 0,
98 "Enable VP8 deblocking");
99 static const arg_def_t demacroblock_level
= ARG_DEF(NULL
, "demacroblock-level", 1,
100 "Enable VP8 demacroblocking, w/ level");
101 static const arg_def_t pp_debug_info
= ARG_DEF(NULL
, "pp-debug-info", 1,
102 "Enable VP8 visible debug info");
103 static const arg_def_t pp_disp_ref_frame
= ARG_DEF(NULL
, "pp-dbg-ref-frame", 1,
104 "Display only selected reference frame per macro block");
105 static const arg_def_t pp_disp_mb_modes
= ARG_DEF(NULL
, "pp-dbg-mb-modes", 1,
106 "Display only selected macro block modes");
107 static const arg_def_t pp_disp_b_modes
= ARG_DEF(NULL
, "pp-dbg-b-modes", 1,
108 "Display only selected block modes");
109 static const arg_def_t pp_disp_mvs
= ARG_DEF(NULL
, "pp-dbg-mvs", 1,
110 "Draw only selected motion vectors");
111 static const arg_def_t mfqe
= ARG_DEF(NULL
, "mfqe", 0,
112 "Enable multiframe quality enhancement");
114 static const arg_def_t
*vp8_pp_args
[] = {
115 &addnoise_level
, &deblock
, &demacroblock_level
, &pp_debug_info
,
116 &pp_disp_ref_frame
, &pp_disp_mb_modes
, &pp_disp_b_modes
, &pp_disp_mvs
, &mfqe
,
121 static int vpx_image_scale(vpx_image_t
*src
, vpx_image_t
*dst
,
122 FilterModeEnum mode
) {
123 assert(src
->fmt
== VPX_IMG_FMT_I420
);
124 assert(dst
->fmt
== VPX_IMG_FMT_I420
);
125 return I420Scale(src
->planes
[VPX_PLANE_Y
], src
->stride
[VPX_PLANE_Y
],
126 src
->planes
[VPX_PLANE_U
], src
->stride
[VPX_PLANE_U
],
127 src
->planes
[VPX_PLANE_V
], src
->stride
[VPX_PLANE_V
],
129 dst
->planes
[VPX_PLANE_Y
], dst
->stride
[VPX_PLANE_Y
],
130 dst
->planes
[VPX_PLANE_U
], dst
->stride
[VPX_PLANE_U
],
131 dst
->planes
[VPX_PLANE_V
], dst
->stride
[VPX_PLANE_V
],
139 fprintf(stderr
, "Usage: %s <options> filename\n\n"
140 "Options:\n", exec_name
);
141 arg_show_usage(stderr
, all_args
);
142 #if CONFIG_VP8_DECODER
143 fprintf(stderr
, "\nVP8 Postprocessing Options:\n");
144 arg_show_usage(stderr
, vp8_pp_args
);
147 "\nOutput File Patterns:\n\n"
148 " The -o argument specifies the name of the file(s) to "
149 "write to. If the\n argument does not include any escape "
150 "characters, the output will be\n written to a single file. "
151 "Otherwise, the filename will be calculated by\n expanding "
152 "the following escape characters:\n");
154 "\n\t%%w - Frame width"
155 "\n\t%%h - Frame height"
156 "\n\t%%<n> - Frame number, zero padded to <n> places (1..9)"
157 "\n\n Pattern arguments are only supported in conjunction "
158 "with the --yv12 and\n --i420 options. If the -o option is "
159 "not specified, the output will be\n directed to stdout.\n"
161 fprintf(stderr
, "\nIncluded decoders:\n\n");
163 for (i
= 0; i
< get_vpx_decoder_count(); ++i
) {
164 const VpxInterface
*const decoder
= get_vpx_decoder_by_index(i
);
165 fprintf(stderr
, " %-6s - %s\n",
166 decoder
->name
, vpx_codec_iface_name(decoder
->interface()));
172 static int raw_read_frame(FILE *infile
, uint8_t **buffer
,
173 size_t *bytes_read
, size_t *buffer_size
) {
174 char raw_hdr
[RAW_FRAME_HDR_SZ
];
175 size_t frame_size
= 0;
177 if (fread(raw_hdr
, RAW_FRAME_HDR_SZ
, 1, infile
) != 1) {
179 warn("Failed to read RAW frame size\n");
181 const size_t kCorruptFrameThreshold
= 256 * 1024 * 1024;
182 const size_t kFrameTooSmallThreshold
= 256 * 1024;
183 frame_size
= mem_get_le32(raw_hdr
);
185 if (frame_size
> kCorruptFrameThreshold
) {
186 warn("Read invalid frame size (%u)\n", (unsigned int)frame_size
);
190 if (frame_size
< kFrameTooSmallThreshold
) {
191 warn("Warning: Read invalid frame size (%u) - not a raw file?\n",
192 (unsigned int)frame_size
);
195 if (frame_size
> *buffer_size
) {
196 uint8_t *new_buf
= realloc(*buffer
, 2 * frame_size
);
199 *buffer_size
= 2 * frame_size
;
201 warn("Failed to allocate compressed data buffer\n");
208 if (fread(*buffer
, 1, frame_size
, infile
) != frame_size
) {
209 warn("Failed to read full frame\n");
212 *bytes_read
= frame_size
;
218 static int read_frame(struct VpxDecInputContext
*input
, uint8_t **buf
,
219 size_t *bytes_in_buffer
, size_t *buffer_size
) {
220 switch (input
->vpx_input_ctx
->file_type
) {
223 return webm_read_frame(input
->webm_ctx
,
224 buf
, bytes_in_buffer
, buffer_size
);
227 return raw_read_frame(input
->vpx_input_ctx
->file
,
228 buf
, bytes_in_buffer
, buffer_size
);
230 return ivf_read_frame(input
->vpx_input_ctx
->file
,
231 buf
, bytes_in_buffer
, buffer_size
);
237 static void update_image_md5(const vpx_image_t
*img
, const int planes
[3],
241 for (i
= 0; i
< 3; ++i
) {
242 const int plane
= planes
[i
];
243 const unsigned char *buf
= img
->planes
[plane
];
244 const int stride
= img
->stride
[plane
];
245 const int w
= vpx_img_plane_width(img
, plane
);
246 const int h
= vpx_img_plane_height(img
, plane
);
248 for (y
= 0; y
< h
; ++y
) {
249 MD5Update(md5
, buf
, w
);
255 static void write_image_file(const vpx_image_t
*img
, const int planes
[3],
259 for (i
= 0; i
< 3; ++i
) {
260 const int plane
= planes
[i
];
261 const unsigned char *buf
= img
->planes
[plane
];
262 const int stride
= img
->stride
[plane
];
263 const int w
= vpx_img_plane_width(img
, plane
);
264 const int h
= vpx_img_plane_height(img
, plane
);
266 for (y
= 0; y
< h
; ++y
) {
267 fwrite(buf
, 1, w
, file
);
273 int file_is_raw(struct VpxInputContext
*input
) {
276 vpx_codec_stream_info_t si
;
280 if (fread(buf
, 1, 32, input
->file
) == 32) {
283 if (mem_get_le32(buf
) < 256 * 1024 * 1024) {
284 for (i
= 0; i
< get_vpx_decoder_count(); ++i
) {
285 const VpxInterface
*const decoder
= get_vpx_decoder_by_index(i
);
286 if (!vpx_codec_peek_stream_info(decoder
->interface(),
287 buf
+ 4, 32 - 4, &si
)) {
289 input
->fourcc
= decoder
->fourcc
;
291 input
->height
= si
.h
;
292 input
->framerate
.numerator
= 30;
293 input
->framerate
.denominator
= 1;
304 void show_progress(int frame_in
, int frame_out
, uint64_t dx_time
) {
306 "%d decoded frames/%d showed frames in %"PRId64
" us (%.2f fps)\r",
307 frame_in
, frame_out
, dx_time
,
308 (double)frame_out
* 1000000.0 / (double)dx_time
);
311 struct ExternalFrameBuffer
{
317 struct ExternalFrameBufferList
{
318 int num_external_frame_buffers
;
319 struct ExternalFrameBuffer
*ext_fb
;
322 // Callback used by libvpx to request an external frame buffer. |cb_priv|
323 // Application private data passed into the set function. |min_size| is the
324 // minimum size in bytes needed to decode the next frame. |fb| pointer to the
326 int get_vp9_frame_buffer(void *cb_priv
, size_t min_size
,
327 vpx_codec_frame_buffer_t
*fb
) {
329 struct ExternalFrameBufferList
*const ext_fb_list
=
330 (struct ExternalFrameBufferList
*)cb_priv
;
331 if (ext_fb_list
== NULL
)
334 // Find a free frame buffer.
335 for (i
= 0; i
< ext_fb_list
->num_external_frame_buffers
; ++i
) {
336 if (!ext_fb_list
->ext_fb
[i
].in_use
)
340 if (i
== ext_fb_list
->num_external_frame_buffers
)
343 if (ext_fb_list
->ext_fb
[i
].size
< min_size
) {
344 free(ext_fb_list
->ext_fb
[i
].data
);
345 ext_fb_list
->ext_fb
[i
].data
= (uint8_t *)malloc(min_size
);
346 if (!ext_fb_list
->ext_fb
[i
].data
)
349 ext_fb_list
->ext_fb
[i
].size
= min_size
;
352 fb
->data
= ext_fb_list
->ext_fb
[i
].data
;
353 fb
->size
= ext_fb_list
->ext_fb
[i
].size
;
354 ext_fb_list
->ext_fb
[i
].in_use
= 1;
356 // Set the frame buffer's private data to point at the external frame buffer.
357 fb
->priv
= &ext_fb_list
->ext_fb
[i
];
361 // Callback used by libvpx when there are no references to the frame buffer.
362 // |cb_priv| user private data passed into the set function. |fb| pointer
363 // to the frame buffer.
364 int release_vp9_frame_buffer(void *cb_priv
,
365 vpx_codec_frame_buffer_t
*fb
) {
366 struct ExternalFrameBuffer
*const ext_fb
=
367 (struct ExternalFrameBuffer
*)fb
->priv
;
373 void generate_filename(const char *pattern
, char *out
, size_t q_len
,
374 unsigned int d_w
, unsigned int d_h
,
375 unsigned int frame_in
) {
376 const char *p
= pattern
;
380 char *next_pat
= strchr(p
, '%');
385 /* parse the pattern */
389 snprintf(q
, q_len
- 1, "%d", d_w
);
392 snprintf(q
, q_len
- 1, "%d", d_h
);
395 snprintf(q
, q_len
- 1, "%d", frame_in
);
398 snprintf(q
, q_len
- 1, "%02d", frame_in
);
401 snprintf(q
, q_len
- 1, "%03d", frame_in
);
404 snprintf(q
, q_len
- 1, "%04d", frame_in
);
407 snprintf(q
, q_len
- 1, "%05d", frame_in
);
410 snprintf(q
, q_len
- 1, "%06d", frame_in
);
413 snprintf(q
, q_len
- 1, "%07d", frame_in
);
416 snprintf(q
, q_len
- 1, "%08d", frame_in
);
419 snprintf(q
, q_len
- 1, "%09d", frame_in
);
422 die("Unrecognized pattern %%%c\n", p
[1]);
426 if (pat_len
>= q_len
- 1)
427 die("Output filename too long.\n");
434 /* copy the next segment */
436 copy_len
= strlen(p
);
438 copy_len
= next_pat
- p
;
440 if (copy_len
>= q_len
- 1)
441 die("Output filename too long.\n");
443 memcpy(q
, p
, copy_len
);
452 static int is_single_file(const char *outfile_pattern
) {
453 const char *p
= outfile_pattern
;
457 if (p
&& p
[1] >= '1' && p
[1] <= '9')
458 return 0; // pattern contains sequence number, so it's not unique
466 static void print_md5(unsigned char digest
[16], const char *filename
) {
469 for (i
= 0; i
< 16; ++i
)
470 printf("%02x", digest
[i
]);
471 printf(" %s\n", filename
);
474 static FILE *open_outfile(const char *name
) {
475 if (strcmp("-", name
) == 0) {
476 set_binary_mode(stdout
);
479 FILE *file
= fopen(name
, "wb");
481 fatal("Failed to output file %s", name
);
486 int main_loop(int argc
, const char **argv_
) {
487 vpx_codec_ctx_t decoder
;
491 size_t bytes_in_buffer
= 0, buffer_size
= 0;
493 int frame_in
= 0, frame_out
= 0, flipuv
= 0, noblit
= 0;
494 int do_md5
= 0, progress
= 0;
495 int stop_after
= 0, postproc
= 0, summary
= 0, quiet
= 1;
498 const VpxInterface
*interface
= NULL
;
499 const VpxInterface
*fourcc_interface
= NULL
;
500 uint64_t dx_time
= 0;
502 char **argv
, **argi
, **argj
;
506 vpx_codec_dec_cfg_t cfg
= {0};
507 #if CONFIG_VP8_DECODER
508 vp8_postproc_cfg_t vp8_pp_cfg
= {0};
509 int vp8_dbg_color_ref_frame
= 0;
510 int vp8_dbg_color_mb_modes
= 0;
511 int vp8_dbg_color_b_modes
= 0;
512 int vp8_dbg_display_mv
= 0;
514 int frames_corrupted
= 0;
517 vpx_image_t
*scaled_img
= NULL
;
518 int frame_avail
, got_data
;
519 int num_external_frame_buffers
= 0;
520 struct ExternalFrameBufferList ext_fb_list
= {0};
522 const char *outfile_pattern
= NULL
;
523 char outfile_name
[PATH_MAX
] = {0};
524 FILE *outfile
= NULL
;
527 unsigned char md5_digest
[16];
529 struct VpxDecInputContext input
= {0};
530 struct VpxInputContext vpx_input_ctx
= {0};
531 struct WebmInputContext webm_ctx
= {0};
532 input
.vpx_input_ctx
= &vpx_input_ctx
;
533 input
.webm_ctx
= &webm_ctx
;
535 /* Parse command line */
536 exec_name
= argv_
[0];
537 argv
= argv_dup(argc
- 1, argv_
+ 1);
539 for (argi
= argj
= argv
; (*argj
= *argi
); argi
+= arg
.argv_step
) {
540 memset(&arg
, 0, sizeof(arg
));
543 if (arg_match(&arg
, &codecarg
, argi
)) {
544 interface
= get_vpx_decoder_by_name(arg
.val
);
546 die("Error: Unrecognized argument (%s) to --codec\n", arg
.val
);
547 } else if (arg_match(&arg
, &looparg
, argi
)) {
549 } else if (arg_match(&arg
, &outputfile
, argi
))
550 outfile_pattern
= arg
.val
;
551 else if (arg_match(&arg
, &use_yv12
, argi
)) {
554 } else if (arg_match(&arg
, &use_i420
, argi
)) {
557 } else if (arg_match(&arg
, &flipuvarg
, argi
))
559 else if (arg_match(&arg
, &noblitarg
, argi
))
561 else if (arg_match(&arg
, &progressarg
, argi
))
563 else if (arg_match(&arg
, &limitarg
, argi
))
564 stop_after
= arg_parse_uint(&arg
);
565 else if (arg_match(&arg
, &skiparg
, argi
))
566 arg_skip
= arg_parse_uint(&arg
);
567 else if (arg_match(&arg
, &postprocarg
, argi
))
569 else if (arg_match(&arg
, &md5arg
, argi
))
571 else if (arg_match(&arg
, &summaryarg
, argi
))
573 else if (arg_match(&arg
, &threadsarg
, argi
))
574 cfg
.threads
= arg_parse_uint(&arg
);
575 else if (arg_match(&arg
, &verbosearg
, argi
))
577 else if (arg_match(&arg
, &scalearg
, argi
))
579 else if (arg_match(&arg
, &fb_arg
, argi
))
580 num_external_frame_buffers
= arg_parse_uint(&arg
);
582 #if CONFIG_VP8_DECODER
583 else if (arg_match(&arg
, &addnoise_level
, argi
)) {
585 vp8_pp_cfg
.post_proc_flag
|= VP8_ADDNOISE
;
586 vp8_pp_cfg
.noise_level
= arg_parse_uint(&arg
);
587 } else if (arg_match(&arg
, &demacroblock_level
, argi
)) {
589 vp8_pp_cfg
.post_proc_flag
|= VP8_DEMACROBLOCK
;
590 vp8_pp_cfg
.deblocking_level
= arg_parse_uint(&arg
);
591 } else if (arg_match(&arg
, &deblock
, argi
)) {
593 vp8_pp_cfg
.post_proc_flag
|= VP8_DEBLOCK
;
594 } else if (arg_match(&arg
, &mfqe
, argi
)) {
596 vp8_pp_cfg
.post_proc_flag
|= VP8_MFQE
;
597 } else if (arg_match(&arg
, &pp_debug_info
, argi
)) {
598 unsigned int level
= arg_parse_uint(&arg
);
601 vp8_pp_cfg
.post_proc_flag
&= ~0x7;
604 vp8_pp_cfg
.post_proc_flag
|= level
;
605 } else if (arg_match(&arg
, &pp_disp_ref_frame
, argi
)) {
606 unsigned int flags
= arg_parse_int(&arg
);
609 vp8_dbg_color_ref_frame
= flags
;
611 } else if (arg_match(&arg
, &pp_disp_mb_modes
, argi
)) {
612 unsigned int flags
= arg_parse_int(&arg
);
615 vp8_dbg_color_mb_modes
= flags
;
617 } else if (arg_match(&arg
, &pp_disp_b_modes
, argi
)) {
618 unsigned int flags
= arg_parse_int(&arg
);
621 vp8_dbg_color_b_modes
= flags
;
623 } else if (arg_match(&arg
, &pp_disp_mvs
, argi
)) {
624 unsigned int flags
= arg_parse_int(&arg
);
627 vp8_dbg_display_mv
= flags
;
629 } else if (arg_match(&arg
, &error_concealment
, argi
)) {
638 /* Check for unrecognized options */
639 for (argi
= argv
; *argi
; argi
++)
640 if (argi
[0][0] == '-' && strlen(argi
[0]) > 1)
641 die("Error: Unrecognized option %s\n", *argi
);
643 /* Handle non-option arguments */
650 infile
= strcmp(fn
, "-") ? fopen(fn
, "rb") : set_binary_mode(stdin
);
653 fprintf(stderr
, "Failed to open file '%s'", strcmp(fn
, "-") ? fn
: "stdin");
656 #if CONFIG_OS_SUPPORT
657 /* Make sure we don't dump to the terminal, unless forced to with -o - */
658 if (!outfile_pattern
&& isatty(fileno(stdout
)) && !do_md5
&& !noblit
) {
660 "Not dumping raw video to your terminal. Use '-o -' to "
665 input
.vpx_input_ctx
->file
= infile
;
666 if (file_is_ivf(input
.vpx_input_ctx
))
667 input
.vpx_input_ctx
->file_type
= FILE_TYPE_IVF
;
669 else if (file_is_webm(input
.webm_ctx
, input
.vpx_input_ctx
))
670 input
.vpx_input_ctx
->file_type
= FILE_TYPE_WEBM
;
672 else if (file_is_raw(input
.vpx_input_ctx
))
673 input
.vpx_input_ctx
->file_type
= FILE_TYPE_RAW
;
675 fprintf(stderr
, "Unrecognized input file type.\n");
677 fprintf(stderr
, "vpxdec was built without WebM container support.\n");
682 outfile_pattern
= outfile_pattern
? outfile_pattern
: "-";
683 single_file
= is_single_file(outfile_pattern
);
685 if (!noblit
&& single_file
) {
686 generate_filename(outfile_pattern
, outfile_name
, PATH_MAX
,
687 vpx_input_ctx
.width
, vpx_input_ctx
.height
, 0);
691 outfile
= open_outfile(outfile_name
);
694 if (use_y4m
&& !noblit
) {
696 fprintf(stderr
, "YUV4MPEG2 not supported with output patterns,"
697 " try --i420 or --yv12.\n");
702 if (vpx_input_ctx
.file_type
== FILE_TYPE_WEBM
) {
703 if (webm_guess_framerate(input
.webm_ctx
, input
.vpx_input_ctx
)) {
704 fprintf(stderr
, "Failed to guess framerate -- error parsing "
712 fourcc_interface
= get_vpx_decoder_by_fourcc(vpx_input_ctx
.fourcc
);
713 if (interface
&& fourcc_interface
&& interface
!= fourcc_interface
)
714 warn("Header indicates codec: %s\n", fourcc_interface
->name
);
716 interface
= fourcc_interface
;
719 interface
= get_vpx_decoder_by_index(0);
721 dec_flags
= (postproc
? VPX_CODEC_USE_POSTPROC
: 0) |
722 (ec_enabled
? VPX_CODEC_USE_ERROR_CONCEALMENT
: 0);
723 if (vpx_codec_dec_init(&decoder
, interface
->interface(), &cfg
, dec_flags
)) {
724 fprintf(stderr
, "Failed to initialize decoder: %s\n",
725 vpx_codec_error(&decoder
));
730 fprintf(stderr
, "%s\n", decoder
.name
);
732 #if CONFIG_VP8_DECODER
734 if (vp8_pp_cfg
.post_proc_flag
735 && vpx_codec_control(&decoder
, VP8_SET_POSTPROC
, &vp8_pp_cfg
)) {
736 fprintf(stderr
, "Failed to configure postproc: %s\n", vpx_codec_error(&decoder
));
740 if (vp8_dbg_color_ref_frame
741 && vpx_codec_control(&decoder
, VP8_SET_DBG_COLOR_REF_FRAME
, vp8_dbg_color_ref_frame
)) {
742 fprintf(stderr
, "Failed to configure reference block visualizer: %s\n", vpx_codec_error(&decoder
));
746 if (vp8_dbg_color_mb_modes
747 && vpx_codec_control(&decoder
, VP8_SET_DBG_COLOR_MB_MODES
, vp8_dbg_color_mb_modes
)) {
748 fprintf(stderr
, "Failed to configure macro block visualizer: %s\n", vpx_codec_error(&decoder
));
752 if (vp8_dbg_color_b_modes
753 && vpx_codec_control(&decoder
, VP8_SET_DBG_COLOR_B_MODES
, vp8_dbg_color_b_modes
)) {
754 fprintf(stderr
, "Failed to configure block visualizer: %s\n", vpx_codec_error(&decoder
));
758 if (vp8_dbg_display_mv
759 && vpx_codec_control(&decoder
, VP8_SET_DBG_DISPLAY_MV
, vp8_dbg_display_mv
)) {
760 fprintf(stderr
, "Failed to configure motion vector visualizer: %s\n", vpx_codec_error(&decoder
));
767 fprintf(stderr
, "Skipping first %d frames.\n", arg_skip
);
769 if (read_frame(&input
, &buf
, &bytes_in_buffer
, &buffer_size
))
774 if (num_external_frame_buffers
> 0) {
775 ext_fb_list
.num_external_frame_buffers
= num_external_frame_buffers
;
776 ext_fb_list
.ext_fb
= (struct ExternalFrameBuffer
*)calloc(
777 num_external_frame_buffers
, sizeof(*ext_fb_list
.ext_fb
));
778 if (vpx_codec_set_frame_buffer_functions(
779 &decoder
, get_vp9_frame_buffer
, release_vp9_frame_buffer
,
781 fprintf(stderr
, "Failed to configure external frame buffers: %s\n",
782 vpx_codec_error(&decoder
));
791 while (frame_avail
|| got_data
) {
792 vpx_codec_iter_t iter
= NULL
;
794 struct vpx_usec_timer timer
;
798 if (!stop_after
|| frame_in
< stop_after
) {
799 if (!read_frame(&input
, &buf
, &bytes_in_buffer
, &buffer_size
)) {
803 vpx_usec_timer_start(&timer
);
805 if (vpx_codec_decode(&decoder
, buf
, (unsigned int)bytes_in_buffer
,
807 const char *detail
= vpx_codec_error_detail(&decoder
);
808 warn("Failed to decode frame %d: %s",
809 frame_in
, vpx_codec_error(&decoder
));
812 warn("Additional information: %s", detail
);
816 vpx_usec_timer_mark(&timer
);
817 dx_time
+= vpx_usec_timer_elapsed(&timer
);
821 vpx_usec_timer_start(&timer
);
824 if ((img
= vpx_codec_get_frame(&decoder
, &iter
))) {
829 vpx_usec_timer_mark(&timer
);
830 dx_time
+= (unsigned int)vpx_usec_timer_elapsed(&timer
);
832 if (vpx_codec_control(&decoder
, VP8D_GET_FRAME_CORRUPTED
, &corrupted
)) {
833 warn("Failed VP8_GET_FRAME_CORRUPTED: %s", vpx_codec_error(&decoder
));
836 frames_corrupted
+= corrupted
;
839 show_progress(frame_in
, frame_out
, dx_time
);
841 if (!noblit
&& img
) {
842 const int PLANES_YUV
[] = {VPX_PLANE_Y
, VPX_PLANE_U
, VPX_PLANE_V
};
843 const int PLANES_YVU
[] = {VPX_PLANE_Y
, VPX_PLANE_V
, VPX_PLANE_U
};
844 const int *planes
= flipuv
? PLANES_YVU
: PLANES_YUV
;
847 if (frame_out
== 1) {
848 // If the output frames are to be scaled to a fixed display size then
849 // use the width and height specified in the container. If either of
850 // these is set to 0, use the display size set in the first frame
851 // header. If that is unavailable, use the raw decoded size of the
852 // first decoded frame.
853 int display_width
= vpx_input_ctx
.width
;
854 int display_height
= vpx_input_ctx
.height
;
855 if (!display_width
|| !display_height
) {
857 if (vpx_codec_control(&decoder
, VP9D_GET_DISPLAY_SIZE
,
859 // As last resort use size of first frame as display size.
860 display_width
= img
->d_w
;
861 display_height
= img
->d_h
;
863 display_width
= display_size
[0];
864 display_height
= display_size
[1];
867 scaled_img
= vpx_img_alloc(NULL
, VPX_IMG_FMT_I420
, display_width
,
871 if (img
->d_w
!= scaled_img
->d_w
|| img
->d_h
!= scaled_img
->d_h
) {
872 vpx_image_scale(img
, scaled_img
, kFilterBox
);
879 char buf
[Y4M_BUFFER_SIZE
] = {0};
881 if (frame_out
== 1) {
883 len
= y4m_write_file_header(buf
, sizeof(buf
),
885 vpx_input_ctx
.height
,
886 &vpx_input_ctx
.framerate
, img
->fmt
);
888 MD5Update(&md5_ctx
, (md5byte
*)buf
, (unsigned int)len
);
895 len
= y4m_write_frame_header(buf
, sizeof(buf
));
897 MD5Update(&md5_ctx
, (md5byte
*)buf
, (unsigned int)len
);
904 update_image_md5(img
, planes
, &md5_ctx
);
906 write_image_file(img
, planes
, outfile
);
909 generate_filename(outfile_pattern
, outfile_name
, PATH_MAX
,
910 img
->d_w
, img
->d_h
, frame_in
);
913 update_image_md5(img
, planes
, &md5_ctx
);
914 MD5Final(md5_digest
, &md5_ctx
);
915 print_md5(md5_digest
, outfile_name
);
917 outfile
= open_outfile(outfile_name
);
918 write_image_file(img
, planes
, outfile
);
924 if (stop_after
&& frame_in
>= stop_after
)
928 if (summary
|| progress
) {
929 show_progress(frame_in
, frame_out
, dx_time
);
930 fprintf(stderr
, "\n");
933 if (frames_corrupted
)
934 fprintf(stderr
, "WARNING: %d frames corrupted.\n", frames_corrupted
);
938 if (vpx_codec_destroy(&decoder
)) {
939 fprintf(stderr
, "Failed to destroy decoder: %s\n",
940 vpx_codec_error(&decoder
));
944 if (!noblit
&& single_file
) {
946 MD5Final(md5_digest
, &md5_ctx
);
947 print_md5(md5_digest
, outfile_name
);
954 if (input
.vpx_input_ctx
->file_type
== FILE_TYPE_WEBM
)
955 webm_free(input
.webm_ctx
);
958 if (input
.vpx_input_ctx
->file_type
!= FILE_TYPE_WEBM
)
961 if (scaled_img
) vpx_img_free(scaled_img
);
963 for (i
= 0; i
< ext_fb_list
.num_external_frame_buffers
; ++i
) {
964 free(ext_fb_list
.ext_fb
[i
].data
);
966 free(ext_fb_list
.ext_fb
);
971 return frames_corrupted
? EXIT_FAILURE
: EXIT_SUCCESS
;
974 int main(int argc
, const char **argv_
) {
975 unsigned int loops
= 1, i
;
976 char **argv
, **argi
, **argj
;
980 argv
= argv_dup(argc
- 1, argv_
+ 1);
981 for (argi
= argj
= argv
; (*argj
= *argi
); argi
+= arg
.argv_step
) {
982 memset(&arg
, 0, sizeof(arg
));
985 if (arg_match(&arg
, &looparg
, argi
)) {
986 loops
= arg_parse_uint(&arg
);
991 for (i
= 0; !error
&& i
< loops
; i
++)
992 error
= main_loop(argc
, argv_
);