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