2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
33 #include "libavutil/audioconvert.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/avutil.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48 for (i = 0; i < o->nb_ ## name; i++) {\
49 char *spec = o->name[i].specifier;\
50 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51 outvar = o->name[i].u.type;\
57 const char *pass_logfilename_prefix;
58 char *vstats_filename;
60 float audio_drift_threshold = 0.1;
61 float dts_delta_threshold = 10;
62 float dts_error_threshold = 3600*30;
64 int audio_volume = 256;
65 int audio_sync_method = 0;
66 int video_sync_method = VSYNC_AUTO;
67 int do_deinterlace = 0;
69 int do_benchmark_all = 0;
76 int exit_on_error = 0;
80 int stdin_interaction = 1;
81 int frame_bits_per_raw_sample = 0;
84 static int intra_only = 0;
85 static const char *video_codec_name = NULL;
86 static const char *audio_codec_name = NULL;
87 static const char *subtitle_codec_name = NULL;
88 static int file_overwrite = 0;
89 static int no_file_overwrite = 0;
90 static int video_discard = 0;
91 static int intra_dc_precision = 8;
92 static int do_psnr = 0;
93 static int do_pass = 0;
94 static int input_sync;
96 void reset_options(OptionsContext *o, int is_input)
98 const OptionDef *po = options;
99 OptionsContext bak= *o;
102 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
104 void *dst = (uint8_t*)o + po->u.off;
106 if (po->flags & OPT_SPEC) {
107 SpecifierOpt **so = dst;
108 int i, *count = (int*)(so + 1);
109 for (i = 0; i < *count; i++) {
110 av_freep(&(*so)[i].specifier);
111 if (po->flags & OPT_STRING)
112 av_freep(&(*so)[i].u.str);
116 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
121 for (i = 0; i < o->nb_stream_maps; i++)
122 av_freep(&o->stream_maps[i].linklabel);
123 av_freep(&o->stream_maps);
124 av_freep(&o->audio_channel_maps);
125 av_freep(&o->streamid_map);
127 memset(o, 0, sizeof(*o));
130 o->recording_time = bak.recording_time;
131 if (o->recording_time != INT64_MAX)
132 av_log(NULL, AV_LOG_WARNING,
133 "-t is not an input option, keeping it for the next output;"
134 " consider fixing your command line.\n");
136 o->recording_time = INT64_MAX;
137 o->mux_max_delay = 0.7;
138 o->limit_filesize = UINT64_MAX;
139 o->chapters_input_file = INT_MAX;
146 static int opt_frame_crop(const char *opt, const char *arg)
148 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
149 return AVERROR(EINVAL);
152 static int opt_pad(const char *opt, const char *arg)
154 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
158 static int opt_video_channel(const char *opt, const char *arg)
160 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
161 return opt_default("channel", arg);
164 static int opt_video_standard(const char *opt, const char *arg)
166 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
167 return opt_default("standard", arg);
170 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
172 audio_codec_name = arg;
173 return parse_option(o, "codec:a", arg, options);
176 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
178 video_codec_name = arg;
179 return parse_option(o, "codec:v", arg, options);
182 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
184 subtitle_codec_name = arg;
185 return parse_option(o, "codec:s", arg, options);
188 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
190 return parse_option(o, "codec:d", arg, options);
193 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
196 int i, negative = 0, file_idx;
197 int sync_file_idx = -1, sync_stream_idx = 0;
205 map = av_strdup(arg);
207 /* parse sync stream first, just pick first matching stream */
208 if (sync = strchr(map, ',')) {
210 sync_file_idx = strtol(sync + 1, &sync, 0);
211 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
212 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
217 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
218 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
219 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
223 if (i == input_files[sync_file_idx]->nb_streams) {
224 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
225 "match any streams.\n", arg);
232 /* this mapping refers to lavfi output */
233 const char *c = map + 1;
234 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
235 &o->nb_stream_maps, o->nb_stream_maps + 1);
236 m = &o->stream_maps[o->nb_stream_maps - 1];
237 m->linklabel = av_get_token(&c, "]");
239 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
243 file_idx = strtol(map, &p, 0);
244 if (file_idx >= nb_input_files || file_idx < 0) {
245 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
249 /* disable some already defined maps */
250 for (i = 0; i < o->nb_stream_maps; i++) {
251 m = &o->stream_maps[i];
252 if (file_idx == m->file_index &&
253 check_stream_specifier(input_files[m->file_index]->ctx,
254 input_files[m->file_index]->ctx->streams[m->stream_index],
255 *p == ':' ? p + 1 : p) > 0)
259 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
260 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
261 *p == ':' ? p + 1 : p) <= 0)
263 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
264 &o->nb_stream_maps, o->nb_stream_maps + 1);
265 m = &o->stream_maps[o->nb_stream_maps - 1];
267 m->file_index = file_idx;
270 if (sync_file_idx >= 0) {
271 m->sync_file_index = sync_file_idx;
272 m->sync_stream_index = sync_stream_idx;
274 m->sync_file_index = file_idx;
275 m->sync_stream_index = i;
281 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
289 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
291 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
292 &o->nb_attachments, o->nb_attachments + 1);
293 o->attachments[o->nb_attachments - 1] = arg;
297 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
303 o->audio_channel_maps =
304 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
305 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
306 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
308 /* muted channel syntax */
309 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
310 if ((n == 1 || n == 3) && m->channel_idx == -1) {
311 m->file_idx = m->stream_idx = -1;
313 m->ofile_idx = m->ostream_idx = -1;
318 n = sscanf(arg, "%d.%d.%d:%d.%d",
319 &m->file_idx, &m->stream_idx, &m->channel_idx,
320 &m->ofile_idx, &m->ostream_idx);
322 if (n != 3 && n != 5) {
323 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
324 "[file.stream.channel|-1][:syncfile:syncstream]\n");
328 if (n != 5) // only file.stream.channel specified
329 m->ofile_idx = m->ostream_idx = -1;
332 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
333 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
337 if (m->stream_idx < 0 ||
338 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
339 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
340 m->file_idx, m->stream_idx);
343 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
344 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
345 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
346 m->file_idx, m->stream_idx);
349 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
350 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
351 m->file_idx, m->stream_idx, m->channel_idx);
358 * Parse a metadata specifier in arg.
359 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
360 * @param index for type c/p, chapter/program index is written here
361 * @param stream_spec for type s, the stream specifier is written here
363 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
371 if (*(++arg) && *arg != ':') {
372 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
375 *stream_spec = *arg == ':' ? arg + 1 : "";
380 *index = strtol(++arg, NULL, 0);
383 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
390 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
392 AVDictionary **meta_in = NULL;
393 AVDictionary **meta_out = NULL;
395 char type_in, type_out;
396 const char *istream_spec = NULL, *ostream_spec = NULL;
397 int idx_in = 0, idx_out = 0;
399 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
400 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
403 if (type_out == 'g' || !*outspec)
404 o->metadata_global_manual = 1;
405 if (type_out == 's' || !*outspec)
406 o->metadata_streams_manual = 1;
407 if (type_out == 'c' || !*outspec)
408 o->metadata_chapters_manual = 1;
412 if (type_in == 'g' || type_out == 'g')
413 o->metadata_global_manual = 1;
414 if (type_in == 's' || type_out == 's')
415 o->metadata_streams_manual = 1;
416 if (type_in == 'c' || type_out == 'c')
417 o->metadata_chapters_manual = 1;
419 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
420 if ((index) < 0 || (index) >= (nb_elems)) {\
421 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
426 #define SET_DICT(type, meta, context, index)\
429 meta = &context->metadata;\
432 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
433 meta = &context->chapters[index]->metadata;\
436 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
437 meta = &context->programs[index]->metadata;\
439 default: av_assert0(0);\
442 SET_DICT(type_in, meta_in, ic, idx_in);
443 SET_DICT(type_out, meta_out, oc, idx_out);
445 /* for input streams choose first matching stream */
446 if (type_in == 's') {
447 for (i = 0; i < ic->nb_streams; i++) {
448 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
449 meta_in = &ic->streams[i]->metadata;
455 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
460 if (type_out == 's') {
461 for (i = 0; i < oc->nb_streams; i++) {
462 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
463 meta_out = &oc->streams[i]->metadata;
464 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
469 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
474 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
477 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
478 struct tm time = *gmtime((time_t*)&recording_timestamp);
479 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
480 parse_option(o, "metadata", buf, options);
482 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
483 "tag instead.\n", opt);
487 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
489 const char *codec_string = encoder ? "encoder" : "decoder";
493 avcodec_find_encoder_by_name(name) :
494 avcodec_find_decoder_by_name(name);
496 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
499 if (codec->type != type) {
500 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
506 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
508 char *codec_name = NULL;
510 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
512 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
513 st->codec->codec_id = codec->id;
516 return avcodec_find_decoder(st->codec->codec_id);
520 * Add all the streams from the given input file to the global
521 * list of input streams.
523 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
526 char *next, *codec_tag = NULL;
528 for (i = 0; i < ic->nb_streams; i++) {
529 AVStream *st = ic->streams[i];
530 AVCodecContext *dec = st->codec;
531 InputStream *ist = av_mallocz(sizeof(*ist));
532 char *framerate = NULL;
537 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
538 input_streams[nb_input_streams - 1] = ist;
541 ist->file_index = nb_input_files;
543 st->discard = AVDISCARD_ALL;
544 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
547 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
549 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
551 uint32_t tag = strtol(codec_tag, &next, 0);
553 tag = AV_RL32(codec_tag);
554 st->codec->codec_tag = tag;
557 ist->dec = choose_decoder(o, ic, st);
559 switch (dec->codec_type) {
560 case AVMEDIA_TYPE_VIDEO:
562 ist->dec = avcodec_find_decoder(dec->codec_id);
564 dec->flags |= CODEC_FLAG_EMU_EDGE;
567 ist->resample_height = dec->height;
568 ist->resample_width = dec->width;
569 ist->resample_pix_fmt = dec->pix_fmt;
571 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
572 if (framerate && av_parse_video_rate(&ist->framerate,
574 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
579 ist->top_field_first = -1;
580 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
583 case AVMEDIA_TYPE_AUDIO:
584 guess_input_channel_layout(ist);
586 ist->resample_sample_fmt = dec->sample_fmt;
587 ist->resample_sample_rate = dec->sample_rate;
588 ist->resample_channels = dec->channels;
589 ist->resample_channel_layout = dec->channel_layout;
592 case AVMEDIA_TYPE_DATA:
593 case AVMEDIA_TYPE_SUBTITLE:
595 ist->dec = avcodec_find_decoder(dec->codec_id);
597 case AVMEDIA_TYPE_ATTACHMENT:
598 case AVMEDIA_TYPE_UNKNOWN:
606 static void assert_file_overwrite(const char *filename)
608 if ((!file_overwrite || no_file_overwrite) &&
609 (strchr(filename, ':') == NULL || filename[1] == ':' ||
610 av_strstart(filename, "file:", NULL))) {
611 if (avio_check(filename, 0) == 0) {
612 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
613 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
616 signal(SIGINT, SIG_DFL);
618 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
624 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
631 static void dump_attachment(AVStream *st, const char *filename)
634 AVIOContext *out = NULL;
635 AVDictionaryEntry *e;
637 if (!st->codec->extradata_size) {
638 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
639 nb_input_files - 1, st->index);
642 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
645 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
646 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
650 assert_file_overwrite(filename);
652 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
653 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
658 avio_write(out, st->codec->extradata, st->codec->extradata_size);
663 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
666 AVInputFormat *file_iformat = NULL;
671 int orig_nb_streams; // number of streams before avformat_find_stream_info
674 if (!(file_iformat = av_find_input_format(o->format))) {
675 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
680 if (!strcmp(filename, "-"))
683 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
684 strcmp(filename, "/dev/stdin");
686 /* get default parameters from command line */
687 ic = avformat_alloc_context();
689 print_error(filename, AVERROR(ENOMEM));
692 if (o->nb_audio_sample_rate) {
693 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
694 av_dict_set(&format_opts, "sample_rate", buf, 0);
696 if (o->nb_audio_channels) {
697 /* because we set audio_channels based on both the "ac" and
698 * "channel_layout" options, we need to check that the specified
699 * demuxer actually has the "channels" option before setting it */
700 if (file_iformat && file_iformat->priv_class &&
701 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
702 AV_OPT_SEARCH_FAKE_OBJ)) {
703 snprintf(buf, sizeof(buf), "%d",
704 o->audio_channels[o->nb_audio_channels - 1].u.i);
705 av_dict_set(&format_opts, "channels", buf, 0);
708 if (o->nb_frame_rates) {
709 /* set the format-level framerate option;
710 * this is important for video grabbers, e.g. x11 */
711 if (file_iformat && file_iformat->priv_class &&
712 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
713 AV_OPT_SEARCH_FAKE_OBJ)) {
714 av_dict_set(&format_opts, "framerate",
715 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
718 if (o->nb_frame_sizes) {
719 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
721 if (o->nb_frame_pix_fmts)
722 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
724 ic->video_codec_id = video_codec_name ?
725 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
726 ic->audio_codec_id = audio_codec_name ?
727 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
728 ic->subtitle_codec_id= subtitle_codec_name ?
729 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
730 ic->flags |= AVFMT_FLAG_NONBLOCK;
731 ic->interrupt_callback = int_cb;
733 /* open the input file with generic avformat function */
734 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
736 print_error(filename, err);
739 assert_avoptions(format_opts);
741 /* apply forced codec ids */
742 for (i = 0; i < ic->nb_streams; i++)
743 choose_decoder(o, ic, ic->streams[i]);
745 /* Set AVCodecContext options for avformat_find_stream_info */
746 opts = setup_find_stream_info_opts(ic, codec_opts);
747 orig_nb_streams = ic->nb_streams;
749 /* If not enough info to get the stream parameters, we decode the
750 first frames to get it. (used in mpeg case for example) */
751 ret = avformat_find_stream_info(ic, opts);
753 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
754 avformat_close_input(&ic);
758 timestamp = o->start_time;
759 /* add the stream start time */
760 if (ic->start_time != AV_NOPTS_VALUE)
761 timestamp += ic->start_time;
763 /* if seeking requested, we execute it */
764 if (o->start_time != 0) {
765 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
767 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
768 filename, (double)timestamp / AV_TIME_BASE);
772 /* update the current parameters so that they match the one of the input stream */
773 add_input_streams(o, ic);
775 /* dump the file content */
776 av_dump_format(ic, nb_input_files, filename, 0);
778 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
779 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
782 input_files[nb_input_files - 1]->ctx = ic;
783 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
784 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
785 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
786 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
788 for (i = 0; i < o->nb_dump_attachment; i++) {
791 for (j = 0; j < ic->nb_streams; j++) {
792 AVStream *st = ic->streams[j];
794 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
795 dump_attachment(st, o->dump_attachment[i].u.str);
799 for (i = 0; i < orig_nb_streams; i++)
800 av_dict_free(&opts[i]);
807 static uint8_t *get_line(AVIOContext *s)
813 if (avio_open_dyn_buf(&line) < 0) {
814 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
818 while ((c = avio_r8(s)) && c != '\n')
821 avio_close_dyn_buf(line, &buf);
826 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
830 const char *base[3] = { getenv("AVCONV_DATADIR"),
835 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
839 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
840 i != 1 ? "" : "/.avconv", codec_name, preset_name);
841 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
844 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
845 i != 1 ? "" : "/.avconv", preset_name);
846 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
852 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
854 char *codec_name = NULL;
856 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
858 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
859 NULL, ost->st->codec->codec_type);
860 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
861 } else if (!strcmp(codec_name, "copy"))
862 ost->stream_copy = 1;
864 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
865 ost->st->codec->codec_id = ost->enc->id;
869 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
872 AVStream *st = avformat_new_stream(oc, NULL);
873 int idx = oc->nb_streams - 1, ret = 0;
874 char *bsf = NULL, *next, *codec_tag = NULL;
875 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
877 char *buf = NULL, *arg = NULL, *preset = NULL;
878 AVIOContext *s = NULL;
881 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
885 if (oc->nb_streams - 1 < o->nb_streamid_map)
886 st->id = o->streamid_map[oc->nb_streams - 1];
888 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
889 nb_output_streams + 1);
890 if (!(ost = av_mallocz(sizeof(*ost))))
892 output_streams[nb_output_streams - 1] = ost;
894 ost->file_index = nb_output_files;
897 st->codec->codec_type = type;
898 choose_encoder(o, oc, ost);
900 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
903 avcodec_get_context_defaults3(st->codec, ost->enc);
904 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
906 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
907 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
910 if (!buf[0] || buf[0] == '#') {
914 if (!(arg = strchr(buf, '='))) {
915 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
919 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
921 } while (!s->eof_reached);
925 av_log(NULL, AV_LOG_FATAL,
926 "Preset %s specified for stream %d:%d, but could not be opened.\n",
927 preset, ost->file_index, ost->index);
931 ost->max_frames = INT64_MAX;
932 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
934 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
936 if (next = strchr(bsf, ','))
938 if (!(bsfc = av_bitstream_filter_init(bsf))) {
939 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
943 bsfc_prev->next = bsfc;
945 ost->bitstream_filters = bsfc;
951 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
953 uint32_t tag = strtol(codec_tag, &next, 0);
955 tag = AV_RL32(codec_tag);
956 st->codec->codec_tag = tag;
959 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
960 if (qscale >= 0 || same_quant) {
961 st->codec->flags |= CODEC_FLAG_QSCALE;
962 st->codec->global_quality = FF_QP2LAMBDA * qscale;
965 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
966 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
968 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
969 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
970 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
972 ost->source_index = source_index;
973 if (source_index >= 0) {
974 ost->sync_ist = input_streams[source_index];
975 input_streams[source_index]->discard = 0;
976 input_streams[source_index]->st->discard = AVDISCARD_NONE;
982 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
992 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
999 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1003 AVCodecContext *video_enc;
1004 char *frame_rate = NULL;
1006 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1008 video_enc = st->codec;
1010 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1011 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1012 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1016 if (!ost->stream_copy) {
1017 const char *p = NULL;
1018 char *frame_size = NULL;
1019 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1020 char *intra_matrix = NULL, *inter_matrix = NULL;
1021 const char *filters = "null";
1024 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1025 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1026 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1030 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1031 if (frame_aspect_ratio) {
1033 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1034 q.num <= 0 || q.den <= 0) {
1035 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1038 ost->frame_aspect_ratio = av_q2d(q);
1041 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1042 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1043 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1044 ost->keep_pix_fmt = 1;
1045 if (!*++frame_pix_fmt)
1046 frame_pix_fmt = NULL;
1048 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
1049 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1052 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1055 video_enc->gop_size = 0;
1056 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1058 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1059 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1062 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1064 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1066 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1067 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1070 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1073 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1074 for (i = 0; p; i++) {
1076 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1078 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1081 /* FIXME realloc failure */
1082 video_enc->rc_override =
1083 av_realloc(video_enc->rc_override,
1084 sizeof(RcOverride) * (i + 1));
1085 video_enc->rc_override[i].start_frame = start;
1086 video_enc->rc_override[i].end_frame = end;
1088 video_enc->rc_override[i].qscale = q;
1089 video_enc->rc_override[i].quality_factor = 1.0;
1092 video_enc->rc_override[i].qscale = 0;
1093 video_enc->rc_override[i].quality_factor = -q/100.0;
1098 video_enc->rc_override_count = i;
1099 if (!video_enc->rc_initial_buffer_occupancy)
1100 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1101 video_enc->intra_dc_precision = intra_dc_precision - 8;
1104 video_enc->flags|= CODEC_FLAG_PSNR;
1109 video_enc->flags |= CODEC_FLAG_PASS1;
1112 video_enc->flags |= CODEC_FLAG_PASS2;
1116 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1117 if (ost->forced_keyframes)
1118 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1120 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1122 ost->top_field_first = -1;
1123 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1125 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1126 ost->avfilter = av_strdup(filters);
1128 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1134 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1139 AVCodecContext *audio_enc;
1141 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1144 audio_enc = st->codec;
1145 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1147 if (!ost->stream_copy) {
1148 char *sample_fmt = NULL;
1149 const char *filters = "anull";
1151 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1153 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1155 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1156 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1160 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1162 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1164 av_assert1(filters);
1165 ost->avfilter = av_strdup(filters);
1167 /* check for channel mapping for this audio stream */
1168 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1169 AudioChannelMap *map = &o->audio_channel_maps[n];
1170 InputStream *ist = input_streams[ost->source_index];
1171 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1172 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1173 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1174 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1175 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1177 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1178 ost->file_index, ost->st->index);
1186 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1190 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1191 if (!ost->stream_copy) {
1192 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1199 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1201 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1202 ost->stream_copy = 1;
1206 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1210 AVCodecContext *subtitle_enc;
1212 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1214 subtitle_enc = st->codec;
1216 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1218 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1223 /* arg format is "output-stream-index:streamid-value". */
1224 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
1230 av_strlcpy(idx_str, arg, sizeof(idx_str));
1231 p = strchr(idx_str, ':');
1233 av_log(NULL, AV_LOG_FATAL,
1234 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1239 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1240 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1241 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1245 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1247 AVFormatContext *is = ifile->ctx;
1248 AVFormatContext *os = ofile->ctx;
1251 for (i = 0; i < is->nb_chapters; i++) {
1252 AVChapter *in_ch = is->chapters[i], *out_ch;
1253 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1254 AV_TIME_BASE_Q, in_ch->time_base);
1255 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1256 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1259 if (in_ch->end < ts_off)
1261 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1264 out_ch = av_mallocz(sizeof(AVChapter));
1266 return AVERROR(ENOMEM);
1268 out_ch->id = in_ch->id;
1269 out_ch->time_base = in_ch->time_base;
1270 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1271 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1274 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1277 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
1279 return AVERROR(ENOMEM);
1280 os->chapters[os->nb_chapters - 1] = out_ch;
1285 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1288 AVFormatContext *ic = avformat_alloc_context();
1290 ic->interrupt_callback = int_cb;
1291 err = avformat_open_input(&ic, filename, NULL, NULL);
1294 /* copy stream format */
1295 for(i=0;i<ic->nb_streams;i++) {
1299 AVCodecContext *avctx;
1301 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1302 ost = new_output_stream(o, s, codec->type, -1);
1307 // FIXME: a more elegant solution is needed
1308 memcpy(st, ic->streams[i], sizeof(AVStream));
1310 st->info = av_malloc(sizeof(*st->info));
1311 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1313 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1315 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1316 choose_sample_fmt(st, codec);
1317 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1318 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1321 avformat_close_input(&ic);
1325 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1326 AVFormatContext *oc)
1330 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1331 ofilter->out_tmp->pad_idx)) {
1332 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1333 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1335 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1340 ost->source_index = -1;
1341 ost->filter = ofilter;
1345 if (ost->stream_copy) {
1346 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1347 "which is fed from a complex filtergraph. Filtering and streamcopy "
1348 "cannot be used together.\n", ost->file_index, ost->index);
1351 if (o->recording_time != INT64_MAX)
1352 av_log(NULL, AV_LOG_WARNING,
1353 "-t does not work with -filter_complex (yet).\n");
1355 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1356 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1359 avfilter_inout_free(&ofilter->out_tmp);
1362 static int configure_complex_filters(void)
1366 for (i = 0; i < nb_filtergraphs; i++)
1367 if (!filtergraphs[i]->graph &&
1368 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1373 void opt_output_file(void *optctx, const char *filename)
1375 OptionsContext *o = optctx;
1376 AVFormatContext *oc;
1378 AVOutputFormat *file_oformat;
1382 if (configure_complex_filters() < 0) {
1383 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1387 if (!strcmp(filename, "-"))
1390 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1392 print_error(filename, err);
1395 file_oformat= oc->oformat;
1396 oc->interrupt_callback = int_cb;
1398 /* create streams for all unlabeled output pads */
1399 for (i = 0; i < nb_filtergraphs; i++) {
1400 FilterGraph *fg = filtergraphs[i];
1401 for (j = 0; j < fg->nb_outputs; j++) {
1402 OutputFilter *ofilter = fg->outputs[j];
1404 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1407 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1408 ofilter->out_tmp->pad_idx)) {
1409 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1410 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1411 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1413 init_output_filter(ofilter, o, oc);
1417 if (!strcmp(file_oformat->name, "ffm") &&
1418 av_strstart(filename, "http:", NULL)) {
1420 /* special case for files sent to ffserver: we get the stream
1421 parameters from ffserver */
1422 int err = read_ffserver_streams(o, oc, filename);
1424 print_error(filename, err);
1427 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1428 ost = output_streams[j];
1429 for (i = 0; i < nb_input_streams; i++) {
1430 ist = input_streams[i];
1431 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1433 ost->source_index= i;
1434 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1435 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1437 ist->st->discard = AVDISCARD_NONE;
1442 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
1446 } else if (!o->nb_stream_maps) {
1447 /* pick the "best" stream of each type */
1449 /* video: highest resolution */
1450 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1451 int area = 0, idx = -1;
1452 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1453 for (i = 0; i < nb_input_streams; i++) {
1454 ist = input_streams[i];
1455 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1456 ist->st->codec->width * ist->st->codec->height > area) {
1457 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1459 area = ist->st->codec->width * ist->st->codec->height;
1464 new_video_stream(o, oc, idx);
1467 /* audio: most channels */
1468 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1469 int channels = 0, idx = -1;
1470 for (i = 0; i < nb_input_streams; i++) {
1471 ist = input_streams[i];
1472 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1473 ist->st->codec->channels > channels) {
1474 channels = ist->st->codec->channels;
1479 new_audio_stream(o, oc, idx);
1482 /* subtitles: pick first */
1483 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1484 for (i = 0; i < nb_input_streams; i++)
1485 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1486 new_subtitle_stream(o, oc, i);
1490 /* do something with data? */
1492 for (i = 0; i < o->nb_stream_maps; i++) {
1493 StreamMap *map = &o->stream_maps[i];
1494 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1499 if (map->linklabel) {
1501 OutputFilter *ofilter = NULL;
1504 for (j = 0; j < nb_filtergraphs; j++) {
1505 fg = filtergraphs[j];
1506 for (k = 0; k < fg->nb_outputs; k++) {
1507 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1508 if (out && !strcmp(out->name, map->linklabel)) {
1509 ofilter = fg->outputs[k];
1516 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1517 "in any defined filter graph.\n", map->linklabel);
1520 init_output_filter(ofilter, o, oc);
1522 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1523 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1525 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1527 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1529 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1532 switch (ist->st->codec->codec_type) {
1533 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1534 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1535 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1536 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1537 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1539 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1540 map->file_index, map->stream_index);
1548 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1549 AVDictionaryEntry *e;
1550 ost = output_streams[i];
1552 if ( ost->stream_copy
1553 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1554 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1555 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1559 /* handle attached files */
1560 for (i = 0; i < o->nb_attachments; i++) {
1562 uint8_t *attachment;
1566 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1567 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1571 if ((len = avio_size(pb)) <= 0) {
1572 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1576 if (!(attachment = av_malloc(len))) {
1577 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1581 avio_read(pb, attachment, len);
1583 ost = new_attachment_stream(o, oc, -1);
1584 ost->stream_copy = 0;
1585 ost->attachment_filename = o->attachments[i];
1586 ost->st->codec->extradata = attachment;
1587 ost->st->codec->extradata_size = len;
1589 p = strrchr(o->attachments[i], '/');
1590 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1594 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1595 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1598 output_files[nb_output_files - 1]->ctx = oc;
1599 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1600 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1601 if (o->recording_time != INT64_MAX)
1602 oc->duration = o->recording_time;
1603 output_files[nb_output_files - 1]->start_time = o->start_time;
1604 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1605 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1607 /* check filename in case of an image number is expected */
1608 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1609 if (!av_filename_number_test(oc->filename)) {
1610 print_error(oc->filename, AVERROR(EINVAL));
1615 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1616 /* test if it already exists to avoid losing precious files */
1617 assert_file_overwrite(filename);
1620 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1621 &oc->interrupt_callback,
1622 &output_files[nb_output_files - 1]->opts)) < 0) {
1623 print_error(filename, err);
1628 if (o->mux_preload) {
1630 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1631 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1633 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1636 for (i = 0; i < o->nb_metadata_map; i++) {
1638 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1640 if (in_file_index >= nb_input_files) {
1641 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1644 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
1648 if (o->chapters_input_file >= nb_input_files) {
1649 if (o->chapters_input_file == INT_MAX) {
1650 /* copy chapters from the first input file that has them*/
1651 o->chapters_input_file = -1;
1652 for (i = 0; i < nb_input_files; i++)
1653 if (input_files[i]->ctx->nb_chapters) {
1654 o->chapters_input_file = i;
1658 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1659 o->chapters_input_file);
1663 if (o->chapters_input_file >= 0)
1664 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1665 !o->metadata_chapters_manual);
1667 /* copy global metadata by default */
1668 if (!o->metadata_global_manual && nb_input_files){
1669 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1670 AV_DICT_DONT_OVERWRITE);
1671 if(o->recording_time != INT64_MAX)
1672 av_dict_set(&oc->metadata, "duration", NULL, 0);
1673 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1675 if (!o->metadata_streams_manual)
1676 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1678 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1680 ist = input_streams[output_streams[i]->source_index];
1681 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1684 /* process manually set metadata */
1685 for (i = 0; i < o->nb_metadata; i++) {
1688 const char *stream_spec;
1689 int index = 0, j, ret = 0;
1691 val = strchr(o->metadata[i].u.str, '=');
1693 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1694 o->metadata[i].u.str);
1699 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1701 for (j = 0; j < oc->nb_streams; j++) {
1702 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1703 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1714 if (index < 0 || index >= oc->nb_chapters) {
1715 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1718 m = &oc->chapters[index]->metadata;
1721 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1724 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1728 reset_options(o, 0);
1731 /* same option as mencoder */
1732 static int opt_pass(const char *opt, const char *arg)
1734 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
1739 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
1741 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1742 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1744 if (!strncmp(arg, "pal-", 4)) {
1747 } else if (!strncmp(arg, "ntsc-", 5)) {
1750 } else if (!strncmp(arg, "film-", 5)) {
1754 /* Try to determine PAL/NTSC by peeking in the input files */
1755 if (nb_input_files) {
1757 for (j = 0; j < nb_input_files; j++) {
1758 for (i = 0; i < input_files[j]->nb_streams; i++) {
1759 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1760 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1762 fr = c->time_base.den * 1000 / c->time_base.num;
1766 } else if ((fr == 29970) || (fr == 23976)) {
1771 if (norm != UNKNOWN)
1775 if (norm != UNKNOWN)
1776 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1779 if (norm == UNKNOWN) {
1780 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1781 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1782 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1786 if (!strcmp(arg, "vcd")) {
1787 opt_video_codec(o, "c:v", "mpeg1video");
1788 opt_audio_codec(o, "c:a", "mp2");
1789 parse_option(o, "f", "vcd", options);
1791 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1792 parse_option(o, "r", frame_rates[norm], options);
1793 opt_default("g", norm == PAL ? "15" : "18");
1795 opt_default("b:v", "1150000");
1796 opt_default("maxrate", "1150000");
1797 opt_default("minrate", "1150000");
1798 opt_default("bufsize", "327680"); // 40*1024*8;
1800 opt_default("b:a", "224000");
1801 parse_option(o, "ar", "44100", options);
1802 parse_option(o, "ac", "2", options);
1804 opt_default("packetsize", "2324");
1805 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
1807 /* We have to offset the PTS, so that it is consistent with the SCR.
1808 SCR starts at 36000, but the first two packs contain only padding
1809 and the first pack from the other stream, respectively, may also have
1810 been written before.
1811 So the real data starts at SCR 36000+3*1200. */
1812 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1813 } else if (!strcmp(arg, "svcd")) {
1815 opt_video_codec(o, "c:v", "mpeg2video");
1816 opt_audio_codec(o, "c:a", "mp2");
1817 parse_option(o, "f", "svcd", options);
1819 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1820 parse_option(o, "r", frame_rates[norm], options);
1821 parse_option(o, "pix_fmt", "yuv420p", options);
1822 opt_default("g", norm == PAL ? "15" : "18");
1824 opt_default("b:v", "2040000");
1825 opt_default("maxrate", "2516000");
1826 opt_default("minrate", "0"); // 1145000;
1827 opt_default("bufsize", "1835008"); // 224*1024*8;
1828 opt_default("scan_offset", "1");
1831 opt_default("b:a", "224000");
1832 parse_option(o, "ar", "44100", options);
1834 opt_default("packetsize", "2324");
1836 } else if (!strcmp(arg, "dvd")) {
1838 opt_video_codec(o, "c:v", "mpeg2video");
1839 opt_audio_codec(o, "c:a", "ac3");
1840 parse_option(o, "f", "dvd", options);
1842 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1843 parse_option(o, "r", frame_rates[norm], options);
1844 parse_option(o, "pix_fmt", "yuv420p", options);
1845 opt_default("g", norm == PAL ? "15" : "18");
1847 opt_default("b:v", "6000000");
1848 opt_default("maxrate", "9000000");
1849 opt_default("minrate", "0"); // 1500000;
1850 opt_default("bufsize", "1835008"); // 224*1024*8;
1852 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1853 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1855 opt_default("b:a", "448000");
1856 parse_option(o, "ar", "48000", options);
1858 } else if (!strncmp(arg, "dv", 2)) {
1860 parse_option(o, "f", "dv", options);
1862 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1863 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1864 norm == PAL ? "yuv420p" : "yuv411p", options);
1865 parse_option(o, "r", frame_rates[norm], options);
1867 parse_option(o, "ar", "48000", options);
1868 parse_option(o, "ac", "2", options);
1871 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1872 return AVERROR(EINVAL);
1877 static int opt_vstats_file(const char *opt, const char *arg)
1879 av_free (vstats_filename);
1880 vstats_filename = av_strdup (arg);
1884 static int opt_vstats(const char *opt, const char *arg)
1887 time_t today2 = time(NULL);
1888 struct tm *today = localtime(&today2);
1890 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1892 return opt_vstats_file(opt, filename);
1895 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
1897 return parse_option(o, "frames:v", arg, options);
1900 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
1902 return parse_option(o, "frames:a", arg, options);
1905 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
1907 return parse_option(o, "frames:d", arg, options);
1910 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
1913 char filename[1000], line[1000], tmp_line[1000];
1914 const char *codec_name = *opt == 'v' ? video_codec_name :
1915 *opt == 'a' ? audio_codec_name :
1916 subtitle_codec_name;
1918 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1919 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1920 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1922 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1926 while (fgets(line, sizeof(line), f)) {
1927 char *key = tmp_line, *value, *endptr;
1929 if (strcspn(line, "#\n\r") == 0)
1931 strcpy(tmp_line, line);
1932 if (!av_strtok(key, "=", &value) ||
1933 !av_strtok(value, "\r\n", &endptr)) {
1934 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
1937 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
1939 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
1940 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
1941 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
1942 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
1943 else if (opt_default(key, value) < 0) {
1944 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
1945 filename, line, key, value);
1955 static int opt_passlogfile(const char *opt, const char *arg)
1957 pass_logfilename_prefix = arg;
1958 #if CONFIG_LIBX264_ENCODER
1959 return opt_default(opt, arg);
1965 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
1967 char *s = av_asprintf("%s:%c", opt + 1, *opt);
1968 int ret = parse_option(o, s, arg, options);
1973 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
1975 if(!strcmp(opt, "b")){
1976 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
1977 return parse_option(o, "b:v", arg, options);
1979 return opt_default(opt, arg);
1982 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
1986 if(!strcmp(opt, "qscale")){
1987 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
1988 return parse_option(o, "q:v", arg, options);
1990 s = av_asprintf("q%s", opt + 6);
1991 ret = parse_option(o, s, arg, options);
1996 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
1998 if(!strcmp(opt, "profile")){
1999 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2000 return parse_option(o, "profile:v", arg, options);
2002 return opt_default(opt, arg);
2005 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
2007 return parse_option(o, "filter:v", arg, options);
2010 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
2012 return parse_option(o, "filter:a", arg, options);
2015 static int opt_vsync(const char *opt, const char *arg)
2017 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2018 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2019 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2020 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2022 if (video_sync_method == VSYNC_AUTO)
2023 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2027 static int opt_deinterlace(const char *opt, const char *arg)
2029 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2034 static int opt_timecode(OptionsContext *o, const char *opt, const char *arg)
2036 char *tcr = av_asprintf("timecode=%s", arg);
2037 int ret = parse_option(o, "metadata:g", tcr, options);
2039 ret = opt_default("gop_timecode", arg);
2044 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
2046 char layout_str[32];
2049 int ret, channels, ac_str_size;
2052 layout = av_get_channel_layout(arg);
2054 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2055 return AVERROR(EINVAL);
2057 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2058 ret = opt_default(opt, layout_str);
2062 /* set 'ac' option based on channel layout */
2063 channels = av_get_channel_layout_nb_channels(layout);
2064 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2065 stream_str = strchr(opt, ':');
2066 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2067 ac_str = av_mallocz(ac_str_size);
2069 return AVERROR(ENOMEM);
2070 av_strlcpy(ac_str, "ac", 3);
2072 av_strlcat(ac_str, stream_str, ac_str_size);
2073 ret = parse_option(o, ac_str, layout_str, options);
2079 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
2081 return parse_option(o, "q:a", arg, options);
2084 static int opt_filter_complex(const char *opt, const char *arg)
2086 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2087 &nb_filtergraphs, nb_filtergraphs + 1);
2088 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2089 return AVERROR(ENOMEM);
2090 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2091 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2095 static int opt_help(const char *opt, const char *arg)
2097 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2098 av_log_set_callback(log_callback_help);
2100 show_help_options(options, "Main options:\n",
2101 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
2102 show_help_options(options, "\nAdvanced options:\n",
2103 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
2105 show_help_options(options, "\nVideo options:\n",
2106 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
2108 show_help_options(options, "\nAdvanced Video options:\n",
2109 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
2110 OPT_VIDEO | OPT_EXPERT);
2111 show_help_options(options, "\nAudio options:\n",
2112 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
2114 show_help_options(options, "\nAdvanced Audio options:\n",
2115 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
2116 OPT_AUDIO | OPT_EXPERT);
2117 show_help_options(options, "\nSubtitle options:\n",
2118 OPT_SUBTITLE | OPT_GRAB,
2120 show_help_options(options, "\nAudio/Video grab options:\n",
2124 show_help_children(avcodec_get_class(), flags);
2125 show_help_children(avformat_get_class(), flags);
2126 show_help_children(sws_get_class(), flags);
2127 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2132 void show_usage(void)
2134 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2135 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2136 av_log(NULL, AV_LOG_INFO, "\n");
2140 static int opt_progress(const char *opt, const char *arg)
2142 AVIOContext *avio = NULL;
2145 if (!strcmp(arg, "-"))
2147 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2149 av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2150 arg, av_err2str(ret));
2153 progress_avio = avio;
2157 #define OFFSET(x) offsetof(OptionsContext, x)
2158 const OptionDef options[] = {
2160 #include "cmdutils_common_opts.h"
2161 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
2162 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
2163 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
2164 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
2165 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
2166 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
2167 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
2168 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2169 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_channel}, "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2170 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
2171 "outfile[,metadata]:infile[,metadata]" },
2172 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
2173 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
2174 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
2175 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
2176 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
2177 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
2178 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
2179 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
2180 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
2181 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
2182 "add timings for benchmarking" },
2183 { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
2184 "add timings for each task" },
2185 { "progress", HAS_ARG | OPT_EXPERT, {(void*)opt_progress},
2186 "write program-readable progress information", "url" },
2187 { "stdin", OPT_BOOL | OPT_EXPERT, {(void*)&stdin_interaction},
2188 "enable or disable interaction on standard input" },
2189 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
2190 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
2191 "dump each input packet" },
2192 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
2193 "when dumping packets, also dump the payload" },
2194 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
2195 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2196 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
2197 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
2198 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
2199 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
2200 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "mode" },
2201 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
2202 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
2203 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
2204 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
2205 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
2206 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
2207 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
2208 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
2209 { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
2210 { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
2211 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
2212 { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
2213 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
2214 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
2215 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
2216 { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
2219 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
2220 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2221 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
2222 { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2223 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
2224 { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
2225 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
2226 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
2227 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
2228 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
2229 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
2230 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
2231 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
2232 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
2233 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
2234 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
2235 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
2236 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
2237 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
2238 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
2239 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
2240 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
2241 "use same quantizer as source (implies VBR)" },
2242 { "timecode", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_timecode}, "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2243 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
2244 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
2245 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
2246 "this option is deprecated, use the yadif filter instead" },
2247 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
2248 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
2249 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
2250 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
2251 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
2252 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
2253 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
2254 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
2255 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
2256 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
2257 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
2258 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
2259 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(forced_key_frames)}, "force key frames at specified timestamps", "timestamps" },
2260 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
2263 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
2264 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
2265 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
2266 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
2267 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
2268 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
2269 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
2270 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
2271 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
2272 { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
2273 { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
2275 /* subtitle options */
2276 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
2277 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
2278 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
2281 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
2282 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
2283 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
2286 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
2287 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
2289 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
2290 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
2291 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
2293 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
2294 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
2295 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
2296 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
2297 /* data codec support */
2298 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
2299 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
2301 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },