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