ffmpeg: copy subtitles frame dimensions.
[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     if (!ost->stream_copy) {
1222         char *frame_size = NULL;
1223
1224         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1225         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1226             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1227             exit_program(1);
1228         }
1229     }
1230
1231     return ost;
1232 }
1233
1234 /* arg format is "output-stream-index:streamid-value". */
1235 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
1236 {
1237     int idx;
1238     char *p;
1239     char idx_str[16];
1240
1241     av_strlcpy(idx_str, arg, sizeof(idx_str));
1242     p = strchr(idx_str, ':');
1243     if (!p) {
1244         av_log(NULL, AV_LOG_FATAL,
1245                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1246                arg, opt);
1247         exit_program(1);
1248     }
1249     *p++ = '\0';
1250     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1251     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1252     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1253     return 0;
1254 }
1255
1256 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1257 {
1258     AVFormatContext *is = ifile->ctx;
1259     AVFormatContext *os = ofile->ctx;
1260     int i;
1261
1262     for (i = 0; i < is->nb_chapters; i++) {
1263         AVChapter *in_ch = is->chapters[i], *out_ch;
1264         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1265                                        AV_TIME_BASE_Q, in_ch->time_base);
1266         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1267                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1268
1269
1270         if (in_ch->end < ts_off)
1271             continue;
1272         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1273             break;
1274
1275         out_ch = av_mallocz(sizeof(AVChapter));
1276         if (!out_ch)
1277             return AVERROR(ENOMEM);
1278
1279         out_ch->id        = in_ch->id;
1280         out_ch->time_base = in_ch->time_base;
1281         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1282         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1283
1284         if (copy_metadata)
1285             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1286
1287         os->nb_chapters++;
1288         os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
1289         if (!os->chapters)
1290             return AVERROR(ENOMEM);
1291         os->chapters[os->nb_chapters - 1] = out_ch;
1292     }
1293     return 0;
1294 }
1295
1296 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1297 {
1298     int i, err;
1299     AVFormatContext *ic = avformat_alloc_context();
1300
1301     ic->interrupt_callback = int_cb;
1302     err = avformat_open_input(&ic, filename, NULL, NULL);
1303     if (err < 0)
1304         return err;
1305     /* copy stream format */
1306     for(i=0;i<ic->nb_streams;i++) {
1307         AVStream *st;
1308         OutputStream *ost;
1309         AVCodec *codec;
1310         AVCodecContext *avctx;
1311
1312         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1313         ost   = new_output_stream(o, s, codec->type, -1);
1314         st    = ost->st;
1315         avctx = st->codec;
1316         ost->enc = codec;
1317
1318         // FIXME: a more elegant solution is needed
1319         memcpy(st, ic->streams[i], sizeof(AVStream));
1320         st->cur_dts = 0;
1321         st->info = av_malloc(sizeof(*st->info));
1322         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1323         st->codec= avctx;
1324         avcodec_copy_context(st->codec, ic->streams[i]->codec);
1325
1326         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1327             choose_sample_fmt(st, codec);
1328         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1329             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1330     }
1331
1332     avformat_close_input(&ic);
1333     return 0;
1334 }
1335
1336 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1337                                AVFormatContext *oc)
1338 {
1339     OutputStream *ost;
1340
1341     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1342                                   ofilter->out_tmp->pad_idx)) {
1343     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1344     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1345     default:
1346         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1347                "currently.\n");
1348         exit_program(1);
1349     }
1350
1351     ost->source_index = -1;
1352     ost->filter       = ofilter;
1353
1354     ofilter->ost      = ost;
1355
1356     if (ost->stream_copy) {
1357         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1358                "which is fed from a complex filtergraph. Filtering and streamcopy "
1359                "cannot be used together.\n", ost->file_index, ost->index);
1360         exit_program(1);
1361     }
1362     if (o->recording_time != INT64_MAX)
1363         av_log(NULL, AV_LOG_WARNING,
1364                "-t does not work with -filter_complex (yet).\n");
1365
1366     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1367         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1368         exit_program(1);
1369     }
1370     avfilter_inout_free(&ofilter->out_tmp);
1371 }
1372
1373 static int configure_complex_filters(void)
1374 {
1375     int i, ret = 0;
1376
1377     for (i = 0; i < nb_filtergraphs; i++)
1378         if (!filtergraphs[i]->graph &&
1379             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1380             return ret;
1381     return 0;
1382 }
1383
1384 void opt_output_file(void *optctx, const char *filename)
1385 {
1386     OptionsContext *o = optctx;
1387     AVFormatContext *oc;
1388     int i, j, err;
1389     AVOutputFormat *file_oformat;
1390     OutputStream *ost;
1391     InputStream  *ist;
1392
1393     if (configure_complex_filters() < 0) {
1394         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1395         exit_program(1);
1396     }
1397
1398     if (!strcmp(filename, "-"))
1399         filename = "pipe:";
1400
1401     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1402     if (!oc) {
1403         print_error(filename, err);
1404         exit_program(1);
1405     }
1406     file_oformat= oc->oformat;
1407     oc->interrupt_callback = int_cb;
1408
1409     /* create streams for all unlabeled output pads */
1410     for (i = 0; i < nb_filtergraphs; i++) {
1411         FilterGraph *fg = filtergraphs[i];
1412         for (j = 0; j < fg->nb_outputs; j++) {
1413             OutputFilter *ofilter = fg->outputs[j];
1414
1415             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1416                 continue;
1417
1418             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1419                                           ofilter->out_tmp->pad_idx)) {
1420             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1421             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1422             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1423             }
1424             init_output_filter(ofilter, o, oc);
1425         }
1426     }
1427
1428     if (!strcmp(file_oformat->name, "ffm") &&
1429         av_strstart(filename, "http:", NULL)) {
1430         int j;
1431         /* special case for files sent to ffserver: we get the stream
1432            parameters from ffserver */
1433         int err = read_ffserver_streams(o, oc, filename);
1434         if (err < 0) {
1435             print_error(filename, err);
1436             exit_program(1);
1437         }
1438         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1439             ost = output_streams[j];
1440             for (i = 0; i < nb_input_streams; i++) {
1441                 ist = input_streams[i];
1442                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1443                     ost->sync_ist= ist;
1444                     ost->source_index= i;
1445                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1446                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1447                     ist->discard = 0;
1448                     ist->st->discard = AVDISCARD_NONE;
1449                     break;
1450                 }
1451             }
1452             if(!ost->sync_ist){
1453                 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));
1454                 exit_program(1);
1455             }
1456         }
1457     } else if (!o->nb_stream_maps) {
1458         /* pick the "best" stream of each type */
1459
1460         /* video: highest resolution */
1461         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1462             int area = 0, idx = -1;
1463             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1464             for (i = 0; i < nb_input_streams; i++) {
1465                 ist = input_streams[i];
1466                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1467                     ist->st->codec->width * ist->st->codec->height > area) {
1468                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1469                         continue;
1470                     area = ist->st->codec->width * ist->st->codec->height;
1471                     idx = i;
1472                 }
1473             }
1474             if (idx >= 0)
1475                 new_video_stream(o, oc, idx);
1476         }
1477
1478         /* audio: most channels */
1479         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1480             int channels = 0, idx = -1;
1481             for (i = 0; i < nb_input_streams; i++) {
1482                 ist = input_streams[i];
1483                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1484                     ist->st->codec->channels > channels) {
1485                     channels = ist->st->codec->channels;
1486                     idx = i;
1487                 }
1488             }
1489             if (idx >= 0)
1490                 new_audio_stream(o, oc, idx);
1491         }
1492
1493         /* subtitles: pick first */
1494         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1495             for (i = 0; i < nb_input_streams; i++)
1496                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1497                     new_subtitle_stream(o, oc, i);
1498                     break;
1499                 }
1500         }
1501         /* do something with data? */
1502     } else {
1503         for (i = 0; i < o->nb_stream_maps; i++) {
1504             StreamMap *map = &o->stream_maps[i];
1505             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1506
1507             if (map->disabled)
1508                 continue;
1509
1510             if (map->linklabel) {
1511                 FilterGraph *fg;
1512                 OutputFilter *ofilter = NULL;
1513                 int j, k;
1514
1515                 for (j = 0; j < nb_filtergraphs; j++) {
1516                     fg = filtergraphs[j];
1517                     for (k = 0; k < fg->nb_outputs; k++) {
1518                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1519                         if (out && !strcmp(out->name, map->linklabel)) {
1520                             ofilter = fg->outputs[k];
1521                             goto loop_end;
1522                         }
1523                     }
1524                 }
1525 loop_end:
1526                 if (!ofilter) {
1527                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1528                            "in any defined filter graph.\n", map->linklabel);
1529                     exit_program(1);
1530                 }
1531                 init_output_filter(ofilter, o, oc);
1532             } else {
1533                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1534                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1535                     continue;
1536                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1537                     continue;
1538                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1539                     continue;
1540                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1541                     continue;
1542
1543                 switch (ist->st->codec->codec_type) {
1544                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1545                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1546                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1547                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1548                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1549                 default:
1550                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1551                            map->file_index, map->stream_index);
1552                     exit_program(1);
1553                 }
1554             }
1555         }
1556     }
1557
1558
1559     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1560         AVDictionaryEntry *e;
1561         ost = output_streams[i];
1562
1563         if (   ost->stream_copy
1564             && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1565             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1566             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1567                 exit_program(1);
1568     }
1569
1570     /* handle attached files */
1571     for (i = 0; i < o->nb_attachments; i++) {
1572         AVIOContext *pb;
1573         uint8_t *attachment;
1574         const char *p;
1575         int64_t len;
1576
1577         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1578             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1579                    o->attachments[i]);
1580             exit_program(1);
1581         }
1582         if ((len = avio_size(pb)) <= 0) {
1583             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1584                    o->attachments[i]);
1585             exit_program(1);
1586         }
1587         if (!(attachment = av_malloc(len))) {
1588             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1589                    o->attachments[i]);
1590             exit_program(1);
1591         }
1592         avio_read(pb, attachment, len);
1593
1594         ost = new_attachment_stream(o, oc, -1);
1595         ost->stream_copy               = 0;
1596         ost->attachment_filename       = o->attachments[i];
1597         ost->st->codec->extradata      = attachment;
1598         ost->st->codec->extradata_size = len;
1599
1600         p = strrchr(o->attachments[i], '/');
1601         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1602         avio_close(pb);
1603     }
1604
1605     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1606     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1607         exit_program(1);
1608
1609     output_files[nb_output_files - 1]->ctx            = oc;
1610     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
1611     output_files[nb_output_files - 1]->recording_time = o->recording_time;
1612     if (o->recording_time != INT64_MAX)
1613         oc->duration = o->recording_time;
1614     output_files[nb_output_files - 1]->start_time     = o->start_time;
1615     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1616     av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1617
1618     /* check filename in case of an image number is expected */
1619     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1620         if (!av_filename_number_test(oc->filename)) {
1621             print_error(oc->filename, AVERROR(EINVAL));
1622             exit_program(1);
1623         }
1624     }
1625
1626     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1627         /* test if it already exists to avoid losing precious files */
1628         assert_file_overwrite(filename);
1629
1630         /* open the file */
1631         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1632                               &oc->interrupt_callback,
1633                               &output_files[nb_output_files - 1]->opts)) < 0) {
1634             print_error(filename, err);
1635             exit_program(1);
1636         }
1637     }
1638
1639     if (o->mux_preload) {
1640         uint8_t buf[64];
1641         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1642         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1643     }
1644     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1645
1646     /* copy metadata */
1647     for (i = 0; i < o->nb_metadata_map; i++) {
1648         char *p;
1649         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1650
1651         if (in_file_index >= nb_input_files) {
1652             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1653             exit_program(1);
1654         }
1655         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
1656     }
1657
1658     /* copy chapters */
1659     if (o->chapters_input_file >= nb_input_files) {
1660         if (o->chapters_input_file == INT_MAX) {
1661             /* copy chapters from the first input file that has them*/
1662             o->chapters_input_file = -1;
1663             for (i = 0; i < nb_input_files; i++)
1664                 if (input_files[i]->ctx->nb_chapters) {
1665                     o->chapters_input_file = i;
1666                     break;
1667                 }
1668         } else {
1669             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1670                    o->chapters_input_file);
1671             exit_program(1);
1672         }
1673     }
1674     if (o->chapters_input_file >= 0)
1675         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1676                       !o->metadata_chapters_manual);
1677
1678     /* copy global metadata by default */
1679     if (!o->metadata_global_manual && nb_input_files){
1680         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1681                      AV_DICT_DONT_OVERWRITE);
1682         if(o->recording_time != INT64_MAX)
1683             av_dict_set(&oc->metadata, "duration", NULL, 0);
1684         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1685     }
1686     if (!o->metadata_streams_manual)
1687         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1688             InputStream *ist;
1689             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1690                 continue;
1691             ist = input_streams[output_streams[i]->source_index];
1692             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1693         }
1694
1695     /* process manually set metadata */
1696     for (i = 0; i < o->nb_metadata; i++) {
1697         AVDictionary **m;
1698         char type, *val;
1699         const char *stream_spec;
1700         int index = 0, j, ret = 0;
1701
1702         val = strchr(o->metadata[i].u.str, '=');
1703         if (!val) {
1704             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1705                    o->metadata[i].u.str);
1706             exit_program(1);
1707         }
1708         *val++ = 0;
1709
1710         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1711         if (type == 's') {
1712             for (j = 0; j < oc->nb_streams; j++) {
1713                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1714                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1715                 } else if (ret < 0)
1716                     exit_program(1);
1717             }
1718         }
1719         else {
1720             switch (type) {
1721             case 'g':
1722                 m = &oc->metadata;
1723                 break;
1724             case 'c':
1725                 if (index < 0 || index >= oc->nb_chapters) {
1726                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1727                     exit_program(1);
1728                 }
1729                 m = &oc->chapters[index]->metadata;
1730                 break;
1731             default:
1732                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1733                 exit_program(1);
1734             }
1735             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1736         }
1737     }
1738
1739     reset_options(o, 0);
1740 }
1741
1742 /* same option as mencoder */
1743 static int opt_pass(const char *opt, const char *arg)
1744 {
1745     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
1746     return 0;
1747 }
1748
1749
1750 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
1751 {
1752     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1753     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1754
1755     if (!strncmp(arg, "pal-", 4)) {
1756         norm = PAL;
1757         arg += 4;
1758     } else if (!strncmp(arg, "ntsc-", 5)) {
1759         norm = NTSC;
1760         arg += 5;
1761     } else if (!strncmp(arg, "film-", 5)) {
1762         norm = FILM;
1763         arg += 5;
1764     } else {
1765         /* Try to determine PAL/NTSC by peeking in the input files */
1766         if (nb_input_files) {
1767             int i, j, fr;
1768             for (j = 0; j < nb_input_files; j++) {
1769                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1770                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1771                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1772                         continue;
1773                     fr = c->time_base.den * 1000 / c->time_base.num;
1774                     if (fr == 25000) {
1775                         norm = PAL;
1776                         break;
1777                     } else if ((fr == 29970) || (fr == 23976)) {
1778                         norm = NTSC;
1779                         break;
1780                     }
1781                 }
1782                 if (norm != UNKNOWN)
1783                     break;
1784             }
1785         }
1786         if (norm != UNKNOWN)
1787             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1788     }
1789
1790     if (norm == UNKNOWN) {
1791         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1792         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1793         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1794         exit_program(1);
1795     }
1796
1797     if (!strcmp(arg, "vcd")) {
1798         opt_video_codec(o, "c:v", "mpeg1video");
1799         opt_audio_codec(o, "c:a", "mp2");
1800         parse_option(o, "f", "vcd", options);
1801
1802         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1803         parse_option(o, "r", frame_rates[norm], options);
1804         opt_default("g", norm == PAL ? "15" : "18");
1805
1806         opt_default("b:v", "1150000");
1807         opt_default("maxrate", "1150000");
1808         opt_default("minrate", "1150000");
1809         opt_default("bufsize", "327680"); // 40*1024*8;
1810
1811         opt_default("b:a", "224000");
1812         parse_option(o, "ar", "44100", options);
1813         parse_option(o, "ac", "2", options);
1814
1815         opt_default("packetsize", "2324");
1816         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
1817
1818         /* We have to offset the PTS, so that it is consistent with the SCR.
1819            SCR starts at 36000, but the first two packs contain only padding
1820            and the first pack from the other stream, respectively, may also have
1821            been written before.
1822            So the real data starts at SCR 36000+3*1200. */
1823         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1824     } else if (!strcmp(arg, "svcd")) {
1825
1826         opt_video_codec(o, "c:v", "mpeg2video");
1827         opt_audio_codec(o, "c:a", "mp2");
1828         parse_option(o, "f", "svcd", options);
1829
1830         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1831         parse_option(o, "r", frame_rates[norm], options);
1832         parse_option(o, "pix_fmt", "yuv420p", options);
1833         opt_default("g", norm == PAL ? "15" : "18");
1834
1835         opt_default("b:v", "2040000");
1836         opt_default("maxrate", "2516000");
1837         opt_default("minrate", "0"); // 1145000;
1838         opt_default("bufsize", "1835008"); // 224*1024*8;
1839         opt_default("scan_offset", "1");
1840
1841
1842         opt_default("b:a", "224000");
1843         parse_option(o, "ar", "44100", options);
1844
1845         opt_default("packetsize", "2324");
1846
1847     } else if (!strcmp(arg, "dvd")) {
1848
1849         opt_video_codec(o, "c:v", "mpeg2video");
1850         opt_audio_codec(o, "c:a", "ac3");
1851         parse_option(o, "f", "dvd", options);
1852
1853         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1854         parse_option(o, "r", frame_rates[norm], options);
1855         parse_option(o, "pix_fmt", "yuv420p", options);
1856         opt_default("g", norm == PAL ? "15" : "18");
1857
1858         opt_default("b:v", "6000000");
1859         opt_default("maxrate", "9000000");
1860         opt_default("minrate", "0"); // 1500000;
1861         opt_default("bufsize", "1835008"); // 224*1024*8;
1862
1863         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1864         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1865
1866         opt_default("b:a", "448000");
1867         parse_option(o, "ar", "48000", options);
1868
1869     } else if (!strncmp(arg, "dv", 2)) {
1870
1871         parse_option(o, "f", "dv", options);
1872
1873         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1874         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1875                           norm == PAL ? "yuv420p" : "yuv411p", options);
1876         parse_option(o, "r", frame_rates[norm], options);
1877
1878         parse_option(o, "ar", "48000", options);
1879         parse_option(o, "ac", "2", options);
1880
1881     } else {
1882         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1883         return AVERROR(EINVAL);
1884     }
1885     return 0;
1886 }
1887
1888 static int opt_vstats_file(const char *opt, const char *arg)
1889 {
1890     av_free (vstats_filename);
1891     vstats_filename = av_strdup (arg);
1892     return 0;
1893 }
1894
1895 static int opt_vstats(const char *opt, const char *arg)
1896 {
1897     char filename[40];
1898     time_t today2 = time(NULL);
1899     struct tm *today = localtime(&today2);
1900
1901     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1902              today->tm_sec);
1903     return opt_vstats_file(opt, filename);
1904 }
1905
1906 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
1907 {
1908     return parse_option(o, "frames:v", arg, options);
1909 }
1910
1911 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
1912 {
1913     return parse_option(o, "frames:a", arg, options);
1914 }
1915
1916 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
1917 {
1918     return parse_option(o, "frames:d", arg, options);
1919 }
1920
1921 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
1922 {
1923     FILE *f=NULL;
1924     char filename[1000], line[1000], tmp_line[1000];
1925     const char *codec_name = *opt == 'v' ? video_codec_name :
1926                              *opt == 'a' ? audio_codec_name :
1927                                            subtitle_codec_name;
1928
1929     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1930         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1931             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1932         }else
1933             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1934         exit_program(1);
1935 }
1936
1937     while (fgets(line, sizeof(line), f)) {
1938         char *key = tmp_line, *value, *endptr;
1939
1940         if (strcspn(line, "#\n\r") == 0)
1941             continue;
1942         strcpy(tmp_line, line);
1943         if (!av_strtok(key,   "=",    &value) ||
1944             !av_strtok(value, "\r\n", &endptr)) {
1945             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
1946             exit_program(1);
1947         }
1948         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
1949
1950         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
1951         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
1952         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
1953         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
1954         else if (opt_default(key, value) < 0) {
1955             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
1956                    filename, line, key, value);
1957             exit_program(1);
1958         }
1959     }
1960
1961     fclose(f);
1962
1963     return 0;
1964 }
1965
1966 static int opt_passlogfile(const char *opt, const char *arg)
1967 {
1968     pass_logfilename_prefix = arg;
1969 #if CONFIG_LIBX264_ENCODER
1970     return opt_default(opt, arg);
1971 #else
1972     return 0;
1973 #endif
1974 }
1975
1976 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
1977 {
1978     char *s = av_asprintf("%s:%c", opt + 1, *opt);
1979     int ret = parse_option(o, s, arg, options);
1980     av_free(s);
1981     return ret;
1982 }
1983
1984 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
1985 {
1986     if(!strcmp(opt, "b")){
1987         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
1988         return parse_option(o, "b:v", arg, options);
1989     }
1990     return opt_default(opt, arg);
1991 }
1992
1993 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
1994 {
1995     char *s;
1996     int ret;
1997     if(!strcmp(opt, "qscale")){
1998         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
1999         return parse_option(o, "q:v", arg, options);
2000     }
2001     s = av_asprintf("q%s", opt + 6);
2002     ret = parse_option(o, s, arg, options);
2003     av_free(s);
2004     return ret;
2005 }
2006
2007 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
2008 {
2009     if(!strcmp(opt, "profile")){
2010         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2011         return parse_option(o, "profile:v", arg, options);
2012     }
2013     return opt_default(opt, arg);
2014 }
2015
2016 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
2017 {
2018     return parse_option(o, "filter:v", arg, options);
2019 }
2020
2021 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
2022 {
2023     return parse_option(o, "filter:a", arg, options);
2024 }
2025
2026 static int opt_vsync(const char *opt, const char *arg)
2027 {
2028     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2029     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2030     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2031     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2032
2033     if (video_sync_method == VSYNC_AUTO)
2034         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2035     return 0;
2036 }
2037
2038 static int opt_deinterlace(const char *opt, const char *arg)
2039 {
2040     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2041     do_deinterlace = 1;
2042     return 0;
2043 }
2044
2045 static int opt_timecode(OptionsContext *o, const char *opt, const char *arg)
2046 {
2047     char *tcr = av_asprintf("timecode=%s", arg);
2048     int ret = parse_option(o, "metadata:g", tcr, options);
2049     if (ret >= 0)
2050         ret = opt_default("gop_timecode", arg);
2051     av_free(tcr);
2052     return ret;
2053 }
2054
2055 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
2056 {
2057     char layout_str[32];
2058     char *stream_str;
2059     char *ac_str;
2060     int ret, channels, ac_str_size;
2061     uint64_t layout;
2062
2063     layout = av_get_channel_layout(arg);
2064     if (!layout) {
2065         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2066         return AVERROR(EINVAL);
2067     }
2068     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2069     ret = opt_default(opt, layout_str);
2070     if (ret < 0)
2071         return ret;
2072
2073     /* set 'ac' option based on channel layout */
2074     channels = av_get_channel_layout_nb_channels(layout);
2075     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2076     stream_str = strchr(opt, ':');
2077     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2078     ac_str = av_mallocz(ac_str_size);
2079     if (!ac_str)
2080         return AVERROR(ENOMEM);
2081     av_strlcpy(ac_str, "ac", 3);
2082     if (stream_str)
2083         av_strlcat(ac_str, stream_str, ac_str_size);
2084     ret = parse_option(o, ac_str, layout_str, options);
2085     av_free(ac_str);
2086
2087     return ret;
2088 }
2089
2090 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
2091 {
2092     return parse_option(o, "q:a", arg, options);
2093 }
2094
2095 static int opt_filter_complex(const char *opt, const char *arg)
2096 {
2097     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2098                               &nb_filtergraphs, nb_filtergraphs + 1);
2099     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2100         return AVERROR(ENOMEM);
2101     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
2102     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2103     return 0;
2104 }
2105
2106 static int opt_help(const char *opt, const char *arg)
2107 {
2108     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2109     av_log_set_callback(log_callback_help);
2110     show_usage();
2111     show_help_options(options, "Main options:\n",
2112                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
2113     show_help_options(options, "\nAdvanced options:\n",
2114                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
2115                       OPT_EXPERT);
2116     show_help_options(options, "\nVideo options:\n",
2117                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
2118                       OPT_VIDEO);
2119     show_help_options(options, "\nAdvanced Video options:\n",
2120                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
2121                       OPT_VIDEO | OPT_EXPERT);
2122     show_help_options(options, "\nAudio options:\n",
2123                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
2124                       OPT_AUDIO);
2125     show_help_options(options, "\nAdvanced Audio options:\n",
2126                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
2127                       OPT_AUDIO | OPT_EXPERT);
2128     show_help_options(options, "\nSubtitle options:\n",
2129                       OPT_SUBTITLE | OPT_GRAB,
2130                       OPT_SUBTITLE);
2131     show_help_options(options, "\nAudio/Video grab options:\n",
2132                       OPT_GRAB,
2133                       OPT_GRAB);
2134     printf("\n");
2135     show_help_children(avcodec_get_class(), flags);
2136     show_help_children(avformat_get_class(), flags);
2137     show_help_children(sws_get_class(), flags);
2138     show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2139
2140     return 0;
2141 }
2142
2143 void show_usage(void)
2144 {
2145     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2146     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2147     av_log(NULL, AV_LOG_INFO, "\n");
2148 }
2149
2150
2151 static int opt_progress(const char *opt, const char *arg)
2152 {
2153     AVIOContext *avio = NULL;
2154     int ret;
2155
2156     if (!strcmp(arg, "-"))
2157         arg = "pipe:";
2158     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2159     if (ret < 0) {
2160         av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2161                arg, av_err2str(ret));
2162         return ret;
2163     }
2164     progress_avio = avio;
2165     return 0;
2166 }
2167
2168 #define OFFSET(x) offsetof(OptionsContext, x)
2169 const OptionDef options[] = {
2170     /* main options */
2171 #include "cmdutils_common_opts.h"
2172     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
2173     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
2174     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
2175     { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
2176     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
2177     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
2178     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
2179     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2180     { "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]" },
2181     { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
2182       "outfile[,metadata]:infile[,metadata]" },
2183     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
2184     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
2185     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
2186     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
2187     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
2188     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
2189     { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
2190     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
2191     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
2192     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
2193       "add timings for benchmarking" },
2194     { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
2195       "add timings for each task" },
2196     { "progress", HAS_ARG | OPT_EXPERT, {(void*)opt_progress},
2197       "write program-readable progress information", "url" },
2198     { "stdin", OPT_BOOL | OPT_EXPERT, {(void*)&stdin_interaction},
2199       "enable or disable interaction on standard input" },
2200     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
2201     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
2202       "dump each input packet" },
2203     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
2204       "when dumping packets, also dump the payload" },
2205     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
2206     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2207     { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
2208     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
2209     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
2210     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
2211     { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying", "mode" },
2212     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
2213     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
2214     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
2215     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
2216     { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
2217     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
2218     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
2219     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
2220     { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
2221     { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
2222     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
2223     { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
2224     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
2225     { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
2226     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
2227     { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
2228
2229     /* video options */
2230     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
2231     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2232     { "s", HAS_ARG | OPT_VIDEO | OPT_SUBTITLE | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
2233     { "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" },
2234     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
2235     { "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" },
2236     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
2237     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
2238     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
2239     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
2240     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
2241     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
2242     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
2243     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
2244     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
2245     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
2246     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
2247     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
2248     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
2249     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
2250     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
2251     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
2252       "use same quantizer as source (implies VBR)" },
2253     { "timecode", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_timecode}, "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2254     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
2255     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
2256     { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
2257       "this option is deprecated, use the yadif filter instead" },
2258     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
2259     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
2260     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
2261     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
2262     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
2263     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
2264     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
2265     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
2266     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
2267     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
2268     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
2269     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
2270     { "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" },
2271     { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
2272
2273     /* audio options */
2274     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
2275     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
2276     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
2277     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
2278     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
2279     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
2280     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
2281     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
2282     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
2283     { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
2284     { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
2285
2286     /* subtitle options */
2287     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
2288     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
2289     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
2290     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, {.off = OFFSET(fix_sub_duration)}, "fix subtitles duration" },
2291
2292     /* grab options */
2293     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
2294     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
2295     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
2296
2297     /* muxer options */
2298     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
2299     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
2300
2301     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
2302     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
2303     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
2304
2305     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
2306     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
2307     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
2308     { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
2309     /* data codec support */
2310     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
2311     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
2312
2313     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
2314     { NULL, },
2315 };