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 char *vstats_filename;
59 float audio_drift_threshold = 0.1;
60 float dts_delta_threshold = 10;
61 float dts_error_threshold = 3600*30;
63 int audio_volume = 256;
64 int audio_sync_method = 0;
65 int video_sync_method = VSYNC_AUTO;
66 int do_deinterlace = 0;
68 int do_benchmark_all = 0;
74 int exit_on_error = 0;
78 int stdin_interaction = 1;
79 int frame_bits_per_raw_sample = 0;
82 static int intra_only = 0;
83 static const char *video_codec_name = NULL;
84 static const char *audio_codec_name = NULL;
85 static const char *subtitle_codec_name = NULL;
86 static int file_overwrite = 0;
87 static int no_file_overwrite = 0;
88 static int video_discard = 0;
89 static int intra_dc_precision = 8;
90 static int do_psnr = 0;
91 static int input_sync;
93 void reset_options(OptionsContext *o, int is_input)
95 const OptionDef *po = options;
96 OptionsContext bak= *o;
99 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
101 void *dst = (uint8_t*)o + po->u.off;
103 if (po->flags & OPT_SPEC) {
104 SpecifierOpt **so = dst;
105 int i, *count = (int*)(so + 1);
106 for (i = 0; i < *count; i++) {
107 av_freep(&(*so)[i].specifier);
108 if (po->flags & OPT_STRING)
109 av_freep(&(*so)[i].u.str);
113 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
118 for (i = 0; i < o->nb_stream_maps; i++)
119 av_freep(&o->stream_maps[i].linklabel);
120 av_freep(&o->stream_maps);
121 av_freep(&o->audio_channel_maps);
122 av_freep(&o->streamid_map);
124 memset(o, 0, sizeof(*o));
127 o->recording_time = bak.recording_time;
128 if (o->recording_time != INT64_MAX)
129 av_log(NULL, AV_LOG_WARNING,
130 "-t is not an input option, keeping it for the next output;"
131 " consider fixing your command line.\n");
133 o->recording_time = INT64_MAX;
134 o->mux_max_delay = 0.7;
135 o->limit_filesize = UINT64_MAX;
136 o->chapters_input_file = INT_MAX;
143 static int opt_frame_crop(void *optctx, const char *opt, const char *arg)
145 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
146 return AVERROR(EINVAL);
149 static int opt_pad(void *optctx, const char *opt, const char *arg)
151 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
155 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
157 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
158 return opt_default(optctx, "channel", arg);
161 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
163 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
164 return opt_default(optctx, "standard", arg);
167 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
169 OptionsContext *o = optctx;
170 audio_codec_name = arg;
171 return parse_option(o, "codec:a", arg, options);
174 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
176 OptionsContext *o = optctx;
177 video_codec_name = arg;
178 return parse_option(o, "codec:v", arg, options);
181 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
183 OptionsContext *o = optctx;
184 subtitle_codec_name = arg;
185 return parse_option(o, "codec:s", arg, options);
188 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
190 OptionsContext *o = optctx;
191 return parse_option(o, "codec:d", arg, options);
194 static int opt_map(void *optctx, const char *opt, const char *arg)
196 OptionsContext *o = optctx;
198 int i, negative = 0, file_idx;
199 int sync_file_idx = -1, sync_stream_idx = 0;
207 map = av_strdup(arg);
209 /* parse sync stream first, just pick first matching stream */
210 if (sync = strchr(map, ',')) {
212 sync_file_idx = strtol(sync + 1, &sync, 0);
213 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
214 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
219 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
220 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
221 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
225 if (i == input_files[sync_file_idx]->nb_streams) {
226 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
227 "match any streams.\n", arg);
234 /* this mapping refers to lavfi output */
235 const char *c = map + 1;
236 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
237 &o->nb_stream_maps, o->nb_stream_maps + 1);
238 m = &o->stream_maps[o->nb_stream_maps - 1];
239 m->linklabel = av_get_token(&c, "]");
241 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
245 file_idx = strtol(map, &p, 0);
246 if (file_idx >= nb_input_files || file_idx < 0) {
247 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
251 /* disable some already defined maps */
252 for (i = 0; i < o->nb_stream_maps; i++) {
253 m = &o->stream_maps[i];
254 if (file_idx == m->file_index &&
255 check_stream_specifier(input_files[m->file_index]->ctx,
256 input_files[m->file_index]->ctx->streams[m->stream_index],
257 *p == ':' ? p + 1 : p) > 0)
261 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
262 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
263 *p == ':' ? p + 1 : p) <= 0)
265 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
266 &o->nb_stream_maps, o->nb_stream_maps + 1);
267 m = &o->stream_maps[o->nb_stream_maps - 1];
269 m->file_index = file_idx;
272 if (sync_file_idx >= 0) {
273 m->sync_file_index = sync_file_idx;
274 m->sync_stream_index = sync_stream_idx;
276 m->sync_file_index = file_idx;
277 m->sync_stream_index = i;
283 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
291 static int opt_attach(void *optctx, const char *opt, const char *arg)
293 OptionsContext *o = optctx;
294 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
295 &o->nb_attachments, o->nb_attachments + 1);
296 o->attachments[o->nb_attachments - 1] = arg;
300 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
302 OptionsContext *o = optctx;
307 o->audio_channel_maps =
308 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
309 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
310 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
312 /* muted channel syntax */
313 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
314 if ((n == 1 || n == 3) && m->channel_idx == -1) {
315 m->file_idx = m->stream_idx = -1;
317 m->ofile_idx = m->ostream_idx = -1;
322 n = sscanf(arg, "%d.%d.%d:%d.%d",
323 &m->file_idx, &m->stream_idx, &m->channel_idx,
324 &m->ofile_idx, &m->ostream_idx);
326 if (n != 3 && n != 5) {
327 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
328 "[file.stream.channel|-1][:syncfile:syncstream]\n");
332 if (n != 5) // only file.stream.channel specified
333 m->ofile_idx = m->ostream_idx = -1;
336 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
337 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
341 if (m->stream_idx < 0 ||
342 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
343 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
344 m->file_idx, m->stream_idx);
347 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
348 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
349 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
350 m->file_idx, m->stream_idx);
353 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
354 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
355 m->file_idx, m->stream_idx, m->channel_idx);
362 * Parse a metadata specifier in arg.
363 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
364 * @param index for type c/p, chapter/program index is written here
365 * @param stream_spec for type s, the stream specifier is written here
367 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
375 if (*(++arg) && *arg != ':') {
376 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
379 *stream_spec = *arg == ':' ? arg + 1 : "";
384 *index = strtol(++arg, NULL, 0);
387 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
394 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
396 AVDictionary **meta_in = NULL;
397 AVDictionary **meta_out = NULL;
399 char type_in, type_out;
400 const char *istream_spec = NULL, *ostream_spec = NULL;
401 int idx_in = 0, idx_out = 0;
403 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
404 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
407 if (type_out == 'g' || !*outspec)
408 o->metadata_global_manual = 1;
409 if (type_out == 's' || !*outspec)
410 o->metadata_streams_manual = 1;
411 if (type_out == 'c' || !*outspec)
412 o->metadata_chapters_manual = 1;
416 if (type_in == 'g' || type_out == 'g')
417 o->metadata_global_manual = 1;
418 if (type_in == 's' || type_out == 's')
419 o->metadata_streams_manual = 1;
420 if (type_in == 'c' || type_out == 'c')
421 o->metadata_chapters_manual = 1;
423 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
424 if ((index) < 0 || (index) >= (nb_elems)) {\
425 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
430 #define SET_DICT(type, meta, context, index)\
433 meta = &context->metadata;\
436 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
437 meta = &context->chapters[index]->metadata;\
440 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
441 meta = &context->programs[index]->metadata;\
443 default: av_assert0(0);\
448 SET_DICT(type_in, meta_in, ic, idx_in);
449 SET_DICT(type_out, meta_out, oc, idx_out);
451 /* for input streams choose first matching stream */
452 if (type_in == 's') {
453 for (i = 0; i < ic->nb_streams; i++) {
454 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
455 meta_in = &ic->streams[i]->metadata;
461 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
466 if (type_out == 's') {
467 for (i = 0; i < oc->nb_streams; i++) {
468 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
469 meta_out = &oc->streams[i]->metadata;
470 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
475 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
480 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
482 OptionsContext *o = optctx;
484 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
485 struct tm time = *gmtime((time_t*)&recording_timestamp);
486 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
487 parse_option(o, "metadata", buf, options);
489 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
490 "tag instead.\n", opt);
494 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
496 const AVCodecDescriptor *desc;
497 const char *codec_string = encoder ? "encoder" : "decoder";
501 avcodec_find_encoder_by_name(name) :
502 avcodec_find_decoder_by_name(name);
504 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
505 codec = encoder ? avcodec_find_encoder(desc->id) :
506 avcodec_find_decoder(desc->id);
508 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
509 codec_string, codec->name, desc->name);
513 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
516 if (codec->type != type) {
517 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
523 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
525 char *codec_name = NULL;
527 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
529 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
530 st->codec->codec_id = codec->id;
533 return avcodec_find_decoder(st->codec->codec_id);
537 * Add all the streams from the given input file to the global
538 * list of input streams.
540 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
543 char *next, *codec_tag = NULL;
545 for (i = 0; i < ic->nb_streams; i++) {
546 AVStream *st = ic->streams[i];
547 AVCodecContext *dec = st->codec;
548 InputStream *ist = av_mallocz(sizeof(*ist));
549 char *framerate = NULL;
554 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
555 input_streams[nb_input_streams - 1] = ist;
558 ist->file_index = nb_input_files;
560 st->discard = AVDISCARD_ALL;
561 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
564 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
566 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
568 uint32_t tag = strtol(codec_tag, &next, 0);
570 tag = AV_RL32(codec_tag);
571 st->codec->codec_tag = tag;
574 ist->dec = choose_decoder(o, ic, st);
576 switch (dec->codec_type) {
577 case AVMEDIA_TYPE_VIDEO:
579 ist->dec = avcodec_find_decoder(dec->codec_id);
581 dec->flags |= CODEC_FLAG_EMU_EDGE;
584 ist->resample_height = dec->height;
585 ist->resample_width = dec->width;
586 ist->resample_pix_fmt = dec->pix_fmt;
588 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
589 if (framerate && av_parse_video_rate(&ist->framerate,
591 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
596 ist->top_field_first = -1;
597 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
600 case AVMEDIA_TYPE_AUDIO:
601 guess_input_channel_layout(ist);
603 ist->resample_sample_fmt = dec->sample_fmt;
604 ist->resample_sample_rate = dec->sample_rate;
605 ist->resample_channels = dec->channels;
606 ist->resample_channel_layout = dec->channel_layout;
609 case AVMEDIA_TYPE_DATA:
610 case AVMEDIA_TYPE_SUBTITLE:
612 ist->dec = avcodec_find_decoder(dec->codec_id);
613 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
615 case AVMEDIA_TYPE_ATTACHMENT:
616 case AVMEDIA_TYPE_UNKNOWN:
624 static void assert_file_overwrite(const char *filename)
626 if ((!file_overwrite || no_file_overwrite) &&
627 (strchr(filename, ':') == NULL || filename[1] == ':' ||
628 av_strstart(filename, "file:", NULL))) {
629 if (avio_check(filename, 0) == 0) {
630 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
631 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
634 signal(SIGINT, SIG_DFL);
636 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
642 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
649 static void dump_attachment(AVStream *st, const char *filename)
652 AVIOContext *out = NULL;
653 AVDictionaryEntry *e;
655 if (!st->codec->extradata_size) {
656 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
657 nb_input_files - 1, st->index);
660 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
663 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
664 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
668 assert_file_overwrite(filename);
670 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
671 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
676 avio_write(out, st->codec->extradata, st->codec->extradata_size);
681 static int opt_input_file(void *optctx, const char *opt, const char *filename)
683 OptionsContext *o = optctx;
685 AVInputFormat *file_iformat = NULL;
690 int orig_nb_streams; // number of streams before avformat_find_stream_info
693 if (!(file_iformat = av_find_input_format(o->format))) {
694 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
699 if (!strcmp(filename, "-"))
702 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
703 strcmp(filename, "/dev/stdin");
705 /* get default parameters from command line */
706 ic = avformat_alloc_context();
708 print_error(filename, AVERROR(ENOMEM));
711 if (o->nb_audio_sample_rate) {
712 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
713 av_dict_set(&format_opts, "sample_rate", buf, 0);
715 if (o->nb_audio_channels) {
716 /* because we set audio_channels based on both the "ac" and
717 * "channel_layout" options, we need to check that the specified
718 * demuxer actually has the "channels" option before setting it */
719 if (file_iformat && file_iformat->priv_class &&
720 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
721 AV_OPT_SEARCH_FAKE_OBJ)) {
722 snprintf(buf, sizeof(buf), "%d",
723 o->audio_channels[o->nb_audio_channels - 1].u.i);
724 av_dict_set(&format_opts, "channels", buf, 0);
727 if (o->nb_frame_rates) {
728 /* set the format-level framerate option;
729 * this is important for video grabbers, e.g. x11 */
730 if (file_iformat && file_iformat->priv_class &&
731 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
732 AV_OPT_SEARCH_FAKE_OBJ)) {
733 av_dict_set(&format_opts, "framerate",
734 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
737 if (o->nb_frame_sizes) {
738 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
740 if (o->nb_frame_pix_fmts)
741 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
743 ic->video_codec_id = video_codec_name ?
744 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
745 ic->audio_codec_id = audio_codec_name ?
746 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
747 ic->subtitle_codec_id= subtitle_codec_name ?
748 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
749 ic->flags |= AVFMT_FLAG_NONBLOCK;
750 ic->interrupt_callback = int_cb;
752 /* open the input file with generic avformat function */
753 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
755 print_error(filename, err);
758 assert_avoptions(format_opts);
760 /* apply forced codec ids */
761 for (i = 0; i < ic->nb_streams; i++)
762 choose_decoder(o, ic, ic->streams[i]);
764 /* Set AVCodecContext options for avformat_find_stream_info */
765 opts = setup_find_stream_info_opts(ic, codec_opts);
766 orig_nb_streams = ic->nb_streams;
768 /* If not enough info to get the stream parameters, we decode the
769 first frames to get it. (used in mpeg case for example) */
770 ret = avformat_find_stream_info(ic, opts);
772 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
773 avformat_close_input(&ic);
777 timestamp = o->start_time;
778 /* add the stream start time */
779 if (ic->start_time != AV_NOPTS_VALUE)
780 timestamp += ic->start_time;
782 /* if seeking requested, we execute it */
783 if (o->start_time != 0) {
784 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
786 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
787 filename, (double)timestamp / AV_TIME_BASE);
791 /* update the current parameters so that they match the one of the input stream */
792 add_input_streams(o, ic);
794 /* dump the file content */
795 av_dump_format(ic, nb_input_files, filename, 0);
797 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
798 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
801 input_files[nb_input_files - 1]->ctx = ic;
802 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
803 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
804 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
805 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
807 for (i = 0; i < o->nb_dump_attachment; i++) {
810 for (j = 0; j < ic->nb_streams; j++) {
811 AVStream *st = ic->streams[j];
813 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
814 dump_attachment(st, o->dump_attachment[i].u.str);
818 for (i = 0; i < orig_nb_streams; i++)
819 av_dict_free(&opts[i]);
826 static uint8_t *get_line(AVIOContext *s)
832 if (avio_open_dyn_buf(&line) < 0) {
833 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
837 while ((c = avio_r8(s)) && c != '\n')
840 avio_close_dyn_buf(line, &buf);
845 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
849 const char *base[3] = { getenv("AVCONV_DATADIR"),
854 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
858 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
859 i != 1 ? "" : "/.avconv", codec_name, preset_name);
860 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
863 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
864 i != 1 ? "" : "/.avconv", preset_name);
865 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
871 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
873 char *codec_name = NULL;
875 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
877 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
878 NULL, ost->st->codec->codec_type);
879 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
880 } else if (!strcmp(codec_name, "copy"))
881 ost->stream_copy = 1;
883 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
884 ost->st->codec->codec_id = ost->enc->id;
888 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
891 AVStream *st = avformat_new_stream(oc, NULL);
892 int idx = oc->nb_streams - 1, ret = 0;
893 char *bsf = NULL, *next, *codec_tag = NULL;
894 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
896 char *buf = NULL, *arg = NULL, *preset = NULL;
897 AVIOContext *s = NULL;
900 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
904 if (oc->nb_streams - 1 < o->nb_streamid_map)
905 st->id = o->streamid_map[oc->nb_streams - 1];
907 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
908 nb_output_streams + 1);
909 if (!(ost = av_mallocz(sizeof(*ost))))
911 output_streams[nb_output_streams - 1] = ost;
913 ost->file_index = nb_output_files;
916 st->codec->codec_type = type;
917 choose_encoder(o, oc, ost);
919 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
922 avcodec_get_context_defaults3(st->codec, ost->enc);
923 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
925 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
926 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
929 if (!buf[0] || buf[0] == '#') {
933 if (!(arg = strchr(buf, '='))) {
934 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
938 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
940 } while (!s->eof_reached);
944 av_log(NULL, AV_LOG_FATAL,
945 "Preset %s specified for stream %d:%d, but could not be opened.\n",
946 preset, ost->file_index, ost->index);
950 ost->max_frames = INT64_MAX;
951 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
953 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
955 if (next = strchr(bsf, ','))
957 if (!(bsfc = av_bitstream_filter_init(bsf))) {
958 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
962 bsfc_prev->next = bsfc;
964 ost->bitstream_filters = bsfc;
970 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
972 uint32_t tag = strtol(codec_tag, &next, 0);
974 tag = AV_RL32(codec_tag);
975 st->codec->codec_tag = tag;
978 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
979 if (qscale >= 0 || same_quant) {
980 st->codec->flags |= CODEC_FLAG_QSCALE;
981 st->codec->global_quality = FF_QP2LAMBDA * qscale;
984 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
985 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
987 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
988 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
989 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
991 ost->source_index = source_index;
992 if (source_index >= 0) {
993 ost->sync_ist = input_streams[source_index];
994 input_streams[source_index]->discard = 0;
995 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1001 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1004 const char *p = str;
1011 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1018 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1022 AVCodecContext *video_enc;
1023 char *frame_rate = NULL;
1025 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1027 video_enc = st->codec;
1029 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1030 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1031 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1035 if (!ost->stream_copy) {
1036 const char *p = NULL;
1037 char *frame_size = NULL;
1038 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1039 char *intra_matrix = NULL, *inter_matrix = NULL;
1040 const char *filters = "null";
1044 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1045 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1046 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1050 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1051 if (frame_aspect_ratio) {
1053 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1054 q.num <= 0 || q.den <= 0) {
1055 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1058 ost->frame_aspect_ratio = av_q2d(q);
1061 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1062 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1063 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1064 ost->keep_pix_fmt = 1;
1065 if (!*++frame_pix_fmt)
1066 frame_pix_fmt = NULL;
1068 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
1069 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1072 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1075 video_enc->gop_size = 0;
1076 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1078 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1079 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1082 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1084 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1086 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1087 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1090 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1093 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1094 for (i = 0; p; i++) {
1096 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1098 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1101 /* FIXME realloc failure */
1102 video_enc->rc_override =
1103 av_realloc(video_enc->rc_override,
1104 sizeof(RcOverride) * (i + 1));
1105 video_enc->rc_override[i].start_frame = start;
1106 video_enc->rc_override[i].end_frame = end;
1108 video_enc->rc_override[i].qscale = q;
1109 video_enc->rc_override[i].quality_factor = 1.0;
1112 video_enc->rc_override[i].qscale = 0;
1113 video_enc->rc_override[i].quality_factor = -q/100.0;
1118 video_enc->rc_override_count = i;
1119 if (!video_enc->rc_initial_buffer_occupancy)
1120 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1121 video_enc->intra_dc_precision = intra_dc_precision - 8;
1124 video_enc->flags|= CODEC_FLAG_PSNR;
1127 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1130 video_enc->flags |= CODEC_FLAG_PASS1;
1133 video_enc->flags |= CODEC_FLAG_PASS2;
1137 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1138 if (ost->logfile_prefix &&
1139 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1142 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1143 if (ost->forced_keyframes)
1144 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1146 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1148 ost->top_field_first = -1;
1149 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1151 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1152 ost->avfilter = av_strdup(filters);
1154 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1160 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1165 AVCodecContext *audio_enc;
1167 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1170 audio_enc = st->codec;
1171 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1173 if (!ost->stream_copy) {
1174 char *sample_fmt = NULL;
1175 const char *filters = "anull";
1177 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1179 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1181 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1182 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1186 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1188 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1190 av_assert1(filters);
1191 ost->avfilter = av_strdup(filters);
1193 /* check for channel mapping for this audio stream */
1194 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1195 AudioChannelMap *map = &o->audio_channel_maps[n];
1196 InputStream *ist = input_streams[ost->source_index];
1197 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1198 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1199 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1200 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1201 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1203 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1204 ost->file_index, ost->st->index);
1212 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1216 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1217 if (!ost->stream_copy) {
1218 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1225 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1227 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1228 ost->stream_copy = 1;
1232 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1236 AVCodecContext *subtitle_enc;
1238 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1240 subtitle_enc = st->codec;
1242 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1244 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1246 if (!ost->stream_copy) {
1247 char *frame_size = NULL;
1249 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1250 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1251 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1259 /* arg format is "output-stream-index:streamid-value". */
1260 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1262 OptionsContext *o = optctx;
1267 av_strlcpy(idx_str, arg, sizeof(idx_str));
1268 p = strchr(idx_str, ':');
1270 av_log(NULL, AV_LOG_FATAL,
1271 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1276 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1277 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1278 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1282 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1284 AVFormatContext *is = ifile->ctx;
1285 AVFormatContext *os = ofile->ctx;
1288 for (i = 0; i < is->nb_chapters; i++) {
1289 AVChapter *in_ch = is->chapters[i], *out_ch;
1290 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1291 AV_TIME_BASE_Q, in_ch->time_base);
1292 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1293 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1296 if (in_ch->end < ts_off)
1298 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1301 out_ch = av_mallocz(sizeof(AVChapter));
1303 return AVERROR(ENOMEM);
1305 out_ch->id = in_ch->id;
1306 out_ch->time_base = in_ch->time_base;
1307 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1308 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1311 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1314 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
1316 return AVERROR(ENOMEM);
1317 os->chapters[os->nb_chapters - 1] = out_ch;
1322 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1325 AVFormatContext *ic = avformat_alloc_context();
1327 ic->interrupt_callback = int_cb;
1328 err = avformat_open_input(&ic, filename, NULL, NULL);
1331 /* copy stream format */
1332 for(i=0;i<ic->nb_streams;i++) {
1336 AVCodecContext *avctx;
1338 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1339 ost = new_output_stream(o, s, codec->type, -1);
1344 // FIXME: a more elegant solution is needed
1345 memcpy(st, ic->streams[i], sizeof(AVStream));
1347 st->info = av_malloc(sizeof(*st->info));
1348 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1350 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1352 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1353 choose_sample_fmt(st, codec);
1354 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1355 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1358 avformat_close_input(&ic);
1362 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1363 AVFormatContext *oc)
1367 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1368 ofilter->out_tmp->pad_idx)) {
1369 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1370 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1372 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1377 ost->source_index = -1;
1378 ost->filter = ofilter;
1382 if (ost->stream_copy) {
1383 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1384 "which is fed from a complex filtergraph. Filtering and streamcopy "
1385 "cannot be used together.\n", ost->file_index, ost->index);
1389 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1390 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1393 avfilter_inout_free(&ofilter->out_tmp);
1396 static int configure_complex_filters(void)
1400 for (i = 0; i < nb_filtergraphs; i++)
1401 if (!filtergraphs[i]->graph &&
1402 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1407 void opt_output_file(void *optctx, const char *filename)
1409 OptionsContext *o = optctx;
1410 AVFormatContext *oc;
1412 AVOutputFormat *file_oformat;
1416 if (configure_complex_filters() < 0) {
1417 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1421 if (!strcmp(filename, "-"))
1424 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1426 print_error(filename, err);
1429 file_oformat= oc->oformat;
1430 oc->interrupt_callback = int_cb;
1432 /* create streams for all unlabeled output pads */
1433 for (i = 0; i < nb_filtergraphs; i++) {
1434 FilterGraph *fg = filtergraphs[i];
1435 for (j = 0; j < fg->nb_outputs; j++) {
1436 OutputFilter *ofilter = fg->outputs[j];
1438 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1441 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1442 ofilter->out_tmp->pad_idx)) {
1443 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1444 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1445 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1447 init_output_filter(ofilter, o, oc);
1451 if (!strcmp(file_oformat->name, "ffm") &&
1452 av_strstart(filename, "http:", NULL)) {
1454 /* special case for files sent to ffserver: we get the stream
1455 parameters from ffserver */
1456 int err = read_ffserver_streams(o, oc, filename);
1458 print_error(filename, err);
1461 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1462 ost = output_streams[j];
1463 for (i = 0; i < nb_input_streams; i++) {
1464 ist = input_streams[i];
1465 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1467 ost->source_index= i;
1468 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1469 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1471 ist->st->discard = AVDISCARD_NONE;
1476 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));
1480 } else if (!o->nb_stream_maps) {
1481 /* pick the "best" stream of each type */
1483 /* video: highest resolution */
1484 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1485 int area = 0, idx = -1;
1486 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1487 for (i = 0; i < nb_input_streams; i++) {
1488 ist = input_streams[i];
1489 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1490 ist->st->codec->width * ist->st->codec->height > area) {
1491 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1493 area = ist->st->codec->width * ist->st->codec->height;
1498 new_video_stream(o, oc, idx);
1501 /* audio: most channels */
1502 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1503 int channels = 0, idx = -1;
1504 for (i = 0; i < nb_input_streams; i++) {
1505 ist = input_streams[i];
1506 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1507 ist->st->codec->channels > channels) {
1508 channels = ist->st->codec->channels;
1513 new_audio_stream(o, oc, idx);
1516 /* subtitles: pick first */
1517 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1518 for (i = 0; i < nb_input_streams; i++)
1519 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1520 new_subtitle_stream(o, oc, i);
1524 /* do something with data? */
1526 for (i = 0; i < o->nb_stream_maps; i++) {
1527 StreamMap *map = &o->stream_maps[i];
1528 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1533 if (map->linklabel) {
1535 OutputFilter *ofilter = NULL;
1538 for (j = 0; j < nb_filtergraphs; j++) {
1539 fg = filtergraphs[j];
1540 for (k = 0; k < fg->nb_outputs; k++) {
1541 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1542 if (out && !strcmp(out->name, map->linklabel)) {
1543 ofilter = fg->outputs[k];
1550 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1551 "in any defined filter graph.\n", map->linklabel);
1554 init_output_filter(ofilter, o, oc);
1556 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1557 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1559 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1561 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1563 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1566 switch (ist->st->codec->codec_type) {
1567 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1568 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1569 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1570 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1571 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1573 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1574 map->file_index, map->stream_index);
1582 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1583 AVDictionaryEntry *e;
1584 ost = output_streams[i];
1586 if ( ost->stream_copy
1587 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1588 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1589 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1593 /* handle attached files */
1594 for (i = 0; i < o->nb_attachments; i++) {
1596 uint8_t *attachment;
1600 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1601 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1605 if ((len = avio_size(pb)) <= 0) {
1606 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1610 if (!(attachment = av_malloc(len))) {
1611 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1615 avio_read(pb, attachment, len);
1617 ost = new_attachment_stream(o, oc, -1);
1618 ost->stream_copy = 0;
1619 ost->attachment_filename = o->attachments[i];
1620 ost->st->codec->extradata = attachment;
1621 ost->st->codec->extradata_size = len;
1623 p = strrchr(o->attachments[i], '/');
1624 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1628 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1629 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1632 output_files[nb_output_files - 1]->ctx = oc;
1633 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1634 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1635 if (o->recording_time != INT64_MAX)
1636 oc->duration = o->recording_time;
1637 output_files[nb_output_files - 1]->start_time = o->start_time;
1638 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1639 output_files[nb_output_files - 1]->shortest = o->shortest;
1640 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1642 /* check filename in case of an image number is expected */
1643 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1644 if (!av_filename_number_test(oc->filename)) {
1645 print_error(oc->filename, AVERROR(EINVAL));
1650 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1651 /* test if it already exists to avoid losing precious files */
1652 assert_file_overwrite(filename);
1655 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1656 &oc->interrupt_callback,
1657 &output_files[nb_output_files - 1]->opts)) < 0) {
1658 print_error(filename, err);
1663 if (o->mux_preload) {
1665 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1666 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1668 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1671 for (i = 0; i < o->nb_metadata_map; i++) {
1673 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1675 if (in_file_index >= nb_input_files) {
1676 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1679 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
1683 if (o->chapters_input_file >= nb_input_files) {
1684 if (o->chapters_input_file == INT_MAX) {
1685 /* copy chapters from the first input file that has them*/
1686 o->chapters_input_file = -1;
1687 for (i = 0; i < nb_input_files; i++)
1688 if (input_files[i]->ctx->nb_chapters) {
1689 o->chapters_input_file = i;
1693 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1694 o->chapters_input_file);
1698 if (o->chapters_input_file >= 0)
1699 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1700 !o->metadata_chapters_manual);
1702 /* copy global metadata by default */
1703 if (!o->metadata_global_manual && nb_input_files){
1704 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1705 AV_DICT_DONT_OVERWRITE);
1706 if(o->recording_time != INT64_MAX)
1707 av_dict_set(&oc->metadata, "duration", NULL, 0);
1708 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1710 if (!o->metadata_streams_manual)
1711 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1713 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1715 ist = input_streams[output_streams[i]->source_index];
1716 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1719 /* process manually set metadata */
1720 for (i = 0; i < o->nb_metadata; i++) {
1723 const char *stream_spec;
1724 int index = 0, j, ret = 0;
1726 val = strchr(o->metadata[i].u.str, '=');
1728 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1729 o->metadata[i].u.str);
1734 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1736 for (j = 0; j < oc->nb_streams; j++) {
1737 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1738 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1749 if (index < 0 || index >= oc->nb_chapters) {
1750 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1753 m = &oc->chapters[index]->metadata;
1756 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1759 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1763 reset_options(o, 0);
1766 static int opt_target(void *optctx, const char *opt, const char *arg)
1768 OptionsContext *o = optctx;
1769 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1770 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1772 if (!strncmp(arg, "pal-", 4)) {
1775 } else if (!strncmp(arg, "ntsc-", 5)) {
1778 } else if (!strncmp(arg, "film-", 5)) {
1782 /* Try to determine PAL/NTSC by peeking in the input files */
1783 if (nb_input_files) {
1785 for (j = 0; j < nb_input_files; j++) {
1786 for (i = 0; i < input_files[j]->nb_streams; i++) {
1787 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1788 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1790 fr = c->time_base.den * 1000 / c->time_base.num;
1794 } else if ((fr == 29970) || (fr == 23976)) {
1799 if (norm != UNKNOWN)
1803 if (norm != UNKNOWN)
1804 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1807 if (norm == UNKNOWN) {
1808 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1809 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1810 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1814 if (!strcmp(arg, "vcd")) {
1815 opt_video_codec(o, "c:v", "mpeg1video");
1816 opt_audio_codec(o, "c:a", "mp2");
1817 parse_option(o, "f", "vcd", options);
1819 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1820 parse_option(o, "r", frame_rates[norm], options);
1821 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1823 opt_default(NULL, "b:v", "1150000");
1824 opt_default(NULL, "maxrate", "1150000");
1825 opt_default(NULL, "minrate", "1150000");
1826 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1828 opt_default(NULL, "b:a", "224000");
1829 parse_option(o, "ar", "44100", options);
1830 parse_option(o, "ac", "2", options);
1832 opt_default(NULL, "packetsize", "2324");
1833 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1835 /* We have to offset the PTS, so that it is consistent with the SCR.
1836 SCR starts at 36000, but the first two packs contain only padding
1837 and the first pack from the other stream, respectively, may also have
1838 been written before.
1839 So the real data starts at SCR 36000+3*1200. */
1840 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1841 } else if (!strcmp(arg, "svcd")) {
1843 opt_video_codec(o, "c:v", "mpeg2video");
1844 opt_audio_codec(o, "c:a", "mp2");
1845 parse_option(o, "f", "svcd", options);
1847 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1848 parse_option(o, "r", frame_rates[norm], options);
1849 parse_option(o, "pix_fmt", "yuv420p", options);
1850 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1852 opt_default(NULL, "b:v", "2040000");
1853 opt_default(NULL, "maxrate", "2516000");
1854 opt_default(NULL, "minrate", "0"); // 1145000;
1855 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1856 opt_default(NULL, "scan_offset", "1");
1858 opt_default(NULL, "b:a", "224000");
1859 parse_option(o, "ar", "44100", options);
1861 opt_default(NULL, "packetsize", "2324");
1863 } else if (!strcmp(arg, "dvd")) {
1865 opt_video_codec(o, "c:v", "mpeg2video");
1866 opt_audio_codec(o, "c:a", "ac3");
1867 parse_option(o, "f", "dvd", options);
1869 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1870 parse_option(o, "r", frame_rates[norm], options);
1871 parse_option(o, "pix_fmt", "yuv420p", options);
1872 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1874 opt_default(NULL, "b:v", "6000000");
1875 opt_default(NULL, "maxrate", "9000000");
1876 opt_default(NULL, "minrate", "0"); // 1500000;
1877 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1879 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1880 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1882 opt_default(NULL, "b:a", "448000");
1883 parse_option(o, "ar", "48000", options);
1885 } else if (!strncmp(arg, "dv", 2)) {
1887 parse_option(o, "f", "dv", options);
1889 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1890 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1891 norm == PAL ? "yuv420p" : "yuv411p", options);
1892 parse_option(o, "r", frame_rates[norm], options);
1894 parse_option(o, "ar", "48000", options);
1895 parse_option(o, "ac", "2", options);
1898 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1899 return AVERROR(EINVAL);
1904 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1906 av_free (vstats_filename);
1907 vstats_filename = av_strdup (arg);
1911 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1914 time_t today2 = time(NULL);
1915 struct tm *today = localtime(&today2);
1917 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1919 return opt_vstats_file(NULL, opt, filename);
1922 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1924 OptionsContext *o = optctx;
1925 return parse_option(o, "frames:v", arg, options);
1928 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1930 OptionsContext *o = optctx;
1931 return parse_option(o, "frames:a", arg, options);
1934 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1936 OptionsContext *o = optctx;
1937 return parse_option(o, "frames:d", arg, options);
1940 static int opt_preset(void *optctx, const char *opt, const char *arg)
1942 OptionsContext *o = optctx;
1944 char filename[1000], line[1000], tmp_line[1000];
1945 const char *codec_name = *opt == 'v' ? video_codec_name :
1946 *opt == 'a' ? audio_codec_name :
1947 subtitle_codec_name;
1949 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1950 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1951 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1953 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1957 while (fgets(line, sizeof(line), f)) {
1958 char *key = tmp_line, *value, *endptr;
1960 if (strcspn(line, "#\n\r") == 0)
1962 strcpy(tmp_line, line);
1963 if (!av_strtok(key, "=", &value) ||
1964 !av_strtok(value, "\r\n", &endptr)) {
1965 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
1968 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
1970 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
1971 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
1972 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
1973 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
1974 else if (opt_default(NULL, key, value) < 0) {
1975 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
1976 filename, line, key, value);
1986 static int opt_old2new(void *optctx, const char *opt, const char *arg)
1988 OptionsContext *o = optctx;
1989 char *s = av_asprintf("%s:%c", opt + 1, *opt);
1990 int ret = parse_option(o, s, arg, options);
1995 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
1997 OptionsContext *o = optctx;
1998 if(!strcmp(opt, "b")){
1999 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2000 return parse_option(o, "b:v", arg, options);
2002 return opt_default(optctx, opt, arg);
2005 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2007 OptionsContext *o = optctx;
2010 if(!strcmp(opt, "qscale")){
2011 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2012 return parse_option(o, "q:v", arg, options);
2014 s = av_asprintf("q%s", opt + 6);
2015 ret = parse_option(o, s, arg, options);
2020 static int opt_profile(void *optctx, const char *opt, const char *arg)
2022 OptionsContext *o = optctx;
2023 if(!strcmp(opt, "profile")){
2024 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2025 return parse_option(o, "profile:v", arg, options);
2027 return opt_default(optctx, opt, arg);
2031 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2033 OptionsContext *o = optctx;
2034 return parse_option(o, "filter:v", arg, options);
2037 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2039 OptionsContext *o = optctx;
2040 return parse_option(o, "filter:a", arg, options);
2043 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2045 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2046 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2047 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2048 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2050 if (video_sync_method == VSYNC_AUTO)
2051 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2055 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2057 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2062 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2064 OptionsContext *o = optctx;
2065 char *tcr = av_asprintf("timecode=%s", arg);
2066 int ret = parse_option(o, "metadata:g", tcr, options);
2068 ret = opt_default(optctx, "gop_timecode", arg);
2073 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2075 OptionsContext *o = optctx;
2076 char layout_str[32];
2079 int ret, channels, ac_str_size;
2082 layout = av_get_channel_layout(arg);
2084 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2085 return AVERROR(EINVAL);
2087 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2088 ret = opt_default(NULL, opt, layout_str);
2092 /* set 'ac' option based on channel layout */
2093 channels = av_get_channel_layout_nb_channels(layout);
2094 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2095 stream_str = strchr(opt, ':');
2096 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2097 ac_str = av_mallocz(ac_str_size);
2099 return AVERROR(ENOMEM);
2100 av_strlcpy(ac_str, "ac", 3);
2102 av_strlcat(ac_str, stream_str, ac_str_size);
2103 ret = parse_option(o, ac_str, layout_str, options);
2109 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2111 OptionsContext *o = optctx;
2112 return parse_option(o, "q:a", arg, options);
2115 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2117 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2118 &nb_filtergraphs, nb_filtergraphs + 1);
2119 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2120 return AVERROR(ENOMEM);
2121 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2122 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2126 void show_help_default(const char *opt, const char *arg)
2128 /* per-file options have at least one of those set */
2129 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2130 int show_advanced = 0, show_avoptions = 0;
2133 if (!strcmp(opt, "long"))
2135 else if (!strcmp(opt, "full"))
2136 show_advanced = show_avoptions = 1;
2138 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2143 printf("Getting help:\n"
2144 " -h -- print basic options\n"
2145 " -h long -- print more options\n"
2146 " -h full -- print all options (including all format and codec specific options, very long)\n"
2147 " See man %s for detailed description of the options.\n"
2148 "\n", program_name);
2150 show_help_options(options, "Print help / information / capabilities:",
2153 show_help_options(options, "Global options (affect whole program "
2154 "instead of just one file:",
2155 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2157 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2158 per_file | OPT_EXIT, 0);
2160 show_help_options(options, "Per-file main options:", 0,
2161 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2162 OPT_EXIT, per_file);
2164 show_help_options(options, "Advanced per-file options:",
2165 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2167 show_help_options(options, "Video options:",
2168 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2170 show_help_options(options, "Advanced Video options:",
2171 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2173 show_help_options(options, "Audio options:",
2174 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2176 show_help_options(options, "Advanced Audio options:",
2177 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2178 show_help_options(options, "Subtitle options:",
2179 OPT_SUBTITLE, 0, 0);
2182 if (show_avoptions) {
2183 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2184 show_help_children(avcodec_get_class(), flags);
2185 show_help_children(avformat_get_class(), flags);
2186 show_help_children(sws_get_class(), flags);
2187 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2188 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2192 void show_usage(void)
2194 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2195 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2196 av_log(NULL, AV_LOG_INFO, "\n");
2200 static int opt_progress(void *optctx, const char *opt, const char *arg)
2202 AVIOContext *avio = NULL;
2205 if (!strcmp(arg, "-"))
2207 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2209 av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2210 arg, av_err2str(ret));
2213 progress_avio = avio;
2217 #define OFFSET(x) offsetof(OptionsContext, x)
2218 const OptionDef options[] = {
2220 #include "cmdutils_common_opts.h"
2221 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2222 "force format", "fmt" },
2223 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
2224 "input file name", "filename" },
2225 { "y", OPT_BOOL, { &file_overwrite },
2226 "overwrite output files" },
2227 { "n", OPT_BOOL, { &no_file_overwrite },
2228 "do not overwrite output files" },
2229 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2230 "codec name", "codec" },
2231 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2232 "codec name", "codec" },
2233 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2234 "preset name", "preset" },
2235 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2236 "set input stream mapping",
2237 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2238 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2239 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2240 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2241 "set metadata information of outfile from infile",
2242 "outfile[,metadata]:infile[,metadata]" },
2243 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2244 "set chapters mapping", "input_file_index" },
2245 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2246 "record or transcode \"duration\" seconds of audio/video",
2248 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2249 "set the limit file size in bytes", "limit_size" },
2250 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2251 "set the start time offset", "time_off" },
2252 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2253 "set the input ts offset", "time_off" },
2254 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2255 "set the input ts scale", "scale" },
2256 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2257 "set the recording timestamp ('now' to set the current time)", "time" },
2258 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2259 "add metadata", "string=string" },
2260 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2261 "set the number of data frames to record", "number" },
2262 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2263 "add timings for benchmarking" },
2264 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2265 "add timings for each task" },
2266 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2267 "write program-readable progress information", "url" },
2268 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2269 "enable or disable interaction on standard input" },
2270 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2271 "set max runtime in seconds", "limit" },
2272 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2273 "dump each input packet" },
2274 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2275 "when dumping packets, also dump the payload" },
2276 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2277 "read input at native frame rate", "" },
2278 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2279 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2280 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2281 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2282 "video sync method", "" },
2283 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2284 "audio sync method", "" },
2285 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2286 "audio drift threshold", "threshold" },
2287 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2288 "copy timestamps" },
2289 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2290 "copy input stream time base when stream copying", "mode" },
2291 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2292 "finish encoding within shortest input" },
2293 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2294 "timestamp discontinuity delta threshold", "threshold" },
2295 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2296 "timestamp error delta threshold", "threshold" },
2297 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2298 "exit on error", "error" },
2299 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2300 "copy initial non-keyframes" },
2301 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2302 "set the number of frames to record", "number" },
2303 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2304 "force codec tag/fourcc", "fourcc/tag" },
2305 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2306 "use fixed quality scale (VBR)", "q" },
2307 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2308 "use fixed quality scale (VBR)", "q" },
2309 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2310 "set profile", "profile" },
2311 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2312 "set stream filterchain", "filter_list" },
2313 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2314 "create a complex filtergraph", "graph_description" },
2315 { "stats", OPT_BOOL, { &print_stats },
2316 "print progress report during encoding", },
2317 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2318 "add an attachment to the output file", "filename" },
2319 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2320 "extract an attachment into a file", "filename" },
2321 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2322 "print timestamp debugging info" },
2325 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2326 "set the number of video frames to record", "number" },
2327 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2328 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2329 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2330 "set frame size (WxH or abbreviation)", "size" },
2331 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2332 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2333 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2334 "set pixel format", "format" },
2335 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2336 "set the number of bits per raw sample", "number" },
2337 { "croptop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2338 "Removed, use the crop filter instead", "size" },
2339 { "cropbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2340 "Removed, use the crop filter instead", "size" },
2341 { "cropleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2342 "Removed, use the crop filter instead", "size" },
2343 { "cropright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2344 "Removed, use the crop filter instead", "size" },
2345 { "padtop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2346 "Removed, use the pad filter instead", "size" },
2347 { "padbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2348 "Removed, use the pad filter instead", "size" },
2349 { "padleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2350 "Removed, use the pad filter instead", "size" },
2351 { "padright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2352 "Removed, use the pad filter instead", "size" },
2353 { "padcolor", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2354 "Removed, use the pad filter instead", "color" },
2355 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2356 "deprecated use -g 1" },
2357 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2359 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2360 "discard threshold", "n" },
2361 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2362 "rate control override for specific intervals", "override" },
2363 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2364 "force video codec ('copy' to copy stream)", "codec" },
2365 { "sameq", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &same_quant },
2366 "use same quantizer as source (implies VBR)" },
2367 { "same_quant", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &same_quant },
2368 "use same quantizer as source (implies VBR)" },
2369 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2370 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2371 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2372 "select the pass number (1 to 3)", "n" },
2373 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2374 "select two pass log file name prefix", "prefix" },
2375 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2376 "this option is deprecated, use the yadif filter instead" },
2377 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2378 "calculate PSNR of compressed frames" },
2379 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2380 "dump video coding statistics to file" },
2381 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2382 "dump video coding statistics to file", "file" },
2383 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2384 "video filters", "filter list" },
2385 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2386 "specify intra matrix coeffs", "matrix" },
2387 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2388 "specify inter matrix coeffs", "matrix" },
2389 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2390 "top=1/bottom=0/auto=-1 field first", "" },
2391 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2392 "intra_dc_precision", "precision" },
2393 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2394 "force video tag/fourcc", "fourcc/tag" },
2395 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2396 "show QP histogram" },
2397 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2398 "force the selected framerate, disable the best supported framerate selection" },
2399 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2400 "set the value of an outfile streamid", "streamIndex:value" },
2401 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2402 { .off = OFFSET(forced_key_frames) },
2403 "force key frames at specified timestamps", "timestamps" },
2404 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2405 "video bitrate (please use -b:v)", "bitrate" },
2408 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2409 "set the number of audio frames to record", "number" },
2410 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2411 "set audio quality (codec-specific)", "quality", },
2412 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2413 "set audio sampling rate (in Hz)", "rate" },
2414 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2415 "set number of audio channels", "channels" },
2416 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2418 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2419 "force audio codec ('copy' to copy stream)", "codec" },
2420 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2421 "force audio tag/fourcc", "fourcc/tag" },
2422 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2423 "change audio volume (256=normal)" , "volume" },
2424 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2425 "set sample format", "format" },
2426 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2427 "set channel layout", "layout" },
2428 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2429 "audio filters", "filter list" },
2431 /* subtitle options */
2432 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2433 "disable subtitle" },
2434 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2435 "force subtitle codec ('copy' to copy stream)", "codec" },
2436 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2437 , "force subtitle tag/fourcc", "fourcc/tag" },
2438 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2439 "fix subtitles duration" },
2442 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2443 "deprecated, use -channel", "channel" },
2444 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2445 "deprecated, use -standard", "standard" },
2446 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2449 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2450 "set the maximum demux-decode delay", "seconds" },
2451 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2452 "set the initial demux-decode delay", "seconds" },
2454 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2455 "A comma-separated list of bitstream filters", "bitstream_filters" },
2456 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2457 "deprecated", "audio bitstream_filters" },
2458 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2459 "deprecated", "video bitstream_filters" },
2461 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2462 "set the audio options to the indicated preset", "preset" },
2463 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2464 "set the video options to the indicated preset", "preset" },
2465 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2466 "set the subtitle options to the indicated preset", "preset" },
2467 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2468 "set options from indicated preset file", "filename" },
2469 /* data codec support */
2470 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2471 "force data codec ('copy' to copy stream)", "codec" },
2472 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2475 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2476 "generic catch all option", "" },