ffmpeg_opt: fix copy_tb
[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 opt_shortest      = 0;
76 int exit_on_error     = 0;
77 int print_stats       = 1;
78 int qp_hist           = 0;
79 int same_quant        = 0;
80 int stdin_interaction = 1;
81 int frame_bits_per_raw_sample = 0;
82
83
84 static int intra_only         = 0;
85 static const char *video_codec_name    = NULL;
86 static const char *audio_codec_name    = NULL;
87 static const char *subtitle_codec_name = NULL;
88 static int file_overwrite     = 0;
89 static int no_file_overwrite  = 0;
90 static int video_discard      = 0;
91 static int intra_dc_precision = 8;
92 static int do_psnr            = 0;
93 static int do_pass            = 0;
94 static int input_sync;
95
96 void reset_options(OptionsContext *o, int is_input)
97 {
98     const OptionDef *po = options;
99     OptionsContext bak= *o;
100     int i;
101
102     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
103     while (po->name) {
104         void *dst = (uint8_t*)o + po->u.off;
105
106         if (po->flags & OPT_SPEC) {
107             SpecifierOpt **so = dst;
108             int i, *count = (int*)(so + 1);
109             for (i = 0; i < *count; i++) {
110                 av_freep(&(*so)[i].specifier);
111                 if (po->flags & OPT_STRING)
112                     av_freep(&(*so)[i].u.str);
113             }
114             av_freep(so);
115             *count = 0;
116         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
117             av_freep(dst);
118         po++;
119     }
120
121     for (i = 0; i < o->nb_stream_maps; i++)
122         av_freep(&o->stream_maps[i].linklabel);
123     av_freep(&o->stream_maps);
124     av_freep(&o->audio_channel_maps);
125     av_freep(&o->streamid_map);
126
127     memset(o, 0, sizeof(*o));
128
129     if (is_input) {
130         o->recording_time = bak.recording_time;
131         if (o->recording_time != INT64_MAX)
132             av_log(NULL, AV_LOG_WARNING,
133                    "-t is not an input option, keeping it for the next output;"
134                    " consider fixing your command line.\n");
135     } else
136     o->recording_time = INT64_MAX;
137     o->mux_max_delay  = 0.7;
138     o->limit_filesize = UINT64_MAX;
139     o->chapters_input_file = INT_MAX;
140
141     uninit_opts();
142     init_opts();
143 }
144
145
146 static int opt_frame_crop(const char *opt, const char *arg)
147 {
148     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
149     return AVERROR(EINVAL);
150 }
151
152 static int opt_pad(const char *opt, const char *arg)
153 {
154     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
155     return -1;
156 }
157
158 static int opt_video_channel(const char *opt, const char *arg)
159 {
160     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
161     return opt_default("channel", arg);
162     }
163
164 static int opt_video_standard(const char *opt, const char *arg)
165 {
166     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
167     return opt_default("standard", arg);
168 }
169
170 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
171 {
172     OptionsContext *o = optctx;
173     audio_codec_name = arg;
174     return parse_option(o, "codec:a", arg, options);
175 }
176
177 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
178 {
179     OptionsContext *o = optctx;
180     video_codec_name = arg;
181     return parse_option(o, "codec:v", arg, options);
182 }
183
184 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
185 {
186     OptionsContext *o = optctx;
187     subtitle_codec_name = arg;
188     return parse_option(o, "codec:s", arg, options);
189 }
190
191 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
192 {
193     OptionsContext *o = optctx;
194     return parse_option(o, "codec:d", arg, options);
195 }
196
197 static int opt_map(void *optctx, const char *opt, const char *arg)
198 {
199     OptionsContext *o = optctx;
200     StreamMap *m = NULL;
201     int i, negative = 0, file_idx;
202     int sync_file_idx = -1, sync_stream_idx = 0;
203     char *p, *sync;
204     char *map;
205
206     if (*arg == '-') {
207         negative = 1;
208         arg++;
209     }
210     map = av_strdup(arg);
211
212     /* parse sync stream first, just pick first matching stream */
213     if (sync = strchr(map, ',')) {
214         *sync = 0;
215         sync_file_idx = strtol(sync + 1, &sync, 0);
216         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
217             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
218             exit_program(1);
219         }
220         if (*sync)
221             sync++;
222         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
223             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
224                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
225                 sync_stream_idx = i;
226                 break;
227             }
228         if (i == input_files[sync_file_idx]->nb_streams) {
229             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
230                                        "match any streams.\n", arg);
231             exit_program(1);
232         }
233     }
234
235
236     if (map[0] == '[') {
237         /* this mapping refers to lavfi output */
238         const char *c = map + 1;
239         o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
240                                     &o->nb_stream_maps, o->nb_stream_maps + 1);
241         m = &o->stream_maps[o->nb_stream_maps - 1];
242         m->linklabel = av_get_token(&c, "]");
243         if (!m->linklabel) {
244             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
245             exit_program(1);
246         }
247     } else {
248         file_idx = strtol(map, &p, 0);
249         if (file_idx >= nb_input_files || file_idx < 0) {
250             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
251             exit_program(1);
252         }
253         if (negative)
254             /* disable some already defined maps */
255             for (i = 0; i < o->nb_stream_maps; i++) {
256                 m = &o->stream_maps[i];
257                 if (file_idx == m->file_index &&
258                     check_stream_specifier(input_files[m->file_index]->ctx,
259                                            input_files[m->file_index]->ctx->streams[m->stream_index],
260                                            *p == ':' ? p + 1 : p) > 0)
261                     m->disabled = 1;
262             }
263         else
264             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
265                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
266                             *p == ':' ? p + 1 : p) <= 0)
267                     continue;
268                 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
269                                             &o->nb_stream_maps, o->nb_stream_maps + 1);
270                 m = &o->stream_maps[o->nb_stream_maps - 1];
271
272                 m->file_index   = file_idx;
273                 m->stream_index = i;
274
275                 if (sync_file_idx >= 0) {
276                     m->sync_file_index   = sync_file_idx;
277                     m->sync_stream_index = sync_stream_idx;
278                 } else {
279                     m->sync_file_index   = file_idx;
280                     m->sync_stream_index = i;
281                 }
282             }
283     }
284
285     if (!m) {
286         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
287         exit_program(1);
288     }
289
290     av_freep(&map);
291     return 0;
292 }
293
294 static int opt_attach(void *optctx, const char *opt, const char *arg)
295 {
296     OptionsContext *o = optctx;
297     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
298                                 &o->nb_attachments, o->nb_attachments + 1);
299     o->attachments[o->nb_attachments - 1] = arg;
300     return 0;
301 }
302
303 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
304 {
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         }\
447
448     SET_DICT(type_in, meta_in, ic, idx_in);
449     SET_DICT(type_out, meta_out, oc, idx_out);
450
451     /* for input streams choose first matching stream */
452     if (type_in == 's') {
453         for (i = 0; i < ic->nb_streams; i++) {
454             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
455                 meta_in = &ic->streams[i]->metadata;
456                 break;
457             } else if (ret < 0)
458                 exit_program(1);
459         }
460         if (!meta_in) {
461             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
462             exit_program(1);
463         }
464     }
465
466     if (type_out == 's') {
467         for (i = 0; i < oc->nb_streams; i++) {
468             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
469                 meta_out = &oc->streams[i]->metadata;
470                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
471             } else if (ret < 0)
472                 exit_program(1);
473         }
474     } else
475         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
476
477     return 0;
478 }
479
480 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
481 {
482     char buf[128];
483     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
484     struct tm time = *gmtime((time_t*)&recording_timestamp);
485     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
486     parse_option(o, "metadata", buf, options);
487
488     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
489                                  "tag instead.\n", opt);
490     return 0;
491 }
492
493 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
494 {
495     const AVCodecDescriptor *desc;
496     const char *codec_string = encoder ? "encoder" : "decoder";
497     AVCodec *codec;
498
499     codec = encoder ?
500         avcodec_find_encoder_by_name(name) :
501         avcodec_find_decoder_by_name(name);
502
503     if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
504         codec = encoder ? avcodec_find_encoder(desc->id) :
505                           avcodec_find_decoder(desc->id);
506         if (codec)
507             av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
508                    codec_string, codec->name, desc->name);
509     }
510
511     if (!codec) {
512         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
513         exit_program(1);
514     }
515     if (codec->type != type) {
516         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
517         exit_program(1);
518     }
519     return codec;
520 }
521
522 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
523 {
524     char *codec_name = NULL;
525
526     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
527     if (codec_name) {
528         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
529         st->codec->codec_id = codec->id;
530         return codec;
531     } else
532         return avcodec_find_decoder(st->codec->codec_id);
533 }
534
535 /**
536  * Add all the streams from the given input file to the global
537  * list of input streams.
538  */
539 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
540 {
541     int i;
542     char *next, *codec_tag = NULL;
543
544     for (i = 0; i < ic->nb_streams; i++) {
545         AVStream *st = ic->streams[i];
546         AVCodecContext *dec = st->codec;
547         InputStream *ist = av_mallocz(sizeof(*ist));
548         char *framerate = NULL;
549
550         if (!ist)
551             exit_program(1);
552
553         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
554         input_streams[nb_input_streams - 1] = ist;
555
556         ist->st = st;
557         ist->file_index = nb_input_files;
558         ist->discard = 1;
559         st->discard  = AVDISCARD_ALL;
560         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
561
562         ist->ts_scale = 1.0;
563         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
564
565         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
566         if (codec_tag) {
567             uint32_t tag = strtol(codec_tag, &next, 0);
568             if (*next)
569                 tag = AV_RL32(codec_tag);
570             st->codec->codec_tag = tag;
571         }
572
573         ist->dec = choose_decoder(o, ic, st);
574
575         switch (dec->codec_type) {
576         case AVMEDIA_TYPE_VIDEO:
577             if(!ist->dec)
578                 ist->dec = avcodec_find_decoder(dec->codec_id);
579             if (dec->lowres) {
580                 dec->flags |= CODEC_FLAG_EMU_EDGE;
581             }
582
583             ist->resample_height  = dec->height;
584             ist->resample_width   = dec->width;
585             ist->resample_pix_fmt = dec->pix_fmt;
586
587             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
588             if (framerate && av_parse_video_rate(&ist->framerate,
589                                                  framerate) < 0) {
590                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
591                        framerate);
592                 exit_program(1);
593             }
594
595             ist->top_field_first = -1;
596             MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
597
598             break;
599         case AVMEDIA_TYPE_AUDIO:
600             guess_input_channel_layout(ist);
601
602             ist->resample_sample_fmt     = dec->sample_fmt;
603             ist->resample_sample_rate    = dec->sample_rate;
604             ist->resample_channels       = dec->channels;
605             ist->resample_channel_layout = dec->channel_layout;
606
607             break;
608         case AVMEDIA_TYPE_DATA:
609         case AVMEDIA_TYPE_SUBTITLE:
610             if(!ist->dec)
611                 ist->dec = avcodec_find_decoder(dec->codec_id);
612             MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
613             break;
614         case AVMEDIA_TYPE_ATTACHMENT:
615         case AVMEDIA_TYPE_UNKNOWN:
616             break;
617         default:
618             abort();
619         }
620     }
621 }
622
623 static void assert_file_overwrite(const char *filename)
624 {
625     if ((!file_overwrite || no_file_overwrite) &&
626         (strchr(filename, ':') == NULL || filename[1] == ':' ||
627          av_strstart(filename, "file:", NULL))) {
628         if (avio_check(filename, 0) == 0) {
629             if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
630                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
631                 fflush(stderr);
632                 term_exit();
633                 signal(SIGINT, SIG_DFL);
634                 if (!read_yesno()) {
635                     av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
636                     exit_program(1);
637                 }
638                 term_init();
639             }
640             else {
641                 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
642                 exit_program(1);
643             }
644         }
645     }
646 }
647
648 static void dump_attachment(AVStream *st, const char *filename)
649 {
650     int ret;
651     AVIOContext *out = NULL;
652     AVDictionaryEntry *e;
653
654     if (!st->codec->extradata_size) {
655         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
656                nb_input_files - 1, st->index);
657         return;
658     }
659     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
660         filename = e->value;
661     if (!*filename) {
662         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
663                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
664         exit_program(1);
665     }
666
667     assert_file_overwrite(filename);
668
669     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
670         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
671                filename);
672         exit_program(1);
673     }
674
675     avio_write(out, st->codec->extradata, st->codec->extradata_size);
676     avio_flush(out);
677     avio_close(out);
678 }
679
680 static int opt_input_file(void *optctx, const char *opt, const char *filename)
681 {
682     OptionsContext *o = optctx;
683     AVFormatContext *ic;
684     AVInputFormat *file_iformat = NULL;
685     int err, i, ret;
686     int64_t timestamp;
687     uint8_t buf[128];
688     AVDictionary **opts;
689     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
690
691     if (o->format) {
692         if (!(file_iformat = av_find_input_format(o->format))) {
693             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
694             exit_program(1);
695         }
696     }
697
698     if (!strcmp(filename, "-"))
699         filename = "pipe:";
700
701     stdin_interaction &= strncmp(filename, "pipe:", 5) &&
702                          strcmp(filename, "/dev/stdin");
703
704     /* get default parameters from command line */
705     ic = avformat_alloc_context();
706     if (!ic) {
707         print_error(filename, AVERROR(ENOMEM));
708         exit_program(1);
709     }
710     if (o->nb_audio_sample_rate) {
711         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
712         av_dict_set(&format_opts, "sample_rate", buf, 0);
713     }
714     if (o->nb_audio_channels) {
715         /* because we set audio_channels based on both the "ac" and
716          * "channel_layout" options, we need to check that the specified
717          * demuxer actually has the "channels" option before setting it */
718         if (file_iformat && file_iformat->priv_class &&
719             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
720                         AV_OPT_SEARCH_FAKE_OBJ)) {
721             snprintf(buf, sizeof(buf), "%d",
722                      o->audio_channels[o->nb_audio_channels - 1].u.i);
723             av_dict_set(&format_opts, "channels", buf, 0);
724         }
725     }
726     if (o->nb_frame_rates) {
727         /* set the format-level framerate option;
728          * this is important for video grabbers, e.g. x11 */
729         if (file_iformat && file_iformat->priv_class &&
730             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
731                         AV_OPT_SEARCH_FAKE_OBJ)) {
732             av_dict_set(&format_opts, "framerate",
733                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
734         }
735     }
736     if (o->nb_frame_sizes) {
737         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
738     }
739     if (o->nb_frame_pix_fmts)
740         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
741
742     ic->video_codec_id   = video_codec_name ?
743         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : AV_CODEC_ID_NONE;
744     ic->audio_codec_id   = audio_codec_name ?
745         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : AV_CODEC_ID_NONE;
746     ic->subtitle_codec_id= subtitle_codec_name ?
747         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
748     ic->flags |= AVFMT_FLAG_NONBLOCK;
749     ic->interrupt_callback = int_cb;
750
751     /* open the input file with generic avformat function */
752     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
753     if (err < 0) {
754         print_error(filename, err);
755         exit_program(1);
756     }
757     assert_avoptions(format_opts);
758
759     /* apply forced codec ids */
760     for (i = 0; i < ic->nb_streams; i++)
761         choose_decoder(o, ic, ic->streams[i]);
762
763     /* Set AVCodecContext options for avformat_find_stream_info */
764     opts = setup_find_stream_info_opts(ic, codec_opts);
765     orig_nb_streams = ic->nb_streams;
766
767     /* If not enough info to get the stream parameters, we decode the
768        first frames to get it. (used in mpeg case for example) */
769     ret = avformat_find_stream_info(ic, opts);
770     if (ret < 0) {
771         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
772         avformat_close_input(&ic);
773         exit_program(1);
774     }
775
776     timestamp = o->start_time;
777     /* add the stream start time */
778     if (ic->start_time != AV_NOPTS_VALUE)
779         timestamp += ic->start_time;
780
781     /* if seeking requested, we execute it */
782     if (o->start_time != 0) {
783         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
784         if (ret < 0) {
785             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
786                    filename, (double)timestamp / AV_TIME_BASE);
787         }
788     }
789
790     /* update the current parameters so that they match the one of the input stream */
791     add_input_streams(o, ic);
792
793     /* dump the file content */
794     av_dump_format(ic, nb_input_files, filename, 0);
795
796     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
797     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
798         exit_program(1);
799
800     input_files[nb_input_files - 1]->ctx        = ic;
801     input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
802     input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
803     input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
804     input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
805
806     for (i = 0; i < o->nb_dump_attachment; i++) {
807         int j;
808
809         for (j = 0; j < ic->nb_streams; j++) {
810             AVStream *st = ic->streams[j];
811
812             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
813                 dump_attachment(st, o->dump_attachment[i].u.str);
814         }
815     }
816
817     for (i = 0; i < orig_nb_streams; i++)
818         av_dict_free(&opts[i]);
819     av_freep(&opts);
820
821     reset_options(o, 1);
822     return 0;
823 }
824
825 static uint8_t *get_line(AVIOContext *s)
826 {
827     AVIOContext *line;
828     uint8_t *buf;
829     char c;
830
831     if (avio_open_dyn_buf(&line) < 0) {
832         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
833         exit_program(1);
834     }
835
836     while ((c = avio_r8(s)) && c != '\n')
837         avio_w8(line, c);
838     avio_w8(line, 0);
839     avio_close_dyn_buf(line, &buf);
840
841     return buf;
842 }
843
844 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
845 {
846     int i, ret = 1;
847     char filename[1000];
848     const char *base[3] = { getenv("AVCONV_DATADIR"),
849                             getenv("HOME"),
850                             AVCONV_DATADIR,
851                             };
852
853     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
854         if (!base[i])
855             continue;
856         if (codec_name) {
857             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
858                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
859             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
860         }
861         if (ret) {
862             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
863                      i != 1 ? "" : "/.avconv", preset_name);
864             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
865         }
866     }
867     return ret;
868 }
869
870 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
871 {
872     char *codec_name = NULL;
873
874     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
875     if (!codec_name) {
876         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
877                                                   NULL, ost->st->codec->codec_type);
878         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
879     } else if (!strcmp(codec_name, "copy"))
880         ost->stream_copy = 1;
881     else {
882         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
883         ost->st->codec->codec_id = ost->enc->id;
884     }
885 }
886
887 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
888 {
889     OutputStream *ost;
890     AVStream *st = avformat_new_stream(oc, NULL);
891     int idx      = oc->nb_streams - 1, ret = 0;
892     char *bsf = NULL, *next, *codec_tag = NULL;
893     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
894     double qscale = -1;
895     char *buf = NULL, *arg = NULL, *preset = NULL;
896     AVIOContext *s = NULL;
897
898     if (!st) {
899         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
900         exit_program(1);
901     }
902
903     if (oc->nb_streams - 1 < o->nb_streamid_map)
904         st->id = o->streamid_map[oc->nb_streams - 1];
905
906     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
907                                 nb_output_streams + 1);
908     if (!(ost = av_mallocz(sizeof(*ost))))
909         exit_program(1);
910     output_streams[nb_output_streams - 1] = ost;
911
912     ost->file_index = nb_output_files;
913     ost->index      = idx;
914     ost->st         = st;
915     st->codec->codec_type = type;
916     choose_encoder(o, oc, ost);
917     if (ost->enc) {
918         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
919     }
920
921     avcodec_get_context_defaults3(st->codec, ost->enc);
922     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
923
924     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
925     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
926         do  {
927             buf = get_line(s);
928             if (!buf[0] || buf[0] == '#') {
929                 av_free(buf);
930                 continue;
931             }
932             if (!(arg = strchr(buf, '='))) {
933                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
934                 exit_program(1);
935             }
936             *arg++ = 0;
937             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
938             av_free(buf);
939         } while (!s->eof_reached);
940         avio_close(s);
941     }
942     if (ret) {
943         av_log(NULL, AV_LOG_FATAL,
944                "Preset %s specified for stream %d:%d, but could not be opened.\n",
945                preset, ost->file_index, ost->index);
946         exit_program(1);
947     }
948
949     ost->max_frames = INT64_MAX;
950     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
951
952     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
953     while (bsf) {
954         if (next = strchr(bsf, ','))
955             *next++ = 0;
956         if (!(bsfc = av_bitstream_filter_init(bsf))) {
957             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
958             exit_program(1);
959         }
960         if (bsfc_prev)
961             bsfc_prev->next = bsfc;
962         else
963             ost->bitstream_filters = bsfc;
964
965         bsfc_prev = bsfc;
966         bsf       = next;
967     }
968
969     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
970     if (codec_tag) {
971         uint32_t tag = strtol(codec_tag, &next, 0);
972         if (*next)
973             tag = AV_RL32(codec_tag);
974         st->codec->codec_tag = tag;
975     }
976
977     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
978     if (qscale >= 0 || same_quant) {
979         st->codec->flags |= CODEC_FLAG_QSCALE;
980         st->codec->global_quality = FF_QP2LAMBDA * qscale;
981     }
982
983     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
984         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
985
986     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
987     av_opt_get_int   (swr_opts, "dither_method", 0, &ost->swr_dither_method);
988     av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
989
990     ost->source_index = source_index;
991     if (source_index >= 0) {
992         ost->sync_ist = input_streams[source_index];
993         input_streams[source_index]->discard = 0;
994         input_streams[source_index]->st->discard = AVDISCARD_NONE;
995     }
996
997     return ost;
998 }
999
1000 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1001 {
1002     int i;
1003     const char *p = str;
1004     for (i = 0;; i++) {
1005         dest[i] = atoi(p);
1006         if (i == 63)
1007             break;
1008         p = strchr(p, ',');
1009         if (!p) {
1010             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1011             exit_program(1);
1012         }
1013         p++;
1014     }
1015 }
1016
1017 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1018 {
1019     AVStream *st;
1020     OutputStream *ost;
1021     AVCodecContext *video_enc;
1022     char *frame_rate = NULL;
1023
1024     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1025     st  = ost->st;
1026     video_enc = st->codec;
1027
1028     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1029     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1030         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1031         exit_program(1);
1032     }
1033
1034     if (!ost->stream_copy) {
1035         const char *p = NULL;
1036         char *frame_size = NULL;
1037         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1038         char *intra_matrix = NULL, *inter_matrix = NULL;
1039         const char *filters = "null";
1040         int i;
1041
1042         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1043         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1044             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1045             exit_program(1);
1046         }
1047
1048         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1049         if (frame_aspect_ratio) {
1050             AVRational q;
1051             if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1052                 q.num <= 0 || q.den <= 0) {
1053                 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1054                 exit_program(1);
1055             }
1056             ost->frame_aspect_ratio = av_q2d(q);
1057         }
1058
1059         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1060         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1061         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1062             ost->keep_pix_fmt = 1;
1063             if (!*++frame_pix_fmt)
1064                 frame_pix_fmt = NULL;
1065         }
1066         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
1067             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1068             exit_program(1);
1069         }
1070         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1071
1072         if (intra_only)
1073             video_enc->gop_size = 0;
1074         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1075         if (intra_matrix) {
1076             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1077                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1078                 exit_program(1);
1079             }
1080             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1081         }
1082         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1083         if (inter_matrix) {
1084             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1085                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1086                 exit_program(1);
1087             }
1088             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1089         }
1090
1091         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1092         for (i = 0; p; i++) {
1093             int start, end, q;
1094             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1095             if (e != 3) {
1096                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1097                 exit_program(1);
1098             }
1099             /* FIXME realloc failure */
1100             video_enc->rc_override =
1101                 av_realloc(video_enc->rc_override,
1102                            sizeof(RcOverride) * (i + 1));
1103             video_enc->rc_override[i].start_frame = start;
1104             video_enc->rc_override[i].end_frame   = end;
1105             if (q > 0) {
1106                 video_enc->rc_override[i].qscale         = q;
1107                 video_enc->rc_override[i].quality_factor = 1.0;
1108             }
1109             else {
1110                 video_enc->rc_override[i].qscale         = 0;
1111                 video_enc->rc_override[i].quality_factor = -q/100.0;
1112             }
1113             p = strchr(p, '/');
1114             if (p) p++;
1115         }
1116         video_enc->rc_override_count = i;
1117         if (!video_enc->rc_initial_buffer_occupancy)
1118             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1119         video_enc->intra_dc_precision = intra_dc_precision - 8;
1120
1121         if (do_psnr)
1122             video_enc->flags|= CODEC_FLAG_PSNR;
1123
1124         /* two pass mode */
1125         if (do_pass) {
1126             if (do_pass & 1) {
1127                 video_enc->flags |= CODEC_FLAG_PASS1;
1128             }
1129             if (do_pass & 2) {
1130                 video_enc->flags |= CODEC_FLAG_PASS2;
1131             }
1132         }
1133
1134         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1135         if (ost->forced_keyframes)
1136             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1137
1138         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1139
1140         ost->top_field_first = -1;
1141         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1142
1143         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1144         ost->avfilter = av_strdup(filters);
1145     } else {
1146         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1147     }
1148
1149     return ost;
1150 }
1151
1152 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1153 {
1154     int n;
1155     AVStream *st;
1156     OutputStream *ost;
1157     AVCodecContext *audio_enc;
1158
1159     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1160     st  = ost->st;
1161
1162     audio_enc = st->codec;
1163     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1164
1165     if (!ost->stream_copy) {
1166         char *sample_fmt = NULL;
1167         const char *filters = "anull";
1168
1169         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1170
1171         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1172         if (sample_fmt &&
1173             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1174             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1175             exit_program(1);
1176         }
1177
1178         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1179
1180         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1181
1182         av_assert1(filters);
1183         ost->avfilter = av_strdup(filters);
1184
1185         /* check for channel mapping for this audio stream */
1186         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1187             AudioChannelMap *map = &o->audio_channel_maps[n];
1188             InputStream *ist = input_streams[ost->source_index];
1189             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1190                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1191                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1192                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1193                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1194                 else
1195                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1196                            ost->file_index, ost->st->index);
1197             }
1198         }
1199     }
1200
1201     return ost;
1202 }
1203
1204 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1205 {
1206     OutputStream *ost;
1207
1208     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1209     if (!ost->stream_copy) {
1210         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1211         exit_program(1);
1212     }
1213
1214     return ost;
1215 }
1216
1217 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1218 {
1219     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1220     ost->stream_copy = 1;
1221     return ost;
1222 }
1223
1224 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1225 {
1226     AVStream *st;
1227     OutputStream *ost;
1228     AVCodecContext *subtitle_enc;
1229
1230     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1231     st  = ost->st;
1232     subtitle_enc = st->codec;
1233
1234     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1235
1236     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1237
1238     if (!ost->stream_copy) {
1239         char *frame_size = NULL;
1240
1241         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1242         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1243             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1244             exit_program(1);
1245         }
1246     }
1247
1248     return ost;
1249 }
1250
1251 /* arg format is "output-stream-index:streamid-value". */
1252 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1253 {
1254     OptionsContext *o = optctx;
1255     int idx;
1256     char *p;
1257     char idx_str[16];
1258
1259     av_strlcpy(idx_str, arg, sizeof(idx_str));
1260     p = strchr(idx_str, ':');
1261     if (!p) {
1262         av_log(NULL, AV_LOG_FATAL,
1263                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1264                arg, opt);
1265         exit_program(1);
1266     }
1267     *p++ = '\0';
1268     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1269     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1270     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1271     return 0;
1272 }
1273
1274 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1275 {
1276     AVFormatContext *is = ifile->ctx;
1277     AVFormatContext *os = ofile->ctx;
1278     int i;
1279
1280     for (i = 0; i < is->nb_chapters; i++) {
1281         AVChapter *in_ch = is->chapters[i], *out_ch;
1282         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1283                                        AV_TIME_BASE_Q, in_ch->time_base);
1284         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1285                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1286
1287
1288         if (in_ch->end < ts_off)
1289             continue;
1290         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1291             break;
1292
1293         out_ch = av_mallocz(sizeof(AVChapter));
1294         if (!out_ch)
1295             return AVERROR(ENOMEM);
1296
1297         out_ch->id        = in_ch->id;
1298         out_ch->time_base = in_ch->time_base;
1299         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1300         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1301
1302         if (copy_metadata)
1303             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1304
1305         os->nb_chapters++;
1306         os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
1307         if (!os->chapters)
1308             return AVERROR(ENOMEM);
1309         os->chapters[os->nb_chapters - 1] = out_ch;
1310     }
1311     return 0;
1312 }
1313
1314 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1315 {
1316     int i, err;
1317     AVFormatContext *ic = avformat_alloc_context();
1318
1319     ic->interrupt_callback = int_cb;
1320     err = avformat_open_input(&ic, filename, NULL, NULL);
1321     if (err < 0)
1322         return err;
1323     /* copy stream format */
1324     for(i=0;i<ic->nb_streams;i++) {
1325         AVStream *st;
1326         OutputStream *ost;
1327         AVCodec *codec;
1328         AVCodecContext *avctx;
1329
1330         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1331         ost   = new_output_stream(o, s, codec->type, -1);
1332         st    = ost->st;
1333         avctx = st->codec;
1334         ost->enc = codec;
1335
1336         // FIXME: a more elegant solution is needed
1337         memcpy(st, ic->streams[i], sizeof(AVStream));
1338         st->cur_dts = 0;
1339         st->info = av_malloc(sizeof(*st->info));
1340         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1341         st->codec= avctx;
1342         avcodec_copy_context(st->codec, ic->streams[i]->codec);
1343
1344         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1345             choose_sample_fmt(st, codec);
1346         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1347             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1348     }
1349
1350     avformat_close_input(&ic);
1351     return 0;
1352 }
1353
1354 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1355                                AVFormatContext *oc)
1356 {
1357     OutputStream *ost;
1358
1359     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1360                                   ofilter->out_tmp->pad_idx)) {
1361     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1362     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1363     default:
1364         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1365                "currently.\n");
1366         exit_program(1);
1367     }
1368
1369     ost->source_index = -1;
1370     ost->filter       = ofilter;
1371
1372     ofilter->ost      = ost;
1373
1374     if (ost->stream_copy) {
1375         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1376                "which is fed from a complex filtergraph. Filtering and streamcopy "
1377                "cannot be used together.\n", ost->file_index, ost->index);
1378         exit_program(1);
1379     }
1380     if (o->recording_time != INT64_MAX)
1381         av_log(NULL, AV_LOG_WARNING,
1382                "-t does not work with -filter_complex (yet).\n");
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(OptionsContext *o, const char *opt, const char *arg)
1945 {
1946     FILE *f=NULL;
1947     char filename[1000], line[1000], tmp_line[1000];
1948     const char *codec_name = *opt == 'v' ? video_codec_name :
1949                              *opt == 'a' ? audio_codec_name :
1950                                            subtitle_codec_name;
1951
1952     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1953         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1954             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1955         }else
1956             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1957         exit_program(1);
1958 }
1959
1960     while (fgets(line, sizeof(line), f)) {
1961         char *key = tmp_line, *value, *endptr;
1962
1963         if (strcspn(line, "#\n\r") == 0)
1964             continue;
1965         strcpy(tmp_line, line);
1966         if (!av_strtok(key,   "=",    &value) ||
1967             !av_strtok(value, "\r\n", &endptr)) {
1968             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
1969             exit_program(1);
1970         }
1971         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
1972
1973         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
1974         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
1975         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
1976         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
1977         else if (opt_default(key, value) < 0) {
1978             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
1979                    filename, line, key, value);
1980             exit_program(1);
1981         }
1982     }
1983
1984     fclose(f);
1985
1986     return 0;
1987 }
1988
1989 static int opt_passlogfile(const char *opt, const char *arg)
1990 {
1991     pass_logfilename_prefix = arg;
1992 #if CONFIG_LIBX264_ENCODER
1993     return opt_default(opt, arg);
1994 #else
1995     return 0;
1996 #endif
1997 }
1998
1999 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
2000 {
2001     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2002     int ret = parse_option(o, s, arg, options);
2003     av_free(s);
2004     return ret;
2005 }
2006
2007 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
2008 {
2009     if(!strcmp(opt, "b")){
2010         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2011         return parse_option(o, "b:v", arg, options);
2012     }
2013     return opt_default(opt, arg);
2014 }
2015
2016 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
2017 {
2018     char *s;
2019     int ret;
2020     if(!strcmp(opt, "qscale")){
2021         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2022         return parse_option(o, "q:v", arg, options);
2023     }
2024     s = av_asprintf("q%s", opt + 6);
2025     ret = parse_option(o, s, arg, options);
2026     av_free(s);
2027     return ret;
2028 }
2029
2030 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
2031 {
2032     if(!strcmp(opt, "profile")){
2033         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2034         return parse_option(o, "profile:v", arg, options);
2035     }
2036     return opt_default(opt, arg);
2037
2038 }
2039
2040 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2041 {
2042     OptionsContext *o = optctx;
2043     return parse_option(o, "filter:v", arg, options);
2044 }
2045
2046 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2047 {
2048     OptionsContext *o = optctx;
2049     return parse_option(o, "filter:a", arg, options);
2050 }
2051
2052 static int opt_vsync(const char *opt, const char *arg)
2053 {
2054     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2055     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2056     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2057     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2058
2059     if (video_sync_method == VSYNC_AUTO)
2060         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2061     return 0;
2062 }
2063
2064 static int opt_deinterlace(const char *opt, const char *arg)
2065 {
2066     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2067     do_deinterlace = 1;
2068     return 0;
2069 }
2070
2071 static int opt_timecode(OptionsContext *o, const char *opt, const char *arg)
2072 {
2073     char *tcr = av_asprintf("timecode=%s", arg);
2074     int ret = parse_option(o, "metadata:g", tcr, options);
2075     if (ret >= 0)
2076         ret = opt_default("gop_timecode", arg);
2077     av_free(tcr);
2078     return ret;
2079 }
2080
2081 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2082 {
2083     OptionsContext *o = optctx;
2084     char layout_str[32];
2085     char *stream_str;
2086     char *ac_str;
2087     int ret, channels, ac_str_size;
2088     uint64_t layout;
2089
2090     layout = av_get_channel_layout(arg);
2091     if (!layout) {
2092         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2093         return AVERROR(EINVAL);
2094     }
2095     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2096     ret = opt_default(opt, layout_str);
2097     if (ret < 0)
2098         return ret;
2099
2100     /* set 'ac' option based on channel layout */
2101     channels = av_get_channel_layout_nb_channels(layout);
2102     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2103     stream_str = strchr(opt, ':');
2104     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2105     ac_str = av_mallocz(ac_str_size);
2106     if (!ac_str)
2107         return AVERROR(ENOMEM);
2108     av_strlcpy(ac_str, "ac", 3);
2109     if (stream_str)
2110         av_strlcat(ac_str, stream_str, ac_str_size);
2111     ret = parse_option(o, ac_str, layout_str, options);
2112     av_free(ac_str);
2113
2114     return ret;
2115 }
2116
2117 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2118 {
2119     OptionsContext *o = optctx;
2120     return parse_option(o, "q:a", arg, options);
2121 }
2122
2123 static int opt_filter_complex(const char *opt, const char *arg)
2124 {
2125     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2126                               &nb_filtergraphs, nb_filtergraphs + 1);
2127     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2128         return AVERROR(ENOMEM);
2129     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
2130     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2131     return 0;
2132 }
2133
2134 static int show_help(const char *opt, const char *arg)
2135 {
2136     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2137     av_log_set_callback(log_callback_help);
2138     show_usage();
2139     show_help_options(options, "Main options:\n",
2140                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
2141     show_help_options(options, "\nAdvanced options:\n",
2142                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
2143                       OPT_EXPERT);
2144     show_help_options(options, "\nVideo options:\n",
2145                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
2146                       OPT_VIDEO);
2147     show_help_options(options, "\nAdvanced Video options:\n",
2148                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
2149                       OPT_VIDEO | OPT_EXPERT);
2150     show_help_options(options, "\nAudio options:\n",
2151                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
2152                       OPT_AUDIO);
2153     show_help_options(options, "\nAdvanced Audio options:\n",
2154                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
2155                       OPT_AUDIO | OPT_EXPERT);
2156     show_help_options(options, "\nSubtitle options:\n",
2157                       OPT_SUBTITLE | OPT_GRAB,
2158                       OPT_SUBTITLE);
2159     show_help_options(options, "\nAudio/Video grab options:\n",
2160                       OPT_GRAB,
2161                       OPT_GRAB);
2162     printf("\n");
2163     show_help_children(avcodec_get_class(), flags);
2164     show_help_children(avformat_get_class(), flags);
2165     show_help_children(sws_get_class(), flags);
2166     show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2167     show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2168     return 0;
2169 }
2170
2171 void show_usage(void)
2172 {
2173     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2174     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2175     av_log(NULL, AV_LOG_INFO, "\n");
2176 }
2177
2178
2179 static int opt_progress(const char *opt, const char *arg)
2180 {
2181     AVIOContext *avio = NULL;
2182     int ret;
2183
2184     if (!strcmp(arg, "-"))
2185         arg = "pipe:";
2186     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2187     if (ret < 0) {
2188         av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2189                arg, av_err2str(ret));
2190         return ret;
2191     }
2192     progress_avio = avio;
2193     return 0;
2194 }
2195
2196 #define OFFSET(x) offsetof(OptionsContext, x)
2197 const OptionDef options[] = {
2198     /* main options */
2199 #include "cmdutils_common_opts.h"
2200     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
2201     { "i", HAS_ARG | OPT_FUNC2, {.func2_arg = opt_input_file}, "input file name", "filename" },
2202     { "y", OPT_BOOL, {&file_overwrite}, "overwrite output files" },
2203     { "n", OPT_BOOL, {&no_file_overwrite}, "do not overwrite output files" },
2204     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
2205     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
2206     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
2207     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {.func2_arg = opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2208     { "map_channel", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {.func2_arg = opt_map_channel}, "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2209     { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
2210       "outfile[,metadata]:infile[,metadata]" },
2211     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
2212     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
2213     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
2214     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
2215     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
2216     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
2217     { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
2218     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
2219     { "dframes", HAS_ARG | OPT_FUNC2, {.func2_arg = opt_data_frames}, "set the number of data frames to record", "number" },
2220     { "benchmark", OPT_BOOL | OPT_EXPERT, {&do_benchmark},
2221       "add timings for benchmarking" },
2222     { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
2223       "add timings for each task" },
2224     { "progress", HAS_ARG | OPT_EXPERT, {(void*)opt_progress},
2225       "write program-readable progress information", "url" },
2226     { "stdin", OPT_BOOL | OPT_EXPERT, {(void*)&stdin_interaction},
2227       "enable or disable interaction on standard input" },
2228     { "timelimit", HAS_ARG, {.func_arg = opt_timelimit}, "set max runtime in seconds", "limit" },
2229     { "dump", OPT_BOOL | OPT_EXPERT, {&do_pkt_dump},
2230       "dump each input packet" },
2231     { "hex", OPT_BOOL | OPT_EXPERT, {&do_hex_dump},
2232       "when dumping packets, also dump the payload" },
2233     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
2234     { "target", HAS_ARG | OPT_FUNC2, {.func2_arg = opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2235     { "vsync", HAS_ARG | OPT_EXPERT, {opt_vsync}, "video sync method", "" },
2236     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {&audio_sync_method}, "audio sync method", "" },
2237     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {&audio_drift_threshold}, "audio drift threshold", "threshold" },
2238     { "copyts", OPT_BOOL | OPT_EXPERT, {&copy_ts}, "copy timestamps" },
2239     { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {&copy_tb}, "copy input stream time base when stream copying", "mode" },
2240     { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(shortest)}, "finish encoding within shortest input" },
2241     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
2242     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
2243     { "xerror", OPT_BOOL, {&exit_on_error}, "exit on error", "error" },
2244     { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
2245     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
2246     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
2247     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
2248     { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
2249     { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
2250     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
2251     { "filter_complex", HAS_ARG | OPT_EXPERT, {.func_arg = opt_filter_complex}, "create a complex filtergraph", "graph_description" },
2252     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
2253     { "attach", HAS_ARG | OPT_FUNC2, {.func2_arg = opt_attach}, "add an attachment to the output file", "filename" },
2254     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
2255     { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
2256
2257     /* video options */
2258     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {.func2_arg = opt_video_frames}, "set the number of video frames to record", "number" },
2259     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2260     { "s", HAS_ARG | OPT_VIDEO | OPT_SUBTITLE | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
2261     { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2262     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
2263     { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
2264     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
2265     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
2266     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
2267     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
2268     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
2269     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
2270     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
2271     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
2272     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
2273     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
2274     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
2275     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {&video_discard}, "discard threshold", "n" },
2276     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
2277     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {.func2_arg = opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
2278     { "sameq", OPT_BOOL | OPT_VIDEO, {&same_quant}, "use same quantizer as source (implies VBR)" },
2279     { "same_quant", OPT_BOOL | OPT_VIDEO, {&same_quant},
2280       "use same quantizer as source (implies VBR)" },
2281     { "timecode", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {.func2_arg = opt_timecode}, "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2282     { "pass", HAS_ARG | OPT_VIDEO, {opt_pass}, "select the pass number (1 or 2)", "n" },
2283     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
2284     { "deinterlace", OPT_EXPERT | OPT_VIDEO, {opt_deinterlace},
2285       "this option is deprecated, use the yadif filter instead" },
2286     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
2287     { "vstats", OPT_EXPERT | OPT_VIDEO, {&opt_vstats}, "dump video coding statistics to file" },
2288     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {opt_vstats_file}, "dump video coding statistics to file", "file" },
2289     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {.func2_arg = opt_video_filters}, "video filters", "filter list" },
2290     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
2291     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
2292     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
2293     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {&intra_dc_precision}, "intra_dc_precision", "precision" },
2294     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {.func2_arg = opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
2295     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {&qp_hist }, "show QP histogram" },
2296     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
2297     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {.func2_arg = opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
2298     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(forced_key_frames)}, "force key frames at specified timestamps", "timestamps" },
2299     { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
2300
2301     /* audio options */
2302     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {.func2_arg = opt_audio_frames}, "set the number of audio frames to record", "number" },
2303     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {.func2_arg = opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
2304     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
2305     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
2306     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
2307     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {.func2_arg = opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
2308     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {.func2_arg = opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
2309     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
2310     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
2311     { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {.func2_arg = opt_channel_layout}, "set channel layout", "layout" },
2312     { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {.func2_arg = opt_audio_filters}, "audio filters", "filter list" },
2313
2314     /* subtitle options */
2315     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
2316     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {.func2_arg = opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
2317     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {.func2_arg = opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
2318     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, {.off = OFFSET(fix_sub_duration)}, "fix subtitles duration" },
2319
2320     /* grab options */
2321     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
2322     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
2323     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {&input_sync}, "sync read on input", "" },
2324
2325     /* muxer options */
2326     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
2327     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
2328
2329     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
2330     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
2331     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
2332
2333     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
2334     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
2335     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
2336     { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
2337     /* data codec support */
2338     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {.func2_arg = opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
2339     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
2340
2341     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {.func_arg = opt_default}, "generic catch all option", "" },
2342     { NULL, },
2343 };