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