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