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