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