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 "./vpx_config.h"
21 #include "third_party/libyuv/include/libyuv/scale.h"
27 #include "vpx/vpx_decoder.h"
28 #include "vpx_ports/mem_ops.h"
29 #include "vpx_ports/vpx_timer.h"
31 #if CONFIG_VP8_DECODER || CONFIG_VP9_DECODER || CONFIG_VP10_DECODER
32 #include "vpx/vp8dx.h"
35 #include "./md5_utils.h"
37 #include "./tools_common.h"
39 #include "./webmdec.h"
43 static const char *exec_name
;
45 struct VpxDecInputContext
{
46 struct VpxInputContext
*vpx_input_ctx
;
47 struct WebmInputContext
*webm_ctx
;
50 static const arg_def_t looparg
= ARG_DEF(
51 NULL
, "loops", 1, "Number of times to decode the file");
52 static const arg_def_t codecarg
= ARG_DEF(
53 NULL
, "codec", 1, "Codec to use");
54 static const arg_def_t use_yv12
= ARG_DEF(
55 NULL
, "yv12", 0, "Output raw YV12 frames");
56 static const arg_def_t use_i420
= ARG_DEF(
57 NULL
, "i420", 0, "Output raw I420 frames");
58 static const arg_def_t flipuvarg
= ARG_DEF(
59 NULL
, "flipuv", 0, "Flip the chroma planes in the output");
60 static const arg_def_t rawvideo
= ARG_DEF(
61 NULL
, "rawvideo", 0, "Output raw YUV frames");
62 static const arg_def_t noblitarg
= ARG_DEF(
63 NULL
, "noblit", 0, "Don't process the decoded frames");
64 static const arg_def_t progressarg
= ARG_DEF(
65 NULL
, "progress", 0, "Show progress after each frame decodes");
66 static const arg_def_t limitarg
= ARG_DEF(
67 NULL
, "limit", 1, "Stop decoding after n frames");
68 static const arg_def_t skiparg
= ARG_DEF(
69 NULL
, "skip", 1, "Skip the first n input frames");
70 static const arg_def_t postprocarg
= ARG_DEF(
71 NULL
, "postproc", 0, "Postprocess decoded frames");
72 static const arg_def_t summaryarg
= ARG_DEF(
73 NULL
, "summary", 0, "Show timing summary");
74 static const arg_def_t outputfile
= ARG_DEF(
75 "o", "output", 1, "Output file name pattern (see below)");
76 static const arg_def_t threadsarg
= ARG_DEF(
77 "t", "threads", 1, "Max threads to use");
78 static const arg_def_t frameparallelarg
= ARG_DEF(
79 NULL
, "frame-parallel", 0, "Frame parallel decode");
80 static const arg_def_t verbosearg
= ARG_DEF(
81 "v", "verbose", 0, "Show version string");
82 static const arg_def_t error_concealment
= ARG_DEF(
83 NULL
, "error-concealment", 0, "Enable decoder error-concealment");
84 static const arg_def_t scalearg
= ARG_DEF(
85 "S", "scale", 0, "Scale output frames uniformly");
86 static const arg_def_t continuearg
= ARG_DEF(
87 "k", "keep-going", 0, "(debug) Continue decoding after error");
88 static const arg_def_t fb_arg
= ARG_DEF(
89 NULL
, "frame-buffers", 1, "Number of frame buffers to use");
90 static const arg_def_t md5arg
= ARG_DEF(
91 NULL
, "md5", 0, "Compute the MD5 sum of the decoded frame");
92 #if CONFIG_VP9_HIGHBITDEPTH
93 static const arg_def_t outbitdeptharg
= ARG_DEF(
94 NULL
, "output-bit-depth", 1, "Output bit-depth for decoded frames");
97 static const arg_def_t
*all_args
[] = {
98 &codecarg
, &use_yv12
, &use_i420
, &flipuvarg
, &rawvideo
, &noblitarg
,
99 &progressarg
, &limitarg
, &skiparg
, &postprocarg
, &summaryarg
, &outputfile
,
100 &threadsarg
, &frameparallelarg
, &verbosearg
, &scalearg
, &fb_arg
,
101 &md5arg
, &error_concealment
, &continuearg
,
102 #if CONFIG_VP9_HIGHBITDEPTH
108 #if CONFIG_VP8_DECODER
109 static const arg_def_t addnoise_level
= ARG_DEF(
110 NULL
, "noise-level", 1, "Enable VP8 postproc add noise");
111 static const arg_def_t deblock
= ARG_DEF(
112 NULL
, "deblock", 0, "Enable VP8 deblocking");
113 static const arg_def_t demacroblock_level
= ARG_DEF(
114 NULL
, "demacroblock-level", 1, "Enable VP8 demacroblocking, w/ level");
115 static const arg_def_t pp_debug_info
= ARG_DEF(
116 NULL
, "pp-debug-info", 1, "Enable VP8 visible debug info");
117 static const arg_def_t pp_disp_ref_frame
= ARG_DEF(
118 NULL
, "pp-dbg-ref-frame", 1,
119 "Display only selected reference frame per macro block");
120 static const arg_def_t pp_disp_mb_modes
= ARG_DEF(
121 NULL
, "pp-dbg-mb-modes", 1, "Display only selected macro block modes");
122 static const arg_def_t pp_disp_b_modes
= ARG_DEF(
123 NULL
, "pp-dbg-b-modes", 1, "Display only selected block modes");
124 static const arg_def_t pp_disp_mvs
= ARG_DEF(
125 NULL
, "pp-dbg-mvs", 1, "Draw only selected motion vectors");
126 static const arg_def_t mfqe
= ARG_DEF(
127 NULL
, "mfqe", 0, "Enable multiframe quality enhancement");
129 static const arg_def_t
*vp8_pp_args
[] = {
130 &addnoise_level
, &deblock
, &demacroblock_level
, &pp_debug_info
,
131 &pp_disp_ref_frame
, &pp_disp_mb_modes
, &pp_disp_b_modes
, &pp_disp_mvs
, &mfqe
,
137 static INLINE
int libyuv_scale(vpx_image_t
*src
, vpx_image_t
*dst
,
138 FilterModeEnum mode
) {
139 #if CONFIG_VP9_HIGHBITDEPTH
140 if (src
->fmt
== VPX_IMG_FMT_I42016
) {
141 assert(dst
->fmt
== VPX_IMG_FMT_I42016
);
142 return I420Scale_16((uint16_t*)src
->planes
[VPX_PLANE_Y
],
143 src
->stride
[VPX_PLANE_Y
]/2,
144 (uint16_t*)src
->planes
[VPX_PLANE_U
],
145 src
->stride
[VPX_PLANE_U
]/2,
146 (uint16_t*)src
->planes
[VPX_PLANE_V
],
147 src
->stride
[VPX_PLANE_V
]/2,
149 (uint16_t*)dst
->planes
[VPX_PLANE_Y
],
150 dst
->stride
[VPX_PLANE_Y
]/2,
151 (uint16_t*)dst
->planes
[VPX_PLANE_U
],
152 dst
->stride
[VPX_PLANE_U
]/2,
153 (uint16_t*)dst
->planes
[VPX_PLANE_V
],
154 dst
->stride
[VPX_PLANE_V
]/2,
159 assert(src
->fmt
== VPX_IMG_FMT_I420
);
160 assert(dst
->fmt
== VPX_IMG_FMT_I420
);
161 return I420Scale(src
->planes
[VPX_PLANE_Y
], src
->stride
[VPX_PLANE_Y
],
162 src
->planes
[VPX_PLANE_U
], src
->stride
[VPX_PLANE_U
],
163 src
->planes
[VPX_PLANE_V
], src
->stride
[VPX_PLANE_V
],
165 dst
->planes
[VPX_PLANE_Y
], dst
->stride
[VPX_PLANE_Y
],
166 dst
->planes
[VPX_PLANE_U
], dst
->stride
[VPX_PLANE_U
],
167 dst
->planes
[VPX_PLANE_V
], dst
->stride
[VPX_PLANE_V
],
173 void usage_exit(void) {
176 fprintf(stderr
, "Usage: %s <options> filename\n\n"
177 "Options:\n", exec_name
);
178 arg_show_usage(stderr
, all_args
);
179 #if CONFIG_VP8_DECODER
180 fprintf(stderr
, "\nVP8 Postprocessing Options:\n");
181 arg_show_usage(stderr
, vp8_pp_args
);
184 "\nOutput File Patterns:\n\n"
185 " The -o argument specifies the name of the file(s) to "
186 "write to. If the\n argument does not include any escape "
187 "characters, the output will be\n written to a single file. "
188 "Otherwise, the filename will be calculated by\n expanding "
189 "the following escape characters:\n");
191 "\n\t%%w - Frame width"
192 "\n\t%%h - Frame height"
193 "\n\t%%<n> - Frame number, zero padded to <n> places (1..9)"
194 "\n\n Pattern arguments are only supported in conjunction "
195 "with the --yv12 and\n --i420 options. If the -o option is "
196 "not specified, the output will be\n directed to stdout.\n"
198 fprintf(stderr
, "\nIncluded decoders:\n\n");
200 for (i
= 0; i
< get_vpx_decoder_count(); ++i
) {
201 const VpxInterface
*const decoder
= get_vpx_decoder_by_index(i
);
202 fprintf(stderr
, " %-6s - %s\n",
203 decoder
->name
, vpx_codec_iface_name(decoder
->codec_interface()));
209 static int raw_read_frame(FILE *infile
, uint8_t **buffer
,
210 size_t *bytes_read
, size_t *buffer_size
) {
211 char raw_hdr
[RAW_FRAME_HDR_SZ
];
212 size_t frame_size
= 0;
214 if (fread(raw_hdr
, RAW_FRAME_HDR_SZ
, 1, infile
) != 1) {
216 warn("Failed to read RAW frame size\n");
218 const size_t kCorruptFrameThreshold
= 256 * 1024 * 1024;
219 const size_t kFrameTooSmallThreshold
= 256 * 1024;
220 frame_size
= mem_get_le32(raw_hdr
);
222 if (frame_size
> kCorruptFrameThreshold
) {
223 warn("Read invalid frame size (%u)\n", (unsigned int)frame_size
);
227 if (frame_size
< kFrameTooSmallThreshold
) {
228 warn("Warning: Read invalid frame size (%u) - not a raw file?\n",
229 (unsigned int)frame_size
);
232 if (frame_size
> *buffer_size
) {
233 uint8_t *new_buf
= realloc(*buffer
, 2 * frame_size
);
236 *buffer_size
= 2 * frame_size
;
238 warn("Failed to allocate compressed data buffer\n");
245 if (fread(*buffer
, 1, frame_size
, infile
) != frame_size
) {
246 warn("Failed to read full frame\n");
249 *bytes_read
= frame_size
;
255 static int read_frame(struct VpxDecInputContext
*input
, uint8_t **buf
,
256 size_t *bytes_in_buffer
, size_t *buffer_size
) {
257 switch (input
->vpx_input_ctx
->file_type
) {
260 return webm_read_frame(input
->webm_ctx
, buf
, bytes_in_buffer
);
263 return raw_read_frame(input
->vpx_input_ctx
->file
,
264 buf
, bytes_in_buffer
, buffer_size
);
266 return ivf_read_frame(input
->vpx_input_ctx
->file
,
267 buf
, bytes_in_buffer
, buffer_size
);
273 static void update_image_md5(const vpx_image_t
*img
, const int planes
[3],
277 for (i
= 0; i
< 3; ++i
) {
278 const int plane
= planes
[i
];
279 const unsigned char *buf
= img
->planes
[plane
];
280 const int stride
= img
->stride
[plane
];
281 const int w
= vpx_img_plane_width(img
, plane
) *
282 ((img
->fmt
& VPX_IMG_FMT_HIGHBITDEPTH
) ? 2 : 1);
283 const int h
= vpx_img_plane_height(img
, plane
);
285 for (y
= 0; y
< h
; ++y
) {
286 MD5Update(md5
, buf
, w
);
292 static void write_image_file(const vpx_image_t
*img
, const int planes
[3],
295 #if CONFIG_VP9_HIGHBITDEPTH
296 const int bytes_per_sample
= ((img
->fmt
& VPX_IMG_FMT_HIGHBITDEPTH
) ? 2 : 1);
298 const int bytes_per_sample
= 1;
301 for (i
= 0; i
< 3; ++i
) {
302 const int plane
= planes
[i
];
303 const unsigned char *buf
= img
->planes
[plane
];
304 const int stride
= img
->stride
[plane
];
305 const int w
= vpx_img_plane_width(img
, plane
);
306 const int h
= vpx_img_plane_height(img
, plane
);
308 for (y
= 0; y
< h
; ++y
) {
309 fwrite(buf
, bytes_per_sample
, w
, file
);
315 static int file_is_raw(struct VpxInputContext
*input
) {
318 vpx_codec_stream_info_t si
;
322 if (fread(buf
, 1, 32, input
->file
) == 32) {
325 if (mem_get_le32(buf
) < 256 * 1024 * 1024) {
326 for (i
= 0; i
< get_vpx_decoder_count(); ++i
) {
327 const VpxInterface
*const decoder
= get_vpx_decoder_by_index(i
);
328 if (!vpx_codec_peek_stream_info(decoder
->codec_interface(),
329 buf
+ 4, 32 - 4, &si
)) {
331 input
->fourcc
= decoder
->fourcc
;
333 input
->height
= si
.h
;
334 input
->framerate
.numerator
= 30;
335 input
->framerate
.denominator
= 1;
346 static void show_progress(int frame_in
, int frame_out
, uint64_t dx_time
) {
348 "%d decoded frames/%d showed frames in %"PRId64
" us (%.2f fps)\r",
349 frame_in
, frame_out
, dx_time
,
350 (double)frame_out
* 1000000.0 / (double)dx_time
);
353 struct ExternalFrameBuffer
{
359 struct ExternalFrameBufferList
{
360 int num_external_frame_buffers
;
361 struct ExternalFrameBuffer
*ext_fb
;
364 // Callback used by libvpx to request an external frame buffer. |cb_priv|
365 // Application private data passed into the set function. |min_size| is the
366 // minimum size in bytes needed to decode the next frame. |fb| pointer to the
368 static int get_vp9_frame_buffer(void *cb_priv
, size_t min_size
,
369 vpx_codec_frame_buffer_t
*fb
) {
371 struct ExternalFrameBufferList
*const ext_fb_list
=
372 (struct ExternalFrameBufferList
*)cb_priv
;
373 if (ext_fb_list
== NULL
)
376 // Find a free frame buffer.
377 for (i
= 0; i
< ext_fb_list
->num_external_frame_buffers
; ++i
) {
378 if (!ext_fb_list
->ext_fb
[i
].in_use
)
382 if (i
== ext_fb_list
->num_external_frame_buffers
)
385 if (ext_fb_list
->ext_fb
[i
].size
< min_size
) {
386 free(ext_fb_list
->ext_fb
[i
].data
);
387 ext_fb_list
->ext_fb
[i
].data
= (uint8_t *)calloc(min_size
, sizeof(uint8_t));
388 if (!ext_fb_list
->ext_fb
[i
].data
)
391 ext_fb_list
->ext_fb
[i
].size
= min_size
;
394 fb
->data
= ext_fb_list
->ext_fb
[i
].data
;
395 fb
->size
= ext_fb_list
->ext_fb
[i
].size
;
396 ext_fb_list
->ext_fb
[i
].in_use
= 1;
398 // Set the frame buffer's private data to point at the external frame buffer.
399 fb
->priv
= &ext_fb_list
->ext_fb
[i
];
403 // Callback used by libvpx when there are no references to the frame buffer.
404 // |cb_priv| user private data passed into the set function. |fb| pointer
405 // to the frame buffer.
406 static int release_vp9_frame_buffer(void *cb_priv
,
407 vpx_codec_frame_buffer_t
*fb
) {
408 struct ExternalFrameBuffer
*const ext_fb
=
409 (struct ExternalFrameBuffer
*)fb
->priv
;
415 static void generate_filename(const char *pattern
, char *out
, size_t q_len
,
416 unsigned int d_w
, unsigned int d_h
,
417 unsigned int frame_in
) {
418 const char *p
= pattern
;
422 char *next_pat
= strchr(p
, '%');
427 /* parse the pattern */
431 snprintf(q
, q_len
- 1, "%d", d_w
);
434 snprintf(q
, q_len
- 1, "%d", d_h
);
437 snprintf(q
, q_len
- 1, "%d", frame_in
);
440 snprintf(q
, q_len
- 1, "%02d", frame_in
);
443 snprintf(q
, q_len
- 1, "%03d", frame_in
);
446 snprintf(q
, q_len
- 1, "%04d", frame_in
);
449 snprintf(q
, q_len
- 1, "%05d", frame_in
);
452 snprintf(q
, q_len
- 1, "%06d", frame_in
);
455 snprintf(q
, q_len
- 1, "%07d", frame_in
);
458 snprintf(q
, q_len
- 1, "%08d", frame_in
);
461 snprintf(q
, q_len
- 1, "%09d", frame_in
);
464 die("Unrecognized pattern %%%c\n", p
[1]);
469 if (pat_len
>= q_len
- 1)
470 die("Output filename too long.\n");
477 /* copy the next segment */
479 copy_len
= strlen(p
);
481 copy_len
= next_pat
- p
;
483 if (copy_len
>= q_len
- 1)
484 die("Output filename too long.\n");
486 memcpy(q
, p
, copy_len
);
495 static int is_single_file(const char *outfile_pattern
) {
496 const char *p
= outfile_pattern
;
500 if (p
&& p
[1] >= '1' && p
[1] <= '9')
501 return 0; // pattern contains sequence number, so it's not unique
509 static void print_md5(unsigned char digest
[16], const char *filename
) {
512 for (i
= 0; i
< 16; ++i
)
513 printf("%02x", digest
[i
]);
514 printf(" %s\n", filename
);
517 static FILE *open_outfile(const char *name
) {
518 if (strcmp("-", name
) == 0) {
519 set_binary_mode(stdout
);
522 FILE *file
= fopen(name
, "wb");
524 fatal("Failed to open output file '%s'", name
);
529 #if CONFIG_VP9_HIGHBITDEPTH
530 static int img_shifted_realloc_required(const vpx_image_t
*img
,
531 const vpx_image_t
*shifted
,
532 vpx_img_fmt_t required_fmt
) {
533 return img
->d_w
!= shifted
->d_w
||
534 img
->d_h
!= shifted
->d_h
||
535 required_fmt
!= shifted
->fmt
;
539 static int main_loop(int argc
, const char **argv_
) {
540 vpx_codec_ctx_t decoder
;
544 size_t bytes_in_buffer
= 0, buffer_size
= 0;
546 int frame_in
= 0, frame_out
= 0, flipuv
= 0, noblit
= 0;
547 int do_md5
= 0, progress
= 0, frame_parallel
= 0;
548 int stop_after
= 0, postproc
= 0, summary
= 0, quiet
= 1;
552 const VpxInterface
*interface
= NULL
;
553 const VpxInterface
*fourcc_interface
= NULL
;
554 uint64_t dx_time
= 0;
556 char **argv
, **argi
, **argj
;
562 vpx_codec_dec_cfg_t cfg
= {0, 0, 0};
563 #if CONFIG_VP9_HIGHBITDEPTH
564 unsigned int output_bit_depth
= 0;
566 #if CONFIG_VP8_DECODER
567 vp8_postproc_cfg_t vp8_pp_cfg
= {0};
568 int vp8_dbg_color_ref_frame
= 0;
569 int vp8_dbg_color_mb_modes
= 0;
570 int vp8_dbg_color_b_modes
= 0;
571 int vp8_dbg_display_mv
= 0;
573 int frames_corrupted
= 0;
576 vpx_image_t
*scaled_img
= NULL
;
577 #if CONFIG_VP9_HIGHBITDEPTH
578 vpx_image_t
*img_shifted
= NULL
;
580 int frame_avail
, got_data
, flush_decoder
= 0;
581 int num_external_frame_buffers
= 0;
582 struct ExternalFrameBufferList ext_fb_list
= {0, NULL
};
584 const char *outfile_pattern
= NULL
;
585 char outfile_name
[PATH_MAX
] = {0};
586 FILE *outfile
= NULL
;
589 unsigned char md5_digest
[16];
591 struct VpxDecInputContext input
= {NULL
, NULL
};
592 struct VpxInputContext vpx_input_ctx
;
594 struct WebmInputContext webm_ctx
;
595 memset(&(webm_ctx
), 0, sizeof(webm_ctx
));
596 input
.webm_ctx
= &webm_ctx
;
598 input
.vpx_input_ctx
= &vpx_input_ctx
;
600 /* Parse command line */
601 exec_name
= argv_
[0];
602 argv
= argv_dup(argc
- 1, argv_
+ 1);
604 for (argi
= argj
= argv
; (*argj
= *argi
); argi
+= arg
.argv_step
) {
605 memset(&arg
, 0, sizeof(arg
));
608 if (arg_match(&arg
, &codecarg
, argi
)) {
609 interface
= get_vpx_decoder_by_name(arg
.val
);
611 die("Error: Unrecognized argument (%s) to --codec\n", arg
.val
);
612 } else if (arg_match(&arg
, &looparg
, argi
)) {
614 } else if (arg_match(&arg
, &outputfile
, argi
))
615 outfile_pattern
= arg
.val
;
616 else if (arg_match(&arg
, &use_yv12
, argi
)) {
620 } else if (arg_match(&arg
, &use_i420
, argi
)) {
624 } else if (arg_match(&arg
, &rawvideo
, argi
)) {
626 } else if (arg_match(&arg
, &flipuvarg
, argi
))
628 else if (arg_match(&arg
, &noblitarg
, argi
))
630 else if (arg_match(&arg
, &progressarg
, argi
))
632 else if (arg_match(&arg
, &limitarg
, argi
))
633 stop_after
= arg_parse_uint(&arg
);
634 else if (arg_match(&arg
, &skiparg
, argi
))
635 arg_skip
= arg_parse_uint(&arg
);
636 else if (arg_match(&arg
, &postprocarg
, argi
))
638 else if (arg_match(&arg
, &md5arg
, argi
))
640 else if (arg_match(&arg
, &summaryarg
, argi
))
642 else if (arg_match(&arg
, &threadsarg
, argi
))
643 cfg
.threads
= arg_parse_uint(&arg
);
644 #if CONFIG_VP9_DECODER || CONFIG_VP10_DECODER
645 else if (arg_match(&arg
, &frameparallelarg
, argi
))
648 else if (arg_match(&arg
, &verbosearg
, argi
))
650 else if (arg_match(&arg
, &scalearg
, argi
))
652 else if (arg_match(&arg
, &fb_arg
, argi
))
653 num_external_frame_buffers
= arg_parse_uint(&arg
);
654 else if (arg_match(&arg
, &continuearg
, argi
))
656 #if CONFIG_VP9_HIGHBITDEPTH
657 else if (arg_match(&arg
, &outbitdeptharg
, argi
)) {
658 output_bit_depth
= arg_parse_uint(&arg
);
661 #if CONFIG_VP8_DECODER
662 else if (arg_match(&arg
, &addnoise_level
, argi
)) {
664 vp8_pp_cfg
.post_proc_flag
|= VP8_ADDNOISE
;
665 vp8_pp_cfg
.noise_level
= arg_parse_uint(&arg
);
666 } else if (arg_match(&arg
, &demacroblock_level
, argi
)) {
668 vp8_pp_cfg
.post_proc_flag
|= VP8_DEMACROBLOCK
;
669 vp8_pp_cfg
.deblocking_level
= arg_parse_uint(&arg
);
670 } else if (arg_match(&arg
, &deblock
, argi
)) {
672 vp8_pp_cfg
.post_proc_flag
|= VP8_DEBLOCK
;
673 } else if (arg_match(&arg
, &mfqe
, argi
)) {
675 vp8_pp_cfg
.post_proc_flag
|= VP8_MFQE
;
676 } else if (arg_match(&arg
, &pp_debug_info
, argi
)) {
677 unsigned int level
= arg_parse_uint(&arg
);
680 vp8_pp_cfg
.post_proc_flag
&= ~0x7;
683 vp8_pp_cfg
.post_proc_flag
|= level
;
684 } else if (arg_match(&arg
, &pp_disp_ref_frame
, argi
)) {
685 unsigned int flags
= arg_parse_int(&arg
);
688 vp8_dbg_color_ref_frame
= flags
;
690 } else if (arg_match(&arg
, &pp_disp_mb_modes
, argi
)) {
691 unsigned int flags
= arg_parse_int(&arg
);
694 vp8_dbg_color_mb_modes
= flags
;
696 } else if (arg_match(&arg
, &pp_disp_b_modes
, argi
)) {
697 unsigned int flags
= arg_parse_int(&arg
);
700 vp8_dbg_color_b_modes
= flags
;
702 } else if (arg_match(&arg
, &pp_disp_mvs
, argi
)) {
703 unsigned int flags
= arg_parse_int(&arg
);
706 vp8_dbg_display_mv
= flags
;
708 } else if (arg_match(&arg
, &error_concealment
, argi
)) {
711 #endif // CONFIG_VP8_DECODER
716 /* Check for unrecognized options */
717 for (argi
= argv
; *argi
; argi
++)
718 if (argi
[0][0] == '-' && strlen(argi
[0]) > 1)
719 die("Error: Unrecognized option %s\n", *argi
);
721 /* Handle non-option arguments */
729 infile
= strcmp(fn
, "-") ? fopen(fn
, "rb") : set_binary_mode(stdin
);
732 fatal("Failed to open input file '%s'", strcmp(fn
, "-") ? fn
: "stdin");
734 #if CONFIG_OS_SUPPORT
735 /* Make sure we don't dump to the terminal, unless forced to with -o - */
736 if (!outfile_pattern
&& isatty(fileno(stdout
)) && !do_md5
&& !noblit
) {
738 "Not dumping raw video to your terminal. Use '-o -' to "
743 input
.vpx_input_ctx
->file
= infile
;
744 if (file_is_ivf(input
.vpx_input_ctx
))
745 input
.vpx_input_ctx
->file_type
= FILE_TYPE_IVF
;
747 else if (file_is_webm(input
.webm_ctx
, input
.vpx_input_ctx
))
748 input
.vpx_input_ctx
->file_type
= FILE_TYPE_WEBM
;
750 else if (file_is_raw(input
.vpx_input_ctx
))
751 input
.vpx_input_ctx
->file_type
= FILE_TYPE_RAW
;
753 fprintf(stderr
, "Unrecognized input file type.\n");
755 fprintf(stderr
, "vpxdec was built without WebM container support.\n");
760 outfile_pattern
= outfile_pattern
? outfile_pattern
: "-";
761 single_file
= is_single_file(outfile_pattern
);
763 if (!noblit
&& single_file
) {
764 generate_filename(outfile_pattern
, outfile_name
, PATH_MAX
,
765 vpx_input_ctx
.width
, vpx_input_ctx
.height
, 0);
769 outfile
= open_outfile(outfile_name
);
772 if (use_y4m
&& !noblit
) {
774 fprintf(stderr
, "YUV4MPEG2 not supported with output patterns,"
775 " try --i420 or --yv12 or --rawvideo.\n");
780 if (vpx_input_ctx
.file_type
== FILE_TYPE_WEBM
) {
781 if (webm_guess_framerate(input
.webm_ctx
, input
.vpx_input_ctx
)) {
782 fprintf(stderr
, "Failed to guess framerate -- error parsing "
790 fourcc_interface
= get_vpx_decoder_by_fourcc(vpx_input_ctx
.fourcc
);
791 if (interface
&& fourcc_interface
&& interface
!= fourcc_interface
)
792 warn("Header indicates codec: %s\n", fourcc_interface
->name
);
794 interface
= fourcc_interface
;
797 interface
= get_vpx_decoder_by_index(0);
799 dec_flags
= (postproc
? VPX_CODEC_USE_POSTPROC
: 0) |
800 (ec_enabled
? VPX_CODEC_USE_ERROR_CONCEALMENT
: 0) |
801 (frame_parallel
? VPX_CODEC_USE_FRAME_THREADING
: 0);
802 if (vpx_codec_dec_init(&decoder
, interface
->codec_interface(),
804 fprintf(stderr
, "Failed to initialize decoder: %s\n",
805 vpx_codec_error(&decoder
));
810 fprintf(stderr
, "%s\n", decoder
.name
);
812 #if CONFIG_VP8_DECODER
813 if (vp8_pp_cfg
.post_proc_flag
814 && vpx_codec_control(&decoder
, VP8_SET_POSTPROC
, &vp8_pp_cfg
)) {
815 fprintf(stderr
, "Failed to configure postproc: %s\n",
816 vpx_codec_error(&decoder
));
820 if (vp8_dbg_color_ref_frame
821 && vpx_codec_control(&decoder
, VP8_SET_DBG_COLOR_REF_FRAME
,
822 vp8_dbg_color_ref_frame
)) {
823 fprintf(stderr
, "Failed to configure reference block visualizer: %s\n",
824 vpx_codec_error(&decoder
));
828 if (vp8_dbg_color_mb_modes
829 && vpx_codec_control(&decoder
, VP8_SET_DBG_COLOR_MB_MODES
,
830 vp8_dbg_color_mb_modes
)) {
831 fprintf(stderr
, "Failed to configure macro block visualizer: %s\n",
832 vpx_codec_error(&decoder
));
836 if (vp8_dbg_color_b_modes
837 && vpx_codec_control(&decoder
, VP8_SET_DBG_COLOR_B_MODES
,
838 vp8_dbg_color_b_modes
)) {
839 fprintf(stderr
, "Failed to configure block visualizer: %s\n",
840 vpx_codec_error(&decoder
));
844 if (vp8_dbg_display_mv
845 && vpx_codec_control(&decoder
, VP8_SET_DBG_DISPLAY_MV
,
846 vp8_dbg_display_mv
)) {
847 fprintf(stderr
, "Failed to configure motion vector visualizer: %s\n",
848 vpx_codec_error(&decoder
));
855 fprintf(stderr
, "Skipping first %d frames.\n", arg_skip
);
857 if (read_frame(&input
, &buf
, &bytes_in_buffer
, &buffer_size
))
862 if (num_external_frame_buffers
> 0) {
863 ext_fb_list
.num_external_frame_buffers
= num_external_frame_buffers
;
864 ext_fb_list
.ext_fb
= (struct ExternalFrameBuffer
*)calloc(
865 num_external_frame_buffers
, sizeof(*ext_fb_list
.ext_fb
));
866 if (vpx_codec_set_frame_buffer_functions(
867 &decoder
, get_vp9_frame_buffer
, release_vp9_frame_buffer
,
869 fprintf(stderr
, "Failed to configure external frame buffers: %s\n",
870 vpx_codec_error(&decoder
));
879 while (frame_avail
|| got_data
) {
880 vpx_codec_iter_t iter
= NULL
;
882 struct vpx_usec_timer timer
;
886 if (!stop_after
|| frame_in
< stop_after
) {
887 if (!read_frame(&input
, &buf
, &bytes_in_buffer
, &buffer_size
)) {
891 vpx_usec_timer_start(&timer
);
893 if (vpx_codec_decode(&decoder
, buf
, (unsigned int)bytes_in_buffer
,
895 const char *detail
= vpx_codec_error_detail(&decoder
);
896 warn("Failed to decode frame %d: %s",
897 frame_in
, vpx_codec_error(&decoder
));
900 warn("Additional information: %s", detail
);
905 vpx_usec_timer_mark(&timer
);
906 dx_time
+= vpx_usec_timer_elapsed(&timer
);
914 vpx_usec_timer_start(&timer
);
917 // Flush the decoder in frame parallel decode.
918 if (vpx_codec_decode(&decoder
, NULL
, 0, NULL
, 0)) {
919 warn("Failed to flush decoder: %s", vpx_codec_error(&decoder
));
924 if ((img
= vpx_codec_get_frame(&decoder
, &iter
))) {
929 vpx_usec_timer_mark(&timer
);
930 dx_time
+= (unsigned int)vpx_usec_timer_elapsed(&timer
);
932 if (!frame_parallel
&&
933 vpx_codec_control(&decoder
, VP8D_GET_FRAME_CORRUPTED
, &corrupted
)) {
934 warn("Failed VP8_GET_FRAME_CORRUPTED: %s", vpx_codec_error(&decoder
));
938 frames_corrupted
+= corrupted
;
941 show_progress(frame_in
, frame_out
, dx_time
);
943 if (!noblit
&& img
) {
944 const int PLANES_YUV
[] = {VPX_PLANE_Y
, VPX_PLANE_U
, VPX_PLANE_V
};
945 const int PLANES_YVU
[] = {VPX_PLANE_Y
, VPX_PLANE_V
, VPX_PLANE_U
};
946 const int *planes
= flipuv
? PLANES_YVU
: PLANES_YUV
;
949 if (frame_out
== 1) {
950 // If the output frames are to be scaled to a fixed display size then
951 // use the width and height specified in the container. If either of
952 // these is set to 0, use the display size set in the first frame
953 // header. If that is unavailable, use the raw decoded size of the
954 // first decoded frame.
955 int render_width
= vpx_input_ctx
.width
;
956 int render_height
= vpx_input_ctx
.height
;
957 if (!render_width
|| !render_height
) {
959 if (vpx_codec_control(&decoder
, VP9D_GET_DISPLAY_SIZE
,
961 // As last resort use size of first frame as display size.
962 render_width
= img
->d_w
;
963 render_height
= img
->d_h
;
965 render_width
= render_size
[0];
966 render_height
= render_size
[1];
969 scaled_img
= vpx_img_alloc(NULL
, img
->fmt
, render_width
,
971 scaled_img
->bit_depth
= img
->bit_depth
;
974 if (img
->d_w
!= scaled_img
->d_w
|| img
->d_h
!= scaled_img
->d_h
) {
976 libyuv_scale(img
, scaled_img
, kFilterBox
);
979 fprintf(stderr
, "Failed to scale output frame: %s.\n"
980 "Scaling is disabled in this configuration. "
981 "To enable scaling, configure with --enable-libyuv\n",
982 vpx_codec_error(&decoder
));
987 #if CONFIG_VP9_HIGHBITDEPTH
988 // Default to codec bit depth if output bit depth not set
989 if (!output_bit_depth
&& single_file
&& !do_md5
) {
990 output_bit_depth
= img
->bit_depth
;
992 // Shift up or down if necessary
993 if (output_bit_depth
!= 0 && output_bit_depth
!= img
->bit_depth
) {
994 const vpx_img_fmt_t shifted_fmt
= output_bit_depth
== 8 ?
995 img
->fmt
^ (img
->fmt
& VPX_IMG_FMT_HIGHBITDEPTH
) :
996 img
->fmt
| VPX_IMG_FMT_HIGHBITDEPTH
;
998 img_shifted_realloc_required(img
, img_shifted
, shifted_fmt
)) {
999 vpx_img_free(img_shifted
);
1003 img_shifted
= vpx_img_alloc(NULL
, shifted_fmt
,
1004 img
->d_w
, img
->d_h
, 16);
1005 img_shifted
->bit_depth
= output_bit_depth
;
1007 if (output_bit_depth
> img
->bit_depth
) {
1008 vpx_img_upshift(img_shifted
, img
,
1009 output_bit_depth
- img
->bit_depth
);
1011 vpx_img_downshift(img_shifted
, img
,
1012 img
->bit_depth
- output_bit_depth
);
1020 char buf
[Y4M_BUFFER_SIZE
] = {0};
1022 if (img
->fmt
== VPX_IMG_FMT_I440
|| img
->fmt
== VPX_IMG_FMT_I44016
) {
1023 fprintf(stderr
, "Cannot produce y4m output for 440 sampling.\n");
1026 if (frame_out
== 1) {
1028 len
= y4m_write_file_header(buf
, sizeof(buf
),
1029 vpx_input_ctx
.width
,
1030 vpx_input_ctx
.height
,
1031 &vpx_input_ctx
.framerate
,
1032 img
->fmt
, img
->bit_depth
);
1034 MD5Update(&md5_ctx
, (md5byte
*)buf
, (unsigned int)len
);
1036 fputs(buf
, outfile
);
1041 len
= y4m_write_frame_header(buf
, sizeof(buf
));
1043 MD5Update(&md5_ctx
, (md5byte
*)buf
, (unsigned int)len
);
1045 fputs(buf
, outfile
);
1048 if (frame_out
== 1) {
1049 // Check if --yv12 or --i420 options are consistent with the
1050 // bit-stream decoded
1052 if (img
->fmt
!= VPX_IMG_FMT_I420
&&
1053 img
->fmt
!= VPX_IMG_FMT_I42016
) {
1054 fprintf(stderr
, "Cannot produce i420 output for bit-stream.\n");
1059 if ((img
->fmt
!= VPX_IMG_FMT_I420
&&
1060 img
->fmt
!= VPX_IMG_FMT_YV12
) || img
->bit_depth
!= 8) {
1061 fprintf(stderr
, "Cannot produce yv12 output for bit-stream.\n");
1069 update_image_md5(img
, planes
, &md5_ctx
);
1071 write_image_file(img
, planes
, outfile
);
1074 generate_filename(outfile_pattern
, outfile_name
, PATH_MAX
,
1075 img
->d_w
, img
->d_h
, frame_in
);
1078 update_image_md5(img
, planes
, &md5_ctx
);
1079 MD5Final(md5_digest
, &md5_ctx
);
1080 print_md5(md5_digest
, outfile_name
);
1082 outfile
= open_outfile(outfile_name
);
1083 write_image_file(img
, planes
, outfile
);
1090 if (summary
|| progress
) {
1091 show_progress(frame_in
, frame_out
, dx_time
);
1092 fprintf(stderr
, "\n");
1095 if (frames_corrupted
)
1096 fprintf(stderr
, "WARNING: %d frames corrupted.\n", frames_corrupted
);
1100 if (vpx_codec_destroy(&decoder
)) {
1101 fprintf(stderr
, "Failed to destroy decoder: %s\n",
1102 vpx_codec_error(&decoder
));
1103 return EXIT_FAILURE
;
1106 if (!noblit
&& single_file
) {
1108 MD5Final(md5_digest
, &md5_ctx
);
1109 print_md5(md5_digest
, outfile_name
);
1116 if (input
.vpx_input_ctx
->file_type
== FILE_TYPE_WEBM
)
1117 webm_free(input
.webm_ctx
);
1120 if (input
.vpx_input_ctx
->file_type
!= FILE_TYPE_WEBM
)
1123 if (scaled_img
) vpx_img_free(scaled_img
);
1124 #if CONFIG_VP9_HIGHBITDEPTH
1125 if (img_shifted
) vpx_img_free(img_shifted
);
1128 for (i
= 0; i
< ext_fb_list
.num_external_frame_buffers
; ++i
) {
1129 free(ext_fb_list
.ext_fb
[i
].data
);
1131 free(ext_fb_list
.ext_fb
);
1136 return frames_corrupted
? EXIT_FAILURE
: EXIT_SUCCESS
;
1139 int main(int argc
, const char **argv_
) {
1140 unsigned int loops
= 1, i
;
1141 char **argv
, **argi
, **argj
;
1145 argv
= argv_dup(argc
- 1, argv_
+ 1);
1146 for (argi
= argj
= argv
; (*argj
= *argi
); argi
+= arg
.argv_step
) {
1147 memset(&arg
, 0, sizeof(arg
));
1150 if (arg_match(&arg
, &looparg
, argi
)) {
1151 loops
= arg_parse_uint(&arg
);
1156 for (i
= 0; !error
&& i
< loops
; i
++)
1157 error
= main_loop(argc
, argv_
);