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