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