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