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