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