2 * avconv option parsing
4 * This file is part of Libav.
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.
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.
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
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.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"
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
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;\
57 char *vstats_filename
;
59 float audio_drift_threshold
= 0.1;
60 float dts_delta_threshold
= 10;
62 int audio_volume
= 256;
63 int audio_sync_method
= 0;
64 int video_sync_method
= VSYNC_AUTO
;
65 int do_deinterlace
= 0;
71 int exit_on_error
= 0;
75 static int file_overwrite
= 0;
76 static int video_discard
= 0;
77 static int intra_dc_precision
= 8;
78 static int using_stdin
= 0;
79 static int input_sync
;
81 static void uninit_options(OptionsContext
*o
)
83 const OptionDef
*po
= options
;
86 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
88 void *dst
= (uint8_t*)o
+ po
->u
.off
;
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
);
100 } else if (po
->flags
& OPT_OFFSET
&& po
->flags
& OPT_STRING
)
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
);
112 static void init_options(OptionsContext
*o
)
114 memset(o
, 0, sizeof(*o
));
116 o
->mux_max_delay
= 0.7;
117 o
->recording_time
= INT64_MAX
;
118 o
->limit_filesize
= UINT64_MAX
;
119 o
->chapters_input_file
= INT_MAX
;
122 static double parse_frame_aspect_ratio(const char *arg
)
129 p
= strchr(arg
, ':');
131 x
= strtol(arg
, &end
, 10);
133 y
= strtol(end
+ 1, &end
, 10);
135 ar
= (double)x
/ (double)y
;
137 ar
= strtod(arg
, NULL
);
140 av_log(NULL
, AV_LOG_FATAL
, "Incorrect aspect ratio specification.\n");
146 static int opt_audio_codec(void *optctx
, const char *opt
, const char *arg
)
148 OptionsContext
*o
= optctx
;
149 return parse_option(o
, "codec:a", arg
, options
);
152 static int opt_video_codec(void *optctx
, const char *opt
, const char *arg
)
154 OptionsContext
*o
= optctx
;
155 return parse_option(o
, "codec:v", arg
, options
);
158 static int opt_subtitle_codec(void *optctx
, const char *opt
, const char *arg
)
160 OptionsContext
*o
= optctx
;
161 return parse_option(o
, "codec:s", arg
, options
);
164 static int opt_data_codec(void *optctx
, const char *opt
, const char *arg
)
166 OptionsContext
*o
= optctx
;
167 return parse_option(o
, "codec:d", arg
, options
);
170 static int opt_map(void *optctx
, const char *opt
, const char *arg
)
172 OptionsContext
*o
= optctx
;
174 int i
, negative
= 0, file_idx
;
175 int sync_file_idx
= -1, sync_stream_idx
;
183 map
= av_strdup(arg
);
185 /* parse sync stream first, just pick first matching stream */
186 if (sync
= strchr(map
, ',')) {
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
);
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) {
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
);
210 /* this mapping refers to lavfi output */
211 const char *c
= map
+ 1;
212 GROW_ARRAY(o
->stream_maps
, o
->nb_stream_maps
);
213 m
= &o
->stream_maps
[o
->nb_stream_maps
- 1];
214 m
->linklabel
= av_get_token(&c
, "]");
216 av_log(NULL
, AV_LOG_ERROR
, "Invalid output link label: %s.\n", map
);
220 file_idx
= strtol(map
, &p
, 0);
221 if (file_idx
>= nb_input_files
|| file_idx
< 0) {
222 av_log(NULL
, AV_LOG_FATAL
, "Invalid input file index: %d.\n", file_idx
);
226 /* disable some already defined maps */
227 for (i
= 0; i
< o
->nb_stream_maps
; i
++) {
228 m
= &o
->stream_maps
[i
];
229 if (file_idx
== m
->file_index
&&
230 check_stream_specifier(input_files
[m
->file_index
]->ctx
,
231 input_files
[m
->file_index
]->ctx
->streams
[m
->stream_index
],
232 *p
== ':' ? p
+ 1 : p
) > 0)
236 for (i
= 0; i
< input_files
[file_idx
]->nb_streams
; i
++) {
237 if (check_stream_specifier(input_files
[file_idx
]->ctx
, input_files
[file_idx
]->ctx
->streams
[i
],
238 *p
== ':' ? p
+ 1 : p
) <= 0)
240 GROW_ARRAY(o
->stream_maps
, o
->nb_stream_maps
);
241 m
= &o
->stream_maps
[o
->nb_stream_maps
- 1];
243 m
->file_index
= file_idx
;
246 if (sync_file_idx
>= 0) {
247 m
->sync_file_index
= sync_file_idx
;
248 m
->sync_stream_index
= sync_stream_idx
;
250 m
->sync_file_index
= file_idx
;
251 m
->sync_stream_index
= i
;
257 av_log(NULL
, AV_LOG_FATAL
, "Stream map '%s' matches no streams.\n", arg
);
265 static int opt_attach(void *optctx
, const char *opt
, const char *arg
)
267 OptionsContext
*o
= optctx
;
268 GROW_ARRAY(o
->attachments
, o
->nb_attachments
);
269 o
->attachments
[o
->nb_attachments
- 1] = arg
;
274 * Parse a metadata specifier passed as 'arg' parameter.
275 * @param arg metadata string to parse
276 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
277 * @param index for type c/p, chapter/program index is written here
278 * @param stream_spec for type s, the stream specifier is written here
280 static void parse_meta_type(char *arg
, char *type
, int *index
, const char **stream_spec
)
288 if (*(++arg
) && *arg
!= ':') {
289 av_log(NULL
, AV_LOG_FATAL
, "Invalid metadata specifier %s.\n", arg
);
292 *stream_spec
= *arg
== ':' ? arg
+ 1 : "";
297 *index
= strtol(++arg
, NULL
, 0);
300 av_log(NULL
, AV_LOG_FATAL
, "Invalid metadata type %c.\n", *arg
);
307 static int copy_metadata(char *outspec
, char *inspec
, AVFormatContext
*oc
, AVFormatContext
*ic
, OptionsContext
*o
)
309 AVDictionary
**meta_in
= NULL
;
310 AVDictionary
**meta_out
;
312 char type_in
, type_out
;
313 const char *istream_spec
= NULL
, *ostream_spec
= NULL
;
314 int idx_in
= 0, idx_out
= 0;
316 parse_meta_type(inspec
, &type_in
, &idx_in
, &istream_spec
);
317 parse_meta_type(outspec
, &type_out
, &idx_out
, &ostream_spec
);
319 if (type_in
== 'g' || type_out
== 'g')
320 o
->metadata_global_manual
= 1;
321 if (type_in
== 's' || type_out
== 's')
322 o
->metadata_streams_manual
= 1;
323 if (type_in
== 'c' || type_out
== 'c')
324 o
->metadata_chapters_manual
= 1;
326 /* ic is NULL when just disabling automatic mappings */
330 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
331 if ((index) < 0 || (index) >= (nb_elems)) {\
332 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
337 #define SET_DICT(type, meta, context, index)\
340 meta = &context->metadata;\
343 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
344 meta = &context->chapters[index]->metadata;\
347 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
348 meta = &context->programs[index]->metadata;\
351 break; /* handled separately below */ \
352 default: av_assert0(0);\
355 SET_DICT(type_in, meta_in, ic, idx_in);
356 SET_DICT(type_out
, meta_out
, oc
, idx_out
);
358 /* for input streams choose first matching stream */
359 if (type_in
== 's') {
360 for (i
= 0; i
< ic
->nb_streams
; i
++) {
361 if ((ret
= check_stream_specifier(ic
, ic
->streams
[i
], istream_spec
)) > 0) {
362 meta_in
= &ic
->streams
[i
]->metadata
;
368 av_log(NULL
, AV_LOG_FATAL
, "Stream specifier %s does not match any streams.\n", istream_spec
);
373 if (type_out
== 's') {
374 for (i
= 0; i
< oc
->nb_streams
; i
++) {
375 if ((ret
= check_stream_specifier(oc
, oc
->streams
[i
], ostream_spec
)) > 0) {
376 meta_out
= &oc
->streams
[i
]->metadata
;
377 av_dict_copy(meta_out
, *meta_in
, AV_DICT_DONT_OVERWRITE
);
382 av_dict_copy(meta_out
, *meta_in
, AV_DICT_DONT_OVERWRITE
);
387 static AVCodec
*find_codec_or_die(const char *name
, enum AVMediaType type
, int encoder
)
389 const AVCodecDescriptor
*desc
;
390 const char *codec_string
= encoder
? "encoder" : "decoder";
394 avcodec_find_encoder_by_name(name
) :
395 avcodec_find_decoder_by_name(name
);
397 if (!codec
&& (desc
= avcodec_descriptor_get_by_name(name
))) {
398 codec
= encoder
? avcodec_find_encoder(desc
->id
) :
399 avcodec_find_decoder(desc
->id
);
401 av_log(NULL
, AV_LOG_VERBOSE
, "Matched %s '%s' for codec '%s'.\n",
402 codec_string
, codec
->name
, desc
->name
);
406 av_log(NULL
, AV_LOG_FATAL
, "Unknown %s '%s'\n", codec_string
, name
);
409 if (codec
->type
!= type
) {
410 av_log(NULL
, AV_LOG_FATAL
, "Invalid %s type '%s'\n", codec_string
, name
);
416 static AVCodec
*choose_decoder(OptionsContext
*o
, AVFormatContext
*s
, AVStream
*st
)
418 char *codec_name
= NULL
;
420 MATCH_PER_STREAM_OPT(codec_names
, str
, codec_name
, s
, st
);
422 AVCodec
*codec
= find_codec_or_die(codec_name
, st
->codec
->codec_type
, 0);
423 st
->codec
->codec_id
= codec
->id
;
426 return avcodec_find_decoder(st
->codec
->codec_id
);
429 /* Add all the streams from the given input file to the global
430 * list of input streams. */
431 static void add_input_streams(OptionsContext
*o
, AVFormatContext
*ic
)
435 for (i
= 0; i
< ic
->nb_streams
; i
++) {
436 AVStream
*st
= ic
->streams
[i
];
437 AVCodecContext
*dec
= st
->codec
;
438 InputStream
*ist
= av_mallocz(sizeof(*ist
));
439 char *framerate
= NULL
;
444 GROW_ARRAY(input_streams
, nb_input_streams
);
445 input_streams
[nb_input_streams
- 1] = ist
;
448 ist
->file_index
= nb_input_files
;
450 st
->discard
= AVDISCARD_ALL
;
453 MATCH_PER_STREAM_OPT(ts_scale
, dbl
, ist
->ts_scale
, ic
, st
);
455 ist
->dec
= choose_decoder(o
, ic
, st
);
456 ist
->opts
= filter_codec_opts(o
->g
->codec_opts
, ist
->st
->codec
->codec_id
, ic
, st
, ist
->dec
);
458 switch (dec
->codec_type
) {
459 case AVMEDIA_TYPE_VIDEO
:
460 ist
->resample_height
= dec
->height
;
461 ist
->resample_width
= dec
->width
;
462 ist
->resample_pix_fmt
= dec
->pix_fmt
;
464 MATCH_PER_STREAM_OPT(frame_rates
, str
, framerate
, ic
, st
);
465 if (framerate
&& av_parse_video_rate(&ist
->framerate
,
467 av_log(NULL
, AV_LOG_ERROR
, "Error parsing framerate %s.\n",
473 case AVMEDIA_TYPE_AUDIO
:
474 guess_input_channel_layout(ist
);
476 ist
->resample_sample_fmt
= dec
->sample_fmt
;
477 ist
->resample_sample_rate
= dec
->sample_rate
;
478 ist
->resample_channels
= dec
->channels
;
479 ist
->resample_channel_layout
= dec
->channel_layout
;
482 case AVMEDIA_TYPE_DATA
:
483 case AVMEDIA_TYPE_SUBTITLE
:
484 case AVMEDIA_TYPE_ATTACHMENT
:
485 case AVMEDIA_TYPE_UNKNOWN
:
493 static void assert_file_overwrite(const char *filename
)
495 if (!file_overwrite
&&
496 (strchr(filename
, ':') == NULL
|| filename
[1] == ':' ||
497 av_strstart(filename
, "file:", NULL
))) {
498 if (avio_check(filename
, 0) == 0) {
500 fprintf(stderr
,"File '%s' already exists. Overwrite ? [y/N] ", filename
);
503 fprintf(stderr
, "Not overwriting - exiting\n");
508 fprintf(stderr
,"File '%s' already exists. Exiting.\n", filename
);
515 static void dump_attachment(AVStream
*st
, const char *filename
)
518 AVIOContext
*out
= NULL
;
519 AVDictionaryEntry
*e
;
521 if (!st
->codec
->extradata_size
) {
522 av_log(NULL
, AV_LOG_WARNING
, "No extradata to dump in stream #%d:%d.\n",
523 nb_input_files
- 1, st
->index
);
526 if (!*filename
&& (e
= av_dict_get(st
->metadata
, "filename", NULL
, 0)))
529 av_log(NULL
, AV_LOG_FATAL
, "No filename specified and no 'filename' tag"
530 "in stream #%d:%d.\n", nb_input_files
- 1, st
->index
);
534 assert_file_overwrite(filename
);
536 if ((ret
= avio_open2(&out
, filename
, AVIO_FLAG_WRITE
, &int_cb
, NULL
)) < 0) {
537 av_log(NULL
, AV_LOG_FATAL
, "Could not open file %s for writing.\n",
542 avio_write(out
, st
->codec
->extradata
, st
->codec
->extradata_size
);
547 static int open_input_file(OptionsContext
*o
, const char *filename
)
550 AVInputFormat
*file_iformat
= NULL
;
555 int orig_nb_streams
; // number of streams before avformat_find_stream_info
558 if (!(file_iformat
= av_find_input_format(o
->format
))) {
559 av_log(NULL
, AV_LOG_FATAL
, "Unknown input format: '%s'\n", o
->format
);
564 if (!strcmp(filename
, "-"))
567 using_stdin
|= !strncmp(filename
, "pipe:", 5) ||
568 !strcmp(filename
, "/dev/stdin");
570 /* get default parameters from command line */
571 ic
= avformat_alloc_context();
573 print_error(filename
, AVERROR(ENOMEM
));
576 if (o
->nb_audio_sample_rate
) {
577 snprintf(buf
, sizeof(buf
), "%d", o
->audio_sample_rate
[o
->nb_audio_sample_rate
- 1].u
.i
);
578 av_dict_set(&o
->g
->format_opts
, "sample_rate", buf
, 0);
580 if (o
->nb_audio_channels
) {
581 /* because we set audio_channels based on both the "ac" and
582 * "channel_layout" options, we need to check that the specified
583 * demuxer actually has the "channels" option before setting it */
584 if (file_iformat
&& file_iformat
->priv_class
&&
585 av_opt_find(&file_iformat
->priv_class
, "channels", NULL
, 0,
586 AV_OPT_SEARCH_FAKE_OBJ
)) {
587 snprintf(buf
, sizeof(buf
), "%d",
588 o
->audio_channels
[o
->nb_audio_channels
- 1].u
.i
);
589 av_dict_set(&o
->g
->format_opts
, "channels", buf
, 0);
592 if (o
->nb_frame_rates
) {
593 /* set the format-level framerate option;
594 * this is important for video grabbers, e.g. x11 */
595 if (file_iformat
&& file_iformat
->priv_class
&&
596 av_opt_find(&file_iformat
->priv_class
, "framerate", NULL
, 0,
597 AV_OPT_SEARCH_FAKE_OBJ
)) {
598 av_dict_set(&o
->g
->format_opts
, "framerate",
599 o
->frame_rates
[o
->nb_frame_rates
- 1].u
.str
, 0);
602 if (o
->nb_frame_sizes
) {
603 av_dict_set(&o
->g
->format_opts
, "video_size", o
->frame_sizes
[o
->nb_frame_sizes
- 1].u
.str
, 0);
605 if (o
->nb_frame_pix_fmts
)
606 av_dict_set(&o
->g
->format_opts
, "pixel_format", o
->frame_pix_fmts
[o
->nb_frame_pix_fmts
- 1].u
.str
, 0);
608 ic
->flags
|= AVFMT_FLAG_NONBLOCK
;
609 ic
->interrupt_callback
= int_cb
;
611 /* open the input file with generic libav function */
612 err
= avformat_open_input(&ic
, filename
, file_iformat
, &o
->g
->format_opts
);
614 print_error(filename
, err
);
617 assert_avoptions(o
->g
->format_opts
);
619 /* apply forced codec ids */
620 for (i
= 0; i
< ic
->nb_streams
; i
++)
621 choose_decoder(o
, ic
, ic
->streams
[i
]);
623 /* Set AVCodecContext options for avformat_find_stream_info */
624 opts
= setup_find_stream_info_opts(ic
, o
->g
->codec_opts
);
625 orig_nb_streams
= ic
->nb_streams
;
627 /* If not enough info to get the stream parameters, we decode the
628 first frames to get it. (used in mpeg case for example) */
629 ret
= avformat_find_stream_info(ic
, opts
);
631 av_log(NULL
, AV_LOG_FATAL
, "%s: could not find codec parameters\n", filename
);
632 avformat_close_input(&ic
);
636 timestamp
= o
->start_time
;
637 /* add the stream start time */
638 if (ic
->start_time
!= AV_NOPTS_VALUE
)
639 timestamp
+= ic
->start_time
;
641 /* if seeking requested, we execute it */
642 if (o
->start_time
!= 0) {
643 ret
= av_seek_frame(ic
, -1, timestamp
, AVSEEK_FLAG_BACKWARD
);
645 av_log(NULL
, AV_LOG_WARNING
, "%s: could not seek to position %0.3f\n",
646 filename
, (double)timestamp
/ AV_TIME_BASE
);
650 /* update the current parameters so that they match the one of the input stream */
651 add_input_streams(o
, ic
);
653 /* dump the file content */
654 av_dump_format(ic
, nb_input_files
, filename
, 0);
656 GROW_ARRAY(input_files
, nb_input_files
);
657 if (!(input_files
[nb_input_files
- 1] = av_mallocz(sizeof(*input_files
[0]))))
660 input_files
[nb_input_files
- 1]->ctx
= ic
;
661 input_files
[nb_input_files
- 1]->ist_index
= nb_input_streams
- ic
->nb_streams
;
662 input_files
[nb_input_files
- 1]->ts_offset
= o
->input_ts_offset
- (copy_ts
? 0 : timestamp
);
663 input_files
[nb_input_files
- 1]->nb_streams
= ic
->nb_streams
;
664 input_files
[nb_input_files
- 1]->rate_emu
= o
->rate_emu
;
666 for (i
= 0; i
< o
->nb_dump_attachment
; i
++) {
669 for (j
= 0; j
< ic
->nb_streams
; j
++) {
670 AVStream
*st
= ic
->streams
[j
];
672 if (check_stream_specifier(ic
, st
, o
->dump_attachment
[i
].specifier
) == 1)
673 dump_attachment(st
, o
->dump_attachment
[i
].u
.str
);
677 for (i
= 0; i
< orig_nb_streams
; i
++)
678 av_dict_free(&opts
[i
]);
684 static uint8_t *get_line(AVIOContext
*s
)
690 if (avio_open_dyn_buf(&line
) < 0) {
691 av_log(NULL
, AV_LOG_FATAL
, "Could not alloc buffer for reading preset.\n");
695 while ((c
= avio_r8(s
)) && c
!= '\n')
698 avio_close_dyn_buf(line
, &buf
);
703 static int get_preset_file_2(const char *preset_name
, const char *codec_name
, AVIOContext
**s
)
707 const char *base
[3] = { getenv("AVCONV_DATADIR"),
712 for (i
= 0; i
< FF_ARRAY_ELEMS(base
) && ret
; i
++) {
716 snprintf(filename
, sizeof(filename
), "%s%s/%s-%s.avpreset", base
[i
],
717 i
!= 1 ? "" : "/.avconv", codec_name
, preset_name
);
718 ret
= avio_open2(s
, filename
, AVIO_FLAG_READ
, &int_cb
, NULL
);
721 snprintf(filename
, sizeof(filename
), "%s%s/%s.avpreset", base
[i
],
722 i
!= 1 ? "" : "/.avconv", preset_name
);
723 ret
= avio_open2(s
, filename
, AVIO_FLAG_READ
, &int_cb
, NULL
);
729 static void choose_encoder(OptionsContext
*o
, AVFormatContext
*s
, OutputStream
*ost
)
731 char *codec_name
= NULL
;
733 MATCH_PER_STREAM_OPT(codec_names
, str
, codec_name
, s
, ost
->st
);
735 ost
->st
->codec
->codec_id
= av_guess_codec(s
->oformat
, NULL
, s
->filename
,
736 NULL
, ost
->st
->codec
->codec_type
);
737 ost
->enc
= avcodec_find_encoder(ost
->st
->codec
->codec_id
);
738 } else if (!strcmp(codec_name
, "copy"))
739 ost
->stream_copy
= 1;
741 ost
->enc
= find_codec_or_die(codec_name
, ost
->st
->codec
->codec_type
, 1);
742 ost
->st
->codec
->codec_id
= ost
->enc
->id
;
746 static OutputStream
*new_output_stream(OptionsContext
*o
, AVFormatContext
*oc
, enum AVMediaType type
)
749 AVStream
*st
= avformat_new_stream(oc
, NULL
);
750 int idx
= oc
->nb_streams
- 1, ret
= 0;
751 char *bsf
= NULL
, *next
, *codec_tag
= NULL
;
752 AVBitStreamFilterContext
*bsfc
, *bsfc_prev
= NULL
;
756 av_log(NULL
, AV_LOG_FATAL
, "Could not alloc stream.\n");
760 if (oc
->nb_streams
- 1 < o
->nb_streamid_map
)
761 st
->id
= o
->streamid_map
[oc
->nb_streams
- 1];
763 GROW_ARRAY(output_streams
, nb_output_streams
);
764 if (!(ost
= av_mallocz(sizeof(*ost
))))
766 output_streams
[nb_output_streams
- 1] = ost
;
768 ost
->file_index
= nb_output_files
;
771 st
->codec
->codec_type
= type
;
772 choose_encoder(o
, oc
, ost
);
774 AVIOContext
*s
= NULL
;
775 char *buf
= NULL
, *arg
= NULL
, *preset
= NULL
;
777 ost
->opts
= filter_codec_opts(o
->g
->codec_opts
, ost
->enc
->id
, oc
, st
, ost
->enc
);
779 MATCH_PER_STREAM_OPT(presets
, str
, preset
, oc
, st
);
780 if (preset
&& (!(ret
= get_preset_file_2(preset
, ost
->enc
->name
, &s
)))) {
783 if (!buf
[0] || buf
[0] == '#') {
787 if (!(arg
= strchr(buf
, '='))) {
788 av_log(NULL
, AV_LOG_FATAL
, "Invalid line found in the preset file.\n");
792 av_dict_set(&ost
->opts
, buf
, arg
, AV_DICT_DONT_OVERWRITE
);
794 } while (!s
->eof_reached
);
798 av_log(NULL
, AV_LOG_FATAL
,
799 "Preset %s specified for stream %d:%d, but could not be opened.\n",
800 preset
, ost
->file_index
, ost
->index
);
805 avcodec_get_context_defaults3(st
->codec
, ost
->enc
);
806 st
->codec
->codec_type
= type
; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
808 ost
->max_frames
= INT64_MAX
;
809 MATCH_PER_STREAM_OPT(max_frames
, i64
, ost
->max_frames
, oc
, st
);
811 MATCH_PER_STREAM_OPT(bitstream_filters
, str
, bsf
, oc
, st
);
813 if (next
= strchr(bsf
, ','))
815 if (!(bsfc
= av_bitstream_filter_init(bsf
))) {
816 av_log(NULL
, AV_LOG_FATAL
, "Unknown bitstream filter %s\n", bsf
);
820 bsfc_prev
->next
= bsfc
;
822 ost
->bitstream_filters
= bsfc
;
828 MATCH_PER_STREAM_OPT(codec_tags
, str
, codec_tag
, oc
, st
);
830 uint32_t tag
= strtol(codec_tag
, &next
, 0);
832 tag
= AV_RL32(codec_tag
);
833 st
->codec
->codec_tag
= tag
;
836 MATCH_PER_STREAM_OPT(qscale
, dbl
, qscale
, oc
, st
);
838 st
->codec
->flags
|= CODEC_FLAG_QSCALE
;
839 st
->codec
->global_quality
= FF_QP2LAMBDA
* qscale
;
842 if (oc
->oformat
->flags
& AVFMT_GLOBALHEADER
)
843 st
->codec
->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
845 av_opt_get_int(o
->g
->sws_opts
, "sws_flags", 0, &ost
->sws_flags
);
847 ost
->pix_fmts
[0] = ost
->pix_fmts
[1] = AV_PIX_FMT_NONE
;
852 static void parse_matrix_coeffs(uint16_t *dest
, const char *str
)
862 av_log(NULL
, AV_LOG_FATAL
, "Syntax error in matrix \"%s\" at coeff %d\n", str
, i
);
869 static OutputStream
*new_video_stream(OptionsContext
*o
, AVFormatContext
*oc
)
873 AVCodecContext
*video_enc
;
875 ost
= new_output_stream(o
, oc
, AVMEDIA_TYPE_VIDEO
);
877 video_enc
= st
->codec
;
879 if (!ost
->stream_copy
) {
880 const char *p
= NULL
;
881 char *frame_rate
= NULL
, *frame_size
= NULL
;
882 char *frame_aspect_ratio
= NULL
, *frame_pix_fmt
= NULL
;
883 char *intra_matrix
= NULL
, *inter_matrix
= NULL
;
884 const char *filters
= "null";
888 MATCH_PER_STREAM_OPT(frame_rates
, str
, frame_rate
, oc
, st
);
889 if (frame_rate
&& av_parse_video_rate(&ost
->frame_rate
, frame_rate
) < 0) {
890 av_log(NULL
, AV_LOG_FATAL
, "Invalid framerate value: %s\n", frame_rate
);
894 MATCH_PER_STREAM_OPT(frame_sizes
, str
, frame_size
, oc
, st
);
895 if (frame_size
&& av_parse_video_size(&video_enc
->width
, &video_enc
->height
, frame_size
) < 0) {
896 av_log(NULL
, AV_LOG_FATAL
, "Invalid frame size: %s.\n", frame_size
);
900 MATCH_PER_STREAM_OPT(frame_aspect_ratios
, str
, frame_aspect_ratio
, oc
, st
);
901 if (frame_aspect_ratio
)
902 ost
->frame_aspect_ratio
= parse_frame_aspect_ratio(frame_aspect_ratio
);
904 MATCH_PER_STREAM_OPT(frame_pix_fmts
, str
, frame_pix_fmt
, oc
, st
);
905 if (frame_pix_fmt
&& (video_enc
->pix_fmt
= av_get_pix_fmt(frame_pix_fmt
)) == AV_PIX_FMT_NONE
) {
906 av_log(NULL
, AV_LOG_FATAL
, "Unknown pixel format requested: %s.\n", frame_pix_fmt
);
909 st
->sample_aspect_ratio
= video_enc
->sample_aspect_ratio
;
911 MATCH_PER_STREAM_OPT(intra_matrices
, str
, intra_matrix
, oc
, st
);
913 if (!(video_enc
->intra_matrix
= av_mallocz(sizeof(*video_enc
->intra_matrix
) * 64))) {
914 av_log(NULL
, AV_LOG_FATAL
, "Could not allocate memory for intra matrix.\n");
917 parse_matrix_coeffs(video_enc
->intra_matrix
, intra_matrix
);
919 MATCH_PER_STREAM_OPT(inter_matrices
, str
, inter_matrix
, oc
, st
);
921 if (!(video_enc
->inter_matrix
= av_mallocz(sizeof(*video_enc
->inter_matrix
) * 64))) {
922 av_log(NULL
, AV_LOG_FATAL
, "Could not allocate memory for inter matrix.\n");
925 parse_matrix_coeffs(video_enc
->inter_matrix
, inter_matrix
);
928 MATCH_PER_STREAM_OPT(rc_overrides
, str
, p
, oc
, st
);
929 for (i
= 0; p
; i
++) {
931 int e
= sscanf(p
, "%d,%d,%d", &start
, &end
, &q
);
933 av_log(NULL
, AV_LOG_FATAL
, "error parsing rc_override\n");
936 video_enc
->rc_override
=
937 av_realloc(video_enc
->rc_override
,
938 sizeof(RcOverride
) * (i
+ 1));
939 video_enc
->rc_override
[i
].start_frame
= start
;
940 video_enc
->rc_override
[i
].end_frame
= end
;
942 video_enc
->rc_override
[i
].qscale
= q
;
943 video_enc
->rc_override
[i
].quality_factor
= 1.0;
946 video_enc
->rc_override
[i
].qscale
= 0;
947 video_enc
->rc_override
[i
].quality_factor
= -q
/100.0;
952 video_enc
->rc_override_count
= i
;
953 if (!video_enc
->rc_initial_buffer_occupancy
)
954 video_enc
->rc_initial_buffer_occupancy
= video_enc
->rc_buffer_size
* 3 / 4;
955 video_enc
->intra_dc_precision
= intra_dc_precision
- 8;
958 MATCH_PER_STREAM_OPT(pass
, i
, do_pass
, oc
, st
);
961 video_enc
->flags
|= CODEC_FLAG_PASS1
;
963 video_enc
->flags
|= CODEC_FLAG_PASS2
;
967 MATCH_PER_STREAM_OPT(passlogfiles
, str
, ost
->logfile_prefix
, oc
, st
);
968 if (ost
->logfile_prefix
&&
969 !(ost
->logfile_prefix
= av_strdup(ost
->logfile_prefix
)))
972 MATCH_PER_STREAM_OPT(forced_key_frames
, str
, ost
->forced_keyframes
, oc
, st
);
973 if (ost
->forced_keyframes
)
974 ost
->forced_keyframes
= av_strdup(ost
->forced_keyframes
);
976 MATCH_PER_STREAM_OPT(force_fps
, i
, ost
->force_fps
, oc
, st
);
978 ost
->top_field_first
= -1;
979 MATCH_PER_STREAM_OPT(top_field_first
, i
, ost
->top_field_first
, oc
, st
);
981 MATCH_PER_STREAM_OPT(filters
, str
, filters
, oc
, st
);
982 ost
->avfilter
= av_strdup(filters
);
984 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes
, i
, ost
->copy_initial_nonkeyframes
, oc
,st
);
990 static OutputStream
*new_audio_stream(OptionsContext
*o
, AVFormatContext
*oc
)
994 AVCodecContext
*audio_enc
;
996 ost
= new_output_stream(o
, oc
, AVMEDIA_TYPE_AUDIO
);
999 audio_enc
= st
->codec
;
1000 audio_enc
->codec_type
= AVMEDIA_TYPE_AUDIO
;
1002 if (!ost
->stream_copy
) {
1003 char *sample_fmt
= NULL
;
1004 const char *filters
= "anull";
1006 MATCH_PER_STREAM_OPT(audio_channels
, i
, audio_enc
->channels
, oc
, st
);
1008 MATCH_PER_STREAM_OPT(sample_fmts
, str
, sample_fmt
, oc
, st
);
1010 (audio_enc
->sample_fmt
= av_get_sample_fmt(sample_fmt
)) == AV_SAMPLE_FMT_NONE
) {
1011 av_log(NULL
, AV_LOG_FATAL
, "Invalid sample format '%s'\n", sample_fmt
);
1015 MATCH_PER_STREAM_OPT(audio_sample_rate
, i
, audio_enc
->sample_rate
, oc
, st
);
1017 MATCH_PER_STREAM_OPT(filters
, str
, filters
, oc
, st
);
1018 ost
->avfilter
= av_strdup(filters
);
1024 static OutputStream
*new_data_stream(OptionsContext
*o
, AVFormatContext
*oc
)
1028 ost
= new_output_stream(o
, oc
, AVMEDIA_TYPE_DATA
);
1029 if (!ost
->stream_copy
) {
1030 av_log(NULL
, AV_LOG_FATAL
, "Data stream encoding not supported yet (only streamcopy)\n");
1037 static OutputStream
*new_attachment_stream(OptionsContext
*o
, AVFormatContext
*oc
)
1039 OutputStream
*ost
= new_output_stream(o
, oc
, AVMEDIA_TYPE_ATTACHMENT
);
1040 ost
->stream_copy
= 1;
1044 static OutputStream
*new_subtitle_stream(OptionsContext
*o
, AVFormatContext
*oc
)
1048 AVCodecContext
*subtitle_enc
;
1050 ost
= new_output_stream(o
, oc
, AVMEDIA_TYPE_SUBTITLE
);
1052 subtitle_enc
= st
->codec
;
1054 subtitle_enc
->codec_type
= AVMEDIA_TYPE_SUBTITLE
;
1059 /* arg format is "output-stream-index:streamid-value". */
1060 static int opt_streamid(void *optctx
, const char *opt
, const char *arg
)
1062 OptionsContext
*o
= optctx
;
1067 av_strlcpy(idx_str
, arg
, sizeof(idx_str
));
1068 p
= strchr(idx_str
, ':');
1070 av_log(NULL
, AV_LOG_FATAL
,
1071 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1076 idx
= parse_number_or_die(opt
, idx_str
, OPT_INT
, 0, INT_MAX
);
1077 o
->streamid_map
= grow_array(o
->streamid_map
, sizeof(*o
->streamid_map
), &o
->nb_streamid_map
, idx
+1);
1078 o
->streamid_map
[idx
] = parse_number_or_die(opt
, p
, OPT_INT
, 0, INT_MAX
);
1082 static int copy_chapters(InputFile
*ifile
, OutputFile
*ofile
, int copy_metadata
)
1084 AVFormatContext
*is
= ifile
->ctx
;
1085 AVFormatContext
*os
= ofile
->ctx
;
1089 tmp
= av_realloc(os
->chapters
, sizeof(*os
->chapters
) * (is
->nb_chapters
+ os
->nb_chapters
));
1091 return AVERROR(ENOMEM
);
1094 for (i
= 0; i
< is
->nb_chapters
; i
++) {
1095 AVChapter
*in_ch
= is
->chapters
[i
], *out_ch
;
1096 int64_t ts_off
= av_rescale_q(ofile
->start_time
- ifile
->ts_offset
,
1097 AV_TIME_BASE_Q
, in_ch
->time_base
);
1098 int64_t rt
= (ofile
->recording_time
== INT64_MAX
) ? INT64_MAX
:
1099 av_rescale_q(ofile
->recording_time
, AV_TIME_BASE_Q
, in_ch
->time_base
);
1102 if (in_ch
->end
< ts_off
)
1104 if (rt
!= INT64_MAX
&& in_ch
->start
> rt
+ ts_off
)
1107 out_ch
= av_mallocz(sizeof(AVChapter
));
1109 return AVERROR(ENOMEM
);
1111 out_ch
->id
= in_ch
->id
;
1112 out_ch
->time_base
= in_ch
->time_base
;
1113 out_ch
->start
= FFMAX(0, in_ch
->start
- ts_off
);
1114 out_ch
->end
= FFMIN(rt
, in_ch
->end
- ts_off
);
1117 av_dict_copy(&out_ch
->metadata
, in_ch
->metadata
, 0);
1119 os
->chapters
[os
->nb_chapters
++] = out_ch
;
1124 static void init_output_filter(OutputFilter
*ofilter
, OptionsContext
*o
,
1125 AVFormatContext
*oc
)
1129 switch (avfilter_pad_get_type(ofilter
->out_tmp
->filter_ctx
->output_pads
,
1130 ofilter
->out_tmp
->pad_idx
)) {
1131 case AVMEDIA_TYPE_VIDEO
: ost
= new_video_stream(o
, oc
); break;
1132 case AVMEDIA_TYPE_AUDIO
: ost
= new_audio_stream(o
, oc
); break;
1134 av_log(NULL
, AV_LOG_FATAL
, "Only video and audio filters are supported "
1139 ost
->source_index
= -1;
1140 ost
->filter
= ofilter
;
1144 if (ost
->stream_copy
) {
1145 av_log(NULL
, AV_LOG_ERROR
, "Streamcopy requested for output stream %d:%d, "
1146 "which is fed from a complex filtergraph. Filtering and streamcopy "
1147 "cannot be used together.\n", ost
->file_index
, ost
->index
);
1151 if (configure_output_filter(ofilter
->graph
, ofilter
, ofilter
->out_tmp
) < 0) {
1152 av_log(NULL
, AV_LOG_FATAL
, "Error configuring filter.\n");
1155 avfilter_inout_free(&ofilter
->out_tmp
);
1158 static int configure_complex_filters(void)
1162 for (i
= 0; i
< nb_filtergraphs
; i
++)
1163 if (!filtergraphs
[i
]->graph
&&
1164 (ret
= configure_filtergraph(filtergraphs
[i
])) < 0)
1169 static int open_output_file(OptionsContext
*o
, const char *filename
)
1171 AVFormatContext
*oc
;
1173 AVOutputFormat
*file_oformat
;
1177 if (configure_complex_filters() < 0) {
1178 av_log(NULL
, AV_LOG_FATAL
, "Error configuring filters.\n");
1182 if (!strcmp(filename
, "-"))
1185 oc
= avformat_alloc_context();
1187 print_error(filename
, AVERROR(ENOMEM
));
1192 file_oformat
= av_guess_format(o
->format
, NULL
, NULL
);
1193 if (!file_oformat
) {
1194 av_log(NULL
, AV_LOG_FATAL
, "Requested output format '%s' is not a suitable output format\n", o
->format
);
1198 file_oformat
= av_guess_format(NULL
, filename
, NULL
);
1199 if (!file_oformat
) {
1200 av_log(NULL
, AV_LOG_FATAL
, "Unable to find a suitable output format for '%s'\n",
1206 oc
->oformat
= file_oformat
;
1207 oc
->interrupt_callback
= int_cb
;
1208 av_strlcpy(oc
->filename
, filename
, sizeof(oc
->filename
));
1210 /* create streams for all unlabeled output pads */
1211 for (i
= 0; i
< nb_filtergraphs
; i
++) {
1212 FilterGraph
*fg
= filtergraphs
[i
];
1213 for (j
= 0; j
< fg
->nb_outputs
; j
++) {
1214 OutputFilter
*ofilter
= fg
->outputs
[j
];
1216 if (!ofilter
->out_tmp
|| ofilter
->out_tmp
->name
)
1219 switch (avfilter_pad_get_type(ofilter
->out_tmp
->filter_ctx
->output_pads
,
1220 ofilter
->out_tmp
->pad_idx
)) {
1221 case AVMEDIA_TYPE_VIDEO
: o
->video_disable
= 1; break;
1222 case AVMEDIA_TYPE_AUDIO
: o
->audio_disable
= 1; break;
1223 case AVMEDIA_TYPE_SUBTITLE
: o
->subtitle_disable
= 1; break;
1225 init_output_filter(ofilter
, o
, oc
);
1229 if (!o
->nb_stream_maps
) {
1230 /* pick the "best" stream of each type */
1231 #define NEW_STREAM(type, index)\
1233 ost = new_ ## type ## _stream(o, oc);\
1234 ost->source_index = index;\
1235 ost->sync_ist = input_streams[index];\
1236 input_streams[index]->discard = 0;\
1237 input_streams[index]->st->discard = AVDISCARD_NONE;\
1240 /* video: highest resolution */
1241 if (!o
->video_disable
&& oc
->oformat
->video_codec
!= AV_CODEC_ID_NONE
) {
1242 int area
= 0, idx
= -1;
1243 for (i
= 0; i
< nb_input_streams
; i
++) {
1244 ist
= input_streams
[i
];
1245 if (ist
->st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
&&
1246 ist
->st
->codec
->width
* ist
->st
->codec
->height
> area
) {
1247 area
= ist
->st
->codec
->width
* ist
->st
->codec
->height
;
1251 NEW_STREAM(video
, idx
);
1254 /* audio: most channels */
1255 if (!o
->audio_disable
&& oc
->oformat
->audio_codec
!= AV_CODEC_ID_NONE
) {
1256 int channels
= 0, idx
= -1;
1257 for (i
= 0; i
< nb_input_streams
; i
++) {
1258 ist
= input_streams
[i
];
1259 if (ist
->st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
&&
1260 ist
->st
->codec
->channels
> channels
) {
1261 channels
= ist
->st
->codec
->channels
;
1265 NEW_STREAM(audio
, idx
);
1268 /* subtitles: pick first */
1269 if (!o
->subtitle_disable
&& oc
->oformat
->subtitle_codec
!= AV_CODEC_ID_NONE
) {
1270 for (i
= 0; i
< nb_input_streams
; i
++)
1271 if (input_streams
[i
]->st
->codec
->codec_type
== AVMEDIA_TYPE_SUBTITLE
) {
1272 NEW_STREAM(subtitle
, i
);
1276 /* do something with data? */
1278 for (i
= 0; i
< o
->nb_stream_maps
; i
++) {
1279 StreamMap
*map
= &o
->stream_maps
[i
];
1284 if (map
->linklabel
) {
1286 OutputFilter
*ofilter
= NULL
;
1289 for (j
= 0; j
< nb_filtergraphs
; j
++) {
1290 fg
= filtergraphs
[j
];
1291 for (k
= 0; k
< fg
->nb_outputs
; k
++) {
1292 AVFilterInOut
*out
= fg
->outputs
[k
]->out_tmp
;
1293 if (out
&& !strcmp(out
->name
, map
->linklabel
)) {
1294 ofilter
= fg
->outputs
[k
];
1301 av_log(NULL
, AV_LOG_FATAL
, "Output with label '%s' does not exist "
1302 "in any defined filter graph.\n", map
->linklabel
);
1305 init_output_filter(ofilter
, o
, oc
);
1307 ist
= input_streams
[input_files
[map
->file_index
]->ist_index
+ map
->stream_index
];
1308 switch (ist
->st
->codec
->codec_type
) {
1309 case AVMEDIA_TYPE_VIDEO
: ost
= new_video_stream(o
, oc
); break;
1310 case AVMEDIA_TYPE_AUDIO
: ost
= new_audio_stream(o
, oc
); break;
1311 case AVMEDIA_TYPE_SUBTITLE
: ost
= new_subtitle_stream(o
, oc
); break;
1312 case AVMEDIA_TYPE_DATA
: ost
= new_data_stream(o
, oc
); break;
1313 case AVMEDIA_TYPE_ATTACHMENT
: ost
= new_attachment_stream(o
, oc
); break;
1315 av_log(NULL
, AV_LOG_FATAL
, "Cannot map stream #%d:%d - unsupported type.\n",
1316 map
->file_index
, map
->stream_index
);
1320 ost
->source_index
= input_files
[map
->file_index
]->ist_index
+ map
->stream_index
;
1321 ost
->sync_ist
= input_streams
[input_files
[map
->sync_file_index
]->ist_index
+
1322 map
->sync_stream_index
];
1324 ist
->st
->discard
= AVDISCARD_NONE
;
1329 /* handle attached files */
1330 for (i
= 0; i
< o
->nb_attachments
; i
++) {
1332 uint8_t *attachment
;
1336 if ((err
= avio_open2(&pb
, o
->attachments
[i
], AVIO_FLAG_READ
, &int_cb
, NULL
)) < 0) {
1337 av_log(NULL
, AV_LOG_FATAL
, "Could not open attachment file %s.\n",
1341 if ((len
= avio_size(pb
)) <= 0) {
1342 av_log(NULL
, AV_LOG_FATAL
, "Could not get size of the attachment %s.\n",
1346 if (!(attachment
= av_malloc(len
))) {
1347 av_log(NULL
, AV_LOG_FATAL
, "Attachment %s too large to fit into memory.\n",
1351 avio_read(pb
, attachment
, len
);
1353 ost
= new_attachment_stream(o
, oc
);
1354 ost
->stream_copy
= 0;
1355 ost
->source_index
= -1;
1356 ost
->attachment_filename
= o
->attachments
[i
];
1357 ost
->st
->codec
->extradata
= attachment
;
1358 ost
->st
->codec
->extradata_size
= len
;
1360 p
= strrchr(o
->attachments
[i
], '/');
1361 av_dict_set(&ost
->st
->metadata
, "filename", (p
&& *p
) ? p
+ 1 : o
->attachments
[i
], AV_DICT_DONT_OVERWRITE
);
1365 GROW_ARRAY(output_files
, nb_output_files
);
1366 if (!(output_files
[nb_output_files
- 1] = av_mallocz(sizeof(*output_files
[0]))))
1369 output_files
[nb_output_files
- 1]->ctx
= oc
;
1370 output_files
[nb_output_files
- 1]->ost_index
= nb_output_streams
- oc
->nb_streams
;
1371 output_files
[nb_output_files
- 1]->recording_time
= o
->recording_time
;
1372 if (o
->recording_time
!= INT64_MAX
)
1373 oc
->duration
= o
->recording_time
;
1374 output_files
[nb_output_files
- 1]->start_time
= o
->start_time
;
1375 output_files
[nb_output_files
- 1]->limit_filesize
= o
->limit_filesize
;
1376 output_files
[nb_output_files
- 1]->shortest
= o
->shortest
;
1377 av_dict_copy(&output_files
[nb_output_files
- 1]->opts
, o
->g
->format_opts
, 0);
1379 /* check filename in case of an image number is expected */
1380 if (oc
->oformat
->flags
& AVFMT_NEEDNUMBER
) {
1381 if (!av_filename_number_test(oc
->filename
)) {
1382 print_error(oc
->filename
, AVERROR(EINVAL
));
1387 if (!(oc
->oformat
->flags
& AVFMT_NOFILE
)) {
1388 /* test if it already exists to avoid losing precious files */
1389 assert_file_overwrite(filename
);
1392 if ((err
= avio_open2(&oc
->pb
, filename
, AVIO_FLAG_WRITE
,
1393 &oc
->interrupt_callback
,
1394 &output_files
[nb_output_files
- 1]->opts
)) < 0) {
1395 print_error(filename
, err
);
1400 if (o
->mux_preload
) {
1402 snprintf(buf
, sizeof(buf
), "%d", (int)(o
->mux_preload
*AV_TIME_BASE
));
1403 av_dict_set(&output_files
[nb_output_files
- 1]->opts
, "preload", buf
, 0);
1405 oc
->max_delay
= (int)(o
->mux_max_delay
* AV_TIME_BASE
);
1406 oc
->flags
|= AVFMT_FLAG_NONBLOCK
;
1409 for (i
= 0; i
< o
->nb_metadata_map
; i
++) {
1411 int in_file_index
= strtol(o
->metadata_map
[i
].u
.str
, &p
, 0);
1413 if (in_file_index
>= nb_input_files
) {
1414 av_log(NULL
, AV_LOG_FATAL
, "Invalid input file index %d while processing metadata maps\n", in_file_index
);
1417 copy_metadata(o
->metadata_map
[i
].specifier
, *p
? p
+ 1 : p
, oc
,
1418 in_file_index
>= 0 ?
1419 input_files
[in_file_index
]->ctx
: NULL
, o
);
1423 if (o
->chapters_input_file
>= nb_input_files
) {
1424 if (o
->chapters_input_file
== INT_MAX
) {
1425 /* copy chapters from the first input file that has them*/
1426 o
->chapters_input_file
= -1;
1427 for (i
= 0; i
< nb_input_files
; i
++)
1428 if (input_files
[i
]->ctx
->nb_chapters
) {
1429 o
->chapters_input_file
= i
;
1433 av_log(NULL
, AV_LOG_FATAL
, "Invalid input file index %d in chapter mapping.\n",
1434 o
->chapters_input_file
);
1438 if (o
->chapters_input_file
>= 0)
1439 copy_chapters(input_files
[o
->chapters_input_file
], output_files
[nb_output_files
- 1],
1440 !o
->metadata_chapters_manual
);
1442 /* copy global metadata by default */
1443 if (!o
->metadata_global_manual
&& nb_input_files
)
1444 av_dict_copy(&oc
->metadata
, input_files
[0]->ctx
->metadata
,
1445 AV_DICT_DONT_OVERWRITE
);
1446 if (!o
->metadata_streams_manual
)
1447 for (i
= output_files
[nb_output_files
- 1]->ost_index
; i
< nb_output_streams
; i
++) {
1449 if (output_streams
[i
]->source_index
< 0) /* this is true e.g. for attached files */
1451 ist
= input_streams
[output_streams
[i
]->source_index
];
1452 av_dict_copy(&output_streams
[i
]->st
->metadata
, ist
->st
->metadata
, AV_DICT_DONT_OVERWRITE
);
1455 /* process manually set metadata */
1456 for (i
= 0; i
< o
->nb_metadata
; i
++) {
1459 const char *stream_spec
;
1460 int index
= 0, j
, ret
;
1462 val
= strchr(o
->metadata
[i
].u
.str
, '=');
1464 av_log(NULL
, AV_LOG_FATAL
, "No '=' character in metadata string %s.\n",
1465 o
->metadata
[i
].u
.str
);
1470 parse_meta_type(o
->metadata
[i
].specifier
, &type
, &index
, &stream_spec
);
1472 for (j
= 0; j
< oc
->nb_streams
; j
++) {
1473 if ((ret
= check_stream_specifier(oc
, oc
->streams
[j
], stream_spec
)) > 0) {
1474 av_dict_set(&oc
->streams
[j
]->metadata
, o
->metadata
[i
].u
.str
, *val
? val
: NULL
, 0);
1485 if (index
< 0 || index
>= oc
->nb_chapters
) {
1486 av_log(NULL
, AV_LOG_FATAL
, "Invalid chapter index %d in metadata specifier.\n", index
);
1489 m
= &oc
->chapters
[index
]->metadata
;
1492 av_log(NULL
, AV_LOG_FATAL
, "Invalid metadata specifier %s.\n", o
->metadata
[i
].specifier
);
1495 av_dict_set(m
, o
->metadata
[i
].u
.str
, *val
? val
: NULL
, 0);
1502 static int opt_target(void *optctx
, const char *opt
, const char *arg
)
1504 OptionsContext
*o
= optctx
;
1505 enum { PAL
, NTSC
, FILM
, UNKNOWN
} norm
= UNKNOWN
;
1506 static const char *const frame_rates
[] = { "25", "30000/1001", "24000/1001" };
1508 if (!strncmp(arg
, "pal-", 4)) {
1511 } else if (!strncmp(arg
, "ntsc-", 5)) {
1514 } else if (!strncmp(arg
, "film-", 5)) {
1518 /* Try to determine PAL/NTSC by peeking in the input files */
1519 if (nb_input_files
) {
1521 for (j
= 0; j
< nb_input_files
; j
++) {
1522 for (i
= 0; i
< input_files
[j
]->nb_streams
; i
++) {
1523 AVCodecContext
*c
= input_files
[j
]->ctx
->streams
[i
]->codec
;
1524 if (c
->codec_type
!= AVMEDIA_TYPE_VIDEO
)
1526 fr
= c
->time_base
.den
* 1000 / c
->time_base
.num
;
1530 } else if ((fr
== 29970) || (fr
== 23976)) {
1535 if (norm
!= UNKNOWN
)
1539 if (norm
!= UNKNOWN
)
1540 av_log(NULL
, AV_LOG_INFO
, "Assuming %s for target.\n", norm
== PAL
? "PAL" : "NTSC");
1543 if (norm
== UNKNOWN
) {
1544 av_log(NULL
, AV_LOG_FATAL
, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1545 av_log(NULL
, AV_LOG_FATAL
, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1546 av_log(NULL
, AV_LOG_FATAL
, "or set a framerate with \"-r xxx\".\n");
1550 if (!strcmp(arg
, "vcd")) {
1551 opt_video_codec(o
, "c:v", "mpeg1video");
1552 opt_audio_codec(o
, "c:a", "mp2");
1553 parse_option(o
, "f", "vcd", options
);
1555 parse_option(o
, "s", norm
== PAL
? "352x288" : "352x240", options
);
1556 parse_option(o
, "r", frame_rates
[norm
], options
);
1557 opt_default(NULL
, "g", norm
== PAL
? "15" : "18");
1559 opt_default(NULL
, "b", "1150000");
1560 opt_default(NULL
, "maxrate", "1150000");
1561 opt_default(NULL
, "minrate", "1150000");
1562 opt_default(NULL
, "bufsize", "327680"); // 40*1024*8;
1564 opt_default(NULL
, "b:a", "224000");
1565 parse_option(o
, "ar", "44100", options
);
1566 parse_option(o
, "ac", "2", options
);
1568 opt_default(NULL
, "packetsize", "2324");
1569 opt_default(NULL
, "muxrate", "1411200"); // 2352 * 75 * 8;
1571 /* We have to offset the PTS, so that it is consistent with the SCR.
1572 SCR starts at 36000, but the first two packs contain only padding
1573 and the first pack from the other stream, respectively, may also have
1574 been written before.
1575 So the real data starts at SCR 36000+3*1200. */
1576 o
->mux_preload
= (36000 + 3 * 1200) / 90000.0; // 0.44
1577 } else if (!strcmp(arg
, "svcd")) {
1579 opt_video_codec(o
, "c:v", "mpeg2video");
1580 opt_audio_codec(o
, "c:a", "mp2");
1581 parse_option(o
, "f", "svcd", options
);
1583 parse_option(o
, "s", norm
== PAL
? "480x576" : "480x480", options
);
1584 parse_option(o
, "r", frame_rates
[norm
], options
);
1585 opt_default(NULL
, "g", norm
== PAL
? "15" : "18");
1587 opt_default(NULL
, "b", "2040000");
1588 opt_default(NULL
, "maxrate", "2516000");
1589 opt_default(NULL
, "minrate", "0"); // 1145000;
1590 opt_default(NULL
, "bufsize", "1835008"); // 224*1024*8;
1591 opt_default(NULL
, "flags", "+scan_offset");
1594 opt_default(NULL
, "b:a", "224000");
1595 parse_option(o
, "ar", "44100", options
);
1597 opt_default(NULL
, "packetsize", "2324");
1599 } else if (!strcmp(arg
, "dvd")) {
1601 opt_video_codec(o
, "c:v", "mpeg2video");
1602 opt_audio_codec(o
, "c:a", "ac3");
1603 parse_option(o
, "f", "dvd", options
);
1605 parse_option(o
, "s", norm
== PAL
? "720x576" : "720x480", options
);
1606 parse_option(o
, "r", frame_rates
[norm
], options
);
1607 opt_default(NULL
, "g", norm
== PAL
? "15" : "18");
1609 opt_default(NULL
, "b", "6000000");
1610 opt_default(NULL
, "maxrate", "9000000");
1611 opt_default(NULL
, "minrate", "0"); // 1500000;
1612 opt_default(NULL
, "bufsize", "1835008"); // 224*1024*8;
1614 opt_default(NULL
, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1615 opt_default(NULL
, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1617 opt_default(NULL
, "b:a", "448000");
1618 parse_option(o
, "ar", "48000", options
);
1620 } else if (!strncmp(arg
, "dv", 2)) {
1622 parse_option(o
, "f", "dv", options
);
1624 parse_option(o
, "s", norm
== PAL
? "720x576" : "720x480", options
);
1625 parse_option(o
, "pix_fmt", !strncmp(arg
, "dv50", 4) ? "yuv422p" :
1626 norm
== PAL
? "yuv420p" : "yuv411p", options
);
1627 parse_option(o
, "r", frame_rates
[norm
], options
);
1629 parse_option(o
, "ar", "48000", options
);
1630 parse_option(o
, "ac", "2", options
);
1633 av_log(NULL
, AV_LOG_ERROR
, "Unknown target: %s\n", arg
);
1634 return AVERROR(EINVAL
);
1639 static int opt_vstats_file(void *optctx
, const char *opt
, const char *arg
)
1641 av_free (vstats_filename
);
1642 vstats_filename
= av_strdup (arg
);
1646 static int opt_vstats(void *optctx
, const char *opt
, const char *arg
)
1649 time_t today2
= time(NULL
);
1650 struct tm
*today
= localtime(&today2
);
1652 snprintf(filename
, sizeof(filename
), "vstats_%02d%02d%02d.log", today
->tm_hour
, today
->tm_min
,
1654 return opt_vstats_file(NULL
, opt
, filename
);
1657 static int opt_video_frames(void *optctx
, const char *opt
, const char *arg
)
1659 OptionsContext
*o
= optctx
;
1660 return parse_option(o
, "frames:v", arg
, options
);
1663 static int opt_audio_frames(void *optctx
, const char *opt
, const char *arg
)
1665 OptionsContext
*o
= optctx
;
1666 return parse_option(o
, "frames:a", arg
, options
);
1669 static int opt_data_frames(void *optctx
, const char *opt
, const char *arg
)
1671 OptionsContext
*o
= optctx
;
1672 return parse_option(o
, "frames:d", arg
, options
);
1675 static int opt_video_tag(void *optctx
, const char *opt
, const char *arg
)
1677 OptionsContext
*o
= optctx
;
1678 return parse_option(o
, "tag:v", arg
, options
);
1681 static int opt_audio_tag(void *optctx
, const char *opt
, const char *arg
)
1683 OptionsContext
*o
= optctx
;
1684 return parse_option(o
, "tag:a", arg
, options
);
1687 static int opt_subtitle_tag(void *optctx
, const char *opt
, const char *arg
)
1689 OptionsContext
*o
= optctx
;
1690 return parse_option(o
, "tag:s", arg
, options
);
1693 static int opt_video_filters(void *optctx
, const char *opt
, const char *arg
)
1695 OptionsContext
*o
= optctx
;
1696 return parse_option(o
, "filter:v", arg
, options
);
1699 static int opt_audio_filters(void *optctx
, const char *opt
, const char *arg
)
1701 OptionsContext
*o
= optctx
;
1702 return parse_option(o
, "filter:a", arg
, options
);
1705 static int opt_vsync(void *optctx
, const char *opt
, const char *arg
)
1707 if (!av_strcasecmp(arg
, "cfr")) video_sync_method
= VSYNC_CFR
;
1708 else if (!av_strcasecmp(arg
, "vfr")) video_sync_method
= VSYNC_VFR
;
1709 else if (!av_strcasecmp(arg
, "passthrough")) video_sync_method
= VSYNC_PASSTHROUGH
;
1711 if (video_sync_method
== VSYNC_AUTO
)
1712 video_sync_method
= parse_number_or_die("vsync", arg
, OPT_INT
, VSYNC_AUTO
, VSYNC_VFR
);
1716 static int opt_deinterlace(void *optctx
, const char *opt
, const char *arg
)
1718 av_log(NULL
, AV_LOG_WARNING
, "-%s is deprecated, use -filter:v yadif instead\n", opt
);
1723 int opt_cpuflags(void *optctx
, const char *opt
, const char *arg
)
1725 int flags
= av_parse_cpu_flags(arg
);
1730 av_set_cpu_flags_mask(flags
);
1734 static int opt_channel_layout(void *optctx
, const char *opt
, const char *arg
)
1736 OptionsContext
*o
= optctx
;
1737 char layout_str
[32];
1740 int ret
, channels
, ac_str_size
;
1743 layout
= av_get_channel_layout(arg
);
1745 av_log(NULL
, AV_LOG_ERROR
, "Unknown channel layout: %s\n", arg
);
1746 return AVERROR(EINVAL
);
1748 snprintf(layout_str
, sizeof(layout_str
), "%"PRIu64
, layout
);
1749 ret
= opt_default(NULL
, opt
, layout_str
);
1753 /* set 'ac' option based on channel layout */
1754 channels
= av_get_channel_layout_nb_channels(layout
);
1755 snprintf(layout_str
, sizeof(layout_str
), "%d", channels
);
1756 stream_str
= strchr(opt
, ':');
1757 ac_str_size
= 3 + (stream_str
? strlen(stream_str
) : 0);
1758 ac_str
= av_mallocz(ac_str_size
);
1760 return AVERROR(ENOMEM
);
1761 av_strlcpy(ac_str
, "ac", 3);
1763 av_strlcat(ac_str
, stream_str
, ac_str_size
);
1764 ret
= parse_option(o
, ac_str
, layout_str
, options
);
1770 static int opt_audio_qscale(void *optctx
, const char *opt
, const char *arg
)
1772 OptionsContext
*o
= optctx
;
1773 return parse_option(o
, "q:a", arg
, options
);
1776 static int opt_filter_complex(void *optctx
, const char *opt
, const char *arg
)
1778 GROW_ARRAY(filtergraphs
, nb_filtergraphs
);
1779 if (!(filtergraphs
[nb_filtergraphs
- 1] = av_mallocz(sizeof(*filtergraphs
[0]))))
1780 return AVERROR(ENOMEM
);
1781 filtergraphs
[nb_filtergraphs
- 1]->index
= nb_filtergraphs
- 1;
1782 filtergraphs
[nb_filtergraphs
- 1]->graph_desc
= arg
;
1786 void show_help_default(const char *opt
, const char *arg
)
1788 /* per-file options have at least one of those set */
1789 const int per_file
= OPT_SPEC
| OPT_OFFSET
| OPT_PERFILE
;
1790 int show_advanced
= 0, show_avoptions
= 0;
1793 if (!strcmp(opt
, "long"))
1795 else if (!strcmp(opt
, "full"))
1796 show_advanced
= show_avoptions
= 1;
1798 av_log(NULL
, AV_LOG_ERROR
, "Unknown help option '%s'.\n", opt
);
1803 printf("Getting help:\n"
1804 " -h -- print basic options\n"
1805 " -h long -- print more options\n"
1806 " -h full -- print all options (including all format and codec specific options, very long)\n"
1807 " See man %s for detailed description of the options.\n"
1808 "\n", program_name
);
1810 show_help_options(options
, "Print help / information / capabilities:",
1813 show_help_options(options
, "Global options (affect whole program "
1814 "instead of just one file:",
1815 0, per_file
| OPT_EXIT
| OPT_EXPERT
, 0);
1817 show_help_options(options
, "Advanced global options:", OPT_EXPERT
,
1818 per_file
| OPT_EXIT
, 0);
1820 show_help_options(options
, "Per-file main options:", 0,
1821 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_SUBTITLE
|
1822 OPT_EXIT
, per_file
);
1824 show_help_options(options
, "Advanced per-file options:",
1825 OPT_EXPERT
, OPT_AUDIO
| OPT_VIDEO
| OPT_SUBTITLE
, per_file
);
1827 show_help_options(options
, "Video options:",
1828 OPT_VIDEO
, OPT_EXPERT
| OPT_AUDIO
, 0);
1830 show_help_options(options
, "Advanced Video options:",
1831 OPT_EXPERT
| OPT_VIDEO
, OPT_AUDIO
, 0);
1833 show_help_options(options
, "Audio options:",
1834 OPT_AUDIO
, OPT_EXPERT
| OPT_VIDEO
, 0);
1836 show_help_options(options
, "Advanced Audio options:",
1837 OPT_EXPERT
| OPT_AUDIO
, OPT_VIDEO
, 0);
1838 show_help_options(options
, "Subtitle options:",
1839 OPT_SUBTITLE
, 0, 0);
1842 if (show_avoptions
) {
1843 int flags
= AV_OPT_FLAG_DECODING_PARAM
| AV_OPT_FLAG_ENCODING_PARAM
;
1844 show_help_children(avcodec_get_class(), flags
);
1845 show_help_children(avformat_get_class(), flags
);
1846 show_help_children(sws_get_class(), flags
);
1850 void show_usage(void)
1852 printf("Hyper fast Audio and Video encoder\n");
1853 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name
);
1862 static const OptionGroupDef groups
[] = {
1863 [GROUP_OUTFILE
] = { "output file", NULL
},
1864 [GROUP_INFILE
] = { "input file", "i" },
1867 static int open_files(OptionGroupList
*l
, const char *inout
,
1868 int (*open_file
)(OptionsContext
*, const char*))
1872 for (i
= 0; i
< l
->nb_groups
; i
++) {
1873 OptionGroup
*g
= &l
->groups
[i
];
1879 ret
= parse_optgroup(&o
, g
);
1881 av_log(NULL
, AV_LOG_ERROR
, "Error parsing options for %s file "
1882 "%s.\n", inout
, g
->arg
);
1886 av_log(NULL
, AV_LOG_DEBUG
, "Opening an %s file: %s.\n", inout
, g
->arg
);
1887 ret
= open_file(&o
, g
->arg
);
1890 av_log(NULL
, AV_LOG_ERROR
, "Error opening %s file %s.\n",
1894 av_log(NULL
, AV_LOG_DEBUG
, "Successfully openened the file.\n");
1900 int avconv_parse_options(int argc
, char **argv
)
1902 OptionParseContext octx
;
1906 memset(&octx
, 0, sizeof(octx
));
1908 /* split the commandline into an internal representation */
1909 ret
= split_commandline(&octx
, argc
, argv
, options
, groups
,
1910 FF_ARRAY_ELEMS(groups
));
1912 av_log(NULL
, AV_LOG_FATAL
, "Error splitting the argument list: ");
1916 /* apply global options */
1917 ret
= parse_optgroup(NULL
, &octx
.global_opts
);
1919 av_log(NULL
, AV_LOG_FATAL
, "Error parsing global options: ");
1923 /* open input files */
1924 ret
= open_files(&octx
.groups
[GROUP_INFILE
], "input", open_input_file
);
1926 av_log(NULL
, AV_LOG_FATAL
, "Error opening input files: ");
1930 /* open output files */
1931 ret
= open_files(&octx
.groups
[GROUP_OUTFILE
], "output", open_output_file
);
1933 av_log(NULL
, AV_LOG_FATAL
, "Error opening output files: ");
1938 uninit_parse_context(&octx
);
1940 av_strerror(ret
, error
, sizeof(error
));
1941 av_log(NULL
, AV_LOG_FATAL
, "%s\n", error
);
1946 #define OFFSET(x) offsetof(OptionsContext, x)
1947 const OptionDef options
[] = {
1949 #include "cmdutils_common_opts.h"
1950 { "f", HAS_ARG
| OPT_STRING
| OPT_OFFSET
, { .off
= OFFSET(format
) },
1951 "force format", "fmt" },
1952 { "y", OPT_BOOL
, { &file_overwrite
},
1953 "overwrite output files" },
1954 { "c", HAS_ARG
| OPT_STRING
| OPT_SPEC
, { .off
= OFFSET(codec_names
) },
1955 "codec name", "codec" },
1956 { "codec", HAS_ARG
| OPT_STRING
| OPT_SPEC
, { .off
= OFFSET(codec_names
) },
1957 "codec name", "codec" },
1958 { "pre", HAS_ARG
| OPT_STRING
| OPT_SPEC
, { .off
= OFFSET(presets
) },
1959 "preset name", "preset" },
1960 { "map", HAS_ARG
| OPT_EXPERT
| OPT_PERFILE
, { .func_arg
= opt_map
},
1961 "set input stream mapping",
1962 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1963 { "map_metadata", HAS_ARG
| OPT_STRING
| OPT_SPEC
, { .off
= OFFSET(metadata_map
) },
1964 "set metadata information of outfile from infile",
1965 "outfile[,metadata]:infile[,metadata]" },
1966 { "map_chapters", HAS_ARG
| OPT_INT
| OPT_EXPERT
| OPT_OFFSET
, { .off
= OFFSET(chapters_input_file
) },
1967 "set chapters mapping", "input_file_index" },
1968 { "t", HAS_ARG
| OPT_TIME
| OPT_OFFSET
, { .off
= OFFSET(recording_time
) },
1969 "record or transcode \"duration\" seconds of audio/video",
1971 { "fs", HAS_ARG
| OPT_INT64
| OPT_OFFSET
, { .off
= OFFSET(limit_filesize
) },
1972 "set the limit file size in bytes", "limit_size" },
1973 { "ss", HAS_ARG
| OPT_TIME
| OPT_OFFSET
, { .off
= OFFSET(start_time
) },
1974 "set the start time offset", "time_off" },
1975 { "itsoffset", HAS_ARG
| OPT_TIME
| OPT_OFFSET
| OPT_EXPERT
,{ .off
= OFFSET(input_ts_offset
) },
1976 "set the input ts offset", "time_off" },
1977 { "itsscale", HAS_ARG
| OPT_DOUBLE
| OPT_SPEC
| OPT_EXPERT
,{ .off
= OFFSET(ts_scale
) },
1978 "set the input ts scale", "scale" },
1979 { "metadata", HAS_ARG
| OPT_STRING
| OPT_SPEC
, { .off
= OFFSET(metadata
) },
1980 "add metadata", "string=string" },
1981 { "dframes", HAS_ARG
| OPT_PERFILE
| OPT_EXPERT
, { .func_arg
= opt_data_frames
},
1982 "set the number of data frames to record", "number" },
1983 { "benchmark", OPT_BOOL
| OPT_EXPERT
, { &do_benchmark
},
1984 "add timings for benchmarking" },
1985 { "timelimit", HAS_ARG
| OPT_EXPERT
, { .func_arg
= opt_timelimit
},
1986 "set max runtime in seconds", "limit" },
1987 { "dump", OPT_BOOL
| OPT_EXPERT
, { &do_pkt_dump
},
1988 "dump each input packet" },
1989 { "hex", OPT_BOOL
| OPT_EXPERT
, { &do_hex_dump
},
1990 "when dumping packets, also dump the payload" },
1991 { "re", OPT_BOOL
| OPT_EXPERT
| OPT_OFFSET
, { .off
= OFFSET(rate_emu
) },
1992 "read input at native frame rate", "" },
1993 { "target", HAS_ARG
| OPT_PERFILE
, { .func_arg
= opt_target
},
1994 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
1995 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
1996 { "vsync", HAS_ARG
| OPT_EXPERT
, { opt_vsync
},
1997 "video sync method", "" },
1998 { "async", HAS_ARG
| OPT_INT
| OPT_EXPERT
, { &audio_sync_method
},
1999 "audio sync method", "" },
2000 { "adrift_threshold", HAS_ARG
| OPT_FLOAT
| OPT_EXPERT
, { &audio_drift_threshold
},
2001 "audio drift threshold", "threshold" },
2002 { "copyts", OPT_BOOL
| OPT_EXPERT
, { ©_ts
},
2003 "copy timestamps" },
2004 { "copytb", OPT_BOOL
| OPT_EXPERT
, { ©_tb
},
2005 "copy input stream time base when stream copying" },
2006 { "shortest", OPT_BOOL
| OPT_EXPERT
| OPT_OFFSET
, { .off
= OFFSET(shortest
) },
2007 "finish encoding within shortest input" },
2008 { "dts_delta_threshold", HAS_ARG
| OPT_FLOAT
| OPT_EXPERT
, { &dts_delta_threshold
},
2009 "timestamp discontinuity delta threshold", "threshold" },
2010 { "xerror", OPT_BOOL
| OPT_EXPERT
, { &exit_on_error
},
2011 "exit on error", "error" },
2012 { "copyinkf", OPT_BOOL
| OPT_EXPERT
| OPT_SPEC
, { .off
= OFFSET(copy_initial_nonkeyframes
) },
2013 "copy initial non-keyframes" },
2014 { "frames", OPT_INT64
| HAS_ARG
| OPT_SPEC
, { .off
= OFFSET(max_frames
) },
2015 "set the number of frames to record", "number" },
2016 { "tag", OPT_STRING
| HAS_ARG
| OPT_SPEC
| OPT_EXPERT
,{ .off
= OFFSET(codec_tags
) },
2017 "force codec tag/fourcc", "fourcc/tag" },
2018 { "q", HAS_ARG
| OPT_EXPERT
| OPT_DOUBLE
| OPT_SPEC
,{ .off
= OFFSET(qscale
) },
2019 "use fixed quality scale (VBR)", "q" },
2020 { "qscale", HAS_ARG
| OPT_EXPERT
| OPT_DOUBLE
| OPT_SPEC
,{ .off
= OFFSET(qscale
) },
2021 "use fixed quality scale (VBR)", "q" },
2022 { "filter", HAS_ARG
| OPT_STRING
| OPT_SPEC
, { .off
= OFFSET(filters
) },
2023 "set stream filterchain", "filter_list" },
2024 { "filter_complex", HAS_ARG
| OPT_EXPERT
, { .func_arg
= opt_filter_complex
},
2025 "create a complex filtergraph", "graph_description" },
2026 { "stats", OPT_BOOL
, { &print_stats
},
2027 "print progress report during encoding", },
2028 { "attach", HAS_ARG
| OPT_PERFILE
| OPT_EXPERT
, { .func_arg
= opt_attach
},
2029 "add an attachment to the output file", "filename" },
2030 { "dump_attachment", HAS_ARG
| OPT_STRING
| OPT_SPEC
|OPT_EXPERT
,{ .off
= OFFSET(dump_attachment
) },
2031 "extract an attachment into a file", "filename" },
2032 { "cpuflags", HAS_ARG
| OPT_EXPERT
, { .func_arg
= opt_cpuflags
},
2033 "set CPU flags mask", "mask" },
2036 { "vframes", OPT_VIDEO
| HAS_ARG
| OPT_PERFILE
, { .func_arg
= opt_video_frames
},
2037 "set the number of video frames to record", "number" },
2038 { "r", OPT_VIDEO
| HAS_ARG
| OPT_STRING
| OPT_SPEC
, { .off
= OFFSET(frame_rates
) },
2039 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2040 { "s", OPT_VIDEO
| HAS_ARG
| OPT_STRING
| OPT_SPEC
, { .off
= OFFSET(frame_sizes
) },
2041 "set frame size (WxH or abbreviation)", "size" },
2042 { "aspect", OPT_VIDEO
| HAS_ARG
| OPT_STRING
| OPT_SPEC
, { .off
= OFFSET(frame_aspect_ratios
) },
2043 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2044 { "pix_fmt", OPT_VIDEO
| HAS_ARG
| OPT_EXPERT
| OPT_STRING
| OPT_SPEC
, { .off
= OFFSET(frame_pix_fmts
) },
2045 "set pixel format", "format" },
2046 { "vn", OPT_VIDEO
| OPT_BOOL
| OPT_OFFSET
, { .off
= OFFSET(video_disable
) },
2048 { "vdt", OPT_VIDEO
| OPT_INT
| HAS_ARG
| OPT_EXPERT
, { &video_discard
},
2049 "discard threshold", "n" },
2050 { "rc_override", OPT_VIDEO
| HAS_ARG
| OPT_EXPERT
| OPT_STRING
| OPT_SPEC
, { .off
= OFFSET(rc_overrides
) },
2051 "rate control override for specific intervals", "override" },
2052 { "vcodec", OPT_VIDEO
| HAS_ARG
| OPT_PERFILE
, { .func_arg
= opt_video_codec
},
2053 "force video codec ('copy' to copy stream)", "codec" },
2054 { "pass", OPT_VIDEO
| HAS_ARG
| OPT_SPEC
| OPT_INT
, { .off
= OFFSET(pass
) },
2055 "select the pass number (1 or 2)", "n" },
2056 { "passlogfile", OPT_VIDEO
| HAS_ARG
| OPT_STRING
| OPT_EXPERT
| OPT_SPEC
, { .off
= OFFSET(passlogfiles
) },
2057 "select two pass log file name prefix", "prefix" },
2058 { "deinterlace", OPT_VIDEO
| OPT_EXPERT
, { .func_arg
= opt_deinterlace
},
2059 "this option is deprecated, use the yadif filter instead" },
2060 { "vstats", OPT_VIDEO
| OPT_EXPERT
, { &opt_vstats
},
2061 "dump video coding statistics to file" },
2062 { "vstats_file", OPT_VIDEO
| HAS_ARG
| OPT_EXPERT
, { opt_vstats_file
},
2063 "dump video coding statistics to file", "file" },
2064 { "vf", OPT_VIDEO
| HAS_ARG
| OPT_PERFILE
, { .func_arg
= opt_video_filters
},
2065 "video filters", "filter list" },
2066 { "intra_matrix", OPT_VIDEO
| HAS_ARG
| OPT_EXPERT
| OPT_STRING
| OPT_SPEC
, { .off
= OFFSET(intra_matrices
) },
2067 "specify intra matrix coeffs", "matrix" },
2068 { "inter_matrix", OPT_VIDEO
| HAS_ARG
| OPT_EXPERT
| OPT_STRING
| OPT_SPEC
, { .off
= OFFSET(inter_matrices
) },
2069 "specify inter matrix coeffs", "matrix" },
2070 { "top", OPT_VIDEO
| HAS_ARG
| OPT_EXPERT
| OPT_INT
| OPT_SPEC
, { .off
= OFFSET(top_field_first
) },
2071 "top=1/bottom=0/auto=-1 field first", "" },
2072 { "dc", OPT_VIDEO
| OPT_INT
| HAS_ARG
| OPT_EXPERT
, { &intra_dc_precision
},
2073 "intra_dc_precision", "precision" },
2074 { "vtag", OPT_VIDEO
| HAS_ARG
| OPT_EXPERT
| OPT_PERFILE
, { .func_arg
= opt_video_tag
},
2075 "force video tag/fourcc", "fourcc/tag" },
2076 { "qphist", OPT_VIDEO
| OPT_BOOL
| OPT_EXPERT
, { &qp_hist
},
2077 "show QP histogram" },
2078 { "force_fps", OPT_VIDEO
| OPT_BOOL
| OPT_EXPERT
| OPT_SPEC
, { .off
= OFFSET(force_fps
) },
2079 "force the selected framerate, disable the best supported framerate selection" },
2080 { "streamid", OPT_VIDEO
| HAS_ARG
| OPT_EXPERT
| OPT_PERFILE
, { .func_arg
= opt_streamid
},
2081 "set the value of an outfile streamid", "streamIndex:value" },
2082 { "force_key_frames", OPT_VIDEO
| OPT_STRING
| HAS_ARG
| OPT_EXPERT
| OPT_SPEC
,
2083 { .off
= OFFSET(forced_key_frames
) }, "force key frames at specified timestamps", "timestamps" },
2086 { "aframes", OPT_AUDIO
| HAS_ARG
| OPT_PERFILE
, { .func_arg
= opt_audio_frames
},
2087 "set the number of audio frames to record", "number" },
2088 { "aq", OPT_AUDIO
| HAS_ARG
| OPT_PERFILE
, { .func_arg
= opt_audio_qscale
},
2089 "set audio quality (codec-specific)", "quality", },
2090 { "ar", OPT_AUDIO
| HAS_ARG
| OPT_INT
| OPT_SPEC
, { .off
= OFFSET(audio_sample_rate
) },
2091 "set audio sampling rate (in Hz)", "rate" },
2092 { "ac", OPT_AUDIO
| HAS_ARG
| OPT_INT
| OPT_SPEC
, { .off
= OFFSET(audio_channels
) },
2093 "set number of audio channels", "channels" },
2094 { "an", OPT_AUDIO
| OPT_BOOL
| OPT_OFFSET
, { .off
= OFFSET(audio_disable
) },
2096 { "acodec", OPT_AUDIO
| HAS_ARG
| OPT_PERFILE
, { .func_arg
= opt_audio_codec
},
2097 "force audio codec ('copy' to copy stream)", "codec" },
2098 { "atag", OPT_AUDIO
| HAS_ARG
| OPT_EXPERT
| OPT_PERFILE
, { .func_arg
= opt_audio_tag
},
2099 "force audio tag/fourcc", "fourcc/tag" },
2100 { "vol", OPT_AUDIO
| HAS_ARG
| OPT_INT
, { &audio_volume
},
2101 "change audio volume (256=normal)" , "volume" },
2102 { "sample_fmt", OPT_AUDIO
| HAS_ARG
| OPT_EXPERT
| OPT_SPEC
| OPT_STRING
, { .off
= OFFSET(sample_fmts
) },
2103 "set sample format", "format" },
2104 { "channel_layout", OPT_AUDIO
| HAS_ARG
| OPT_EXPERT
| OPT_PERFILE
, { .func_arg
= opt_channel_layout
},
2105 "set channel layout", "layout" },
2106 { "af", OPT_AUDIO
| HAS_ARG
| OPT_PERFILE
, { .func_arg
= opt_audio_filters
},
2107 "audio filters", "filter list" },
2109 /* subtitle options */
2110 { "sn", OPT_SUBTITLE
| OPT_BOOL
| OPT_OFFSET
, { .off
= OFFSET(subtitle_disable
) },
2111 "disable subtitle" },
2112 { "scodec", OPT_SUBTITLE
| HAS_ARG
| OPT_PERFILE
, { .func_arg
= opt_subtitle_codec
},
2113 "force subtitle codec ('copy' to copy stream)", "codec" },
2114 { "stag", OPT_SUBTITLE
| HAS_ARG
| OPT_EXPERT
| OPT_PERFILE
, { .func_arg
= opt_subtitle_tag
}
2115 , "force subtitle tag/fourcc", "fourcc/tag" },
2118 { "isync", OPT_BOOL
| OPT_EXPERT
, { &input_sync
}, "this option is deprecated and does nothing", "" },
2121 { "muxdelay", OPT_FLOAT
| HAS_ARG
| OPT_EXPERT
| OPT_OFFSET
, { .off
= OFFSET(mux_max_delay
) },
2122 "set the maximum demux-decode delay", "seconds" },
2123 { "muxpreload", OPT_FLOAT
| HAS_ARG
| OPT_EXPERT
| OPT_OFFSET
, { .off
= OFFSET(mux_preload
) },
2124 "set the initial demux-decode delay", "seconds" },
2126 { "bsf", HAS_ARG
| OPT_STRING
| OPT_SPEC
| OPT_EXPERT
, { .off
= OFFSET(bitstream_filters
) },
2127 "A comma-separated list of bitstream filters", "bitstream_filters" },
2129 /* data codec support */
2130 { "dcodec", HAS_ARG
| OPT_DATA
| OPT_PERFILE
| OPT_EXPERT
, { .func_arg
= opt_data_codec
},
2131 "force data codec ('copy' to copy stream)", "codec" },