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