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