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