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