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