openharmony/third_party_ffmpeg
1
0
Fork 0
mirror of https://gitee.com/openharmony/third_party_ffmpeg synced 2024-11-23 11:19:55 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge commit 'ec36aa69448f20a78d8c4588265022e0b2272ab5'

Browse Source 
* commit 'ec36aa69448f20a78d8c4588265022e0b2272ab5':
  x86: Fix linking with some or all of yasm, mmx, optimizations disabled
  configure: Add more fine-grained SSE CPU capabilities flags
  avfilter: x86: Use more precise compile template names
  x86: cosmetics: Comment some #endifs for better readability
  g723_1: add comfort noise generation
  utvideoenc: Switch to dsputils' median prediction
  utvideoenc: Avoid writing into the input picture
  avtools: remove the distinction between func_arg and func2_arg.
  avconv: make the -passlogfile option per-stream.
  avconv: make the -pass option per-stream.
  cmdutils: make -codecs print lossy/lossless flags.
  lavc: add lossy/lossless codec properties.

Conflicts:
	Changelog
	cmdutils.c
	configure
	doc/APIchanges
	ffmpeg.h
	ffmpeg_opt.c
	ffprobe.c
	libavcodec/codec_desc.c
	libavcodec/g723_1.c
	libavcodec/utvideoenc.c
	libavcodec/version.h
	libavcodec/x86/mpegaudiodec.c
	libavcodec/x86/rv40dsp_init.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2012-08-31 12:04:17 +02:00
commit 98298eb103
33 changed files with 930 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Changelog
View File

@ -50,6 +50,7 @@ version next:
- edge detection filter
- framestep filter
- ffmpeg -shortest option is now per-output file
-pass and -passlogfile are now per-output stream
- volume measurement filter
- Ut Video encoder
- Matroska demuxer now identifies SRT subtitles as AV_CODEC_ID_SUBRIP

63
cmdutils.c
View File

