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