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