@ -316,8 +316,7 @@ int parse_option(void *optctx, const char *opt, const char *arg,
} else if (po->flags & OPT_DOUBLE) {
*(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
} else if (po->u.func_arg) {
int ret = po->flags & OPT_FUNC2 ? po->u.func2_arg(optctx, opt, arg)
: po->u.func_arg(opt, arg);
int ret = po->u.func_arg(optctx, opt, arg);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR,
"Failed to set value '%s' for option '%s'\n", arg, opt);
@ -416,7 +415,7 @@ void parse_loglevel(int argc, char **argv, const OptionDef *options)
if (!idx)
idx = locate_option(argc, argv, options, "v");
if (idx && argv[idx + 1])
opt_loglevel("loglevel", argv[idx + 1]);
opt_loglevel(NULL, "loglevel", argv[idx + 1]);
idx = locate_option(argc, argv, options, "report");
if (idx || getenv("FFREPORT")) {
opt_report("report");
@ -433,7 +432,7 @@ void parse_loglevel(int argc, char **argv, const OptionDef *options)
}
#define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
int opt_default(const char *opt, const char *arg)
int opt_default(void *optctx, const char *opt, const char *arg)
{
const AVOption *o;
char opt_stripped[128];
@ -482,7 +481,7 @@ int opt_default(const char *opt, const char *arg)
return AVERROR_OPTION_NOT_FOUND;
}
int opt_loglevel(const char *opt, const char *arg)
int opt_loglevel(void *optctx, const char *opt, const char *arg)
{
const struct { const char *name; int level; } log_levels[] = {
{ "quiet" , AV_LOG_QUIET },
@ -549,7 +548,7 @@ int opt_report(const char *opt)
return 0;
}
int opt_max_alloc(const char *opt, const char *arg)
int opt_max_alloc(void *optctx, const char *opt, const char *arg)
{
char *tail;
size_t max;
@ -563,7 +562,7 @@ int opt_max_alloc(const char *opt, const char *arg)
return 0;
}
int opt_cpuflags(const char *opt, const char *arg)
int opt_cpuflags(void *optctx, const char *opt, const char *arg)
{
int ret;
unsigned flags = av_get_cpu_flags();
@ -575,13 +574,13 @@ int opt_cpuflags(const char *opt, const char *arg)
return 0;
}
int opt_codec_debug(const char *opt, const char *arg)
int opt_codec_debug(void *optctx, const char *opt, const char *arg)
{
av_log_set_level(AV_LOG_DEBUG);
return opt_default(opt, arg);
return opt_default(NULL, opt, arg);
}
int opt_timelimit(const char *opt, const char *arg)
int opt_timelimit(void *optctx, const char *opt, const char *arg)
{
#if HAVE_SETRLIMIT
int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
@ -680,7 +679,7 @@ void show_banner(int argc, char **argv, const OptionDef *options)
print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
}
int show_version(const char *opt, const char *arg)
int show_version(void *optctx, const char *opt, const char *arg)
{
av_log_set_callback(log_callback_help);
print_program_info (0 , AV_LOG_INFO);
@ -689,7 +688,7 @@ int show_version(const char *opt, const char *arg)
return 0;
}
int show_license(const char *opt, const char *arg)
int show_license(void *optctx, const char *opt, const char *arg)
{
printf(
#if CONFIG_NONFREE
@ -760,7 +759,7 @@ int show_license(const char *opt, const char *arg)
return 0;
}
int show_formats(const char *opt, const char *arg)
int show_formats(void *optctx, const char *opt, const char *arg)
{
AVInputFormat *ifmt = NULL;
AVOutputFormat *ofmt = NULL;
@ -902,18 +901,20 @@ static void print_codecs_for_id(enum AVCodecID id, int encoder)
printf(")");
}
int show_codecs(const char *opt, const char *arg)
int show_codecs(void *optctx, const char *opt, const char *arg)
{
const AVCodecDescriptor *desc = NULL;
printf("Codecs:\n"
" D... = Decoding supported\n"
" .E.. = Encoding supported\n"
" ..V. = Video codec\n"
" ..A. = Audio codec\n"
" ..S. = Subtitle codec\n"
" ...I = Intra frame-only codec\n"
" -----\n");
" D..... = Decoding supported\n"
" .E.... = Encoding supported\n"
" ..V... = Video codec\n"
" ..A... = Audio codec\n"
" ..S... = Subtitle codec\n"
" ...I.. = Intra frame-only codec\n"
" ....L. = Lossy compression\n"
" .....S = Lossless compression\n"
" -------\n");
while ((desc = avcodec_descriptor_next(desc))) {
const AVCodec *codec = NULL;
@ -923,6 +924,8 @@ int show_codecs(const char *opt, const char *arg)
printf("%c", get_media_type_char(desc->type));
printf((desc->props & AV_CODEC_PROP_INTRA_ONLY) ? "I" : ".");
printf((desc->props & AV_CODEC_PROP_LOSSY) ? "L" : ".");
printf((desc->props & AV_CODEC_PROP_LOSSLESS) ? "S" : ".");
printf(" %-20s %s", desc->name, desc->long_name ? desc->long_name : "");
@ -982,19 +985,19 @@ static void print_codecs(int encoder)
}
}
int show_decoders(const char *opt, const char *arg)
int show_decoders(void *optctx, const char *opt, const char *arg)
{
print_codecs(0);
return 0;
}
int show_encoders(const char *opt, const char *arg)
int show_encoders(void *optctx, const char *opt, const char *arg)
{
print_codecs(1);
return 0;
}
int show_bsfs(const char *opt, const char *arg)
int show_bsfs(void *optctx, const char *opt, const char *arg)
{
AVBitStreamFilter *bsf = NULL;
@ -1005,7 +1008,7 @@ int show_bsfs(const char *opt, const char *arg)
return 0;
}
int show_protocols(const char *opt, const char *arg)
int show_protocols(void *optctx, const char *opt, const char *arg)
{
void *opaque = NULL;
const char *name;
@ -1020,7 +1023,7 @@ int show_protocols(const char *opt, const char *arg)
return 0;
}
int show_filters(const char *opt, const char *arg)
int show_filters(void *optctx, const char *opt, const char *arg)
{
AVFilter av_unused(**filter) = NULL;
char descr[64], *descr_cur;
@ -1052,7 +1055,7 @@ int show_filters(const char *opt, const char *arg)
return 0;
}
int show_pix_fmts(const char *opt, const char *arg)
int show_pix_fmts(void *optctx, const char *opt, const char *arg)
{
enum PixelFormat pix_fmt;
@ -1087,7 +1090,7 @@ int show_pix_fmts(const char *opt, const char *arg)
return 0;
}
int show_layouts(const char *opt, const char *arg)
int show_layouts(void *optctx, const char *opt, const char *arg)
{
int i = 0;
uint64_t layout, j;
@ -1116,7 +1119,7 @@ int show_layouts(const char *opt, const char *arg)
return 0;
}
int show_sample_fmts(const char *opt, const char *arg)
int show_sample_fmts(void *optctx, const char *opt, const char *arg)
{
int i;
char fmt_str[128];
@ -1211,7 +1214,7 @@ static void show_help_muxer(const char *name)
show_help_children(fmt->priv_class, AV_OPT_FLAG_ENCODING_PARAM);
}
int show_help(const char *opt, const char *arg)
int show_help(void *optctx, const char *opt, const char *arg)
{
char *topic, *par;
av_log_set_callback(log_callback_help);

44
cmdutils.h
View File

@ -75,25 +75,25 @@ void log_callback_help(void* ptr, int level, const char* fmt, va_list vl);
* Fallback for options that are not explicitly handled, these will be
* parsed through AVOptions.
*/
int opt_default(const char *opt, const char *arg);
int opt_default(void *optctx, const char *opt, const char *arg);
/**
* Set the libav* libraries log level.
*/
int opt_loglevel(const char *opt, const char *arg);
int opt_loglevel(void *optctx, const char *opt, const char *arg);
int opt_report(const char *opt);
int opt_max_alloc(const char *opt, const char *arg);
int opt_max_alloc(void *optctx, const char *opt, const char *arg);
int opt_cpuflags(const char *opt, const char *arg);
int opt_cpuflags(void *optctx, const char *opt, const char *arg);
int opt_codec_debug(const char *opt, const char *arg);
int opt_codec_debug(void *optctx, const char *opt, const char *arg);
/**
* Limit the execution time.
*/
int opt_timelimit(const char *opt, const char *arg);
int opt_timelimit(void *optctx, const char *opt, const char *arg);
/**
* Parse a string and return its corresponding value as a double.
@ -154,7 +154,8 @@ typedef struct {
#define OPT_INT64 0x0400
#define OPT_EXIT 0x0800
#define OPT_DATA 0x1000
#define OPT_FUNC2 0x2000
#define OPT_PERFILE 0x2000 /* the option is per-file (currently ffmpeg-only).
implied by OPT_OFFSET or OPT_SPEC */
#define OPT_OFFSET 0x4000 /* option is specified as an offset in a passed optctx */
#define OPT_SPEC 0x8000 /* option is to be stored in an array of SpecifierOpt.
Implies OPT_OFFSET. Next element after the offset is
@ -163,8 +164,7 @@ typedef struct {
#define OPT_DOUBLE 0x20000
union {
void *dst_ptr;
int (*func_arg)(const char *, const char *);
int (*func2_arg)(void *, const char *, const char *);
int (*func_arg)(void *, const char *, const char *);
size_t off;
} u;
const char *help;
@ -198,7 +198,7 @@ void show_help_default(const char *opt, const char *arg);
/**
* Generic -h handler common to all avtools.
*/
int show_help(const char *opt, const char *arg);
int show_help(void *optctx, const char *opt, const char *arg);
/**
* Parse the command line arguments.
@ -296,81 +296,81 @@ void show_banner(int argc, char **argv, const OptionDef *options);
* libraries.
* This option processing function does not utilize the arguments.
*/
int show_version(const char *opt, const char *arg);
int show_version(void *optctx, const char *opt, const char *arg);
/**
* Print the license of the program to stdout. The license depends on
* the license of the libraries compiled into the program.
* This option processing function does not utilize the arguments.
*/
int show_license(const char *opt, const char *arg);
int show_license(void *optctx, const char *opt, const char *arg);
/**
* Print a listing containing all the formats supported by the
* program.
* This option processing function does not utilize the arguments.
*/
int show_formats(const char *opt, const char *arg);
int show_formats(void *optctx, const char *opt, const char *arg);
/**
* Print a listing containing all the codecs supported by the
* program.
* This option processing function does not utilize the arguments.
*/
int show_codecs(const char *opt, const char *arg);
int show_codecs(void *optctx, const char *opt, const char *arg);
/**
* Print a listing containing all the decoders supported by the
* program.
*/
int show_decoders(const char *opt, const char *arg);
int show_decoders(void *optctx, const char *opt, const char *arg);
/**
* Print a listing containing all the encoders supported by the
* program.
*/
int show_encoders(const char *opt, const char *arg);
int show_encoders(void *optctx, const char *opt, const char *arg);
/**
* Print a listing containing all the filters supported by the
* program.
* This option processing function does not utilize the arguments.
*/
int show_filters(const char *opt, const char *arg);
int show_filters(void *optctx, const char *opt, const char *arg);
/**
* Print a listing containing all the bit stream filters supported by the
* program.
* This option processing function does not utilize the arguments.
*/
int show_bsfs(const char *opt, const char *arg);
int show_bsfs(void *optctx, const char *opt, const char *arg);
/**
* Print a listing containing all the protocols supported by the
* program.
* This option processing function does not utilize the arguments.
*/
int show_protocols(const char *opt, const char *arg);
int show_protocols(void *optctx, const char *opt, const char *arg);
/**
* Print a listing containing all the pixel formats supported by the
* program.
* This option processing function does not utilize the arguments.
*/
int show_pix_fmts(const char *opt, const char *arg);
int show_pix_fmts(void *optctx, const char *opt, const char *arg);
/**
* Print a listing containing all the standard channel layouts supported by
* the program.
* This option processing function does not utilize the arguments.
*/
int show_layouts(const char *opt, const char *arg);
int show_layouts(void *optctx, const char *opt, const char *arg);
/**
* Print a listing containing all the sample formats supported by the
* program.
*/
int show_sample_fmts(const char *opt, const char *arg);
int show_sample_fmts(void *optctx, const char *opt, const char *arg);
/**
* Return a positive value if a line read from standard input

41
configure vendored
View File

@ -276,7 +276,11 @@ Optimization options (experts only):
--disable-mmx disable MMX optimizations
--disable-mmxext disable MMXEXT optimizations
--disable-sse disable SSE optimizations
--disable-sse2 disable SSE2 optimizations
--disable-sse3 disable SSE3 optimizations
--disable-ssse3 disable SSSE3 optimizations
--disable-sse4 disable SSE4 optimizations
--disable-sse42 disable SSE4.2 optimizations
--disable-avx disable AVX optimizations
--disable-fma4 disable FMA4 optimizations
--disable-armv5te disable armv5te optimizations
@ -1202,30 +1206,38 @@ ARCH_LIST='
x86_64
'
ARCH_EXT_LIST='
altivec
ARCH_EXT_LIST_X86='
amd3dnow
amd3dnowext
avx
fma4
mmx
mmxext
sse
sse2
sse3
sse4
sse42
ssse3
'
ARCH_EXT_LIST="
$ARCH_EXT_LIST_X86
altivec
armv5te
armv6
armv6t2
armvfp
avx
fma4
mmi
mmx
mmxext
neon
ppc4xx
sse
ssse3
vfpv3
vis
mipsfpu
mips32r2
mipsdspr1
mipsdspr2
'
"
HAVE_LIST_PUB='
bigendian
@ -1498,13 +1510,18 @@ ppc4xx_deps="ppc"
vis_deps="sparc"
x86_64_suggest="cmov fast_cmov"
amd3dnow_deps="mmx"
amd3dnowext_deps="amd3dnow"
mmx_deps="x86"
mmxext_deps="mmx"
sse_deps="mmx"
ssse3_deps="sse"
avx_deps="ssse3"
sse_deps="mmxext"
sse2_deps="sse"
sse3_deps="sse2"
ssse3_deps="sse3"
sse4_deps="ssse3"
sse42_deps="sse4"
avx_deps="sse42"
fma4_deps="avx"
aligned_stack_if_any="ppc x86"

4
doc/APIchanges
View File

@ -77,6 +77,10 @@ API changes, most recent first:
2012-03-26 - a67d9cf - lavfi 2.66.100
Add avfilter_fill_frame_from_{audio_,}buffer_ref() functions.
2012-xx-xx - xxxxxxx - lavc 54.26.1 - avcodec.h
Add codec descriptor properties AV_CODEC_PROP_LOSSY and
AV_CODEC_PROP_LOSSLESS.
2012-08-18 - lavc 54.26 - avcodec.h
Add codec descriptors for accessing codec properties without having
to refer to a specific decoder or encoder.

4
doc/ffmpeg.texi
View File

@ -476,7 +476,7 @@ Use same quantizer as source (implies VBR).
Note that this is NOT SAME QUALITY. Do not use this option unless you know you
need it.
@item -pass @var{n}
@item -pass[:@var{stream_specifier}] @var{n} (@emph{output,per-stream})
Select the pass number (1 or 2). It is used to do two-pass
video encoding. The statistics of the video are recorded in the first
pass into a log file (see also the option -passlogfile),
@ -489,7 +489,7 @@ ffmpeg -i foo.mov -c:v libxvid -pass 1 -an -f rawvideo -y NUL
ffmpeg -i foo.mov -c:v libxvid -pass 1 -an -f rawvideo -y /dev/null
@end example
@item -passlogfile @var{prefix} (@emph{global})
@item -passlogfile[:@var{stream_specifier}] @var{prefix} (@emph{output,per-stream})
Set two-pass log file name prefix to @var{prefix}, the default file name
prefix is ``ffmpeg2pass''. The complete file name will be
@file{PREFIX-N.log}, where N is a number specific to the output

6
ffmpeg.c
View File

@ -414,6 +414,7 @@ void av_noreturn exit_program(int ret)
av_freep(&output_streams[i]->forced_keyframes);
av_freep(&output_streams[i]->avfilter);
av_freep(&output_streams[i]->logfile_prefix);
av_freep(&output_streams[i]->filtered_frame);
av_freep(&output_streams[i]);
}
@ -2207,7 +2208,8 @@ static int transcode_init(void)
FILE *f;
snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
ost->logfile_prefix ? ost->logfile_prefix :
DEFAULT_PASS_LOGFILENAME_PREFIX,
i);
if (!strcmp(ost->enc->name, "libx264")) {
av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
@ -3089,7 +3091,7 @@ static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
{
int idx = locate_option(argc, argv, options, "cpuflags");
if (idx && argv[idx + 1])
opt_cpuflags("cpuflags", argv[idx + 1]);
opt_cpuflags(NULL, "cpuflags", argv[idx + 1]);
}
int main(int argc, char **argv)

6
ffmpeg.h
View File

@ -161,6 +161,10 @@ typedef struct OptionsContext {
int nb_filters;
SpecifierOpt *fix_sub_duration;
int nb_fix_sub_duration;
SpecifierOpt *pass;
int nb_pass;
SpecifierOpt *passlogfiles;
int nb_passlogfiles;
} OptionsContext;
typedef struct InputFilter {
@ -308,6 +312,7 @@ typedef struct OutputStream {
int audio_channels_map[SWR_CH_MAX]; /* list of the channels id to pick from the source stream */
int audio_channels_mapped; /* number of channels in audio_channels_map */
char *logfile_prefix;
FILE *logfile;
OutputFilter *filter;
@ -350,7 +355,6 @@ extern int nb_output_files;
extern FilterGraph **filtergraphs;
extern int nb_filtergraphs;
extern const char *pass_logfilename_prefix;
extern char *vstats_filename;
extern float audio_drift_threshold;

184
ffmpeg_opt.c
View File

@ -54,7 +54,6 @@
}\
}
const char *pass_logfilename_prefix;
char *vstats_filename;
float audio_drift_threshold = 0.1;
@ -89,7 +88,6 @@ static int no_file_overwrite = 0;
static int video_discard = 0;
static int intra_dc_precision = 8;
static int do_psnr = 0;
static int do_pass = 0;
static int input_sync;
void reset_options(OptionsContext *o, int is_input)
@ -142,28 +140,28 @@ void reset_options(OptionsContext *o, int is_input)
}
static int opt_frame_crop(const char *opt, const char *arg)
static int opt_frame_crop(void *optctx, const char *opt, const char *arg)
{
av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
return AVERROR(EINVAL);
}
static int opt_pad(const char *opt, const char *arg)
static int opt_pad(void *optctx, const char *opt, const char *arg)
{
av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
return -1;
}
static int opt_video_channel(const char *opt, const char *arg)
static int opt_video_channel(void *optctx, const char *opt, const char *arg)
{
av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
return opt_default("channel", arg);
return opt_default(optctx, "channel", arg);
}
static int opt_video_standard(const char *opt, const char *arg)
static int opt_video_standard(void *optctx, const char *opt, const char *arg)
{
av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
return opt_default("standard", arg);
return opt_default(optctx, "standard", arg);
}
static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
@ -1040,6 +1038,7 @@ static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, in
char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
char *intra_matrix = NULL, *inter_matrix = NULL;
const char *filters = "null";
int do_pass = 0;
int i;
MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
@ -1125,6 +1124,7 @@ static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, in
video_enc->flags|= CODEC_FLAG_PSNR;
/* two pass mode */
MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
if (do_pass) {
if (do_pass & 1) {
video_enc->flags |= CODEC_FLAG_PASS1;
@ -1134,6 +1134,11 @@ static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, in
}
}
MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
if (ost->logfile_prefix &&
!(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
exit_program(1);
MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
if (ost->forced_keyframes)
ost->forced_keyframes = av_strdup(ost->forced_keyframes);
@ -1758,14 +1763,6 @@ loop_end:
reset_options(o, 0);
}
/* same option as mencoder */
static int opt_pass(const char *opt, const char *arg)
{
do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
return 0;
}
static int opt_target(void *optctx, const char *opt, const char *arg)
{
OptionsContext *o = optctx;
@ -1821,19 +1818,19 @@ static int opt_target(void *optctx, const char *opt, const char *arg)
parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
parse_option(o, "r", frame_rates[norm], options);
opt_default("g", norm == PAL ? "15" : "18");
opt_default(NULL, "g", norm == PAL ? "15" : "18");
opt_default("b:v", "1150000");
opt_default("maxrate", "1150000");
opt_default("minrate", "1150000");
opt_default("bufsize", "327680"); // 40*1024*8;
opt_default(NULL, "b:v", "1150000");
opt_default(NULL, "maxrate", "1150000");
opt_default(NULL, "minrate", "1150000");
opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
opt_default("b:a", "224000");
opt_default(NULL, "b:a", "224000");
parse_option(o, "ar", "44100", options);
parse_option(o, "ac", "2", options);
opt_default("packetsize", "2324");
opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
opt_default(NULL, "packetsize", "2324");
opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
/* We have to offset the PTS, so that it is consistent with the SCR.
SCR starts at 36000, but the first two packs contain only padding
@ -1850,19 +1847,18 @@ static int opt_target(void *optctx, const char *opt, const char *arg)
parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
parse_option(o, "r", frame_rates[norm], options);
parse_option(o, "pix_fmt", "yuv420p", options);
opt_default("g", norm == PAL ? "15" : "18");
opt_default(NULL, "g", norm == PAL ? "15" : "18");
opt_default("b:v", "2040000");
opt_default("maxrate", "2516000");
opt_default("minrate", "0"); // 1145000;
opt_default("bufsize", "1835008"); // 224*1024*8;
opt_default("scan_offset", "1");
opt_default(NULL, "b:v", "2040000");
opt_default(NULL, "maxrate", "2516000");
opt_default(NULL, "minrate", "0"); // 1145000;
opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
opt_default(NULL, "scan_offset", "1");
opt_default("b:a", "224000");
opt_default(NULL, "b:a", "224000");
parse_option(o, "ar", "44100", options);
opt_default("packetsize", "2324");
opt_default(NULL, "packetsize", "2324");
} else if (!strcmp(arg, "dvd")) {
@ -1873,17 +1869,17 @@ static int opt_target(void *optctx, const char *opt, const char *arg)
parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
parse_option(o, "r", frame_rates[norm], options);
parse_option(o, "pix_fmt", "yuv420p", options);
opt_default("g", norm == PAL ? "15" : "18");
opt_default(NULL, "g", norm == PAL ? "15" : "18");
opt_default("b:v", "6000000");
opt_default("maxrate", "9000000");
opt_default("minrate", "0"); // 1500000;
opt_default("bufsize", "1835008"); // 224*1024*8;
opt_default(NULL, "b:v", "6000000");
opt_default(NULL, "maxrate", "9000000");
opt_default(NULL, "minrate", "0"); // 1500000;
opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
opt_default("b:a", "448000");
opt_default(NULL, "b:a", "448000");
parse_option(o, "ar", "48000", options);
} else if (!strncmp(arg, "dv", 2)) {
@ -1905,14 +1901,14 @@ static int opt_target(void *optctx, const char *opt, const char *arg)
return 0;
}
static int opt_vstats_file(const char *opt, const char *arg)
static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
{
av_free (vstats_filename);
vstats_filename = av_strdup (arg);
return 0;
}
static int opt_vstats(const char *opt, const char *arg)
static int opt_vstats(void *optctx, const char *opt, const char *arg)
{
char filename[40];
time_t today2 = time(NULL);
@ -1920,7 +1916,7 @@ static int opt_vstats(const char *opt, const char *arg)
snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
today->tm_sec);
return opt_vstats_file(opt, filename);
return opt_vstats_file(NULL, opt, filename);
}
static int opt_video_frames(void *optctx, const char *opt, const char *arg)
@ -1975,7 +1971,7 @@ static int opt_preset(void *optctx, const char *opt, const char *arg)
else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
else if (opt_default(key, value) < 0) {
else if (opt_default(NULL, key, value) < 0) {
av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
filename, line, key, value);
exit_program(1);
@ -1987,16 +1983,6 @@ static int opt_preset(void *optctx, const char *opt, const char *arg)
return 0;
}
static int opt_passlogfile(const char *opt, const char *arg)
{
pass_logfilename_prefix = arg;
#if CONFIG_LIBX264_ENCODER
return opt_default(opt, arg);
#else
return 0;
#endif
}
static int opt_old2new(void *optctx, const char *opt, const char *arg)
{
OptionsContext *o = optctx;
@ -2013,7 +1999,7 @@ static int opt_bitrate(void *optctx, const char *opt, const char *arg)
av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
return parse_option(o, "b:v", arg, options);
}
return opt_default(opt, arg);
return opt_default(optctx, opt, arg);
}
static int opt_qscale(void *optctx, const char *opt, const char *arg)
@ -2038,7 +2024,7 @@ static int opt_profile(void *optctx, const char *opt, const char *arg)
av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
return parse_option(o, "profile:v", arg, options);
}
return opt_default(opt, arg);
return opt_default(optctx, opt, arg);
}
@ -2054,7 +2040,7 @@ static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
return parse_option(o, "filter:a", arg, options);
}
static int opt_vsync(const char *opt, const char *arg)
static int opt_vsync(void *optctx, const char *opt, const char *arg)
{
if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
@ -2066,7 +2052,7 @@ static int opt_vsync(const char *opt, const char *arg)
return 0;
}
static int opt_deinterlace(const char *opt, const char *arg)
static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
{
av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
do_deinterlace = 1;
@ -2079,7 +2065,7 @@ static int opt_timecode(void *optctx, const char *opt, const char *arg)
char *tcr = av_asprintf("timecode=%s", arg);
int ret = parse_option(o, "metadata:g", tcr, options);
if (ret >= 0)
ret = opt_default("gop_timecode", arg);
ret = opt_default(optctx, "gop_timecode", arg);
av_free(tcr);
return ret;
}
@ -2099,7 +2085,7 @@ static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
return AVERROR(EINVAL);
}
snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
ret = opt_default(opt, layout_str);
ret = opt_default(NULL, opt, layout_str);
if (ret < 0)
return ret;
@ -2126,7 +2112,7 @@ static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
return parse_option(o, "q:a", arg, options);
}
static int opt_filter_complex(const char *opt, const char *arg)
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
{
filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
&nb_filtergraphs, nb_filtergraphs + 1);
@ -2140,7 +2126,7 @@ static int opt_filter_complex(const char *opt, const char *arg)
void show_help_default(const char *opt, const char *arg)
{
/* per-file options have at least one of those set */
const int per_file = OPT_SPEC | OPT_OFFSET | OPT_FUNC2;
const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
int show_advanced = 0, show_avoptions = 0;
if (opt) {
@ -2211,7 +2197,7 @@ void show_usage(void)
}
static int opt_progress(const char *opt, const char *arg)
static int opt_progress(void *optctx, const char *opt, const char *arg)
{
AVIOContext *avio = NULL;
int ret;
@ -2234,7 +2220,7 @@ const OptionDef options[] = {
#include "cmdutils_common_opts.h"
{ "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
"force format", "fmt" },
{ "i", HAS_ARG | OPT_FUNC2, { .func2_arg = opt_input_file },
{ "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
"input file name", "filename" },
{ "y", OPT_BOOL, { &file_overwrite },
"overwrite output files" },
@ -2246,10 +2232,10 @@ const OptionDef options[] = {
"codec name", "codec" },
{ "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
"preset name", "preset" },
{ "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_map },
{ "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
"set input stream mapping",
"[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
{ "map_channel", HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_map_channel },
{ "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
"map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
{ "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
"set metadata information of outfile from infile",
@ -2267,11 +2253,11 @@ const OptionDef options[] = {
"set the input ts offset", "time_off" },
{ "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
"set the input ts scale", "scale" },
{ "timestamp", HAS_ARG | OPT_FUNC2, { .func2_arg = opt_recording_timestamp },
{ "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
"set the recording timestamp ('now' to set the current time)", "time" },
{ "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
"add metadata", "string=string" },
{ "dframes", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, { .func2_arg = opt_data_frames },
{ "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
"set the number of data frames to record", "number" },
{ "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
"add timings for benchmarking" },
@ -2289,7 +2275,7 @@ const OptionDef options[] = {
"when dumping packets, also dump the payload" },
{ "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
"read input at native frame rate", "" },
{ "target", HAS_ARG | OPT_FUNC2, { .func2_arg = opt_target },
{ "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
"specify target file type (\"vcd\", \"svcd\", \"dvd\","
" \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
{ "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
@ -2318,9 +2304,9 @@ const OptionDef options[] = {
"force codec tag/fourcc", "fourcc/tag" },
{ "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
"use fixed quality scale (VBR)", "q" },
{ "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_qscale },
{ "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
"use fixed quality scale (VBR)", "q" },
{ "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_profile },
{ "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
"set profile", "profile" },
{ "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
"set stream filterchain", "filter_list" },
@ -2328,7 +2314,7 @@ const OptionDef options[] = {
"create a complex filtergraph", "graph_description" },
{ "stats", OPT_BOOL, { &print_stats },
"print progress report during encoding", },
{ "attach", HAS_ARG | OPT_FUNC2 | OPT_EXPERT, { .func2_arg = opt_attach },
{ "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
"add an attachment to the output file", "filename" },
{ "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
"extract an attachment into a file", "filename" },
@ -2336,7 +2322,7 @@ const OptionDef options[] = {
"print timestamp debugging info" },
/* video options */
{ "vframes", OPT_VIDEO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_video_frames },
{ "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
"set the number of video frames to record", "number" },
{ "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
"set frame rate (Hz value, fraction or abbreviation)", "rate" },
@ -2374,17 +2360,17 @@ const OptionDef options[] = {
"discard threshold", "n" },
{ "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
"rate control override for specific intervals", "override" },
{ "vcodec", OPT_VIDEO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_video_codec },
{ "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
"force video codec ('copy' to copy stream)", "codec" },
{ "sameq", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &same_quant },
"use same quantizer as source (implies VBR)" },
{ "same_quant", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &same_quant },
"use same quantizer as source (implies VBR)" },
{ "timecode", OPT_VIDEO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_timecode },
{ "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
"set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
{ "pass", OPT_VIDEO | HAS_ARG , { opt_pass },
"select the pass number (1 or 2)", "n" },
{ "passlogfile", OPT_VIDEO | HAS_ARG, { .func_arg = &opt_passlogfile },
{ "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
"select the pass number (1 to 3)", "n" },
{ "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
"select two pass log file name prefix", "prefix" },
{ "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
"this option is deprecated, use the yadif filter instead" },
@ -2394,7 +2380,7 @@ const OptionDef options[] = {
"dump video coding statistics to file" },
{ "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
"dump video coding statistics to file", "file" },
{ "vf", OPT_VIDEO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_video_filters },
{ "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
"video filters", "filter list" },
{ "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
"specify intra matrix coeffs", "matrix" },
@ -2404,24 +2390,24 @@ const OptionDef options[] = {
"top=1/bottom=0/auto=-1 field first", "" },
{ "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
"intra_dc_precision", "precision" },
{ "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_old2new },
{ "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
"force video tag/fourcc", "fourcc/tag" },
{ "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
"show QP histogram" },
{ "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
"force the selected framerate, disable the best supported framerate selection" },
{ "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_streamid },
{ "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
"set the value of an outfile streamid", "streamIndex:value" },
{ "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
{ .off = OFFSET(forced_key_frames) },
"force key frames at specified timestamps", "timestamps" },
{ "b", OPT_VIDEO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_bitrate },
{ "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
"video bitrate (please use -b:v)", "bitrate" },
/* audio options */
{ "aframes", OPT_AUDIO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_audio_frames },
{ "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
"set the number of audio frames to record", "number" },
{ "aq", OPT_AUDIO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_audio_qscale },
{ "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
"set audio quality (codec-specific)", "quality", },
{ "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
"set audio sampling rate (in Hz)", "rate" },
@ -2429,26 +2415,26 @@ const OptionDef options[] = {
"set number of audio channels", "channels" },
{ "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
"disable audio" },
{ "acodec", OPT_AUDIO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_audio_codec },
{ "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
"force audio codec ('copy' to copy stream)", "codec" },
{ "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_old2new },
{ "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
"force audio tag/fourcc", "fourcc/tag" },
{ "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
"change audio volume (256=normal)" , "volume" },
{ "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
"set sample format", "format" },
{ "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_FUNC2, { .func2_arg = opt_channel_layout },
{ "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
"set channel layout", "layout" },
{ "af", OPT_AUDIO | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_audio_filters },
{ "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
"audio filters", "filter list" },
/* subtitle options */
{ "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
"disable subtitle" },
{ "scodec", OPT_SUBTITLE | HAS_ARG | OPT_FUNC2, { .func2_arg = opt_subtitle_codec },
{ "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
"force subtitle codec ('copy' to copy stream)", "codec" },
{ "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, { .func2_arg = opt_old2new },
"force subtitle tag/fourcc", "fourcc/tag" },
{ "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
, "force subtitle tag/fourcc", "fourcc/tag" },
{ "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
"fix subtitles duration" },
@ -2467,21 +2453,21 @@ const OptionDef options[] = {
{ "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
"A comma-separated list of bitstream filters", "bitstream_filters" },
{ "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_old2new },
{ "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
"deprecated", "audio bitstream_filters" },
{ "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_old2new },
{ "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
"deprecated", "video bitstream_filters" },
{ "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_preset },
{ "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
"set the audio options to the indicated preset", "preset" },
{ "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_preset },
{ "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
"set the video options to the indicated preset", "preset" },
{ "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_preset },
{ "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
"set the subtitle options to the indicated preset", "preset" },
{ "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_preset },
{ "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
"set options from indicated preset file", "filename" },
/* data codec support */
{ "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2 | OPT_EXPERT, { .func2_arg = opt_data_codec },
{ "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
"force data codec ('copy' to copy stream)", "codec" },
{ "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
"disable data" },

8
ffplay.c
View File

@ -2884,7 +2884,7 @@ static void event_loop(VideoState *cur_stream)
static int opt_frame_size(const char *opt, const char *arg)
{
av_log(NULL, AV_LOG_WARNING, "Option -s is deprecated, use -video_size.\n");
return opt_default("video_size", arg);
return opt_default(NULL, "video_size", arg);
}
static int opt_width(const char *opt, const char *arg)
@ -2912,7 +2912,7 @@ static int opt_format(const char *opt, const char *arg)
static int opt_frame_pix_fmt(const char *opt, const char *arg)
{
av_log(NULL, AV_LOG_WARNING, "Option -pix_fmt is deprecated, use -pixel_format.\n");
return opt_default("pixel_format", arg);
return opt_default(NULL, "pixel_format", arg);
}
static int opt_sync(const char *opt, const char *arg)
@ -2936,7 +2936,7 @@ static int opt_seek(const char *opt, const char *arg)
return 0;
}
static int opt_duration(const char *opt, const char *arg)
static int opt_duration(void *optctx, const char *opt, const char *arg)
{
duration = parse_time_or_die(opt, arg, 1);
return 0;
@ -3018,7 +3018,7 @@ static const OptionDef options[] = {
{ "showmode", HAS_ARG, {(void*)opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
{ "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { (void*)opt_default }, "generic catch all option", "" },
{ "i", OPT_BOOL, {(void *)&dummy}, "read specified file", "input_file"},
{ "codec", HAS_ARG | OPT_FUNC2, {(void*)opt_codec}, "force decoder", "decoder" },
{ "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder" },
{ NULL, },
};

14
ffprobe.c
View File

@ -2042,7 +2042,7 @@ static void ffprobe_show_library_versions(WriterContext *w)
writer_print_chapter_footer(w, "library_versions");
}
static int opt_format(const char *opt, const char *arg)
static int opt_format(void *optctx, const char *opt, const char *arg)
{
iformat = av_find_input_format(arg);
if (!iformat) {
@ -2052,7 +2052,7 @@ static int opt_format(const char *opt, const char *arg)
return 0;
}
static int opt_show_format_entry(const char *opt, const char *arg)
static int opt_show_format_entry(void *optctx, const char *opt, const char *arg)
{
do_show_format = 1;
av_dict_set(&fmt_entries_to_show, arg, "", 0);
@ -2072,6 +2072,12 @@ static void opt_input_file(void *optctx, const char *arg)
input_filename = arg;
}
static int opt_input_file_i(void *optctx, const char *opt, const char *arg)
{
opt_input_file(optctx, arg);
return 0;
}
void show_help_default(const char *opt, const char *arg)
{
av_log_set_callback(log_callback_help);
@ -2082,7 +2088,7 @@ void show_help_default(const char *opt, const char *arg)
show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
}
static int opt_pretty(const char *opt, const char *arg)
static int opt_pretty(void *optctx, const char *opt, const char *arg)
{
show_value_unit = 1;
use_value_prefix = 1;
@ -2128,7 +2134,7 @@ static const OptionDef real_options[] = {
{ "show_private_data", OPT_BOOL, {(void*)&show_private_data}, "show private data" },
{ "private", OPT_BOOL, {(void*)&show_private_data}, "same as show_private_data" },
{ "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {.func_arg = opt_default}, "generic catch all option", "" },
{ "i", HAS_ARG, {(void *)opt_input_file}, "read specified file", "input_file"},
{ "i", HAS_ARG, {.func_arg = opt_input_file_i}, "read specified file", "input_file"},
{ NULL, },
};

10
libavcodec/avcodec.h
View File

@ -501,6 +501,16 @@ typedef struct AVCodecDescriptor {
* Video codecs only.
*/
#define AV_CODEC_PROP_INTRA_ONLY (1 << 0)
/**
* Codec supports lossy compression. Audio and video codecs only.
* @note a codec may support both lossy and lossless
* compression modes
*/
#define AV_CODEC_PROP_LOSSY (1 << 1)
/**
* Codec supports lossless compression. Audio and video codecs only.
*/
#define AV_CODEC_PROP_LOSSLESS (1 << 2)
#if FF_API_OLD_DECODE_AUDIO
/* in bytes */

363
libavcodec/codec_desc.c
View File

File diff suppressed because it is too large Load Diff

227
libavcodec/g723_1.c
View File

@ -37,6 +37,8 @@
#include "celp_math.h"
#include "g723_1_data.h"
#define CNG_RANDOM_SEED 12345
typedef struct g723_1_context {
AVClass *class;
AVFrame frame;
@ -50,6 +52,7 @@ typedef struct g723_1_context {
int erased_frames;
int16_t prev_lsp[LPC_ORDER];
int16_t sid_lsp[LPC_ORDER];
int16_t prev_excitation[PITCH_MAX];
int16_t excitation[PITCH_MAX + FRAME_LEN + 4];
int16_t synth_mem[LPC_ORDER];
@ -57,6 +60,7 @@ typedef struct g723_1_context {
int iir_mem[LPC_ORDER];
int random_seed;
int cng_random_seed;
int interp_index;
int interp_gain;
int sid_gain;
@ -65,7 +69,8 @@ typedef struct g723_1_context {
int pf_gain; ///< formant postfilter
///< gain scaling unit memory
int postfilter;
int16_t audio[FRAME_LEN + LPC_ORDER + PITCH_MAX];
int16_t audio[FRAME_LEN + LPC_ORDER + PITCH_MAX + 4];
int16_t prev_data[HALF_FRAME_LEN];
int16_t prev_weight_sig[PITCH_MAX];
@ -91,6 +96,10 @@ static av_cold int g723_1_decode_init(AVCodecContext *avctx)
avctx->coded_frame = &p->frame;
memcpy(p->prev_lsp, dc_lsp, LPC_ORDER * sizeof(*p->prev_lsp));
memcpy(p->sid_lsp, dc_lsp, LPC_ORDER * sizeof(*p->sid_lsp));
p->cng_random_seed = CNG_RANDOM_SEED;
p->past_frame_type = SID_FRAME;
return 0;
}
@ -947,6 +956,201 @@ static void formant_postfilter(G723_1_Context *p, int16_t *lpc,
}
}
static int sid_gain_to_lsp_index(int gain)
{
if (gain < 0x10)
return gain << 6;
else if (gain < 0x20)
return gain - 8 << 7;
else
return gain - 20 << 8;
}
static inline int cng_rand(int *state, int base)
{
*state = (*state * 521 + 259) & 0xFFFF;
return (*state & 0x7FFF) * base >> 15;
}
static int estimate_sid_gain(G723_1_Context *p)
{
int i, shift, seg, seg2, t, val, val_add, x, y;
shift = 16 - p->cur_gain * 2;
if (shift > 0)
t = p->sid_gain << shift;
else
t = p->sid_gain >> -shift;
x = t * cng_filt[0] >> 16;
if (x >= cng_bseg[2])
return 0x3F;
if (x >= cng_bseg[1]) {
shift = 4;
seg = 3;
} else {
shift = 3;
seg = (x >= cng_bseg[0]);
}
seg2 = FFMIN(seg, 3);
val = 1 << shift;
val_add = val >> 1;
for (i = 0; i < shift; i++) {
t = seg * 32 + (val << seg2);
t *= t;
if (x >= t)
val += val_add;
else
val -= val_add;
val_add >>= 1;
}
t = seg * 32 + (val << seg2);
y = t * t - x;
if (y <= 0) {
t = seg * 32 + (val + 1 << seg2);
t = t * t - x;
val = (seg2 - 1 << 4) + val;
if (t >= y)
val++;
} else {
t = seg * 32 + (val - 1 << seg2);
t = t * t - x;
val = (seg2 - 1 << 4) + val;
if (t >= y)
val--;
}
return val;
}
static void generate_noise(G723_1_Context *p)
{
int i, j, idx, t;
int off[SUBFRAMES];
int signs[SUBFRAMES / 2 * 11], pos[SUBFRAMES / 2 * 11];
int tmp[SUBFRAME_LEN * 2];
int16_t *vector_ptr;
int64_t sum;
int b0, c, delta, x, shift;
p->pitch_lag[0] = cng_rand(&p->cng_random_seed, 21) + 123;
p->pitch_lag[1] = cng_rand(&p->cng_random_seed, 19) + 123;
for (i = 0; i < SUBFRAMES; i++) {
p->subframe[i].ad_cb_gain = cng_rand(&p->cng_random_seed, 50) + 1;
p->subframe[i].ad_cb_lag = cng_adaptive_cb_lag[i];
}
for (i = 0; i < SUBFRAMES / 2; i++) {
t = cng_rand(&p->cng_random_seed, 1 << 13);
off[i * 2] = t & 1;
off[i * 2 + 1] = ((t >> 1) & 1) + SUBFRAME_LEN;
t >>= 2;
for (j = 0; j < 11; j++) {
signs[i * 11 + j] = (t & 1) * 2 - 1 << 14;
t >>= 1;
}
}
idx = 0;
for (i = 0; i < SUBFRAMES; i++) {
for (j = 0; j < SUBFRAME_LEN / 2; j++)
tmp[j] = j;
t = SUBFRAME_LEN / 2;
for (j = 0; j < pulses[i]; j++, idx++) {
int idx2 = cng_rand(&p->cng_random_seed, t);
pos[idx] = tmp[idx2] * 2 + off[i];
tmp[idx2] = tmp[--t];
}
}
vector_ptr = p->audio + LPC_ORDER;
memcpy(vector_ptr, p->prev_excitation,
PITCH_MAX * sizeof(*p->excitation));
for (i = 0; i < SUBFRAMES; i += 2) {
gen_acb_excitation(vector_ptr, vector_ptr,
p->pitch_lag[i >> 1], &p->subframe[i],
p->cur_rate);
gen_acb_excitation(vector_ptr + SUBFRAME_LEN,
vector_ptr + SUBFRAME_LEN,
p->pitch_lag[i >> 1], &p->subframe[i + 1],
p->cur_rate);
t = 0;
for (j = 0; j < SUBFRAME_LEN * 2; j++)
t |= FFABS(vector_ptr[j]);
t = FFMIN(t, 0x7FFF);
if (!t) {
shift = 0;
} else {
shift = -10 + av_log2(t);
if (shift < -2)
shift = -2;
}
sum = 0;
if (shift < 0) {
for (j = 0; j < SUBFRAME_LEN * 2; j++) {
t = vector_ptr[j] << -shift;
sum += t * t;
tmp[j] = t;
}
} else {
for (j = 0; j < SUBFRAME_LEN * 2; j++) {
t = vector_ptr[j] >> shift;
sum += t * t;
tmp[j] = t;
}
}
b0 = 0;
for (j = 0; j < 11; j++)
b0 += tmp[pos[(i / 2) * 11 + j]] * signs[(i / 2) * 11 + j];
b0 = b0 * 2 * 2979LL + (1 << 29) >> 30; // approximated division by 11
c = p->cur_gain * (p->cur_gain * SUBFRAME_LEN >> 5);
if (shift * 2 + 3 >= 0)
c >>= shift * 2 + 3;
else
c <<= -(shift * 2 + 3);
c = (av_clipl_int32(sum << 1) - c) * 2979LL >> 15;
delta = b0 * b0 * 2 - c;
if (delta <= 0) {
x = -b0;
} else {
delta = square_root(delta);
x = delta - b0;
t = delta + b0;
if (FFABS(t) < FFABS(x))
x = -t;
}
shift++;
if (shift < 0)
x >>= -shift;
else
x <<= shift;
x = av_clip(x, -10000, 10000);
for (j = 0; j < 11; j++) {
idx = (i / 2) * 11 + j;
vector_ptr[pos[idx]] = av_clip_int16(vector_ptr[pos[idx]] +
(x * signs[idx] >> 15));
}
/* copy decoded data to serve as a history for the next decoded subframes */
memcpy(vector_ptr + PITCH_MAX, vector_ptr,
sizeof(*vector_ptr) * SUBFRAME_LEN * 2);
vector_ptr += SUBFRAME_LEN * 2;
}
/* Save the excitation for the next frame */
memcpy(p->prev_excitation, p->audio + LPC_ORDER + FRAME_LEN,
PITCH_MAX * sizeof(*p->excitation));
}
static int g723_1_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
@ -1071,14 +1275,23 @@ static int g723_1_decode_frame(AVCodecContext *avctx, void *data,
PITCH_MAX * sizeof(*p->excitation));
}
}
p->cng_random_seed = CNG_RANDOM_SEED;
} else {
memset(out, 0, FRAME_LEN * 2);
av_log(avctx, AV_LOG_WARNING,
"G.723.1: Comfort noise generation not supported yet\n");
if (p->cur_frame_type == SID_FRAME) {
p->sid_gain = sid_gain_to_lsp_index(p->subframe[0].amp_index);
inverse_quant(p->sid_lsp, p->prev_lsp, p->lsp_index, 0);
} else if (p->past_frame_type == ACTIVE_FRAME) {
p->sid_gain = estimate_sid_gain(p);
}
*got_frame_ptr = 1;
*(AVFrame *)data = p->frame;
return frame_size[dec_mode];
if (p->past_frame_type == ACTIVE_FRAME)
p->cur_gain = p->sid_gain;
else
p->cur_gain = (p->cur_gain * 7 + p->sid_gain) >> 3;
generate_noise(p);
lsp_interpolate(lpc, p->sid_lsp, p->prev_lsp);
/* Save the lsp_vector for the next frame */
memcpy(p->prev_lsp, p->sid_lsp, LPC_ORDER * sizeof(*p->prev_lsp));
}
p->past_frame_type = p->cur_frame_type;

6
libavcodec/g723_1_data.h
View File

@ -1319,4 +1319,10 @@ static const int16_t percept_flt_tbl[2][LPC_ORDER] = {
{16384, 8192, 4096, 2048, 1024, 512, 256, 128, 64, 32}
};
static const int cng_adaptive_cb_lag[4] = { 1, 0, 1, 3 };
static const int cng_filt[4] = { 273, 998, 499, 333 };
static const int cng_bseg[3] = { 2048, 18432, 231233 };
#endif /* AVCODEC_G723_1_DATA_H */

14
libavcodec/utvideoenc.c
View File

@ -62,6 +62,7 @@ static av_cold int utvideo_encode_init(AVCodecContext *avctx)
c->avctx = avctx;
c->frame_info_size = 4;
c->slice_stride = FFALIGN(avctx->width, 32);
switch (avctx->pix_fmt) {
case PIX_FMT_RGB24:
@ -145,7 +146,6 @@ static av_cold int utvideo_encode_init(AVCodecContext *avctx)
}
for (i = 0; i < c->planes; i++) {
c->slice_stride = FFALIGN(avctx->width, 32);
c->slice_buffer[i] = av_malloc(c->slice_stride * (avctx->height + 2) +
FF_INPUT_BUFFER_PADDING_SIZE);
if (!c->slice_buffer[i]) {
@ -202,14 +202,14 @@ static void mangle_rgb_planes(uint8_t *dst[4], int dst_stride, uint8_t *src,
{
int i, j;
int k = 2 * dst_stride;
unsigned g;
unsigned int g;
for (j = 0; j < height; j++) {
if (step == 3) {
for (i = 0; i < width * step; i += step) {
g = src[i + 1];
dst[0][k] = g;
g += 0x80;
g += 0x80;
dst[1][k] = src[i + 2] - g;
dst[2][k] = src[i + 0] - g;
k++;
@ -218,7 +218,7 @@ static void mangle_rgb_planes(uint8_t *dst[4], int dst_stride, uint8_t *src,
for (i = 0; i < width * step; i += step) {
g = src[i + 1];
dst[0][k] = g;
g += 0x80;
g += 0x80;
dst[1][k] = src[i + 2] - g;
dst[2][k] = src[i + 0] - g;
dst[3][k] = src[i + 3];
@ -266,7 +266,7 @@ static void median_predict(UtvideoContext *c, uint8_t *src, uint8_t *dst, int st
int width, int height)
{
int i, j;
int A, C;
int A, B;
uint8_t prev;
/* First line uses left neighbour prediction */
@ -285,11 +285,11 @@ static void median_predict(UtvideoContext *c, uint8_t *src, uint8_t *dst, int st
* Second line uses top prediction for the first sample,
* and median for the rest.
*/
A = C = 0;
A = B = 0;
/* Rest of the coded part uses median prediction */
for (j = 1; j < height; j++) {
c->dsp.sub_hfyu_median_prediction(dst, src - stride, src, width, &A, &C);
c->dsp.sub_hfyu_median_prediction(dst, src - stride, src, width, &A, &B);
dst += width;
src += stride;
}

2
libavcodec/version.h
View File

@ -28,7 +28,7 @@
#define LIBAVCODEC_VERSION_MAJOR 54
#define LIBAVCODEC_VERSION_MINOR 54
#define LIBAVCODEC_VERSION_MICRO 100
#define LIBAVCODEC_VERSION_MICRO 101
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
LIBAVCODEC_VERSION_MINOR, \

10
libavcodec/x86/dsputil_mmx.c
View File

@ -2822,7 +2822,7 @@ static void dsputil_init_mmx2(DSPContext *c, AVCodecContext *avctx,
#endif
SET_QPEL_FUNCS(put_h264_qpel, 2, 4, 10_mmxext, ff_);
SET_QPEL_FUNCS(avg_h264_qpel, 2, 4, 10_mmxext, ff_);
#endif
#endif /* HAVE_YASM */
}
#if HAVE_INLINE_ASM
@ -2857,7 +2857,7 @@ static void dsputil_init_mmx2(DSPContext *c, AVCodecContext *avctx,
} else {
c->apply_window_int16 = ff_apply_window_int16_mmxext;
}
#endif
#endif /* HAVE_YASM */
}
static void dsputil_init_3dnow(DSPContext *c, AVCodecContext *avctx,
@ -2936,7 +2936,7 @@ static void dsputil_init_3dnow(DSPContext *c, AVCodecContext *avctx,
c->avg_h264_chroma_pixels_tab[0] = ff_avg_h264_chroma_mc8_3dnow_rnd;
c->avg_h264_chroma_pixels_tab[1] = ff_avg_h264_chroma_mc4_3dnow;
}
#endif
#endif /* HAVE_YASM */
}
static void dsputil_init_3dnowext(DSPContext *c, AVCodecContext *avctx,
@ -2982,7 +2982,7 @@ static void dsputil_init_sse(DSPContext *c, AVCodecContext *avctx, int mm_flags)
#if HAVE_INLINE_ASM
c->gmc = gmc_sse;
#endif
#endif
#endif /* HAVE_YASM */
}
static void dsputil_init_sse2(DSPContext *c, AVCodecContext *avctx,
@ -3050,7 +3050,7 @@ static void dsputil_init_sse2(DSPContext *c, AVCodecContext *avctx,
c->apply_window_int16 = ff_apply_window_int16_sse2;
}
c->bswap_buf = ff_bswap32_buf_sse2;
#endif
#endif /* HAVE_YASM */
}
static void dsputil_init_ssse3(DSPContext *c, AVCodecContext *avctx,

4
libavcodec/x86/fmtconvert_init.c
View File

@ -110,7 +110,7 @@ static void float_interleave_sse(float *dst, const float **src,
else
ff_float_interleave_c(dst, src, len, channels);
}
#endif
#endif /* HAVE_YASM */
void ff_fmt_convert_init_x86(FmtConvertContext *c, AVCodecContext *avctx)
{
@ -143,5 +143,5 @@ void ff_fmt_convert_init_x86(FmtConvertContext *c, AVCodecContext *avctx)
c->float_to_int16_interleave = float_to_int16_interleave_sse2;
}
}
#endif
#endif /* HAVE_YASM */
}

4
libavcodec/x86/mpegaudiodec.c
View File

@ -182,6 +182,7 @@ static void apply_window_mp3(float *in, float *win, int *unused, float *out,
#endif /* HAVE_INLINE_ASM */
#if HAVE_YASM
#define DECL_IMDCT_BLOCKS(CPU1, CPU2) \
static void imdct36_blocks_ ## CPU1(float *out, float *buf, float *in, \
int count, int switch_point, int block_type) \
@ -214,7 +215,6 @@ static void imdct36_blocks_ ## CPU1(float *out, float *buf, float *in, \
} \
}
#if HAVE_YASM
#if HAVE_SSE
DECL_IMDCT_BLOCKS(sse,sse)
DECL_IMDCT_BLOCKS(sse2,sse)
@ -224,7 +224,7 @@ DECL_IMDCT_BLOCKS(ssse3,sse)
#if HAVE_AVX
DECL_IMDCT_BLOCKS(avx,avx)
#endif
#endif
#endif /* HAVE_YASM */
void ff_mpadsp_init_mmx(MPADSPContext *s)
{

34
libavcodec/x86/mpegvideoenc.c
View File

@ -30,13 +30,16 @@
extern uint16_t ff_inv_zigzag_direct16[64];
#if HAVE_MMX
#define COMPILE_TEMPLATE_MMXEXT 0
#define COMPILE_TEMPLATE_SSE2 0
#define COMPILE_TEMPLATE_SSSE3 0
#define RENAME(a) a ## _MMX
#define RENAMEl(a) a ## _mmx
#include "mpegvideoenc_template.c"
#endif /* HAVE_MMX */
#if HAVE_MMXEXT
#undef COMPILE_TEMPLATE_SSSE3
#undef COMPILE_TEMPLATE_SSE2
#undef COMPILE_TEMPLATE_MMXEXT
@ -48,7 +51,9 @@ extern uint16_t ff_inv_zigzag_direct16[64];
#define RENAME(a) a ## _MMX2
#define RENAMEl(a) a ## _mmx2
#include "mpegvideoenc_template.c"
#endif /* HAVE_MMXEXT */
#if HAVE_SSE2
#undef COMPILE_TEMPLATE_MMXEXT
#undef COMPILE_TEMPLATE_SSE2
#undef COMPILE_TEMPLATE_SSSE3
@ -60,6 +65,7 @@ extern uint16_t ff_inv_zigzag_direct16[64];
#define RENAME(a) a ## _SSE2
#define RENAMEl(a) a ## _sse2
#include "mpegvideoenc_template.c"
#endif /* HAVE_SSE2 */
#if HAVE_SSSE3
#undef COMPILE_TEMPLATE_MMXEXT
@ -73,7 +79,7 @@ extern uint16_t ff_inv_zigzag_direct16[64];
#define RENAME(a) a ## _SSSE3
#define RENAMEl(a) a ## _sse2
#include "mpegvideoenc_template.c"
#endif
#endif /* HAVE_SSSE3 */
#endif /* HAVE_INLINE_ASM */
@ -84,18 +90,22 @@ void ff_MPV_encode_init_x86(MpegEncContext *s)
const int dct_algo = s->avctx->dct_algo;
if (dct_algo == FF_DCT_AUTO || dct_algo == FF_DCT_MMX) {
#if HAVE_SSSE3
if (mm_flags & AV_CPU_FLAG_SSSE3) {
s->dct_quantize = dct_quantize_SSSE3;
} else
#endif
if (mm_flags & AV_CPU_FLAG_SSE2 && HAVE_SSE) {
s->dct_quantize = dct_quantize_SSE2;
} else if (mm_flags & AV_CPU_FLAG_MMXEXT && HAVE_MMXEXT) {
s->dct_quantize = dct_quantize_MMX2;
} else if (mm_flags & AV_CPU_FLAG_MMX && HAVE_MMX) {
#if HAVE_MMX
if (mm_flags & AV_CPU_FLAG_MMX && HAVE_MMX)
s->dct_quantize = dct_quantize_MMX;
}
#endif
#if HAVE_MMXEXT
if (mm_flags & AV_CPU_FLAG_MMXEXT && HAVE_MMXEXT)
s->dct_quantize = dct_quantize_MMX2;
#endif
#if HAVE_SSE2
if (mm_flags & AV_CPU_FLAG_SSE2 && HAVE_SSE2)
s->dct_quantize = dct_quantize_SSE2;
#endif
#if HAVE_SSSE3
if (mm_flags & AV_CPU_FLAG_SSSE3)
s->dct_quantize = dct_quantize_SSSE3;
#endif
}
#endif /* HAVE_INLINE_ASM */
}

2
libavcodec/x86/rv34dsp_init.c
View File

@ -43,5 +43,5 @@ av_cold void ff_rv34dsp_init_x86(RV34DSPContext* c, DSPContext *dsp)
}
if (mm_flags & AV_CPU_FLAG_SSE4)
c->rv34_idct_dc_add = ff_rv34_idct_dc_add_sse4;
#endif
#endif /* HAVE_YASM */
}

15
libavcodec/x86/rv40dsp_init.c
View File

@ -2,20 +2,20 @@
* RV40 decoder motion compensation functions x86-optimised
* Copyright (c) 2008 Konstantin Shishkov
*
* This file is part of Libav.
* This file is part of FFmpeg.
*
* Libav is free software; you can redistribute it and/or
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Libav is distributed in the hope that it will be useful,
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with Libav; if not, write to the Free Software
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
@ -30,6 +30,7 @@
#include "libavutil/mem.h"
#include "dsputil_mmx.h"
#if HAVE_YASM
void ff_put_rv40_chroma_mc8_mmx (uint8_t *dst, uint8_t *src,
int stride, int h, int x, int y);
void ff_avg_rv40_chroma_mc8_mmx2 (uint8_t *dst, uint8_t *src,
@ -57,8 +58,6 @@ DECLARE_WEIGHT(mmx2)
DECLARE_WEIGHT(sse2)
DECLARE_WEIGHT(ssse3)
#if HAVE_YASM
/** @{ */
/**
* Define one qpel function.
@ -185,7 +184,7 @@ QPEL_FUNCS_SET (OP, 3, 1, OPT) \
QPEL_FUNCS_SET (OP, 3, 2, OPT)
/** @} */
#endif //HAVE_YASM
#endif /* HAVE_YASM */
void ff_rv40dsp_init_x86(RV34DSPContext *c, DSPContext *dsp)
{
@ -238,5 +237,5 @@ void ff_rv40dsp_init_x86(RV34DSPContext *c, DSPContext *dsp)
QPEL_MC_SET(put_, _ssse3)
QPEL_MC_SET(avg_, _ssse3)
}
#endif
#endif /* HAVE_YASM */
}

5
libavcodec/x86/vc1dsp_mmx.c
View File

@ -717,8 +717,7 @@ static void vc1_h_loop_filter16_sse4(uint8_t *src, int stride, int pq)
ff_vc1_h_loop_filter8_sse4(src, stride, pq);
ff_vc1_h_loop_filter8_sse4(src+8*stride, stride, pq);
}
#endif
#endif /* HAVE_YASM */
void ff_put_vc1_chroma_mc8_mmx_nornd (uint8_t *dst, uint8_t *src,
int stride, int h, int x, int y);
@ -828,5 +827,5 @@ void ff_vc1dsp_init_mmx(VC1DSPContext *dsp)
dsp->vc1_h_loop_filter8 = ff_vc1_h_loop_filter8_sse4;
dsp->vc1_h_loop_filter16 = vc1_h_loop_filter16_sse4;
}
#endif
#endif /* HAVE_YASM */
}

4
libavcodec/x86/vp8dsp_init.c
View File

@ -289,7 +289,7 @@ DECLARE_LOOP_FILTER(sse2)
DECLARE_LOOP_FILTER(ssse3)
DECLARE_LOOP_FILTER(sse4)
#endif
#endif /* HAVE_YASM */
#define VP8_LUMA_MC_FUNC(IDX, SIZE, OPT) \
c->put_vp8_epel_pixels_tab[IDX][0][2] = ff_put_vp8_epel ## SIZE ## _h6_ ## OPT; \
@ -446,5 +446,5 @@ av_cold void ff_vp8dsp_init_x86(VP8DSPContext* c)
c->vp8_h_loop_filter8uv = ff_vp8_h_loop_filter8uv_mbedge_sse4;
#endif
}
#endif
#endif /* HAVE_YASM */
}

4
libavfilter/x86/yadif.c
View File

@ -31,7 +31,7 @@ DECLARE_ASM_CONST(16, const xmm_reg, pb_1) = {0x0101010101010101ULL, 0x010101010
DECLARE_ASM_CONST(16, const xmm_reg, pw_1) = {0x0001000100010001ULL, 0x0001000100010001ULL};
#if HAVE_SSSE3
#define COMPILE_TEMPLATE_SSE 1
#define COMPILE_TEMPLATE_SSE2 1
#define COMPILE_TEMPLATE_SSSE3 1
#undef RENAME
#define RENAME(a) a ## _ssse3
@ -43,7 +43,7 @@ DECLARE_ASM_CONST(16, const xmm_reg, pw_1) = {0x0001000100010001ULL, 0x000100010
#undef RENAME
#define RENAME(a) a ## _sse2
#include "yadif_template.c"
#undef COMPILE_TEMPLATE_SSE
#undef COMPILE_TEMPLATE_SSE2
#endif
#if HAVE_MMXEXT

2
libavfilter/x86/yadif_template.c
View File

@ -18,7 +18,7 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifdef COMPILE_TEMPLATE_SSE
#ifdef COMPILE_TEMPLATE_SSE2
#define MM "%%xmm"
#define MOV "movq"
#define MOVQ "movdqa"

2
libavresample/x86/audio_mix_init.c
View File

@ -210,5 +210,5 @@ av_cold void ff_audio_mix_init_x86(AudioMix *am)
SET_MIX_3_8_TO_1_2(6)
SET_MIX_3_8_TO_1_2(7)
SET_MIX_3_8_TO_1_2(8)
#endif
#endif /* HAVE_YASM */
}

4
libavutil/x86/cpu.c
View File

@ -144,8 +144,8 @@ int ff_get_cpu_flags_x86(void)
if ((eax & 0x6) == 0x6)
rval |= AV_CPU_FLAG_AVX;
}
#endif
#endif
#endif /* HAVE_AVX */
#endif /* HAVE_SSE */
}
cpuid(0x80000000, max_ext_level, ebx, ecx, edx);

2
libswscale/x86/swscale.c
View File

@ -474,7 +474,7 @@ switch(c->dstBpc){ \
if (cpu_flags & AV_CPU_FLAG_MMXEXT) {
ASSIGN_VSCALEX_FUNC(c->yuv2planeX, mmx2, , 1);
}
#endif
#endif /* ARCH_X86_32 */
#define ASSIGN_SSE_SCALE_FUNC(hscalefn, filtersize, opt1, opt2) \
switch (filtersize) { \
case 4: ASSIGN_SCALE_FUNC2(hscalefn, 4, opt1, opt2); break; \

6
tests/fate/voice.mak
View File

@ -27,6 +27,12 @@ fate-g723_1-dec-5: CMD = framecrc -postfilter 1 -i $(SAMPLES)/g723_1/pathd63p.tc
FATE_G723_1 += fate-g723_1-dec-6
fate-g723_1-dec-6: CMD = framecrc -postfilter 1 -i $(SAMPLES)/g723_1/tamed63p.tco
FATE_G723_1 += fate-g723_1-dec-7
fate-g723_1-dec-7: CMD = framecrc -postfilter 1 -i $(SAMPLES)/g723_1/dtx63b.tco
FATE_G723_1 += fate-g723_1-dec-8
fate-g723_1-dec-8: CMD = framecrc -postfilter 1 -i $(SAMPLES)/g723_1/dtx63e.tco
FATE_SAMPLES_AVCONV += $(FATE_G723_1)
fate-g723_1: $(FATE_G723_1)

12
tests/ref/fate/g723_1-dec-7 Normal file
View File

@ -0,0 +1,12 @@
#tb 0: 1/8000
0, 0, 0, 240, 480, 0x35e4a1fd
0, 240, 240, 240, 480, 0x2f7bdd60
0, 480, 480, 240, 480, 0x0407e499
0, 720, 720, 240, 480, 0x5f5ef209
0, 960, 960, 240, 480, 0xe936e8d1
0, 1200, 1200, 240, 480, 0x0896ddba
0, 1440, 1440, 240, 480, 0xa885ea94
0, 1680, 1680, 240, 480, 0x40bff3d0
0, 1920, 1920, 240, 480, 0xe05ce4c3
0, 2160, 2160, 240, 480, 0x80c4f790
0, 2400, 2400, 240, 480, 0x65d5e8f9

121
tests/ref/fate/g723_1-dec-8 Normal file
View File

@ -0,0 +1,121 @@
#tb 0: 1/8000
0, 0, 0, 240, 480, 0x17930e0f
0, 240, 240, 240, 480, 0x7c7f4247
0, 480, 480, 240, 480, 0xbf3489e5
0, 720, 720, 240, 480, 0x24319fc9
0, 960, 960, 240, 480, 0xb327eec0
0, 1200, 1200, 240, 480, 0xc2ddcbca
0, 1440, 1440, 240, 480, 0xeebad740
0, 1680, 1680, 240, 480, 0x77fcb933
0, 1920, 1920, 240, 480, 0x9677c5b7
0, 2160, 2160, 240, 480, 0xb49dcb9e
0, 2400, 2400, 240, 480, 0x0e78d7e6
0, 2640, 2640, 240, 480, 0xf752dc3e
0, 2880, 2880, 240, 480, 0xc95af091
0, 3120, 3120, 240, 480, 0xa25de399
0, 3360, 3360, 240, 480, 0x34e7e0da
0, 3600, 3600, 240, 480, 0x6c84e3f4
0, 3840, 3840, 240, 480, 0x2c7dda20
0, 4080, 4080, 240, 480, 0x00a5f112
0, 4320, 4320, 240, 480, 0x943ddd89
0, 4560, 4560, 240, 480, 0x4ad4ebac
0, 4800, 4800, 240, 480, 0xa4ff0aa8
0, 5040, 5040, 240, 480, 0xc0f805f2
0, 5280, 5280, 240, 480, 0x859ce987
0, 5520, 5520, 240, 480, 0x9ebcd0de
0, 5760, 5760, 240, 480, 0x3de2db0b
0, 6000, 6000, 240, 480, 0x0affea9c
0, 6240, 6240, 240, 480, 0xcb1bf81e
0, 6480, 6480, 240, 480, 0x8a72d71d
0, 6720, 6720, 240, 480, 0x583cd5cd
0, 6960, 6960, 240, 480, 0x4be7dc7b
0, 7200, 7200, 240, 480, 0xb08108c0
0, 7440, 7440, 240, 480, 0xd0b3ed59
0, 7680, 7680, 240, 480, 0x7d33f822
0, 7920, 7920, 240, 480, 0x199c0111
0, 8160, 8160, 240, 480, 0x7d29f2a8
0, 8400, 8400, 240, 480, 0x424dec5e
0, 8640, 8640, 240, 480, 0x946cf258
0, 8880, 8880, 240, 480, 0xd429da7a
0, 9120, 9120, 240, 480, 0x0f11df46
0, 9360, 9360, 240, 480, 0xf4dce502
0, 9600, 9600, 240, 480, 0x01c1de78
0, 9840, 9840, 240, 480, 0xd1d3da59
0, 10080, 10080, 240, 480, 0x5822f3ec
0, 10320, 10320, 240, 480, 0xadd5fe67
0, 10560, 10560, 240, 480, 0xdcf5f2c3
0, 10800, 10800, 240, 480, 0x5176e39b
0, 11040, 11040, 240, 480, 0xf947e0b1
0, 11280, 11280, 240, 480, 0x33b1eb36
0, 11520, 11520, 240, 480, 0x57bce9bd
0, 11760, 11760, 240, 480, 0x806eec1f
0, 12000, 12000, 240, 480, 0x0a60f94a
0, 12240, 12240, 240, 480, 0x9eddf27d
0, 12480, 12480, 240, 480, 0x3d28ef2f
0, 12720, 12720, 240, 480, 0x52f0e562
0, 12960, 12960, 240, 480, 0xf2d6c8a0
0, 13200, 13200, 240, 480, 0xfa0df4a1
0, 13440, 13440, 240, 480, 0x9cccfda9
0, 13680, 13680, 240, 480, 0xa7c1e528
0, 13920, 13920, 240, 480, 0xe130e8f9
0, 14160, 14160, 240, 480, 0x80f6eabe
0, 14400, 14400, 240, 480, 0x9bbb027e
0, 14640, 14640, 240, 480, 0x33cdea7f
0, 14880, 14880, 240, 480, 0x84d8e761
0, 15120, 15120, 240, 480, 0xb99ce457
0, 15360, 15360, 240, 480, 0x5dc1e324
0, 15600, 15600, 240, 480, 0xc914e6c3
0, 15840, 15840, 240, 480, 0x8e77f5c2
0, 16080, 16080, 240, 480, 0x3997034d
0, 16320, 16320, 240, 480, 0x820cfd49
0, 16560, 16560, 240, 480, 0x8ad5f24c
0, 16800, 16800, 240, 480, 0xe21be71c
0, 17040, 17040, 240, 480, 0x516ae8c8
0, 17280, 17280, 240, 480, 0x595bdc3d
0, 17520, 17520, 240, 480, 0x8a4bee79
0, 17760, 17760, 240, 480, 0x307fed64
0, 18000, 18000, 240, 480, 0xe71cf219
0, 18240, 18240, 240, 480, 0xdb0be1a1
0, 18480, 18480, 240, 480, 0x7947dfbd
0, 18720, 18720, 240, 480, 0x5d90fbf0
0, 18960, 18960, 240, 480, 0xa449fc55
0, 19200, 19200, 240, 480, 0x45b2f979
0, 19440, 19440, 240, 480, 0x2b2be378
0, 19680, 19680, 240, 480, 0x2d2edf42
0, 19920, 19920, 240, 480, 0x568ee04f
0, 20160, 20160, 240, 480, 0x66f0debe
0, 20400, 20400, 240, 480, 0xc943eab7
0, 20640, 20640, 240, 480, 0xc9ade3c9
0, 20880, 20880, 240, 480, 0x6971f92d
0, 21120, 21120, 240, 480, 0x48d0ecbc
0, 21360, 21360, 240, 480, 0xf641dc98
0, 21600, 21600, 240, 480, 0xbb18e167
0, 21840, 21840, 240, 480, 0x72ce0968
0, 22080, 22080, 240, 480, 0x15bee6f6
0, 22320, 22320, 240, 480, 0x93d5e91f
0, 22560, 22560, 240, 480, 0x7aee010b
0, 22800, 22800, 240, 480, 0x9e82dc87
0, 23040, 23040, 240, 480, 0x4ee6f547
0, 23280, 23280, 240, 480, 0x3072d102
0, 23520, 23520, 240, 480, 0x74d4fb04
0, 23760, 23760, 240, 480, 0xc670f958
0, 24000, 24000, 240, 480, 0x3965c41f
0, 24240, 24240, 240, 480, 0x6a2de869
0, 24480, 24480, 240, 480, 0xa757f44b
0, 24720, 24720, 240, 480, 0x94a5168c
0, 24960, 24960, 240, 480, 0xef0f0c28
0, 25200, 25200, 240, 480, 0x3770ebb3
0, 25440, 25440, 240, 480, 0x4343de6f
0, 25680, 25680, 240, 480, 0x3ec8d816
0, 25920, 25920, 240, 480, 0x1661e3d3
0, 26160, 26160, 240, 480, 0x077cd9fd
0, 26400, 26400, 240, 480, 0xb5ece07e
0, 26640, 26640, 240, 480, 0xf303e151
0, 26880, 26880, 240, 480, 0x95e4d019
0, 27120, 27120, 240, 480, 0x4bd0ddc0
0, 27360, 27360, 240, 480, 0x6cebd341
0, 27600, 27600, 240, 480, 0xea3fea9e
0, 27840, 27840, 240, 480, 0x5ad30c3f
0, 28080, 28080, 240, 480, 0x218c02a5
0, 28320, 28320, 240, 480, 0x662decd0
0, 28560, 28560, 240, 480, 0x6865e2f2