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