ad252daf65
This patch enables ivfdec to decode WebM files. WebM demuxing is provided by the Matthew Gregan's Nestegg library. This patch also makes minor changes to the timebase->framerate handling when doing Y4M output. For WebM files, the framerate is guessed by looking at the first second of video. For IVF files, the timebase=1/(2*fps) hack is still in place, but is only used if the timebase denominator is less than 1000. This is in anticipation of change I8d25b5b, which introduces the distinction between framerate and timebase to ivfenc. In the case of high resolution timebases, like 100ns, we would have to guess the framerate like we do for WebM, but since WebM support in ivfenc will deprecate IVF output, we just assume 30fps rather than writing the lookahead code. Change-Id: I1dd8600f13bf6071533d2816f005da9ede4f60a2
867 lines
24 KiB
C
867 lines
24 KiB
C
/*
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
|
|
/* This is a simple program that reads ivf files and decodes them
|
|
* using the new interface. Decoded frames are output as YV12 raw.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#define VPX_CODEC_DISABLE_COMPAT 1
|
|
#include "vpx_config.h"
|
|
#include "vpx/vpx_decoder.h"
|
|
#include "vpx_ports/vpx_timer.h"
|
|
#if CONFIG_VP8_DECODER
|
|
#include "vpx/vp8dx.h"
|
|
#endif
|
|
#if CONFIG_MD5
|
|
#include "md5_utils.h"
|
|
#endif
|
|
#include "nestegg/include/nestegg/nestegg.h"
|
|
|
|
static const char *exec_name;
|
|
|
|
#define VP8_FOURCC (0x00385056)
|
|
static const struct
|
|
{
|
|
char const *name;
|
|
const vpx_codec_iface_t *iface;
|
|
unsigned int fourcc;
|
|
unsigned int fourcc_mask;
|
|
} ifaces[] =
|
|
{
|
|
#if CONFIG_VP8_DECODER
|
|
{"vp8", &vpx_codec_vp8_dx_algo, VP8_FOURCC, 0x00FFFFFF},
|
|
#endif
|
|
};
|
|
|
|
#include "args.h"
|
|
static const arg_def_t codecarg = ARG_DEF(NULL, "codec", 1,
|
|
"Codec to use");
|
|
static const arg_def_t prefixarg = ARG_DEF("p", "prefix", 1,
|
|
"Prefix to use when saving frames");
|
|
static const arg_def_t use_yv12 = ARG_DEF(NULL, "yv12", 0,
|
|
"Output file is YV12 ");
|
|
static const arg_def_t use_i420 = ARG_DEF(NULL, "i420", 0,
|
|
"Output file is I420 (default)");
|
|
static const arg_def_t flipuvarg = ARG_DEF(NULL, "flipuv", 0,
|
|
"Synonym for --yv12");
|
|
static const arg_def_t noblitarg = ARG_DEF(NULL, "noblit", 0,
|
|
"Don't process the decoded frames");
|
|
static const arg_def_t progressarg = ARG_DEF(NULL, "progress", 0,
|
|
"Show progress after each frame decodes");
|
|
static const arg_def_t limitarg = ARG_DEF(NULL, "limit", 1,
|
|
"Stop decoding after n frames");
|
|
static const arg_def_t postprocarg = ARG_DEF(NULL, "postproc", 0,
|
|
"Postprocess decoded frames");
|
|
static const arg_def_t summaryarg = ARG_DEF(NULL, "summary", 0,
|
|
"Show timing summary");
|
|
static const arg_def_t outputfile = ARG_DEF("o", "output", 1,
|
|
"Output raw yv12 file instead of images");
|
|
static const arg_def_t usey4marg = ARG_DEF("y", "y4m", 0,
|
|
"Output file is YUV4MPEG2");
|
|
static const arg_def_t threadsarg = ARG_DEF("t", "threads", 1,
|
|
"Max threads to use");
|
|
static const arg_def_t quietarg = ARG_DEF("q", "quiet", 0,
|
|
"Suppress version string");
|
|
|
|
#if CONFIG_MD5
|
|
static const arg_def_t md5arg = ARG_DEF(NULL, "md5", 0,
|
|
"Compute the MD5 sum of the decoded frame");
|
|
#endif
|
|
static const arg_def_t *all_args[] =
|
|
{
|
|
&codecarg, &prefixarg, &use_yv12, &use_i420, &flipuvarg, &noblitarg,
|
|
&progressarg, &limitarg, &postprocarg, &summaryarg, &outputfile,
|
|
&usey4marg, &threadsarg, &quietarg,
|
|
#if CONFIG_MD5
|
|
&md5arg,
|
|
#endif
|
|
NULL
|
|
};
|
|
|
|
#if CONFIG_VP8_DECODER
|
|
static const arg_def_t addnoise_level = ARG_DEF(NULL, "noise-level", 1,
|
|
"Enable VP8 postproc add noise");
|
|
static const arg_def_t deblock = ARG_DEF(NULL, "deblock", 0,
|
|
"Enable VP8 deblocking");
|
|
static const arg_def_t demacroblock_level = ARG_DEF(NULL, "demacroblock-level", 1,
|
|
"Enable VP8 demacroblocking, w/ level");
|
|
static const arg_def_t pp_debug_info = ARG_DEF(NULL, "pp-debug-info", 1,
|
|
"Enable VP8 visible debug info");
|
|
|
|
|
|
static const arg_def_t *vp8_pp_args[] =
|
|
{
|
|
&addnoise_level, &deblock, &demacroblock_level, &pp_debug_info,
|
|
NULL
|
|
};
|
|
#endif
|
|
|
|
static void usage_exit()
|
|
{
|
|
int i;
|
|
|
|
fprintf(stderr, "Usage: %s <options> filename\n\n"
|
|
"Options:\n", exec_name);
|
|
arg_show_usage(stderr, all_args);
|
|
#if CONFIG_VP8_DECODER
|
|
fprintf(stderr, "\nVP8 Postprocessing Options:\n");
|
|
arg_show_usage(stderr, vp8_pp_args);
|
|
#endif
|
|
fprintf(stderr, "\nIncluded decoders:\n\n");
|
|
|
|
for (i = 0; i < sizeof(ifaces) / sizeof(ifaces[0]); i++)
|
|
fprintf(stderr, " %-6s - %s\n",
|
|
ifaces[i].name,
|
|
vpx_codec_iface_name(ifaces[i].iface));
|
|
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
void die(const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
vfprintf(stderr, fmt, ap);
|
|
fprintf(stderr, "\n");
|
|
usage_exit();
|
|
}
|
|
|
|
static unsigned int mem_get_le16(const void *vmem)
|
|
{
|
|
unsigned int val;
|
|
const unsigned char *mem = (const unsigned char *)vmem;
|
|
|
|
val = mem[1] << 8;
|
|
val |= mem[0];
|
|
return val;
|
|
}
|
|
|
|
static unsigned int mem_get_le32(const void *vmem)
|
|
{
|
|
unsigned int val;
|
|
const unsigned char *mem = (const unsigned char *)vmem;
|
|
|
|
val = mem[3] << 24;
|
|
val |= mem[2] << 16;
|
|
val |= mem[1] << 8;
|
|
val |= mem[0];
|
|
return val;
|
|
}
|
|
|
|
enum file_kind
|
|
{
|
|
RAW_FILE,
|
|
IVF_FILE,
|
|
WEBM_FILE
|
|
};
|
|
|
|
struct input_ctx
|
|
{
|
|
enum file_kind kind;
|
|
FILE *infile;
|
|
nestegg *nestegg_ctx;
|
|
nestegg_packet *pkt;
|
|
unsigned int chunk;
|
|
unsigned int chunks;
|
|
unsigned int video_track;
|
|
};
|
|
|
|
#define IVF_FRAME_HDR_SZ (sizeof(uint32_t) + sizeof(uint64_t))
|
|
#define RAW_FRAME_HDR_SZ (sizeof(uint32_t))
|
|
static int read_frame(struct input_ctx *input,
|
|
uint8_t **buf,
|
|
size_t *buf_sz,
|
|
size_t *buf_alloc_sz)
|
|
{
|
|
char raw_hdr[IVF_FRAME_HDR_SZ];
|
|
size_t new_buf_sz;
|
|
FILE *infile = input->infile;
|
|
enum file_kind kind = input->kind;
|
|
if(kind == WEBM_FILE)
|
|
{
|
|
if(input->chunk >= input->chunks)
|
|
{
|
|
unsigned int track;
|
|
|
|
do
|
|
{
|
|
/* End of this packet, get another. */
|
|
if(input->pkt)
|
|
nestegg_free_packet(input->pkt);
|
|
|
|
if(nestegg_read_packet(input->nestegg_ctx, &input->pkt) <= 0
|
|
|| nestegg_packet_track(input->pkt, &track))
|
|
return 1;
|
|
|
|
} while(track != input->video_track);
|
|
|
|
if(nestegg_packet_count(input->pkt, &input->chunks))
|
|
return 1;
|
|
input->chunk = 0;
|
|
}
|
|
|
|
if(nestegg_packet_data(input->pkt, input->chunk, buf, buf_sz))
|
|
return 1;
|
|
input->chunk++;
|
|
|
|
return 0;
|
|
}
|
|
/* For both the raw and ivf formats, the frame size is the first 4 bytes
|
|
* of the frame header. We just need to special case on the header
|
|
* size.
|
|
*/
|
|
else if (fread(raw_hdr, kind==IVF_FILE
|
|
? IVF_FRAME_HDR_SZ : RAW_FRAME_HDR_SZ, 1, infile) != 1)
|
|
{
|
|
if (!feof(infile))
|
|
fprintf(stderr, "Failed to read frame size\n");
|
|
|
|
new_buf_sz = 0;
|
|
}
|
|
else
|
|
{
|
|
new_buf_sz = mem_get_le32(raw_hdr);
|
|
|
|
if (new_buf_sz > 256 * 1024 * 1024)
|
|
{
|
|
fprintf(stderr, "Error: Read invalid frame size (%u)\n",
|
|
(unsigned int)new_buf_sz);
|
|
new_buf_sz = 0;
|
|
}
|
|
|
|
if (kind == RAW_FILE && new_buf_sz > 256 * 1024)
|
|
fprintf(stderr, "Warning: Read invalid frame size (%u)"
|
|
" - not a raw file?\n", (unsigned int)new_buf_sz);
|
|
|
|
if (new_buf_sz > *buf_alloc_sz)
|
|
{
|
|
uint8_t *new_buf = realloc(*buf, 2 * new_buf_sz);
|
|
|
|
if (new_buf)
|
|
{
|
|
*buf = new_buf;
|
|
*buf_alloc_sz = 2 * new_buf_sz;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Failed to allocate compressed data buffer\n");
|
|
new_buf_sz = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
*buf_sz = new_buf_sz;
|
|
|
|
if (*buf_sz)
|
|
{
|
|
if (fread(*buf, 1, *buf_sz, infile) != *buf_sz)
|
|
{
|
|
fprintf(stderr, "Failed to read full frame\n");
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
void *out_open(const char *out_fn, int do_md5)
|
|
{
|
|
void *out = NULL;
|
|
|
|
if (do_md5)
|
|
{
|
|
#if CONFIG_MD5
|
|
MD5Context *md5_ctx = out = malloc(sizeof(MD5Context));
|
|
(void)out_fn;
|
|
MD5Init(md5_ctx);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
FILE *outfile = out = strcmp("-", out_fn) ? fopen(out_fn, "wb") : stdout;
|
|
|
|
if (!outfile)
|
|
{
|
|
fprintf(stderr, "Failed to output file");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
void out_put(void *out, const uint8_t *buf, unsigned int len, int do_md5)
|
|
{
|
|
if (do_md5)
|
|
{
|
|
#if CONFIG_MD5
|
|
MD5Update(out, buf, len);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
fwrite(buf, 1, len, out);
|
|
}
|
|
}
|
|
|
|
void out_close(void *out, const char *out_fn, int do_md5)
|
|
{
|
|
if (do_md5)
|
|
{
|
|
#if CONFIG_MD5
|
|
uint8_t md5[16];
|
|
int i;
|
|
|
|
MD5Final(md5, out);
|
|
free(out);
|
|
|
|
for (i = 0; i < 16; i++)
|
|
printf("%02x", md5[i]);
|
|
|
|
printf(" %s\n", out_fn);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
fclose(out);
|
|
}
|
|
}
|
|
|
|
unsigned int file_is_ivf(FILE *infile,
|
|
unsigned int *fourcc,
|
|
unsigned int *width,
|
|
unsigned int *height,
|
|
unsigned int *fps_den,
|
|
unsigned int *fps_num)
|
|
{
|
|
char raw_hdr[32];
|
|
int is_ivf = 0;
|
|
|
|
if (fread(raw_hdr, 1, 32, infile) == 32)
|
|
{
|
|
if (raw_hdr[0] == 'D' && raw_hdr[1] == 'K'
|
|
&& raw_hdr[2] == 'I' && raw_hdr[3] == 'F')
|
|
{
|
|
is_ivf = 1;
|
|
|
|
if (mem_get_le16(raw_hdr + 4) != 0)
|
|
fprintf(stderr, "Error: Unrecognized IVF version! This file may not"
|
|
" decode properly.");
|
|
|
|
*fourcc = mem_get_le32(raw_hdr + 8);
|
|
*width = mem_get_le16(raw_hdr + 12);
|
|
*height = mem_get_le16(raw_hdr + 14);
|
|
*fps_num = mem_get_le32(raw_hdr + 16);
|
|
*fps_den = mem_get_le32(raw_hdr + 20);
|
|
|
|
/* Some versions of ivfenc used 1/(2*fps) for the timebase, so
|
|
* we can guess the framerate using only the timebase in this
|
|
* case. Other files would require reading ahead to guess the
|
|
* timebase, like we do for webm.
|
|
*/
|
|
if(*fps_num < 1000)
|
|
{
|
|
/* Correct for the factor of 2 applied to the timebase in the
|
|
* encoder.
|
|
*/
|
|
if(*fps_num&1)*fps_den<<=1;
|
|
else *fps_num>>=1;
|
|
}
|
|
else
|
|
{
|
|
/* Don't know FPS for sure, and don't have readahead code
|
|
* (yet?), so just default to 30fps.
|
|
*/
|
|
*fps_num = 30;
|
|
*fps_den = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!is_ivf)
|
|
rewind(infile);
|
|
|
|
return is_ivf;
|
|
}
|
|
|
|
|
|
static int
|
|
nestegg_read_cb(void *buffer, size_t length, void *userdata)
|
|
{
|
|
FILE *f = userdata;
|
|
|
|
fread(buffer, 1, length, f);
|
|
if (ferror(f))
|
|
return -1;
|
|
if (feof(f))
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int
|
|
nestegg_seek_cb(int64_t offset, int whence, void * userdata)
|
|
{
|
|
switch(whence) {
|
|
case NESTEGG_SEEK_SET: whence = SEEK_SET; break;
|
|
case NESTEGG_SEEK_CUR: whence = SEEK_CUR; break;
|
|
case NESTEGG_SEEK_END: whence = SEEK_END; break;
|
|
};
|
|
return fseek(userdata, offset, whence)? -1 : 0;
|
|
}
|
|
|
|
|
|
static int64_t
|
|
nestegg_tell_cb(void * userdata)
|
|
{
|
|
return ftell(userdata);
|
|
}
|
|
|
|
|
|
static void
|
|
nestegg_log_cb(nestegg * context, unsigned int severity, char const * format,
|
|
...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
vfprintf(stderr, format, ap);
|
|
fprintf(stderr, "\n");
|
|
va_end(ap);
|
|
}
|
|
|
|
|
|
static int
|
|
webm_guess_framerate(struct input_ctx *input,
|
|
unsigned int *fps_den,
|
|
unsigned int *fps_num)
|
|
{
|
|
unsigned int i;
|
|
uint64_t tstamp=0;
|
|
|
|
/* Guess the framerate. Read up to 1 second, or 50 video packets,
|
|
* whichever comes first.
|
|
*/
|
|
for(i=0; tstamp < 1000000000 && i < 50;)
|
|
{
|
|
nestegg_packet * pkt;
|
|
unsigned int track;
|
|
|
|
if(nestegg_read_packet(input->nestegg_ctx, &pkt) <= 0)
|
|
break;
|
|
|
|
nestegg_packet_track(pkt, &track);
|
|
if(track == input->video_track)
|
|
{
|
|
nestegg_packet_tstamp(pkt, &tstamp);
|
|
i++;
|
|
}
|
|
|
|
nestegg_free_packet(pkt);
|
|
}
|
|
|
|
if(nestegg_track_seek(input->nestegg_ctx, input->video_track, 0))
|
|
goto fail;
|
|
|
|
*fps_num = (i - 1) * 1000000;
|
|
*fps_den = tstamp / 1000;
|
|
return 0;
|
|
fail:
|
|
input->nestegg_ctx = NULL;
|
|
rewind(input->infile);
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int
|
|
file_is_webm(struct input_ctx *input,
|
|
unsigned int *fourcc,
|
|
unsigned int *width,
|
|
unsigned int *height,
|
|
unsigned int *fps_den,
|
|
unsigned int *fps_num)
|
|
{
|
|
unsigned int i, n;
|
|
int track_type = -1;
|
|
uint64_t tstamp=0;
|
|
|
|
nestegg_io io = {nestegg_read_cb, nestegg_seek_cb, nestegg_tell_cb,
|
|
input->infile};
|
|
nestegg_video_params params;
|
|
nestegg_packet * pkt;
|
|
|
|
if(nestegg_init(&input->nestegg_ctx, io, NULL))
|
|
goto fail;
|
|
|
|
if(nestegg_track_count(input->nestegg_ctx, &n))
|
|
goto fail;
|
|
|
|
for(i=0; i<n; i++)
|
|
{
|
|
track_type = nestegg_track_type(input->nestegg_ctx, i);
|
|
|
|
if(track_type == NESTEGG_TRACK_VIDEO)
|
|
break;
|
|
else if(track_type < 0)
|
|
goto fail;
|
|
}
|
|
|
|
if(nestegg_track_codec_id(input->nestegg_ctx, i) != NESTEGG_CODEC_VP8)
|
|
{
|
|
fprintf(stderr, "Not VP8 video, quitting.\n");
|
|
exit(1);
|
|
}
|
|
|
|
input->video_track = i;
|
|
|
|
if(nestegg_track_video_params(input->nestegg_ctx, i, ¶ms))
|
|
goto fail;
|
|
|
|
*fps_den = 0;
|
|
*fps_num = 0;
|
|
*fourcc = VP8_FOURCC;
|
|
*width = params.width;
|
|
*height = params.height;
|
|
return 1;
|
|
fail:
|
|
input->nestegg_ctx = NULL;
|
|
rewind(input->infile);
|
|
return 0;
|
|
}
|
|
|
|
int main(int argc, const char **argv_)
|
|
{
|
|
vpx_codec_ctx_t decoder;
|
|
char *prefix = NULL, *fn = NULL;
|
|
int i;
|
|
uint8_t *buf = NULL;
|
|
size_t buf_sz = 0, buf_alloc_sz = 0;
|
|
FILE *infile;
|
|
int frame_in = 0, frame_out = 0, flipuv = 0, noblit = 0, do_md5 = 0, progress = 0;
|
|
int stop_after = 0, postproc = 0, summary = 0, quiet = 0;
|
|
vpx_codec_iface_t *iface = NULL;
|
|
unsigned int fourcc;
|
|
unsigned long dx_time = 0;
|
|
struct arg arg;
|
|
char **argv, **argi, **argj;
|
|
const char *fn2 = 0;
|
|
int use_y4m = 0;
|
|
unsigned int width;
|
|
unsigned int height;
|
|
unsigned int fps_den;
|
|
unsigned int fps_num;
|
|
void *out = NULL;
|
|
vpx_codec_dec_cfg_t cfg = {0};
|
|
#if CONFIG_VP8_DECODER
|
|
vp8_postproc_cfg_t vp8_pp_cfg = {0};
|
|
#endif
|
|
struct input_ctx input = {0};
|
|
|
|
/* Parse command line */
|
|
exec_name = argv_[0];
|
|
argv = argv_dup(argc - 1, argv_ + 1);
|
|
|
|
for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step)
|
|
{
|
|
memset(&arg, 0, sizeof(arg));
|
|
arg.argv_step = 1;
|
|
|
|
if (arg_match(&arg, &codecarg, argi))
|
|
{
|
|
int j, k = -1;
|
|
|
|
for (j = 0; j < sizeof(ifaces) / sizeof(ifaces[0]); j++)
|
|
if (!strcmp(ifaces[j].name, arg.val))
|
|
k = j;
|
|
|
|
if (k >= 0)
|
|
iface = ifaces[k].iface;
|
|
else
|
|
die("Error: Unrecognized argument (%s) to --codec\n",
|
|
arg.val);
|
|
}
|
|
else if (arg_match(&arg, &outputfile, argi))
|
|
fn2 = arg.val;
|
|
else if (arg_match(&arg, &usey4marg, argi))
|
|
use_y4m = 1;
|
|
else if (arg_match(&arg, &prefixarg, argi))
|
|
prefix = strdup(arg.val);
|
|
else if (arg_match(&arg, &use_yv12, argi))
|
|
flipuv = 1;
|
|
else if (arg_match(&arg, &use_i420, argi))
|
|
flipuv = 0;
|
|
else if (arg_match(&arg, &flipuvarg, argi))
|
|
flipuv = 1;
|
|
else if (arg_match(&arg, &noblitarg, argi))
|
|
noblit = 1;
|
|
else if (arg_match(&arg, &progressarg, argi))
|
|
progress = 1;
|
|
else if (arg_match(&arg, &limitarg, argi))
|
|
stop_after = arg_parse_uint(&arg);
|
|
else if (arg_match(&arg, &postprocarg, argi))
|
|
postproc = 1;
|
|
else if (arg_match(&arg, &md5arg, argi))
|
|
do_md5 = 1;
|
|
else if (arg_match(&arg, &summaryarg, argi))
|
|
summary = 1;
|
|
else if (arg_match(&arg, &threadsarg, argi))
|
|
cfg.threads = arg_parse_uint(&arg);
|
|
else if (arg_match(&arg, &quietarg, argi))
|
|
quiet = 1;
|
|
|
|
#if CONFIG_VP8_DECODER
|
|
else if (arg_match(&arg, &addnoise_level, argi))
|
|
{
|
|
postproc = 1;
|
|
vp8_pp_cfg.post_proc_flag |= VP8_ADDNOISE;
|
|
vp8_pp_cfg.noise_level = arg_parse_uint(&arg);
|
|
}
|
|
else if (arg_match(&arg, &demacroblock_level, argi))
|
|
{
|
|
postproc = 1;
|
|
vp8_pp_cfg.post_proc_flag |= VP8_DEMACROBLOCK;
|
|
vp8_pp_cfg.deblocking_level = arg_parse_uint(&arg);
|
|
}
|
|
else if (arg_match(&arg, &deblock, argi))
|
|
{
|
|
postproc = 1;
|
|
vp8_pp_cfg.post_proc_flag |= VP8_DEBLOCK;
|
|
}
|
|
else if (arg_match(&arg, &pp_debug_info, argi))
|
|
{
|
|
unsigned int level = arg_parse_uint(&arg);
|
|
|
|
postproc = 1;
|
|
vp8_pp_cfg.post_proc_flag &= ~0x7;
|
|
|
|
if (level)
|
|
vp8_pp_cfg.post_proc_flag |= 8 << (level - 1);
|
|
}
|
|
|
|
#endif
|
|
else
|
|
argj++;
|
|
}
|
|
|
|
/* Check for unrecognized options */
|
|
for (argi = argv; *argi; argi++)
|
|
if (argi[0][0] == '-' && strlen(argi[0]) > 1)
|
|
die("Error: Unrecognized option %s\n", *argi);
|
|
|
|
/* Handle non-option arguments */
|
|
fn = argv[0];
|
|
|
|
if (!fn)
|
|
usage_exit();
|
|
|
|
if (!prefix)
|
|
prefix = strdup("img");
|
|
|
|
/* Open file */
|
|
infile = strcmp(fn, "-") ? fopen(fn, "rb") : stdin;
|
|
|
|
if (!infile)
|
|
{
|
|
fprintf(stderr, "Failed to open file");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if (fn2)
|
|
out = out_open(fn2, do_md5);
|
|
|
|
input.infile = infile;
|
|
if(file_is_ivf(infile, &fourcc, &width, &height, &fps_den,
|
|
&fps_num))
|
|
input.kind = IVF_FILE;
|
|
else if(file_is_webm(&input, &fourcc, &width, &height, &fps_den, &fps_num))
|
|
input.kind = WEBM_FILE;
|
|
else
|
|
input.kind = RAW_FILE;
|
|
|
|
if (input.kind != RAW_FILE)
|
|
{
|
|
if (use_y4m)
|
|
{
|
|
char buffer[128];
|
|
if (!fn2)
|
|
{
|
|
fprintf(stderr, "YUV4MPEG2 output only supported with -o.\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if(input.kind == WEBM_FILE)
|
|
webm_guess_framerate(&input, &fps_den, &fps_num);
|
|
|
|
/*Note: We can't output an aspect ratio here because IVF doesn't
|
|
store one, and neither does VP8.
|
|
That will have to wait until these tools support WebM natively.*/
|
|
sprintf(buffer, "YUV4MPEG2 C%s W%u H%u F%u:%u I%c\n",
|
|
"420jpeg", width, height, fps_num, fps_den, 'p');
|
|
out_put(out, (unsigned char *)buffer, strlen(buffer), do_md5);
|
|
}
|
|
|
|
/* Try to determine the codec from the fourcc. */
|
|
for (i = 0; i < sizeof(ifaces) / sizeof(ifaces[0]); i++)
|
|
if ((fourcc & ifaces[i].fourcc_mask) == ifaces[i].fourcc)
|
|
{
|
|
vpx_codec_iface_t *ivf_iface = ifaces[i].iface;
|
|
|
|
if (iface && iface != ivf_iface)
|
|
fprintf(stderr, "Notice -- IVF header indicates codec: %s\n",
|
|
ifaces[i].name);
|
|
else
|
|
iface = ivf_iface;
|
|
|
|
break;
|
|
}
|
|
}
|
|
else if(use_y4m)
|
|
{
|
|
fprintf(stderr, "YUV4MPEG2 output not supported from raw input.\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if (vpx_codec_dec_init(&decoder, iface ? iface : ifaces[0].iface, &cfg,
|
|
postproc ? VPX_CODEC_USE_POSTPROC : 0))
|
|
{
|
|
fprintf(stderr, "Failed to initialize decoder: %s\n", vpx_codec_error(&decoder));
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if (!quiet)
|
|
fprintf(stderr, "%s\n", decoder.name);
|
|
|
|
#if CONFIG_VP8_DECODER
|
|
|
|
if (vp8_pp_cfg.post_proc_flag
|
|
&& vpx_codec_control(&decoder, VP8_SET_POSTPROC, &vp8_pp_cfg))
|
|
{
|
|
fprintf(stderr, "Failed to configure postproc: %s\n", vpx_codec_error(&decoder));
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Decode file */
|
|
while (!read_frame(&input, &buf, &buf_sz, &buf_alloc_sz))
|
|
{
|
|
vpx_codec_iter_t iter = NULL;
|
|
vpx_image_t *img;
|
|
struct vpx_usec_timer timer;
|
|
|
|
vpx_usec_timer_start(&timer);
|
|
|
|
if (vpx_codec_decode(&decoder, buf, buf_sz, NULL, 0))
|
|
{
|
|
const char *detail = vpx_codec_error_detail(&decoder);
|
|
fprintf(stderr, "Failed to decode frame: %s\n", vpx_codec_error(&decoder));
|
|
|
|
if (detail)
|
|
fprintf(stderr, " Additional information: %s\n", detail);
|
|
|
|
goto fail;
|
|
}
|
|
|
|
vpx_usec_timer_mark(&timer);
|
|
dx_time += vpx_usec_timer_elapsed(&timer);
|
|
|
|
++frame_in;
|
|
|
|
if (progress)
|
|
fprintf(stderr, "decoded frame %d.\n", frame_in);
|
|
|
|
if ((img = vpx_codec_get_frame(&decoder, &iter)))
|
|
++frame_out;
|
|
|
|
if (!noblit)
|
|
{
|
|
if (img)
|
|
{
|
|
unsigned int y;
|
|
char out_fn[128+24];
|
|
uint8_t *buf;
|
|
const char *sfx = flipuv ? "yv12" : "i420";
|
|
|
|
if (!fn2)
|
|
{
|
|
sprintf(out_fn, "%s-%dx%d-%04d.%s",
|
|
prefix, img->d_w, img->d_h, frame_in, sfx);
|
|
out = out_open(out_fn, do_md5);
|
|
}
|
|
else if(use_y4m)
|
|
out_put(out, (unsigned char *)"FRAME\n", 6, do_md5);
|
|
|
|
buf = img->planes[VPX_PLANE_Y];
|
|
|
|
for (y = 0; y < img->d_h; y++)
|
|
{
|
|
out_put(out, buf, img->d_w, do_md5);
|
|
buf += img->stride[VPX_PLANE_Y];
|
|
}
|
|
|
|
buf = img->planes[flipuv?VPX_PLANE_V:VPX_PLANE_U];
|
|
|
|
for (y = 0; y < (1 + img->d_h) / 2; y++)
|
|
{
|
|
out_put(out, buf, (1 + img->d_w) / 2, do_md5);
|
|
buf += img->stride[VPX_PLANE_U];
|
|
}
|
|
|
|
buf = img->planes[flipuv?VPX_PLANE_U:VPX_PLANE_V];
|
|
|
|
for (y = 0; y < (1 + img->d_h) / 2; y++)
|
|
{
|
|
out_put(out, buf, (1 + img->d_w) / 2, do_md5);
|
|
buf += img->stride[VPX_PLANE_V];
|
|
}
|
|
|
|
if (!fn2)
|
|
out_close(out, out_fn, do_md5);
|
|
}
|
|
}
|
|
|
|
if (stop_after && frame_in >= stop_after)
|
|
break;
|
|
}
|
|
|
|
if (summary)
|
|
{
|
|
fprintf(stderr, "%d decoded frames/%d showed frames in %lu us (%.2f fps)\n",
|
|
frame_in, frame_out, dx_time, (float)frame_out * 1000000.0 / (float)dx_time);
|
|
}
|
|
|
|
fail:
|
|
|
|
if (vpx_codec_destroy(&decoder))
|
|
{
|
|
fprintf(stderr, "Failed to destroy decoder: %s\n", vpx_codec_error(&decoder));
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if (fn2)
|
|
out_close(out, fn2, do_md5);
|
|
|
|
if(input.nestegg_ctx)
|
|
nestegg_destroy(input.nestegg_ctx);
|
|
if(input.kind != WEBM_FILE)
|
|
free(buf);
|
|
fclose(infile);
|
|
free(prefix);
|
|
free(argv);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|