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