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