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