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