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