44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
49 for (i = 0; i < o->nb_ ## name; i++) {\
50 char *spec = o->name[i].specifier;\
51 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52 outvar = o->name[i].u.type;\
58 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
61 for (i = 0; i < o->nb_ ## name; i++) {\
62 char *spec = o->name[i].specifier;\
63 if (!strcmp(spec, mediatype))\
64 outvar = o->name[i].u.type;\
78 #if CONFIG_VIDEOTOOLBOX
148 int i, *
count = (
int*)(so + 1);
149 for (i = 0; i < *
count; i++) {
171 memset(o, 0,
sizeof(*o));
187 printf(
"Hardware acceleration methods:\n");
188 for (i = 0; hwaccels[i].
name; i++) {
189 printf(
"%s\n", hwaccels[i].
name);
202 char *p = strchr(e->
key,
':');
226 const AVClass *pclass = &
class;
234 "If you are looking for an option to preserve the quality (which is not "
235 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
276 static int opt_map(
void *optctx,
const char *opt,
const char *
arg)
280 int i, negative = 0, file_idx;
281 int sync_file_idx = -1, sync_stream_idx = 0;
295 if (sync = strchr(map,
',')) {
297 sync_file_idx = strtol(sync + 1, &sync, 0);
312 "match any streams.\n", arg);
320 const char *
c = map + 1;
329 if (allow_unused = strchr(map,
'?'))
331 file_idx = strtol(map, &p, 0);
343 *p ==
':' ? p + 1 : p) > 0)
349 *p ==
':' ? p + 1 : p) <= 0)
357 if (sync_file_idx >= 0) {
372 "To ignore this, add a trailing '?' to the map.\n", arg);
409 n = sscanf(arg,
"%d.%d.%d:%d.%d",
413 if (n != 3 && n != 5) {
415 "[file.stream.channel|-1][:syncfile:syncstream]\n");
456 static int opt_vaapi_device(
void *optctx,
const char *opt,
const char *
arg)
481 if (*(++arg) && *arg !=
':') {
485 *stream_spec = *arg ==
':' ? arg + 1 :
"";
490 *index = strtol(++arg,
NULL, 0);
505 char type_in, type_out;
506 const char *istream_spec =
NULL, *ostream_spec =
NULL;
507 int idx_in = 0, idx_out = 0;
513 if (type_out ==
'g' || !*outspec)
515 if (type_out ==
's' || !*outspec)
517 if (type_out ==
'c' || !*outspec)
522 if (type_in ==
'g' || type_out ==
'g')
524 if (type_in ==
's' || type_out ==
's')
526 if (type_in ==
'c' || type_out ==
'c')
533 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
534 if ((index) < 0 || (index) >= (nb_elems)) {\
535 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
540 #define SET_DICT(type, meta, context, index)\
543 meta = &context->metadata;\
546 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
547 meta = &context->chapters[index]->metadata;\
550 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
551 meta = &context->programs[index]->metadata;\
555 default: av_assert0(0);\
558 SET_DICT(type_in, meta_in, ic, idx_in);
559 SET_DICT(type_out, meta_out, oc, idx_out);
562 if (type_in ==
's') {
576 if (type_out ==
's') {
595 struct tm time = *gmtime((time_t*)&recording_timestamp);
596 if (!strftime(buf,
sizeof(buf),
"creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
601 "tag instead.\n", opt);
608 const char *codec_string = encoder ?
"encoder" :
"decoder";
620 codec_string, codec->
name, desc->
name);
627 if (codec->
type != type) {
636 char *codec_name =
NULL;
657 char *framerate =
NULL, *hwaccel =
NULL, *hwaccel_device =
NULL;
658 char *hwaccel_output_format =
NULL;
659 char *codec_tag =
NULL;
661 char *discard_str =
NULL;
687 uint32_t
tag = strtol(codec_tag, &next, 0);
752 if (!strcmp(hwaccel,
"none"))
754 else if (!strcmp(hwaccel,
"auto"))
758 for (i = 0; hwaccels[i].
name; i++) {
759 if (!strcmp(hwaccels[i].
name, hwaccel)) {
769 for (i = 0; hwaccels[i].
name; i++)
778 if (hwaccel_device) {
785 hwaccel_output_format, ic, st);
786 if (hwaccel_output_format) {
790 "format: %s", hwaccel_output_format);
806 char *canvas_size =
NULL;
836 fprintf(stderr,
"Error, both -y and -n supplied. Exiting.\n");
842 if (proto_name && !strcmp(proto_name,
"file") &&
avio_check(filename, 0) == 0) {
844 fprintf(stderr,
"File '%s' already exists. Overwrite ? [y/N] ", filename);
847 signal(SIGINT, SIG_DFL);
908 char * data_codec_name =
NULL;
909 int scan_all_pmts_set = 0;
918 if (!strcmp(filename,
"-"))
922 strcmp(filename,
"/dev/stdin");
930 ic->
flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
938 if (file_iformat && file_iformat->
priv_class &&
947 if (file_iformat && file_iformat->
priv_class &&
974 if (video_codec_name)
976 if (audio_codec_name)
978 if (subtitle_codec_name)
988 scan_all_pmts_set = 1;
998 if (scan_all_pmts_set)
1035 int64_t seek_timestamp = timestamp;
1038 int dts_heuristic = 0;
1044 if (dts_heuristic) {
1100 if (!option || foption)
1106 "input file #%d (%s) is not a decoding option.\n", e->
key,
1113 "input file #%d (%s) has not been used for any stream. The most "
1114 "likely reason is either wrong type (e.g. a video option with "
1115 "no video streams) or that it is a private option of some decoder "
1116 "which was not actually used for any stream.\n", e->
key,
1132 for (i = 0; i < orig_nb_streams; i++)
1152 while ((c =
avio_r8(s)) && c !=
'\n')
1163 char filename[1000];
1164 const char *base[3] = { getenv(
"AVCONV_DATADIR"),
1173 snprintf(filename,
sizeof(filename),
"%s%s/%s-%s.avpreset", base[i],
1174 i != 1 ?
"" :
"/.avconv", codec_name, preset_name);
1178 snprintf(filename,
sizeof(filename),
"%s%s/%s.avpreset", base[i],
1179 i != 1 ?
"" :
"/.avconv", preset_name);
1189 char *codec_name =
NULL;
1199 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1200 "probably disabled. Please choose an encoder manually.\n",
1205 }
else if (!strcmp(codec_name,
"copy"))
1226 const char *bsfs =
NULL, *time_base =
NULL;
1227 char *next, *codec_tag =
NULL;
1279 if (!buf[0] || buf[0] ==
'#') {
1283 if (!(arg = strchr(buf,
'='))) {
1295 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1307 q.
num <= 0 || q.
den <= 0) {
1328 while (bsfs && *bsfs) {
1330 char *bsf, *bsf_options_str, *bsf_name;
1335 bsf_name =
av_strtok(bsf,
"=", &bsf_options_str);
1361 const char * shorthand[2] = {
NULL};
1364 shorthand[0] = opt->
name;
1387 uint32_t
tag = strtol(codec_tag, &next, 0);
1419 if (source_index >= 0) {
1436 const char *p = str;
1468 while ((ret =
avio_read(pb, buf,
sizeof(buf))) > 0)
1504 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1505 "Filtering and streamcopy cannot be used together.\n",
1506 ost->
filters ?
"Filtergraph" :
"Filtergraph script",
1518 char *frame_rate =
NULL, *frame_aspect_ratio =
NULL;
1533 if (frame_aspect_ratio) {
1536 q.
num <= 0 || q.
den <= 0) {
1547 const char *p =
NULL;
1549 char *frame_pix_fmt =
NULL;
1550 char *intra_matrix =
NULL, *inter_matrix =
NULL;
1551 char *chroma_intra_matrix =
NULL;
1563 if (frame_pix_fmt && *frame_pix_fmt ==
'+') {
1565 if (!*++frame_pix_fmt)
1566 frame_pix_fmt =
NULL;
1585 if (chroma_intra_matrix) {
1604 for (i = 0; p; i++) {
1606 int e = sscanf(p,
"%d,%d,%d", &start, &end, &q);
1655 char logfilename[1024];
1658 snprintf(logfilename,
sizeof(logfilename),
"%s-%d.log",
1662 if (!strcmp(ost->
enc->name,
"libx264")) {
1666 char *logbuffer =
read_file(logfilename);
1679 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1680 logfilename, strerror(errno));
1728 char *sample_fmt =
NULL;
1854 p = strchr(idx_str,
':');
1857 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1889 if (in_ch->
end < ts_off)
1891 if (rt != INT64_MAX && in_ch->
start > rt + ts_off)
1898 out_ch->id = in_ch->
id;
1900 out_ch->start =
FFMAX(0, in_ch->
start - ts_off);
1901 out_ch->end =
FFMIN(rt, in_ch->
end - ts_off);
1916 ic->
flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
1926 const char *enc_config;
1967 switch (ofilter->
type) {
1984 "which is fed from a complex filtergraph. Filtering and streamcopy "
1990 const char *opt = ost->
filters ?
"-vf/-af/-filter" :
"-filter_script";
1992 "%s '%s' was specified through the %s option "
1993 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1994 "%s and -filter_complex cannot be used together for the same stream.\n",
1995 ost->
filters ?
"Filtergraph" :
"Filtergraph script",
2026 int format_flags = 0;
2056 if (!strcmp(filename,
"-"))
2087 switch (ofilter->
type) {
2097 if (!strcmp(file_oformat->
name,
"ffm") &&
2142 int area = 0, idx = -1;
2164 int best_score = 0, idx = -1;
2170 score > best_score) {
2189 int input_props = 0, output_props = 0;
2192 if (input_descriptor)
2194 if (output_descriptor)
2196 if (subtitle_codec_name ||
2197 input_props & output_props ||
2199 input_descriptor && output_descriptor &&
2200 (!input_descriptor->
props ||
2201 !output_descriptor->
props)) {
2241 "in any defined filter graph, or was already used elsewhere.\n", map->
linklabel);
2272 "Cannot map stream #%d:%d - unsupported type.\n",
2276 "If you want unsupported types ignored instead "
2277 "of failing, please use the -ignore_unknown option\n"
2278 "If you want them copied, please use -copy_unknown\n");
2324 #if FF_API_LAVF_AVCTX
2360 if (!option || foption)
2366 "output file #%d (%s) is not an encoding option.\n", e->
key,
2373 if (!strcmp(e->
key,
"gop_timecode"))
2377 "output file #%d (%s) has not been used for any stream. The most "
2378 "likely reason is either wrong type (e.g. a video option with "
2379 "no video streams) or that it is a private option of some encoder "
2380 "which was not actually used for any stream.\n", e->
key,
2398 "Error initializing a simple filtergraph between streams "
2417 }
else if (ost->
enc->pix_fmts) {
2430 }
else if (ost->
enc->sample_fmts) {
2441 }
else if (ost->
enc->supported_samplerates) {
2443 while (ost->
enc->supported_samplerates[count])
2453 }
else if (ost->
enc->channel_layouts) {
2455 while (ost->
enc->channel_layouts[count])
2478 "No input streams but output needs an input stream\n");
2507 av_log(
NULL,
AV_LOG_FATAL,
"Invalid input file index %d while processing metadata maps\n", in_file_index);
2511 in_file_index >= 0 ?
2550 if (!output_streams[i]->stream_copy) {
2563 const char *to_dealloc = p2;
2578 if (!strcmp(key,
"program_num"))
2579 progid = strtol(p2,
NULL, 0);
2589 const char *to_dealloc = p2;
2598 "No '=' character in program string %s.\n",
2606 if (!strcmp(key,
"title")) {
2608 }
else if (!strcmp(key,
"program_num")) {
2609 }
else if (!strcmp(key,
"st")) {
2610 int st_num = strtol(p2,
NULL, 0);
2625 const char *stream_spec;
2626 int index = 0, j, ret = 0;
2685 static int opt_target(
void *optctx,
const char *opt,
const char *arg)
2689 static const char *
const frame_rates[] = {
"25",
"30000/1001",
"24000/1001" };
2691 if (!strncmp(arg,
"pal-", 4)) {
2694 }
else if (!strncmp(arg,
"ntsc-", 5)) {
2697 }
else if (!strncmp(arg,
"film-", 5)) {
2713 }
else if ((fr == 29970) || (fr == 23976)) {
2733 if (!strcmp(arg,
"vcd")) {
2760 }
else if (!strcmp(arg,
"svcd")) {
2782 }
else if (!strcmp(arg,
"dvd")) {
2804 }
else if (!strncmp(arg,
"dv", 2)) {
2809 parse_option(o,
"pix_fmt", !strncmp(arg,
"dv50", 4) ?
"yuv422p" :
2810 norm ==
PAL ?
"yuv420p" :
"yuv411p",
options);
2834 static int opt_vstats(
void *optctx,
const char *opt,
const char *arg)
2837 time_t today2 = time(
NULL);
2838 struct tm *today = localtime(&today2);
2845 snprintf(filename,
sizeof(filename),
"vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2888 static int opt_preset(
void *optctx,
const char *opt,
const char *arg)
2892 char filename[1000],
line[1000], tmp_line[1000];
2893 const char *codec_name =
NULL;
2899 if (!(f =
get_preset_file(filename,
sizeof(filename), arg, *opt ==
'f', codec_name))) {
2900 if(!strncmp(arg,
"libx264-lossless", strlen(
"libx264-lossless"))){
2907 while (fgets(line,
sizeof(line), f)) {
2908 char *key = tmp_line, *
value, *endptr;
2910 if (strcspn(line,
"#\n\r") == 0)
2912 av_strlcpy(tmp_line, line,
sizeof(tmp_line));
2926 filename, line, key, value);
2936 static int opt_old2new(
void *optctx,
const char *opt,
const char *arg)
2945 static int opt_bitrate(
void *optctx,
const char *opt,
const char *arg)
2949 if(!strcmp(opt,
"ab")){
2952 }
else if(!strcmp(opt,
"b")){
2961 static int opt_qscale(
void *optctx,
const char *opt,
const char *arg)
2966 if(!strcmp(opt,
"qscale")){
2976 static int opt_profile(
void *optctx,
const char *opt,
const char *arg)
2979 if(!strcmp(opt,
"profile")){
3000 static int opt_vsync(
void *optctx,
const char *opt,
const char *arg)
3026 char layout_str[32];
3029 int ret, channels, ac_str_size;
3037 snprintf(layout_str,
sizeof(layout_str),
"%"PRIu64, layout);
3044 snprintf(layout_str,
sizeof(layout_str),
"%d", channels);
3045 stream_str = strchr(opt,
':');
3046 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3101 int show_advanced = 0, show_avoptions = 0;
3104 if (!strcmp(opt,
"long"))
3106 else if (!strcmp(opt,
"full"))
3107 show_advanced = show_avoptions = 1;
3114 printf(
"Getting help:\n"
3115 " -h -- print basic options\n"
3116 " -h long -- print more options\n"
3117 " -h full -- print all options (including all format and codec specific options, very long)\n"
3118 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3119 " See man %s for detailed description of the options.\n"
3126 "instead of just one file:",
3154 if (show_avoptions) {
3198 "%s.\n", inout, g->
arg);
3222 memset(&octx, 0,
sizeof(octx));
3279 if (!strcmp(arg,
"-"))
3291 #define OFFSET(x) offsetof(OptionsContext, x)
3297 "force format",
"fmt" },
3299 "overwrite output files" },
3301 "never overwrite output files" },
3303 "Ignore unknown stream types" },
3305 "Copy unknown stream types" },
3308 "codec name",
"codec" },
3311 "codec name",
"codec" },
3314 "preset name",
"preset" },
3317 "set input stream mapping",
3318 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3320 "map an audio channel from one stream to another",
"file.stream.channel[:syncfile.syncstream]" },
3323 "set metadata information of outfile from infile",
3324 "outfile[,metadata]:infile[,metadata]" },
3327 "set chapters mapping",
"input_file_index" },
3330 "record or transcode \"duration\" seconds of audio/video",
3333 "record or transcode stop time",
"time_stop" },
3335 "set the limit file size in bytes",
"limit_size" },
3338 "set the start time offset",
"time_off" },
3341 "set the start time offset relative to EOF",
"time_off" },
3344 "enable/disable seeking by timestamp with -ss" },
3347 "enable/disable accurate seeking with -ss" },
3350 "set the input ts offset",
"time_off" },
3353 "set the input ts scale",
"scale" },
3355 "set the recording timestamp ('now' to set the current time)",
"time" },
3357 "add metadata",
"string=string" },
3359 "add program with specified streams",
"title=string:st=number..." },
3362 "set the number of data frames to output",
"number" },
3364 "add timings for benchmarking" },
3366 "add timings for each task" },
3368 "write program-readable progress information",
"url" },
3370 "enable or disable interaction on standard input" },
3372 "set max runtime in seconds",
"limit" },
3374 "dump each input packet" },
3376 "when dumping packets, also dump the payload" },
3379 "read input at native frame rate",
"" },
3381 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3382 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")",
"type" },
3384 "video sync method",
"" },
3386 "frame drop threshold",
"" },
3388 "audio sync method",
"" },
3390 "audio drift threshold",
"threshold" },
3392 "copy timestamps" },
3394 "shift input timestamps to start at 0 when using copyts" },
3396 "copy input stream time base when stream copying",
"mode" },
3399 "finish encoding within shortest input" },
3404 "timestamp discontinuity delta threshold",
"threshold" },
3406 "timestamp error delta threshold",
"threshold" },
3408 "exit on error",
"error" },
3410 "abort on the specified condition flags",
"flags" },
3413 "copy initial non-keyframes" },
3415 "copy or discard frames before start time" },
3417 "set the number of frames to output",
"number" },
3420 "force codec tag/fourcc",
"fourcc/tag" },
3423 "use fixed quality scale (VBR)",
"q" },
3426 "use fixed quality scale (VBR)",
"q" },
3428 "set profile",
"profile" },
3430 "set stream filtergraph",
"filter_graph" },
3432 "number of non-complex filter threads" },
3434 "read stream filtergraph description from a file",
"filename" },
3436 "reinit filtergraph on input parameter changes",
"" },
3438 "create a complex filtergraph",
"graph_description" },
3440 "number of threads for -filter_complex" },
3442 "create a complex filtergraph",
"graph_description" },
3444 "read complex filtergraph description from a file",
"filename" },
3446 "print progress report during encoding", },
3449 "add an attachment to the output file",
"filename" },
3452 "extract an attachment into a file",
"filename" },
3454 OPT_OFFSET, { .off =
OFFSET(
loop) },
"set number of times input stream shall be looped",
"loop count" },
3456 "print timestamp debugging info" },
3458 "maximum error rate",
"ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3464 "disposition",
"" },
3466 { .off =
OFFSET(thread_queue_size) },
3467 "set the maximum number of queued packets from the demuxer" },
3471 "set the number of video frames to output",
"number" },
3474 "set frame rate (Hz value, fraction or abbreviation)",
"rate" },
3477 "set frame size (WxH or abbreviation)",
"size" },
3480 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)",
"aspect" },
3483 "set pixel format",
"format" },
3485 "set the number of bits per raw sample",
"number" },
3487 "deprecated use -g 1" },
3492 "rate control override for specific intervals",
"override" },
3495 "force video codec ('copy' to copy stream)",
"codec" },
3501 "set initial TimeCode value.",
"hh:mm:ss[:;.]ff" },
3503 "select the pass number (1 to 3)",
"n" },
3506 "select two pass log file name prefix",
"prefix" },
3508 "this option is deprecated, use the yadif filter instead" },
3510 "calculate PSNR of compressed frames" },
3512 "dump video coding statistics to file" },
3514 "dump video coding statistics to file",
"file" },
3516 "Version of the vstats format to use."},
3518 "set video filters",
"filter_graph" },
3521 "specify intra matrix coeffs",
"matrix" },
3524 "specify inter matrix coeffs",
"matrix" },
3527 "specify intra matrix coeffs",
"matrix" },
3530 "top=1/bottom=0/auto=-1 field first",
"" },
3533 "force video tag/fourcc",
"fourcc/tag" },
3535 "show QP histogram" },
3538 "force the selected framerate, disable the best supported framerate selection" },
3541 "set the value of an outfile streamid",
"streamIndex:value" },
3544 "force key frames at specified timestamps",
"timestamps" },
3546 "audio bitrate (please use -b:a)",
"bitrate" },
3548 "video bitrate (please use -b:v)",
"bitrate" },
3551 "use HW accelerated decoding",
"hwaccel name" },
3554 "select a device for HW acceleration",
"devicename" },
3557 "select output format used with HW accelerated decoding",
"format" },
3558 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3562 "show available HW acceleration methods" },
3565 "automatically insert correct rotate filters" },
3567 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3571 "set the number of audio frames to output",
"number" },
3573 "set audio quality (codec-specific)",
"quality", },
3576 "set audio sampling rate (in Hz)",
"rate" },
3579 "set number of audio channels",
"channels" },
3584 "force audio codec ('copy' to copy stream)",
"codec" },
3587 "force audio tag/fourcc",
"fourcc/tag" },
3589 "change audio volume (256=normal)" ,
"volume" },
3592 "set sample format",
"format" },
3595 "set channel layout",
"layout" },
3597 "set audio filters",
"filter_graph" },
3599 "set the maximum number of channels to try to guess the channel layout" },
3603 "disable subtitle" },
3605 "force subtitle codec ('copy' to copy stream)",
"codec" },
3607 ,
"force subtitle tag/fourcc",
"fourcc/tag" },
3609 "fix subtitles duration" },
3611 "set canvas size (WxH or abbreviation)",
"size" },
3615 "deprecated, use -channel",
"channel" },
3617 "deprecated, use -standard",
"standard" },
3622 "set the maximum demux-decode delay",
"seconds" },
3624 "set the initial demux-decode delay",
"seconds" },
3626 "override the options from ffserver",
"" },
3628 "specify a file in which to print sdp information",
"file" },
3631 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)",
"ratio" },
3634 "A comma-separated list of bitstream filters",
"bitstream_filters" },
3636 "deprecated",
"audio bitstream_filters" },
3638 "deprecated",
"video bitstream_filters" },
3641 "set the audio options to the indicated preset",
"preset" },
3643 "set the video options to the indicated preset",
"preset" },
3645 "set the subtitle options to the indicated preset",
"preset" },
3647 "set options from indicated preset file",
"filename" },
3650 "maximum number of packets that can be buffered while waiting for all streams to initialize",
"packets" },
3654 "force data codec ('copy' to copy stream)",
"codec" },
3660 "set VAAPI hardware device (DRM path or X11 display name)",
"device" },
3665 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)",
"device"},
unsigned int nb_chapters
Number of chapters in AVChapter array.
#define AVERROR_ENCODER_NOT_FOUND
Encoder not found.
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
int parse_optgroup(void *optctx, OptionGroup *g)
Parse an options group and write results into optctx.
int av_parse_ratio(AVRational *q, const char *str, int max, int log_offset, void *log_ctx)
Parse str and store the parsed ratio in q.
int guess_input_channel_layout(InputStream *ist)
const char const char void * val
AVDictionary * resample_opts
const AVClass * priv_class
A class for the private data, used to declare bitstream filter private AVOptions. ...
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
int64_t avio_size(AVIOContext *s)
Get the filesize.
enum AVPixelFormat choose_pixel_fmt(AVStream *st, AVCodecContext *avctx, AVCodec *codec, enum AVPixelFormat target)
#define av_realloc_f(p, o, n)
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str)
Parse str and put in width_ptr and height_ptr the detected values.
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o, AVFormatContext *oc)
char * filters
filtergraph associated to the -filter option
static AVInputFormat * file_iformat
int coded_width
Bitstream width / height, may be different from width/height e.g.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
Main libavfilter public API header.
uint8_t * bsf_extradata_updated
static void assert_file_overwrite(const char *filename)
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
hardware decoding through Videotoolbox
int split_commandline(OptionParseContext *octx, int argc, char *argv[], const OptionDef *options, const OptionGroupDef *groups, int nb_groups)
Split the commandline into an intermediate form convenient for further processing.
void choose_sample_fmt(AVStream *st, AVCodec *codec)
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
FILE * av_fopen_utf8(const char *path, const char *mode)
Open a file using a UTF-8 filename.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
#define AV_OPT_FLAG_AUDIO_PARAM
int index
stream index in AVFormatContext
int max_muxing_queue_size
#define AVIO_FLAG_READ
read-only
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
static OutputStream * new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
#define AVIO_FLAG_WRITE
write-only
static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Convenience header that includes libavutil's core.
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
int cuvid_init(AVCodecContext *s)
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
static int file_overwrite
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static OutputStream * new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
static const char * audio_codec_name
static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
void * priv_data
Opaque filter-specific private data.
enum AVCodecID subtitle_codec_id
Forced subtitle codec_id.
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, AVCodec *codec)
Filter out options for given codec.
This struct describes the properties of an encoded stream.
int64_t start_time
start time in microseconds == AV_TIME_BASE units
static int opt_preset(void *optctx, const char *opt, const char *arg)
SpecifierOpt * frame_pix_fmts
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
int avio_check(const char *url, int flags)
Return AVIO_FLAG_* access flags corresponding to the access permissions of the resource in url...
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx)
Allocate a context for a given bitstream filter.
int av_opt_set_from_string(void *ctx, const char *opts, const char *const *shorthand, const char *key_val_sep, const char *pairs_sep)
Parse the key-value pairs list in opts.
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
void av_codec_set_chroma_intra_matrix(AVCodecContext *avctx, uint16_t *val)
static const uint8_t frame_sizes[]
int vdpau_init(AVCodecContext *s)
static int ignore_unknown_streams
static int64_t start_time
int copy_initial_nonkeyframes
enum AVSampleFormat sample_fmt
audio sample format
Opaque data information usually continuous.
int opt_default(void *optctx, const char *opt, const char *arg)
Fallback for options that are not explicitly handled, these will be parsed through AVOptions...
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
static int open_input_file(OptionsContext *o, const char *filename)
static const OptionGroupDef groups[]
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
static av_cold int end(AVCodecContext *avctx)
uint16_t * chroma_intra_matrix
custom intra quantization matrix
int id
unique ID to identify the chapter
static int opt_vsync(void *optctx, const char *opt, const char *arg)
int id
Format-specific stream ID.
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, uint8_t clip)
AVStream ** streams
A list of all streams in the file.
static int opt_vstats(void *optctx, const char *opt, const char *arg)
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
void av_codec_set_lowres(AVCodecContext *avctx, int val)
#define AVERROR_PROTOCOL_NOT_FOUND
Protocol not found.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
int flags
Flags modifying the (de)muxer behaviour.
AVProgram * av_new_program(AVFormatContext *s, int id)
AVDictionary * resample_opts
#define AV_LOG_VERBOSE
Detailed information.
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
int init_complex_filtergraph(FilterGraph *fg)
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags, int alt_flags)
Print help for all options matching specified flags.
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
const OptionDef options[]
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
enum AVCodecID video_codec_id
Forced video codec_id.
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
static int opt_qscale(void *optctx, const char *opt, const char *arg)
struct AVOutputFormat * oformat
The output container format.
AVDictionary ** setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts)
Setup AVCodecContext options for avformat_find_stream_info().
AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
AVDictionary * format_opts
static OutputStream * new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Print detailed information about the input or output format, such as duration, bitrate, streams, container, programs, metadata, side data, codec and time base.
int filter_complex_nbthreads
AVCodecID
Identify the syntax and semantics of the bitstream.
static int opt_profile(void *optctx, const char *opt, const char *arg)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
AVDictionary * metadata
Metadata that applies to the whole file.
void check_filter_outputs(void)
FilterGraph ** filtergraphs
const AVIOInterruptCB int_cb
static int open_files(OptionGroupList *l, const char *inout, int(*open_file)(OptionsContext *, const char *))
static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
#define AV_OPT_FLAG_FILTERING_PARAM
a generic parameter which can be set by the user for filtering
static int opt_video_channel(void *optctx, const char *opt, const char *arg)
int av_opt_eval_flags(void *obj, const AVOption *o, const char *val, int *flags_out)
static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
int vaapi_device_init(const char *device)
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
int video_delay
Video only.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
AudioChannelMap * audio_channel_maps
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
enum AVMediaType codec_type
General type of the encoded data.
int flags
AV_CODEC_FLAG_*.
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
Parse one given option.
static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
Parse a metadata specifier passed as 'arg' parameter.
simple assert() macros that are a bit more flexible than ISO C assert().
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
const char * name
Name of the codec implementation.
static int opt_old2new(void *optctx, const char *opt, const char *arg)
void remove_avoptions(AVDictionary **a, AVDictionary *b)
static int opt_sameq(void *optctx, const char *opt, const char *arg)
HW acceleration through VDA, data[3] contains a CVPixelBufferRef.
static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
AVRational avg_frame_rate
Average framerate.
New fields can be added to the end with minor version bumps.
static void uninit_options(OptionsContext *o)
static void * av_mallocz_array(size_t nmemb, size_t size)
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
int av_codec_get_lowres(const AVCodecContext *avctx)
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
int extradata_size
Size of the extradata content in bytes.
int avio_r8(AVIOContext *s)
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
Test if the given container can store a codec.
int ffmpeg_parse_options(int argc, char **argv)
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
AVRational frame_aspect_ratio
static AVDictionary * strip_specifiers(AVDictionary *dict)
static int opt_abort_on(void *optctx, const char *opt, const char *arg)
char * av_asprintf(const char *fmt,...)
const AVOption * av_opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Look for an option in an object.
static const char * subtitle_codec_name
static int subtitle_disable
int nb_audio_channel_maps
int vaapi_decode_init(AVCodecContext *avctx)
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
static int opt_video_filters(void *optctx, const char *opt, const char *arg)
int rc_override_count
ratecontrol override, see RcOverride
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
audio channel layout utility functions
char filename[1024]
input or output filename
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
#define AV_TIME_BASE
Internal time base represented as integer.
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
enum AVCodecID audio_codec_id
Forced audio codec_id.
SpecifierOpt * audio_channels
uint64_t * channel_layouts
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
static void add_input_streams(OptionsContext *o, AVFormatContext *ic)