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