utvideoenc: use dsp.sub_hfyu_median_prediction
[ffmpeg.git] / ffmpeg_opt.c
1 /*
2  * ffmpeg option parsing
3  *
4  * This file is part of FFmpeg.
5  *
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.
10  *
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.
15  *
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
19  */
20
21 #include <stdint.h>
22
23 #include "ffmpeg.h"
24 #include "cmdutils.h"
25
26 #include "libavformat/avformat.h"
27
28 #include "libavcodec/avcodec.h"
29
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
32
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"
44
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
46 {\
47     int i, ret;\
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;\
52         else if (ret < 0)\
53             exit_program(1);\
54     }\
55 }
56
57 const char *pass_logfilename_prefix;
58 char *vstats_filename;
59
60 float audio_drift_threshold = 0.1;
61 float dts_delta_threshold   = 10;
62 float dts_error_threshold   = 3600*30;
63
64 int audio_volume      = 256;
65 int audio_sync_method = 0;
66 int video_sync_method = VSYNC_AUTO;
67 int do_deinterlace    = 0;
68 int do_benchmark      = 0;
69 int do_benchmark_all  = 0;
70 int do_hex_dump       = 0;
71 int do_pkt_dump       = 0;
72 int copy_ts           = 0;
73 int copy_tb           = -1;
74 int debug_ts          = 0;
75 int opt_shortest      = 0;
76 int exit_on_error     = 0;
77 int print_stats       = 1;
78 int qp_hist           = 0;
79 int same_quant        = 0;
80 int stdin_interaction = 1;
81 int frame_bits_per_raw_sample = 0;
82
83
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;
95
96 void reset_options(OptionsContext *o, int is_input)
97 {
98     const OptionDef *po = options;
99     OptionsContext bak= *o;
100     int i;
101
102     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
103     while (po->name) {
104         void *dst = (uint8_t*)o + po->u.off;
105
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);
113             }
114             av_freep(so);
115             *count = 0;
116         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
117             av_freep(dst);
118         po++;
119     }
120
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);
126
127     memset(o, 0, sizeof(*o));
128
129     if (is_input) {
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");
135     } else
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;
140
141     uninit_opts();
142     init_opts();
143 }
144
145
146 static int opt_frame_crop(const char *opt, const char *arg)
147 {
148     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
149     return AVERROR(EINVAL);
150 }
151
152 static int opt_pad(const char *opt, const char *arg)
153 {
154     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
155     return -1;
156 }
157
158 static int opt_video_channel(const char *opt, const char *arg)
159 {
160     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
161     return opt_default("channel", arg);
162     }
163
164 static int opt_video_standard(const char *opt, const char *arg)
165 {
166     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
167     return opt_default("standard", arg);
168 }
169
170 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
171 {
172     OptionsContext *o = optctx;
173     audio_codec_name = arg;
174     return parse_option(o, "codec:a", arg, options);
175 }
176
177 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
178 {
179     OptionsContext *o = optctx;
180     video_codec_name = arg;
181     return parse_option(o, "codec:v", arg, options);
182 }
183
184 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
185 {
186     OptionsContext *o = optctx;
187     subtitle_codec_name = arg;
188     return parse_option(o, "codec:s", arg, options);
189 }
190
191 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
192 {
193     OptionsContext *o = optctx;
194     return parse_option(o, "codec:d", arg, options);
195 }
196
197 static int opt_map(void *optctx, const char *opt, const char *arg)
198 {
199     OptionsContext *o = optctx;
200     StreamMap *m = NULL;
201     int i, negative = 0, file_idx;
202     int sync_file_idx = -1, sync_stream_idx = 0;
203     char *p, *sync;
204     char *map;
205
206     if (*arg == '-') {
207         negative = 1;
208         arg++;
209     }
210     map = av_strdup(arg);
211
212     /* parse sync stream first, just pick first matching stream */
213     if (sync = strchr(map, ',')) {
214         *sync = 0;
215         sync_file_idx = strtol(sync + 1, &sync, 0);
216         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
217             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
218             exit_program(1);
219         }
220         if (*sync)
221             sync++;
222         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
223             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
224                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
225                 sync_stream_idx = i;
226                 break;
227             }
228         if (i == input_files[sync_file_idx]->nb_streams) {
229             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
230                                        "match any streams.\n", arg);
231             exit_program(1);
232         }
233     }
234
235
236     if (map[0] == '[') {
237         /* this mapping refers to lavfi output */
238         const char *c = map + 1;
239         o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
240                                     &o->nb_stream_maps, o->nb_stream_maps + 1);
241         m = &o->stream_maps[o->nb_stream_maps - 1];
242         m->linklabel = av_get_token(&c, "]");
243         if (!m->linklabel) {
244             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
245             exit_program(1);
246         }
247     } else {
248         file_idx = strtol(map, &p, 0);
249         if (file_idx >= nb_input_files || file_idx < 0) {
250             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
251             exit_program(1);
252         }
253         if (negative)
254             /* disable some already defined maps */
255             for (i = 0; i < o->nb_stream_maps; i++) {
256                 m = &o->stream_maps[i];
257                 if (file_idx == m->file_index &&
258                     check_stream_specifier(input_files[m->file_index]->ctx,
259                                            input_files[m->file_index]->ctx->streams[m->stream_index],
260                                            *p == ':' ? p + 1 : p) > 0)
261                     m->disabled = 1;
262             }
263         else
264             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
265                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
266                             *p == ':' ? p + 1 : p) <= 0)
267                     continue;
268                 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
269                                             &o->nb_stream_maps, o->nb_stream_maps + 1);
270                 m = &o->stream_maps[o->nb_stream_maps - 1];
271
272                 m->file_index   = file_idx;
273                 m->stream_index = i;
274
275                 if (sync_file_idx >= 0) {
276                     m->sync_file_index   = sync_file_idx;
277                     m->sync_stream_index = sync_stream_idx;
278                 } else {
279                     m->sync_file_index   = file_idx;
280                     m->sync_stream_index = i;
281                 }
282             }
283     }
284
285     if (!m) {
286         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
287         exit_program(1);
288     }
289
290     av_freep(&map);
291     return 0;
292 }
293
294 static int opt_attach(void *optctx, const char *opt, const char *arg)
295 {
296     OptionsContext *o = optctx;
297     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
298                                 &o->nb_attachments, o->nb_attachments + 1);
299     o->attachments[o->nb_attachments - 1] = arg;
300     return 0;
301 }
302
303 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
304 {
305     OptionsContext *o = optctx;
306     int n;
307     AVStream *st;
308     AudioChannelMap *m;
309
310     o->audio_channel_maps =
311         grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
312                    &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
313     m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
314
315     /* muted channel syntax */
316     n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
317     if ((n == 1 || n == 3) && m->channel_idx == -1) {
318         m->file_idx = m->stream_idx = -1;
319         if (n == 1)
320             m->ofile_idx = m->ostream_idx = -1;
321         return 0;
322     }
323
324     /* normal syntax */
325     n = sscanf(arg, "%d.%d.%d:%d.%d",
326                &m->file_idx,  &m->stream_idx, &m->channel_idx,
327                &m->ofile_idx, &m->ostream_idx);
328
329     if (n != 3 && n != 5) {
330         av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
331                "[file.stream.channel|-1][:syncfile:syncstream]\n");
332         exit_program(1);
333     }
334
335     if (n != 5) // only file.stream.channel specified
336         m->ofile_idx = m->ostream_idx = -1;
337
338     /* check input */
339     if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
340         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
341                m->file_idx);
342         exit_program(1);
343     }
344     if (m->stream_idx < 0 ||
345         m->stream_idx >= input_files[m->file_idx]->nb_streams) {
346         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
347                m->file_idx, m->stream_idx);
348         exit_program(1);
349     }
350     st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
351     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
352         av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
353                m->file_idx, m->stream_idx);
354         exit_program(1);
355     }
356     if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
357         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
358                m->file_idx, m->stream_idx, m->channel_idx);
359         exit_program(1);
360     }
361     return 0;
362 }
363
364 /**
365  * Parse a metadata specifier in arg.
366  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
367  * @param index for type c/p, chapter/program index is written here
368  * @param stream_spec for type s, the stream specifier is written here
369  */
370 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
371 {
372     if (*arg) {
373         *type = *arg;
374         switch (*arg) {
375         case 'g':
376             break;
377         case 's':
378             if (*(++arg) && *arg != ':') {
379                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
380                 exit_program(1);
381             }
382             *stream_spec = *arg == ':' ? arg + 1 : "";
383             break;
384         case 'c':
385         case 'p':
386             if (*(++arg) == ':')
387                 *index = strtol(++arg, NULL, 0);
388             break;
389         default:
390             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
391             exit_program(1);
392         }
393     } else
394         *type = 'g';
395 }
396
397 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
398 {
399     AVDictionary **meta_in = NULL;
400     AVDictionary **meta_out = NULL;
401     int i, ret = 0;
402     char type_in, type_out;
403     const char *istream_spec = NULL, *ostream_spec = NULL;
404     int idx_in = 0, idx_out = 0;
405
406     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
407     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
408
409     if (!ic) {
410         if (type_out == 'g' || !*outspec)
411             o->metadata_global_manual = 1;
412         if (type_out == 's' || !*outspec)
413             o->metadata_streams_manual = 1;
414         if (type_out == 'c' || !*outspec)
415             o->metadata_chapters_manual = 1;
416         return 0;
417     }
418
419     if (type_in == 'g' || type_out == 'g')
420         o->metadata_global_manual = 1;
421     if (type_in == 's' || type_out == 's')
422         o->metadata_streams_manual = 1;
423     if (type_in == 'c' || type_out == 'c')
424         o->metadata_chapters_manual = 1;
425
426 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
427     if ((index) < 0 || (index) >= (nb_elems)) {\
428         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
429                 (desc), (index));\
430         exit_program(1);\
431     }
432
433 #define SET_DICT(type, meta, context, index)\
434         switch (type) {\
435         case 'g':\
436             meta = &context->metadata;\
437             break;\
438         case 'c':\
439             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
440             meta = &context->chapters[index]->metadata;\
441             break;\
442         case 'p':\
443             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
444             meta = &context->programs[index]->metadata;\
445             break;\
446         default: av_assert0(0);\
447         }\
448
449     SET_DICT(type_in, meta_in, ic, idx_in);
450     SET_DICT(type_out, meta_out, oc, idx_out);
451
452     /* for input streams choose first matching stream */
453     if (type_in == 's') {
454         for (i = 0; i < ic->nb_streams; i++) {
455             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
456                 meta_in = &ic->streams[i]->metadata;
457                 break;
458             } else if (ret < 0)
459                 exit_program(1);
460         }
461         if (!meta_in) {
462             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
463             exit_program(1);
464         }
465     }
466
467     if (type_out == 's') {
468         for (i = 0; i < oc->nb_streams; i++) {
469             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
470                 meta_out = &oc->streams[i]->metadata;
471                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
472             } else if (ret < 0)
473                 exit_program(1);
474         }
475     } else
476         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
477
478     return 0;
479 }
480
481 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
482 {
483     OptionsContext *o = optctx;
484     char buf[128];
485     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
486     struct tm time = *gmtime((time_t*)&recording_timestamp);
487     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
488     parse_option(o, "metadata", buf, options);
489
490     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
491                                  "tag instead.\n", opt);
492     return 0;
493 }
494
495 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
496 {
497     const AVCodecDescriptor *desc;
498     const char *codec_string = encoder ? "encoder" : "decoder";
499     AVCodec *codec;
500
501     codec = encoder ?
502         avcodec_find_encoder_by_name(name) :
503         avcodec_find_decoder_by_name(name);
504
505     if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
506         codec = encoder ? avcodec_find_encoder(desc->id) :
507                           avcodec_find_decoder(desc->id);
508         if (codec)
509             av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
510                    codec_string, codec->name, desc->name);
511     }
512
513     if (!codec) {
514         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
515         exit_program(1);
516     }
517     if (codec->type != type) {
518         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
519         exit_program(1);
520     }
521     return codec;
522 }
523
524 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
525 {
526     char *codec_name = NULL;
527
528     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
529     if (codec_name) {
530         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
531         st->codec->codec_id = codec->id;
532         return codec;
533     } else
534         return avcodec_find_decoder(st->codec->codec_id);
535 }
536
537 /**
538  * Add all the streams from the given input file to the global
539  * list of input streams.
540  */
541 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
542 {
543     int i;
544     char *next, *codec_tag = NULL;
545
546     for (i = 0; i < ic->nb_streams; i++) {
547         AVStream *st = ic->streams[i];
548         AVCodecContext *dec = st->codec;
549         InputStream *ist = av_mallocz(sizeof(*ist));
550         char *framerate = NULL;
551
552         if (!ist)
553             exit_program(1);
554
555         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
556         input_streams[nb_input_streams - 1] = ist;
557
558         ist->st = st;
559         ist->file_index = nb_input_files;
560         ist->discard = 1;
561         st->discard  = AVDISCARD_ALL;
562         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
563
564         ist->ts_scale = 1.0;
565         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
566
567         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
568         if (codec_tag) {
569             uint32_t tag = strtol(codec_tag, &next, 0);
570             if (*next)
571                 tag = AV_RL32(codec_tag);
572             st->codec->codec_tag = tag;
573         }
574
575         ist->dec = choose_decoder(o, ic, st);
576
577         switch (dec->codec_type) {
578         case AVMEDIA_TYPE_VIDEO:
579             if(!ist->dec)
580                 ist->dec = avcodec_find_decoder(dec->codec_id);
581             if (dec->lowres) {
582                 dec->flags |= CODEC_FLAG_EMU_EDGE;
583             }
584
585             ist->resample_height  = dec->height;
586             ist->resample_width   = dec->width;
587             ist->resample_pix_fmt = dec->pix_fmt;
588
589             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
590             if (framerate && av_parse_video_rate(&ist->framerate,
591                                                  framerate) < 0) {
592                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
593                        framerate);
594                 exit_program(1);
595             }
596
597             ist->top_field_first = -1;
598             MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
599
600             break;
601         case AVMEDIA_TYPE_AUDIO:
602             guess_input_channel_layout(ist);
603
604             ist->resample_sample_fmt     = dec->sample_fmt;
605             ist->resample_sample_rate    = dec->sample_rate;
606             ist->resample_channels       = dec->channels;
607             ist->resample_channel_layout = dec->channel_layout;
608
609             break;
610         case AVMEDIA_TYPE_DATA:
611         case AVMEDIA_TYPE_SUBTITLE:
612             if(!ist->dec)
613                 ist->dec = avcodec_find_decoder(dec->codec_id);
614             MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
615             break;
616         case AVMEDIA_TYPE_ATTACHMENT:
617         case AVMEDIA_TYPE_UNKNOWN:
618             break;
619         default:
620             abort();
621         }
622     }
623 }
624
625 static void assert_file_overwrite(const char *filename)
626 {
627     if ((!file_overwrite || no_file_overwrite) &&
628         (strchr(filename, ':') == NULL || filename[1] == ':' ||
629          av_strstart(filename, "file:", NULL))) {
630         if (avio_check(filename, 0) == 0) {
631             if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
632                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
633                 fflush(stderr);
634                 term_exit();
635                 signal(SIGINT, SIG_DFL);
636                 if (!read_yesno()) {
637                     av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
638                     exit_program(1);
639                 }
640                 term_init();
641             }
642             else {
643                 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
644                 exit_program(1);
645             }
646         }
647     }
648 }
649
650 static void dump_attachment(AVStream *st, const char *filename)
651 {
652     int ret;
653     AVIOContext *out = NULL;
654     AVDictionaryEntry *e;
655
656     if (!st->codec->extradata_size) {
657         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
658                nb_input_files - 1, st->index);
659         return;
660     }
661     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
662         filename = e->value;
663     if (!*filename) {
664         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
665                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
666         exit_program(1);
667     }
668
669     assert_file_overwrite(filename);
670
671     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
672         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
673                filename);
674         exit_program(1);
675     }
676
677     avio_write(out, st->codec->extradata, st->codec->extradata_size);
678     avio_flush(out);
679     avio_close(out);
680 }
681
682 static int opt_input_file(void *optctx, const char *opt, const char *filename)
683 {
684     OptionsContext *o = optctx;
685     AVFormatContext *ic;
686     AVInputFormat *file_iformat = NULL;
687     int err, i, ret;
688     int64_t timestamp;
689     uint8_t buf[128];
690     AVDictionary **opts;
691     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
692
693     if (o->format) {
694         if (!(file_iformat = av_find_input_format(o->format))) {
695             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
696             exit_program(1);
697         }
698     }
699
700     if (!strcmp(filename, "-"))
701         filename = "pipe:";
702
703     stdin_interaction &= strncmp(filename, "pipe:", 5) &&
704                          strcmp(filename, "/dev/stdin");
705
706     /* get default parameters from command line */
707     ic = avformat_alloc_context();
708     if (!ic) {
709         print_error(filename, AVERROR(ENOMEM));
710         exit_program(1);
711     }
712     if (o->nb_audio_sample_rate) {
713         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
714         av_dict_set(&format_opts, "sample_rate", buf, 0);
715     }
716     if (o->nb_audio_channels) {
717         /* because we set audio_channels based on both the "ac" and
718          * "channel_layout" options, we need to check that the specified
719          * demuxer actually has the "channels" option before setting it */
720         if (file_iformat && file_iformat->priv_class &&
721             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
722                         AV_OPT_SEARCH_FAKE_OBJ)) {
723             snprintf(buf, sizeof(buf), "%d",
724                      o->audio_channels[o->nb_audio_channels - 1].u.i);
725             av_dict_set(&format_opts, "channels", buf, 0);
726         }
727     }
728     if (o->nb_frame_rates) {
729         /* set the format-level framerate option;
730          * this is important for video grabbers, e.g. x11 */
731         if (file_iformat && file_iformat->priv_class &&
732             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
733                         AV_OPT_SEARCH_FAKE_OBJ)) {
734             av_dict_set(&format_opts, "framerate",
735                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
736         }
737     }
738     if (o->nb_frame_sizes) {
739         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
740     }
741     if (o->nb_frame_pix_fmts)
742         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
743
744     ic->video_codec_id   = video_codec_name ?
745         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : AV_CODEC_ID_NONE;
746     ic->audio_codec_id   = audio_codec_name ?
747         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : AV_CODEC_ID_NONE;
748     ic->subtitle_codec_id= subtitle_codec_name ?
749         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
750     ic->flags |= AVFMT_FLAG_NONBLOCK;
751     ic->interrupt_callback = int_cb;
752
753     /* open the input file with generic avformat function */
754     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
755     if (err < 0) {
756         print_error(filename, err);
757         exit_program(1);
758     }
759     assert_avoptions(format_opts);
760
761     /* apply forced codec ids */
762     for (i = 0; i < ic->nb_streams; i++)
763         choose_decoder(o, ic, ic->streams[i]);
764
765     /* Set AVCodecContext options for avformat_find_stream_info */
766     opts = setup_find_stream_info_opts(ic, codec_opts);
767     orig_nb_streams = ic->nb_streams;
768
769     /* If not enough info to get the stream parameters, we decode the
770        first frames to get it. (used in mpeg case for example) */
771     ret = avformat_find_stream_info(ic, opts);
772     if (ret < 0) {
773         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
774         avformat_close_input(&ic);
775         exit_program(1);
776     }
777
778     timestamp = o->start_time;
779     /* add the stream start time */
780     if (ic->start_time != AV_NOPTS_VALUE)
781         timestamp += ic->start_time;
782
783     /* if seeking requested, we execute it */
784     if (o->start_time != 0) {
785         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
786         if (ret < 0) {
787             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
788                    filename, (double)timestamp / AV_TIME_BASE);
789         }
790     }
791
792     /* update the current parameters so that they match the one of the input stream */
793     add_input_streams(o, ic);
794
795     /* dump the file content */
796     av_dump_format(ic, nb_input_files, filename, 0);
797
798     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
799     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
800         exit_program(1);
801
802     input_files[nb_input_files - 1]->ctx        = ic;
803     input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
804     input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
805     input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
806     input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
807
808     for (i = 0; i < o->nb_dump_attachment; i++) {
809         int j;
810
811         for (j = 0; j < ic->nb_streams; j++) {
812             AVStream *st = ic->streams[j];
813
814             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
815                 dump_attachment(st, o->dump_attachment[i].u.str);
816         }
817     }
818
819     for (i = 0; i < orig_nb_streams; i++)
820         av_dict_free(&opts[i]);
821     av_freep(&opts);
822
823     reset_options(o, 1);
824     return 0;
825 }
826
827 static uint8_t *get_line(AVIOContext *s)
828 {
829     AVIOContext *line;
830     uint8_t *buf;
831     char c;
832
833     if (avio_open_dyn_buf(&line) < 0) {
834         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
835         exit_program(1);
836     }
837
838     while ((c = avio_r8(s)) && c != '\n')
839         avio_w8(line, c);
840     avio_w8(line, 0);
841     avio_close_dyn_buf(line, &buf);
842
843     return buf;
844 }
845
846 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
847 {
848     int i, ret = 1;
849     char filename[1000];
850     const char *base[3] = { getenv("AVCONV_DATADIR"),
851                             getenv("HOME"),
852                             AVCONV_DATADIR,
853                             };
854
855     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
856         if (!base[i])
857             continue;
858         if (codec_name) {
859             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
860                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
861             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
862         }
863         if (ret) {
864             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
865                      i != 1 ? "" : "/.avconv", preset_name);
866             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
867         }
868     }
869     return ret;
870 }
871
872 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
873 {
874     char *codec_name = NULL;
875
876     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
877     if (!codec_name) {
878         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
879                                                   NULL, ost->st->codec->codec_type);
880         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
881     } else if (!strcmp(codec_name, "copy"))
882         ost->stream_copy = 1;
883     else {
884         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
885         ost->st->codec->codec_id = ost->enc->id;
886     }
887 }
888
889 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
890 {
891     OutputStream *ost;
892     AVStream *st = avformat_new_stream(oc, NULL);
893     int idx      = oc->nb_streams - 1, ret = 0;
894     char *bsf = NULL, *next, *codec_tag = NULL;
895     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
896     double qscale = -1;
897     char *buf = NULL, *arg = NULL, *preset = NULL;
898     AVIOContext *s = NULL;
899
900     if (!st) {
901         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
902         exit_program(1);
903     }
904
905     if (oc->nb_streams - 1 < o->nb_streamid_map)
906         st->id = o->streamid_map[oc->nb_streams - 1];
907
908     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
909                                 nb_output_streams + 1);
910     if (!(ost = av_mallocz(sizeof(*ost))))
911         exit_program(1);
912     output_streams[nb_output_streams - 1] = ost;
913
914     ost->file_index = nb_output_files;
915     ost->index      = idx;
916     ost->st         = st;
917     st->codec->codec_type = type;
918     choose_encoder(o, oc, ost);
919     if (ost->enc) {
920         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
921     }
922
923     avcodec_get_context_defaults3(st->codec, ost->enc);
924     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
925
926     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
927     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
928         do  {
929             buf = get_line(s);
930             if (!buf[0] || buf[0] == '#') {
931                 av_free(buf);
932                 continue;
933             }
934             if (!(arg = strchr(buf, '='))) {
935                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
936                 exit_program(1);
937             }
938             *arg++ = 0;
939             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
940             av_free(buf);
941         } while (!s->eof_reached);
942         avio_close(s);
943     }
944     if (ret) {
945         av_log(NULL, AV_LOG_FATAL,
946                "Preset %s specified for stream %d:%d, but could not be opened.\n",
947                preset, ost->file_index, ost->index);
948         exit_program(1);
949     }
950
951     ost->max_frames = INT64_MAX;
952     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
953
954     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
955     while (bsf) {
956         if (next = strchr(bsf, ','))
957             *next++ = 0;
958         if (!(bsfc = av_bitstream_filter_init(bsf))) {
959             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
960             exit_program(1);
961         }
962         if (bsfc_prev)
963             bsfc_prev->next = bsfc;
964         else
965             ost->bitstream_filters = bsfc;
966
967         bsfc_prev = bsfc;
968         bsf       = next;
969     }
970
971     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
972     if (codec_tag) {
973         uint32_t tag = strtol(codec_tag, &next, 0);
974         if (*next)
975             tag = AV_RL32(codec_tag);
976         st->codec->codec_tag = tag;
977     }
978
979     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
980     if (qscale >= 0 || same_quant) {
981         st->codec->flags |= CODEC_FLAG_QSCALE;
982         st->codec->global_quality = FF_QP2LAMBDA * qscale;
983     }
984
985     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
986         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
987
988     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
989     av_opt_get_int   (swr_opts, "dither_method", 0, &ost->swr_dither_method);
990     av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
991
992     ost->source_index = source_index;
993     if (source_index >= 0) {
994         ost->sync_ist = input_streams[source_index];
995         input_streams[source_index]->discard = 0;
996         input_streams[source_index]->st->discard = AVDISCARD_NONE;
997     }
998
999     return ost;
1000 }
1001
1002 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1003 {
1004     int i;
1005     const char *p = str;
1006     for (i = 0;; i++) {
1007         dest[i] = atoi(p);
1008         if (i == 63)
1009             break;
1010         p = strchr(p, ',');
1011         if (!p) {
1012             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1013             exit_program(1);
1014         }
1015         p++;
1016     }
1017 }
1018
1019 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1020 {
1021     AVStream *st;
1022     OutputStream *ost;
1023     AVCodecContext *video_enc;
1024     char *frame_rate = NULL;
1025
1026     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1027     st  = ost->st;
1028     video_enc = st->codec;
1029
1030     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1031     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1032         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1033         exit_program(1);
1034     }
1035
1036     if (!ost->stream_copy) {
1037         const char *p = NULL;
1038         char *frame_size = NULL;
1039         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1040         char *intra_matrix = NULL, *inter_matrix = NULL;
1041         const char *filters = "null";
1042         int i;
1043
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);
1047             exit_program(1);
1048         }
1049
1050         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1051         if (frame_aspect_ratio) {
1052             AVRational q;
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);
1056                 exit_program(1);
1057             }
1058             ost->frame_aspect_ratio = av_q2d(q);
1059         }
1060
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;
1067         }
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);
1070             exit_program(1);
1071         }
1072         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1073
1074         if (intra_only)
1075             video_enc->gop_size = 0;
1076         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1077         if (intra_matrix) {
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");
1080                 exit_program(1);
1081             }
1082             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1083         }
1084         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1085         if (inter_matrix) {
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");
1088                 exit_program(1);
1089             }
1090             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1091         }
1092
1093         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1094         for (i = 0; p; i++) {
1095             int start, end, q;
1096             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1097             if (e != 3) {
1098                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1099                 exit_program(1);
1100             }
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;
1107             if (q > 0) {
1108                 video_enc->rc_override[i].qscale         = q;
1109                 video_enc->rc_override[i].quality_factor = 1.0;
1110             }
1111             else {
1112                 video_enc->rc_override[i].qscale         = 0;
1113                 video_enc->rc_override[i].quality_factor = -q/100.0;
1114             }
1115             p = strchr(p, '/');
1116             if (p) p++;
1117         }
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;
1122
1123         if (do_psnr)
1124             video_enc->flags|= CODEC_FLAG_PSNR;
1125
1126         /* two pass mode */
1127         if (do_pass) {
1128             if (do_pass & 1) {
1129                 video_enc->flags |= CODEC_FLAG_PASS1;
1130             }
1131             if (do_pass & 2) {
1132                 video_enc->flags |= CODEC_FLAG_PASS2;
1133             }
1134         }
1135
1136         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1137         if (ost->forced_keyframes)
1138             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1139
1140         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1141
1142         ost->top_field_first = -1;
1143         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1144
1145         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1146         ost->avfilter = av_strdup(filters);
1147     } else {
1148         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1149     }
1150
1151     return ost;
1152 }
1153
1154 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1155 {
1156     int n;
1157     AVStream *st;
1158     OutputStream *ost;
1159     AVCodecContext *audio_enc;
1160
1161     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1162     st  = ost->st;
1163
1164     audio_enc = st->codec;
1165     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1166
1167     if (!ost->stream_copy) {
1168         char *sample_fmt = NULL;
1169         const char *filters = "anull";
1170
1171         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1172
1173         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1174         if (sample_fmt &&
1175             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1176             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1177             exit_program(1);
1178         }
1179
1180         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1181
1182         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1183
1184         av_assert1(filters);
1185         ost->avfilter = av_strdup(filters);
1186
1187         /* check for channel mapping for this audio stream */
1188         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1189             AudioChannelMap *map = &o->audio_channel_maps[n];
1190             InputStream *ist = input_streams[ost->source_index];
1191             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1192                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1193                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1194                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1195                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1196                 else
1197                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1198                            ost->file_index, ost->st->index);
1199             }
1200         }
1201     }
1202
1203     return ost;
1204 }
1205
1206 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1207 {
1208     OutputStream *ost;
1209
1210     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1211     if (!ost->stream_copy) {
1212         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1213         exit_program(1);
1214     }
1215
1216     return ost;
1217 }
1218
1219 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1220 {
1221     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1222     ost->stream_copy = 1;
1223     return ost;
1224 }
1225
1226 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1227 {
1228     AVStream *st;
1229     OutputStream *ost;
1230     AVCodecContext *subtitle_enc;
1231
1232     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1233     st  = ost->st;
1234     subtitle_enc = st->codec;
1235
1236     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1237
1238     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1239
1240     if (!ost->stream_copy) {
1241         char *frame_size = NULL;
1242
1243         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1244         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1245             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1246             exit_program(1);
1247         }
1248     }
1249
1250     return ost;
1251 }
1252
1253 /* arg format is "output-stream-index:streamid-value". */
1254 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1255 {
1256     OptionsContext *o = optctx;
1257     int idx;
1258     char *p;
1259     char idx_str[16];
1260
1261     av_strlcpy(idx_str, arg, sizeof(idx_str));
1262     p = strchr(idx_str, ':');
1263     if (!p) {
1264         av_log(NULL, AV_LOG_FATAL,
1265                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1266                arg, opt);
1267         exit_program(1);
1268     }
1269     *p++ = '\0';
1270     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1271     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1272     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1273     return 0;
1274 }
1275
1276 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1277 {
1278     AVFormatContext *is = ifile->ctx;
1279     AVFormatContext *os = ofile->ctx;
1280     int i;
1281
1282     for (i = 0; i < is->nb_chapters; i++) {
1283         AVChapter *in_ch = is->chapters[i], *out_ch;
1284         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1285                                        AV_TIME_BASE_Q, in_ch->time_base);
1286         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1287                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1288
1289
1290         if (in_ch->end < ts_off)
1291             continue;
1292         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1293             break;
1294
1295         out_ch = av_mallocz(sizeof(AVChapter));
1296         if (!out_ch)
1297             return AVERROR(ENOMEM);
1298
1299         out_ch->id        = in_ch->id;
1300         out_ch->time_base = in_ch->time_base;
1301         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1302         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1303
1304         if (copy_metadata)
1305             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1306
1307         os->nb_chapters++;
1308         os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
1309         if (!os->chapters)
1310             return AVERROR(ENOMEM);
1311         os->chapters[os->nb_chapters - 1] = out_ch;
1312     }
1313     return 0;
1314 }
1315
1316 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1317 {
1318     int i, err;
1319     AVFormatContext *ic = avformat_alloc_context();
1320
1321     ic->interrupt_callback = int_cb;
1322     err = avformat_open_input(&ic, filename, NULL, NULL);
1323     if (err < 0)
1324         return err;
1325     /* copy stream format */
1326     for(i=0;i<ic->nb_streams;i++) {
1327         AVStream *st;
1328         OutputStream *ost;
1329         AVCodec *codec;
1330         AVCodecContext *avctx;
1331
1332         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1333         ost   = new_output_stream(o, s, codec->type, -1);
1334         st    = ost->st;
1335         avctx = st->codec;
1336         ost->enc = codec;
1337
1338         // FIXME: a more elegant solution is needed
1339         memcpy(st, ic->streams[i], sizeof(AVStream));
1340         st->cur_dts = 0;
1341         st->info = av_malloc(sizeof(*st->info));
1342         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1343         st->codec= avctx;
1344         avcodec_copy_context(st->codec, ic->streams[i]->codec);
1345
1346         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1347             choose_sample_fmt(st, codec);
1348         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1349             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1350     }
1351
1352     avformat_close_input(&ic);
1353     return 0;
1354 }
1355
1356 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1357                                AVFormatContext *oc)
1358 {
1359     OutputStream *ost;
1360
1361     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1362                                   ofilter->out_tmp->pad_idx)) {
1363     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1364     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1365     default:
1366         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1367                "currently.\n");
1368         exit_program(1);
1369     }
1370
1371     ost->source_index = -1;
1372     ost->filter       = ofilter;
1373
1374     ofilter->ost      = ost;
1375
1376     if (ost->stream_copy) {
1377         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1378                "which is fed from a complex filtergraph. Filtering and streamcopy "
1379                "cannot be used together.\n", ost->file_index, ost->index);
1380         exit_program(1);
1381     }
1382
1383     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1384         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1385         exit_program(1);
1386     }
1387     avfilter_inout_free(&ofilter->out_tmp);
1388 }
1389
1390 static int configure_complex_filters(void)
1391 {
1392     int i, ret = 0;
1393
1394     for (i = 0; i < nb_filtergraphs; i++)
1395         if (!filtergraphs[i]->graph &&
1396             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1397             return ret;
1398     return 0;
1399 }
1400
1401 void opt_output_file(void *optctx, const char *filename)
1402 {
1403     OptionsContext *o = optctx;
1404     AVFormatContext *oc;
1405     int i, j, err;
1406     AVOutputFormat *file_oformat;
1407     OutputStream *ost;
1408     InputStream  *ist;
1409
1410     if (configure_complex_filters() < 0) {
1411         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1412         exit_program(1);
1413     }
1414
1415     if (!strcmp(filename, "-"))
1416         filename = "pipe:";
1417
1418     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1419     if (!oc) {
1420         print_error(filename, err);
1421         exit_program(1);
1422     }
1423     file_oformat= oc->oformat;
1424     oc->interrupt_callback = int_cb;
1425
1426     /* create streams for all unlabeled output pads */
1427     for (i = 0; i < nb_filtergraphs; i++) {
1428         FilterGraph *fg = filtergraphs[i];
1429         for (j = 0; j < fg->nb_outputs; j++) {
1430             OutputFilter *ofilter = fg->outputs[j];
1431
1432             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1433                 continue;
1434
1435             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1436                                           ofilter->out_tmp->pad_idx)) {
1437             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1438             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1439             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1440             }
1441             init_output_filter(ofilter, o, oc);
1442         }
1443     }
1444
1445     if (!strcmp(file_oformat->name, "ffm") &&
1446         av_strstart(filename, "http:", NULL)) {
1447         int j;
1448         /* special case for files sent to ffserver: we get the stream
1449            parameters from ffserver */
1450         int err = read_ffserver_streams(o, oc, filename);
1451         if (err < 0) {
1452             print_error(filename, err);
1453             exit_program(1);
1454         }
1455         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1456             ost = output_streams[j];
1457             for (i = 0; i < nb_input_streams; i++) {
1458                 ist = input_streams[i];
1459                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1460                     ost->sync_ist= ist;
1461                     ost->source_index= i;
1462                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1463                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1464                     ist->discard = 0;
1465                     ist->st->discard = AVDISCARD_NONE;
1466                     break;
1467                 }
1468             }
1469             if(!ost->sync_ist){
1470                 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));
1471                 exit_program(1);
1472             }
1473         }
1474     } else if (!o->nb_stream_maps) {
1475         /* pick the "best" stream of each type */
1476
1477         /* video: highest resolution */
1478         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1479             int area = 0, idx = -1;
1480             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1481             for (i = 0; i < nb_input_streams; i++) {
1482                 ist = input_streams[i];
1483                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1484                     ist->st->codec->width * ist->st->codec->height > area) {
1485                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1486                         continue;
1487                     area = ist->st->codec->width * ist->st->codec->height;
1488                     idx = i;
1489                 }
1490             }
1491             if (idx >= 0)
1492                 new_video_stream(o, oc, idx);
1493         }
1494
1495         /* audio: most channels */
1496         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1497             int channels = 0, idx = -1;
1498             for (i = 0; i < nb_input_streams; i++) {
1499                 ist = input_streams[i];
1500                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1501                     ist->st->codec->channels > channels) {
1502                     channels = ist->st->codec->channels;
1503                     idx = i;
1504                 }
1505             }
1506             if (idx >= 0)
1507                 new_audio_stream(o, oc, idx);
1508         }
1509
1510         /* subtitles: pick first */
1511         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1512             for (i = 0; i < nb_input_streams; i++)
1513                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1514                     new_subtitle_stream(o, oc, i);
1515                     break;
1516                 }
1517         }
1518         /* do something with data? */
1519     } else {
1520         for (i = 0; i < o->nb_stream_maps; i++) {
1521             StreamMap *map = &o->stream_maps[i];
1522             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1523
1524             if (map->disabled)
1525                 continue;
1526
1527             if (map->linklabel) {
1528                 FilterGraph *fg;
1529                 OutputFilter *ofilter = NULL;
1530                 int j, k;
1531
1532                 for (j = 0; j < nb_filtergraphs; j++) {
1533                     fg = filtergraphs[j];
1534                     for (k = 0; k < fg->nb_outputs; k++) {
1535                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1536                         if (out && !strcmp(out->name, map->linklabel)) {
1537                             ofilter = fg->outputs[k];
1538                             goto loop_end;
1539                         }
1540                     }
1541                 }
1542 loop_end:
1543                 if (!ofilter) {
1544                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1545                            "in any defined filter graph.\n", map->linklabel);
1546                     exit_program(1);
1547                 }
1548                 init_output_filter(ofilter, o, oc);
1549             } else {
1550                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1551                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1552                     continue;
1553                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1554                     continue;
1555                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1556                     continue;
1557                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1558                     continue;
1559
1560                 switch (ist->st->codec->codec_type) {
1561                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1562                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1563                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1564                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1565                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1566                 default:
1567                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1568                            map->file_index, map->stream_index);
1569                     exit_program(1);
1570                 }
1571             }
1572         }
1573     }
1574
1575
1576     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1577         AVDictionaryEntry *e;
1578         ost = output_streams[i];
1579
1580         if (   ost->stream_copy
1581             && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1582             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1583             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1584                 exit_program(1);
1585     }
1586
1587     /* handle attached files */
1588     for (i = 0; i < o->nb_attachments; i++) {
1589         AVIOContext *pb;
1590         uint8_t *attachment;
1591         const char *p;
1592         int64_t len;
1593
1594         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1595             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1596                    o->attachments[i]);
1597             exit_program(1);
1598         }
1599         if ((len = avio_size(pb)) <= 0) {
1600             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1601                    o->attachments[i]);
1602             exit_program(1);
1603         }
1604         if (!(attachment = av_malloc(len))) {
1605             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1606                    o->attachments[i]);
1607             exit_program(1);
1608         }
1609         avio_read(pb, attachment, len);
1610
1611         ost = new_attachment_stream(o, oc, -1);
1612         ost->stream_copy               = 0;
1613         ost->attachment_filename       = o->attachments[i];
1614         ost->st->codec->extradata      = attachment;
1615         ost->st->codec->extradata_size = len;
1616
1617         p = strrchr(o->attachments[i], '/');
1618         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1619         avio_close(pb);
1620     }
1621
1622     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1623     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1624         exit_program(1);
1625
1626     output_files[nb_output_files - 1]->ctx            = oc;
1627     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
1628     output_files[nb_output_files - 1]->recording_time = o->recording_time;
1629     if (o->recording_time != INT64_MAX)
1630         oc->duration = o->recording_time;
1631     output_files[nb_output_files - 1]->start_time     = o->start_time;
1632     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1633     output_files[nb_output_files - 1]->shortest       = o->shortest;
1634     av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1635
1636     /* check filename in case of an image number is expected */
1637     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1638         if (!av_filename_number_test(oc->filename)) {
1639             print_error(oc->filename, AVERROR(EINVAL));
1640             exit_program(1);
1641         }
1642     }
1643
1644     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1645         /* test if it already exists to avoid losing precious files */
1646         assert_file_overwrite(filename);
1647
1648         /* open the file */
1649         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1650                               &oc->interrupt_callback,
1651                               &output_files[nb_output_files - 1]->opts)) < 0) {
1652             print_error(filename, err);
1653             exit_program(1);
1654         }
1655     }
1656
1657     if (o->mux_preload) {
1658         uint8_t buf[64];
1659         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1660         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1661     }
1662     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1663
1664     /* copy metadata */
1665     for (i = 0; i < o->nb_metadata_map; i++) {
1666         char *p;
1667         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1668
1669         if (in_file_index >= nb_input_files) {
1670             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1671             exit_program(1);
1672         }
1673         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
1674     }
1675
1676     /* copy chapters */
1677     if (o->chapters_input_file >= nb_input_files) {
1678         if (o->chapters_input_file == INT_MAX) {
1679             /* copy chapters from the first input file that has them*/
1680             o->chapters_input_file = -1;
1681             for (i = 0; i < nb_input_files; i++)
1682                 if (input_files[i]->ctx->nb_chapters) {
1683                     o->chapters_input_file = i;
1684                     break;
1685                 }
1686         } else {
1687             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1688                    o->chapters_input_file);
1689             exit_program(1);
1690         }
1691     }
1692     if (o->chapters_input_file >= 0)
1693         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1694                       !o->metadata_chapters_manual);
1695
1696     /* copy global metadata by default */
1697     if (!o->metadata_global_manual && nb_input_files){
1698         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1699                      AV_DICT_DONT_OVERWRITE);
1700         if(o->recording_time != INT64_MAX)
1701             av_dict_set(&oc->metadata, "duration", NULL, 0);
1702         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1703     }
1704     if (!o->metadata_streams_manual)
1705         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1706             InputStream *ist;
1707             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1708                 continue;
1709             ist = input_streams[output_streams[i]->source_index];
1710             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1711         }
1712
1713     /* process manually set metadata */
1714     for (i = 0; i < o->nb_metadata; i++) {
1715         AVDictionary **m;
1716         char type, *val;
1717         const char *stream_spec;
1718         int index = 0, j, ret = 0;
1719
1720         val = strchr(o->metadata[i].u.str, '=');
1721         if (!val) {
1722             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1723                    o->metadata[i].u.str);
1724             exit_program(1);
1725         }
1726         *val++ = 0;
1727
1728         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1729         if (type == 's') {
1730             for (j = 0; j < oc->nb_streams; j++) {
1731                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1732                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1733                 } else if (ret < 0)
1734                     exit_program(1);
1735             }
1736         }
1737         else {
1738             switch (type) {
1739             case 'g':
1740                 m = &oc->metadata;
1741                 break;
1742             case 'c':
1743                 if (index < 0 || index >= oc->nb_chapters) {
1744                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1745                     exit_program(1);
1746                 }
1747                 m = &oc->chapters[index]->metadata;
1748                 break;
1749             default:
1750                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1751                 exit_program(1);
1752             }
1753             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1754         }
1755     }
1756
1757     reset_options(o, 0);
1758 }
1759
1760 /* same option as mencoder */
1761 static int opt_pass(const char *opt, const char *arg)
1762 {
1763     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
1764     return 0;
1765 }
1766
1767
1768 static int opt_target(void *optctx, const char *opt, const char *arg)
1769 {
1770     OptionsContext *o = optctx;
1771     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1772     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1773
1774     if (!strncmp(arg, "pal-", 4)) {
1775         norm = PAL;
1776         arg += 4;
1777     } else if (!strncmp(arg, "ntsc-", 5)) {
1778         norm = NTSC;
1779         arg += 5;
1780     } else if (!strncmp(arg, "film-", 5)) {
1781         norm = FILM;
1782         arg += 5;
1783     } else {
1784         /* Try to determine PAL/NTSC by peeking in the input files */
1785         if (nb_input_files) {
1786             int i, j, fr;
1787             for (j = 0; j < nb_input_files; j++) {
1788                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1789                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1790                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1791                         continue;
1792                     fr = c->time_base.den * 1000 / c->time_base.num;
1793                     if (fr == 25000) {
1794                         norm = PAL;
1795                         break;
1796                     } else if ((fr == 29970) || (fr == 23976)) {
1797                         norm = NTSC;
1798                         break;
1799                     }
1800                 }
1801                 if (norm != UNKNOWN)
1802                     break;
1803             }
1804         }
1805         if (norm != UNKNOWN)
1806             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1807     }
1808
1809     if (norm == UNKNOWN) {
1810         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1811         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1812         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1813         exit_program(1);
1814     }
1815
1816     if (!strcmp(arg, "vcd")) {
1817         opt_video_codec(o, "c:v", "mpeg1video");
1818         opt_audio_codec(o, "c:a", "mp2");
1819         parse_option(o, "f", "vcd", options);
1820
1821         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1822         parse_option(o, "r", frame_rates[norm], options);
1823         opt_default("g", norm == PAL ? "15" : "18");
1824
1825         opt_default("b:v", "1150000");
1826         opt_default("maxrate", "1150000");
1827         opt_default("minrate", "1150000");
1828         opt_default("bufsize", "327680"); // 40*1024*8;
1829
1830         opt_default("b:a", "224000");
1831         parse_option(o, "ar", "44100", options);
1832         parse_option(o, "ac", "2", options);
1833
1834         opt_default("packetsize", "2324");
1835         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
1836
1837         /* We have to offset the PTS, so that it is consistent with the SCR.
1838            SCR starts at 36000, but the first two packs contain only padding
1839            and the first pack from the other stream, respectively, may also have
1840            been written before.
1841            So the real data starts at SCR 36000+3*1200. */
1842         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1843     } else if (!strcmp(arg, "svcd")) {
1844
1845         opt_video_codec(o, "c:v", "mpeg2video");
1846         opt_audio_codec(o, "c:a", "mp2");
1847         parse_option(o, "f", "svcd", options);
1848
1849         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1850         parse_option(o, "r", frame_rates[norm], options);
1851         parse_option(o, "pix_fmt", "yuv420p", options);
1852         opt_default("g", norm == PAL ? "15" : "18");
1853
1854         opt_default("b:v", "2040000");
1855         opt_default("maxrate", "2516000");
1856         opt_default("minrate", "0"); // 1145000;
1857         opt_default("bufsize", "1835008"); // 224*1024*8;
1858         opt_default("scan_offset", "1");
1859
1860
1861         opt_default("b:a", "224000");
1862         parse_option(o, "ar", "44100", options);
1863
1864         opt_default("packetsize", "2324");
1865
1866     } else if (!strcmp(arg, "dvd")) {
1867
1868         opt_video_codec(o, "c:v", "mpeg2video");
1869         opt_audio_codec(o, "c:a", "ac3");
1870         parse_option(o, "f", "dvd", options);
1871
1872         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1873         parse_option(o, "r", frame_rates[norm], options);
1874         parse_option(o, "pix_fmt", "yuv420p", options);
1875         opt_default("g", norm == PAL ? "15" : "18");
1876
1877         opt_default("b:v", "6000000");
1878         opt_default("maxrate", "9000000");
1879         opt_default("minrate", "0"); // 1500000;
1880         opt_default("bufsize", "1835008"); // 224*1024*8;
1881
1882         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1883         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1884
1885         opt_default("b:a", "448000");
1886         parse_option(o, "ar", "48000", options);
1887
1888     } else if (!strncmp(arg, "dv", 2)) {
1889
1890         parse_option(o, "f", "dv", options);
1891
1892         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1893         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1894                           norm == PAL ? "yuv420p" : "yuv411p", options);
1895         parse_option(o, "r", frame_rates[norm], options);
1896
1897         parse_option(o, "ar", "48000", options);
1898         parse_option(o, "ac", "2", options);
1899
1900     } else {
1901         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1902         return AVERROR(EINVAL);
1903     }
1904     return 0;
1905 }
1906
1907 static int opt_vstats_file(const char *opt, const char *arg)
1908 {
1909     av_free (vstats_filename);
1910     vstats_filename = av_strdup (arg);
1911     return 0;
1912 }
1913
1914 static int opt_vstats(const char *opt, const char *arg)
1915 {
1916     char filename[40];
1917     time_t today2 = time(NULL);
1918     struct tm *today = localtime(&today2);
1919
1920     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1921              today->tm_sec);
1922     return opt_vstats_file(opt, filename);
1923 }
1924
1925 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1926 {
1927     OptionsContext *o = optctx;
1928     return parse_option(o, "frames:v", arg, options);
1929 }
1930
1931 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1932 {
1933     OptionsContext *o = optctx;
1934     return parse_option(o, "frames:a", arg, options);
1935 }
1936
1937 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1938 {
1939     OptionsContext *o = optctx;
1940     return parse_option(o, "frames:d", arg, options);
1941 }
1942
1943 static int opt_preset(void *optctx, const char *opt, const char *arg)
1944 {
1945     OptionsContext *o = optctx;
1946     FILE *f=NULL;
1947     char filename[1000], line[1000], tmp_line[1000];
1948     const char *codec_name = *opt == 'v' ? video_codec_name :
1949                              *opt == 'a' ? audio_codec_name :
1950                                            subtitle_codec_name;
1951
1952     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1953         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1954             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1955         }else
1956             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1957         exit_program(1);
1958 }
1959
1960     while (fgets(line, sizeof(line), f)) {
1961         char *key = tmp_line, *value, *endptr;
1962
1963         if (strcspn(line, "#\n\r") == 0)
1964             continue;
1965         strcpy(tmp_line, line);
1966         if (!av_strtok(key,   "=",    &value) ||
1967             !av_strtok(value, "\r\n", &endptr)) {
1968             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
1969             exit_program(1);
1970         }
1971         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
1972
1973         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
1974         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
1975         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
1976         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
1977         else if (opt_default(key, value) < 0) {
1978             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
1979                    filename, line, key, value);
1980             exit_program(1);
1981         }
1982     }
1983
1984     fclose(f);
1985
1986     return 0;
1987 }
1988
1989 static int opt_passlogfile(const char *opt, const char *arg)
1990 {
1991     pass_logfilename_prefix = arg;
1992 #if CONFIG_LIBX264_ENCODER
1993     return opt_default(opt, arg);
1994 #else
1995     return 0;
1996 #endif
1997 }
1998
1999 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2000 {
2001     OptionsContext *o = optctx;
2002     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2003     int ret = parse_option(o, s, arg, options);
2004     av_free(s);
2005     return ret;
2006 }
2007
2008 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2009 {
2010     OptionsContext *o = optctx;
2011     if(!strcmp(opt, "b")){
2012         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2013         return parse_option(o, "b:v", arg, options);
2014     }
2015     return opt_default(opt, arg);
2016 }
2017
2018 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2019 {
2020     OptionsContext *o = optctx;
2021     char *s;
2022     int ret;
2023     if(!strcmp(opt, "qscale")){
2024         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2025         return parse_option(o, "q:v", arg, options);
2026     }
2027     s = av_asprintf("q%s", opt + 6);
2028     ret = parse_option(o, s, arg, options);
2029     av_free(s);
2030     return ret;
2031 }
2032
2033 static int opt_profile(void *optctx, const char *opt, const char *arg)
2034 {
2035     OptionsContext *o = optctx;
2036     if(!strcmp(opt, "profile")){
2037         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2038         return parse_option(o, "profile:v", arg, options);
2039     }
2040     return opt_default(opt, arg);
2041
2042 }
2043
2044 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2045 {
2046     OptionsContext *o = optctx;
2047     return parse_option(o, "filter:v", arg, options);
2048 }
2049
2050 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2051 {
2052     OptionsContext *o = optctx;
2053     return parse_option(o, "filter:a", arg, options);
2054 }
2055
2056 static int opt_vsync(const char *opt, const char *arg)
2057 {
2058     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2059     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2060     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2061     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2062
2063     if (video_sync_method == VSYNC_AUTO)
2064         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2065     return 0;
2066 }
2067
2068 static int opt_deinterlace(const char *opt, const char *arg)
2069 {
2070     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2071     do_deinterlace = 1;
2072     return 0;
2073 }
2074
2075 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2076 {
2077     OptionsContext *o = optctx;
2078     char *tcr = av_asprintf("timecode=%s", arg);
2079     int ret = parse_option(o, "metadata:g", tcr, options);
2080     if (ret >= 0)
2081         ret = opt_default("gop_timecode", arg);
2082     av_free(tcr);
2083     return ret;
2084 }
2085
2086 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2087 {
2088     OptionsContext *o = optctx;
2089     char layout_str[32];
2090     char *stream_str;
2091     char *ac_str;
2092     int ret, channels, ac_str_size;
2093     uint64_t layout;
2094
2095     layout = av_get_channel_layout(arg);
2096     if (!layout) {
2097         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2098         return AVERROR(EINVAL);
2099     }
2100     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2101     ret = opt_default(opt, layout_str);
2102     if (ret < 0)
2103         return ret;
2104
2105     /* set 'ac' option based on channel layout */
2106     channels = av_get_channel_layout_nb_channels(layout);
2107     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2108     stream_str = strchr(opt, ':');
2109     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2110     ac_str = av_mallocz(ac_str_size);
2111     if (!ac_str)
2112         return AVERROR(ENOMEM);
2113     av_strlcpy(ac_str, "ac", 3);
2114     if (stream_str)
2115         av_strlcat(ac_str, stream_str, ac_str_size);
2116     ret = parse_option(o, ac_str, layout_str, options);
2117     av_free(ac_str);
2118
2119     return ret;
2120 }
2121
2122 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2123 {
2124     OptionsContext *o = optctx;
2125     return parse_option(o, "q:a", arg, options);
2126 }
2127
2128 static int opt_filter_complex(const char *opt, const char *arg)
2129 {
2130     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2131                               &nb_filtergraphs, nb_filtergraphs + 1);
2132     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2133         return AVERROR(ENOMEM);
2134     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
2135     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2136     return 0;
2137 }
2138
2139 void show_help_default(const char *opt, const char *arg)
2140 {
2141     /* per-file options have at least one of those set */
2142     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_FUNC2;
2143     int show_advanced = 0, show_avoptions = 0;
2144
2145     if (opt) {
2146         if (!strcmp(opt, "long"))
2147             show_advanced = 1;
2148         else if (!strcmp(opt, "full"))
2149             show_advanced = show_avoptions = 1;
2150         else
2151             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2152     }
2153
2154     show_usage();
2155
2156     printf("Getting help:\n"
2157            "    -h      -- print basic options\n"
2158            "    -h long -- print more options\n"
2159            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2160            "    See man %s for detailed description of the options.\n"
2161            "\n", program_name);
2162
2163     show_help_options(options, "Print help / information / capabilities:",
2164                       OPT_EXIT, 0, 0);
2165
2166     show_help_options(options, "Global options (affect whole program "
2167                       "instead of just one file:",
2168                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2169     if (show_advanced)
2170         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2171                           per_file | OPT_EXIT, 0);
2172
2173     show_help_options(options, "Per-file main options:", 0,
2174                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2175                       OPT_EXIT, per_file);
2176     if (show_advanced)
2177         show_help_options(options, "Advanced per-file options:",
2178                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2179
2180     show_help_options(options, "Video options:",
2181                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2182     if (show_advanced)
2183         show_help_options(options, "Advanced Video options:",
2184                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2185
2186     show_help_options(options, "Audio options:",
2187                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2188     if (show_advanced)
2189         show_help_options(options, "Advanced Audio options:",
2190                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2191     show_help_options(options, "Subtitle options:",
2192                       OPT_SUBTITLE, 0, 0);
2193     printf("\n");
2194
2195     if (show_avoptions) {
2196         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2197         show_help_children(avcodec_get_class(), flags);
2198         show_help_children(avformat_get_class(), flags);
2199         show_help_children(sws_get_class(), flags);
2200         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2201         show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2202     }
2203 }
2204
2205 void show_usage(void)
2206 {
2207     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2208     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2209     av_log(NULL, AV_LOG_INFO, "\n");
2210 }
2211
2212
2213 static int opt_progress(const char *opt, const char *arg)
2214 {
2215     AVIOContext *avio = NULL;
2216     int ret;
2217
2218     if (!strcmp(arg, "-"))
2219         arg = "pipe:";
2220     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2221     if (ret < 0) {
2222         av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2223                arg, av_err2str(ret));
2224         return ret;
2225     }
2226     progress_avio = avio;
2227     return 0;
2228 }
2229
2230 #define OFFSET(x) offsetof(OptionsContext, x)
2231 const OptionDef options[] = {
2232     /* main options */
2233 #include "cmdutils_common_opts.h"
2234     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET,           { .off       = OFFSET(format) },
2235         "force format", "fmt" },
2236     { "i",              HAS_ARG | OPT_FUNC2,                         { .func2_arg = opt_input_file },
2237         "input file name", "filename" },
2238     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2239         "overwrite output files" },
2240     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2241         "do not overwrite output files" },
2242     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
2243         "codec name", "codec" },
2244     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
2245         "codec name", "codec" },
2246     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(presets) },
2247         "preset name", "preset" },
2248     { "map",            HAS_ARG | OPT_EXPERT | OPT_FUNC2,            { .func2_arg = opt_map },
2249         "set input stream mapping",
2250         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2251     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_FUNC2,            { .func2_arg = opt_map_channel },
2252         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2253     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(metadata_map) },
2254         "set metadata information of outfile from infile",
2255         "outfile[,metadata]:infile[,metadata]" },
2256     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2257         "set chapters mapping", "input_file_index" },
2258     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(recording_time) },
2259         "record or transcode \"duration\" seconds of audio/video",
2260         "duration" },
2261     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET,            { .off = OFFSET(limit_filesize) },
2262         "set the limit file size in bytes", "limit_size" },
2263     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(start_time) },
2264         "set the start time offset", "time_off" },
2265     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2266         "set the input ts offset", "time_off" },
2267     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2268         "set the input ts scale", "scale" },
2269     { "timestamp",      HAS_ARG | OPT_FUNC2,                         { .func2_arg = opt_recording_timestamp },
2270         "set the recording timestamp ('now' to set the current time)", "time" },
2271     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(metadata) },
2272         "add metadata", "string=string" },
2273     { "dframes",        HAS_ARG | OPT_FUNC2 | OPT_EXPERT,            { .func2_arg = opt_data_frames },
2274         "set the number of data frames to record", "number" },
2275     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2276         "add timings for benchmarking" },
2277     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2278       "add timings for each task" },
2279     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2280       "write program-readable progress information", "url" },
2281     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2282       "enable or disable interaction on standard input" },
2283     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2284         "set max runtime in seconds", "limit" },
2285     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2286         "dump each input packet" },
2287     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2288         "when dumping packets, also dump the payload" },
2289     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(rate_emu) },
2290         "read input at native frame rate", "" },
2291     { "target",         HAS_ARG | OPT_FUNC2,                         { .func2_arg = opt_target },
2292         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2293         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2294     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2295         "video sync method", "" },
2296     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2297         "audio sync method", "" },
2298     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2299         "audio drift threshold", "threshold" },
2300     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2301         "copy timestamps" },
2302     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2303         "copy input stream time base when stream copying", "mode" },
2304     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(shortest) },
2305         "finish encoding within shortest input" },
2306     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2307         "timestamp discontinuity delta threshold", "threshold" },
2308     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
2309         "timestamp error delta threshold", "threshold" },
2310     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2311         "exit on error", "error" },
2312     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC,            { .off = OFFSET(copy_initial_nonkeyframes) },
2313         "copy initial non-keyframes" },
2314     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC,              { .off = OFFSET(max_frames) },
2315         "set the number of frames to record", "number" },
2316     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2317         "force codec tag/fourcc", "fourcc/tag" },
2318     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2319         "use fixed quality scale (VBR)", "q" },
2320     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_FUNC2,            { .func2_arg = opt_qscale },
2321         "use fixed quality scale (VBR)", "q" },
2322     { "profile",        HAS_ARG | OPT_EXPERT | OPT_FUNC2,            { .func2_arg = opt_profile },
2323         "set profile", "profile" },
2324     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(filters) },
2325         "set stream filterchain", "filter_list" },
2326     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2327         "create a complex filtergraph", "graph_description" },
2328     { "stats",          OPT_BOOL,                                    { &print_stats },
2329         "print progress report during encoding", },
2330     { "attach",         HAS_ARG | OPT_FUNC2 | OPT_EXPERT,            { .func2_arg = opt_attach },
2331         "add an attachment to the output file", "filename" },
2332     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2333         "extract an attachment into a file", "filename" },
2334     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
2335         "print timestamp debugging info" },
2336
2337     /* video options */
2338     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_video_frames },
2339         "set the number of video frames to record", "number" },
2340     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_rates) },
2341         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2342     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2343         "set frame size (WxH or abbreviation)", "size" },
2344     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_aspect_ratios) },
2345         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2346     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2347         "set pixel format", "format" },
2348     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
2349         "set the number of bits per raw sample", "number" },
2350     { "croptop",      OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2351         "Removed, use the crop filter instead", "size" },
2352     { "cropbottom",   OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2353         "Removed, use the crop filter instead", "size" },
2354     { "cropleft",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2355         "Removed, use the crop filter instead", "size" },
2356     { "cropright",    OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2357         "Removed, use the crop filter instead", "size" },
2358     { "padtop",       OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2359         "Removed, use the pad filter instead", "size" },
2360     { "padbottom",    OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2361         "Removed, use the pad filter instead", "size" },
2362     { "padleft",      OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2363         "Removed, use the pad filter instead", "size" },
2364     { "padright",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2365         "Removed, use the pad filter instead", "size" },
2366     { "padcolor",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2367         "Removed, use the pad filter instead", "color" },
2368     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
2369         "deprecated use -g 1" },
2370     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET,                        { .off = OFFSET(video_disable) },
2371         "disable video" },
2372     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2373         "discard threshold", "n" },
2374     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2375         "rate control override for specific intervals", "override" },
2376     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_video_codec },
2377         "force video codec ('copy' to copy stream)", "codec" },
2378     { "sameq",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &same_quant },
2379         "use same quantizer as source (implies VBR)" },
2380     { "same_quant",   OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &same_quant },
2381         "use same quantizer as source (implies VBR)" },
2382     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_FUNC2,                           { .func2_arg = opt_timecode },
2383         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2384     { "pass",         OPT_VIDEO | HAS_ARG ,                                      { opt_pass },
2385         "select the pass number (1 or 2)", "n" },
2386     { "passlogfile",  OPT_VIDEO | HAS_ARG,                                       { .func_arg = &opt_passlogfile },
2387         "select two pass log file name prefix", "prefix" },
2388     { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
2389         "this option is deprecated, use the yadif filter instead" },
2390     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
2391         "calculate PSNR of compressed frames" },
2392     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2393         "dump video coding statistics to file" },
2394     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2395         "dump video coding statistics to file", "file" },
2396     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_video_filters },
2397         "video filters", "filter list" },
2398     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2399         "specify intra matrix coeffs", "matrix" },
2400     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2401         "specify inter matrix coeffs", "matrix" },
2402     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC,     { .off = OFFSET(top_field_first) },
2403         "top=1/bottom=0/auto=-1 field first", "" },
2404     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2405         "intra_dc_precision", "precision" },
2406     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_FUNC2,             { .func2_arg = opt_old2new },
2407         "force video tag/fourcc", "fourcc/tag" },
2408     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2409         "show QP histogram" },
2410     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC,             { .off = OFFSET(force_fps) },
2411         "force the selected framerate, disable the best supported framerate selection" },
2412     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_FUNC2,              { .func2_arg = opt_streamid },
2413         "set the value of an outfile streamid", "streamIndex:value" },
2414     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT  | OPT_SPEC,
2415         { .off = OFFSET(forced_key_frames) },
2416         "force key frames at specified timestamps", "timestamps" },
2417     { "b",            OPT_VIDEO | HAS_ARG | OPT_FUNC2,                           { .func2_arg = opt_bitrate },
2418         "video bitrate (please use -b:v)", "bitrate" },
2419
2420     /* audio options */
2421     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_audio_frames },
2422         "set the number of audio frames to record", "number" },
2423     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_audio_qscale },
2424         "set audio quality (codec-specific)", "quality", },
2425     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_sample_rate) },
2426         "set audio sampling rate (in Hz)", "rate" },
2427     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_channels) },
2428         "set number of audio channels", "channels" },
2429     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET,                         { .off = OFFSET(audio_disable) },
2430         "disable audio" },
2431     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_audio_codec },
2432         "force audio codec ('copy' to copy stream)", "codec" },
2433     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_FUNC2,             { .func2_arg = opt_old2new },
2434         "force audio tag/fourcc", "fourcc/tag" },
2435     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2436         "change audio volume (256=normal)" , "volume" },
2437     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2438         "set sample format", "format" },
2439     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_FUNC2,             { .func2_arg = opt_channel_layout },
2440         "set channel layout", "layout" },
2441     { "af",             OPT_AUDIO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_audio_filters },
2442         "audio filters", "filter list" },
2443
2444     /* subtitle options */
2445     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2446         "disable subtitle" },
2447     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_FUNC2,  { .func2_arg = opt_subtitle_codec },
2448         "force subtitle codec ('copy' to copy stream)", "codec" },
2449     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, { .func2_arg = opt_old2new },
2450         "force subtitle tag/fourcc", "fourcc/tag" },
2451     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2452         "fix subtitles duration" },
2453
2454     /* grab options */
2455     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2456         "deprecated, use -channel", "channel" },
2457     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2458         "deprecated, use -standard", "standard" },
2459     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2460
2461     /* muxer options */
2462     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2463         "set the maximum demux-decode delay", "seconds" },
2464     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2465         "set the initial demux-decode delay", "seconds" },
2466
2467     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2468         "A comma-separated list of bitstream filters", "bitstream_filters" },
2469     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_old2new },
2470         "deprecated", "audio bitstream_filters" },
2471     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_old2new },
2472         "deprecated", "video bitstream_filters" },
2473
2474     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_preset },
2475         "set the audio options to the indicated preset", "preset" },
2476     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_preset },
2477         "set the video options to the indicated preset", "preset" },
2478     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_preset },
2479         "set the subtitle options to the indicated preset", "preset" },
2480     { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_preset },
2481         "set options from indicated preset file", "filename" },
2482     /* data codec support */
2483     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2 | OPT_EXPERT, { .func2_arg = opt_data_codec },
2484         "force data codec ('copy' to copy stream)", "codec" },
2485     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2486         "disable data" },
2487
2488     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2489         "generic catch all option", "" },
2490     { NULL, },
2491 };