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