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