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