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