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