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