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