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