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