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