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