static int nb_ts_scale;
static AVFormatContext *output_files[MAX_FILES];
+static AVDictionary *output_opts[MAX_FILES];
static int nb_output_files = 0;
static StreamMap *stream_maps = NULL;
static int rate_emu = 0;
-static int video_channel = 0;
-static char *video_standard;
-
static int audio_volume = 256;
static int exit_on_error = 0;
#endif
int sws_flags;
+ AVDictionary *opts;
} OutputStream;
static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
int is_start; /* is 1 at the start and after a discontinuity */
int showed_multi_packet_warning;
int is_past_recording_time;
+ AVDictionary *opts;
} InputStream;
typedef struct InputFile {
avio_close(s->pb);
avformat_free_context(s);
av_free(output_streams_for_file[i]);
+ av_dict_free(&output_opts[i]);
}
for(i=0;i<nb_input_files;i++) {
av_close_input_file(input_files[i].ctx);
}
+ for (i = 0; i < nb_input_streams; i++)
+ av_dict_free(&input_streams[i].opts);
av_free(intra_matrix);
av_free(inter_matrix);
av_free(subtitle_codec_name);
av_free(data_codec_name);
- av_free(video_standard);
-
uninit_opts();
av_free(audio_buf);
av_free(audio_out);
return ret;
}
+static void assert_avoptions(AVDictionary *m)
+{
+ AVDictionaryEntry *t;
+ if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
+ av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
+ ffmpeg_exit(1);
+ }
+}
+
+static void assert_codec_experimental(AVCodecContext *c, int encoder)
+{
+ const char *codec_string = encoder ? "encoder" : "decoder";
+ AVCodec *codec;
+ if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
+ c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
+ av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
+ "results.\nAdd '-strict experimental' if you want to use it.\n",
+ codec_string, c->codec->name);
+ codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
+ if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
+ av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
+ codec_string, codec->name);
+ ffmpeg_exit(1);
+ }
+}
+
/* similar to ff_dynarray_add() and av_fast_realloc() */
static void *grow_array(void *array, int elem_size, int *size, int new_size)
{
ost->index = idx;
ost->st = st;
ost->enc = codec;
+ if (codec)
+ ost->opts = filter_codec_opts(codec_opts, codec->id, 1);
avcodec_get_context_defaults3(st->codec, codec);
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
{
int i, err;
- AVFormatContext *ic;
+ AVFormatContext *ic = NULL;
int nopts = 0;
- err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
+ err = avformat_open_input(&ic, filename, NULL, NULL);
if (err < 0)
return err;
/* copy stream format */
goto fail;
memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
codec->extradata_size= icodec->extradata_size;
- if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
- codec->time_base = icodec->time_base;
- codec->time_base.num *= icodec->ticks_per_frame;
- av_reduce(&codec->time_base.num, &codec->time_base.den,
- codec->time_base.num, codec->time_base.den, INT_MAX);
- }else
- codec->time_base = ist->st->time_base;
+
+ codec->time_base = ist->st->time_base;
+ if(!strcmp(os->oformat->name, "avi")) {
+ if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
+ codec->time_base = icodec->time_base;
+ codec->time_base.num *= icodec->ticks_per_frame;
+ codec->time_base.den *= 2;
+ }
+ } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
+ if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
+ codec->time_base = icodec->time_base;
+ codec->time_base.num *= icodec->ticks_per_frame;
+ }
+ }
+ av_reduce(&codec->time_base.num, &codec->time_base.den,
+ codec->time_base.num, codec->time_base.den, INT_MAX);
+
switch(codec->codec_type) {
case AVMEDIA_TYPE_AUDIO:
if(audio_volume != 256) {
ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
if (!codec->sample_rate) {
codec->sample_rate = icodec->sample_rate;
- if (icodec->lowres)
- codec->sample_rate >>= icodec->lowres;
}
choose_sample_rate(ost->st, ost->enc);
codec->time_base = (AVRational){1, codec->sample_rate};
fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
ffmpeg_exit(1);
}
+
+ if (!codec->width || !codec->height) {
+ codec->width = icodec->width;
+ codec->height = icodec->height;
+ }
+
ost->video_resample = codec->width != icodec->width ||
codec->height != icodec->height ||
codec->pix_fmt != icodec->pix_fmt;
if (ost->video_resample) {
codec->bits_per_raw_sample= frame_bits_per_raw_sample;
}
- if (!codec->width || !codec->height) {
- codec->width = icodec->width;
- codec->height = icodec->height;
- }
+
ost->resample_height = icodec->height;
ost->resample_width = icodec->width;
ost->resample_pix_fmt= icodec->pix_fmt;
memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
}
- if (avcodec_open(ost->st->codec, codec) < 0) {
+ if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
ost->file_index, ost->index);
ret = AVERROR(EINVAL);
goto dump_format;
}
+ assert_codec_experimental(ost->st->codec, 1);
+ assert_avoptions(ost->opts);
+ if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
+ av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
+ "It takes bits/s as argument, not kbits/s\n");
extra_size += ost->st->codec->extradata_size;
}
}
ret = AVERROR(EINVAL);
goto dump_format;
}
- if (avcodec_open(ist->st->codec, codec) < 0) {
+ if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
ist->file_index, ist->st->index);
ret = AVERROR(EINVAL);
goto dump_format;
}
+ assert_codec_experimental(ist->st->codec, 0);
+ assert_avoptions(ost->opts);
//if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
// ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
}
/* open files and write file headers */
for(i=0;i<nb_output_files;i++) {
os = output_files[i];
- if (av_write_header(os) < 0) {
+ if (avformat_write_header(os, &output_opts[i]) < 0) {
snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
ret = AVERROR(EINVAL);
goto dump_format;
}
+// assert_avoptions(output_opts[i]);
if (strcmp(output_files[i]->oformat->name, "rtp")) {
want_sdp = 0;
}
audio_resample_close(ost->resample);
if (ost->reformat_ctx)
av_audio_convert_free(ost->reformat_ctx);
+ av_dict_free(&ost->opts);
av_free(ost);
}
}
return 0;
}
-static int opt_bitrate(const char *opt, const char *arg)
-{
- int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
-
- opt_default(opt, arg);
-
- if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
- fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
-
- return 0;
-}
-
static int opt_frame_crop(const char *opt, const char *arg)
{
fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
static int opt_video_channel(const char *opt, const char *arg)
{
- video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
+ av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
+ opt_default("channel", arg);
return 0;
}
static int opt_video_standard(const char *opt, const char *arg)
{
- video_standard = av_strdup(arg);
+ av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
+ opt_default("standard", arg);
return 0;
}
p++;
scale= strtod(p, &p);
+ if(stream >= MAX_STREAMS)
+ ffmpeg_exit(1);
+
ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
ts_scale[stream] = scale;
return 0;
return 0;
}
-static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
+static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
{
const char *codec_string = encoder ? "encoder" : "decoder";
AVCodec *codec;
fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
ffmpeg_exit(1);
}
- if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
- strict > FF_COMPLIANCE_EXPERIMENTAL) {
- fprintf(stderr, "%s '%s' is experimental and might produce bad "
- "results.\nAdd '-strict experimental' if you want to use it.\n",
- codec_string, codec->name);
- codec = encoder ?
- avcodec_find_encoder(codec->id) :
- avcodec_find_decoder(codec->id);
- if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
- fprintf(stderr, "Or use the non experimental %s '%s'.\n",
- codec_string, codec->name);
- ffmpeg_exit(1);
- }
return codec->id;
}
static int opt_input_file(const char *opt, const char *filename)
{
AVFormatContext *ic;
- AVFormatParameters params, *ap = ¶ms;
AVInputFormat *file_iformat = NULL;
int err, i, ret, rfps, rfps_base;
int64_t timestamp;
+ uint8_t buf[128];
+ AVDictionary **opts;
+ int orig_nb_streams; // number of streams before avformat_find_stream_info
if (last_asked_format) {
if (!(file_iformat = av_find_input_format(last_asked_format))) {
print_error(filename, AVERROR(ENOMEM));
ffmpeg_exit(1);
}
-
- memset(ap, 0, sizeof(*ap));
- ap->prealloced_context = 1;
- ap->sample_rate = audio_sample_rate;
- ap->channels = audio_channels;
- ap->time_base.den = frame_rate.num;
- ap->time_base.num = frame_rate.den;
- ap->width = frame_width;
- ap->height = frame_height;
- ap->pix_fmt = frame_pix_fmt;
- // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
- ap->channel = video_channel;
- ap->standard = video_standard;
-
- set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
+ if (audio_sample_rate) {
+ snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
+ av_dict_set(&format_opts, "sample_rate", buf, 0);
+ }
+ if (audio_channels) {
+ snprintf(buf, sizeof(buf), "%d", audio_channels);
+ av_dict_set(&format_opts, "channels", buf, 0);
+ }
+ if (frame_rate.num) {
+ snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
+ av_dict_set(&format_opts, "framerate", buf, 0);
+ }
+ if (frame_width && frame_height) {
+ snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
+ av_dict_set(&format_opts, "video_size", buf, 0);
+ }
+ if (frame_pix_fmt != PIX_FMT_NONE)
+ av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
ic->video_codec_id =
- find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0,
- avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance);
+ find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
ic->audio_codec_id =
- find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0,
- avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance);
+ find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
ic->subtitle_codec_id=
- find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
- avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
- ic->flags |= AVFMT_FLAG_NONBLOCK | AVFMT_FLAG_PRIV_OPT;
+ find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
+ ic->flags |= AVFMT_FLAG_NONBLOCK;
/* open the input file with generic libav function */
- err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
- if(err >= 0){
- set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
- err = av_demuxer_open(ic, ap);
- if(err < 0)
- avformat_free_context(ic);
- }
+ err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
if (err < 0) {
print_error(filename, err);
ffmpeg_exit(1);
}
+ assert_avoptions(format_opts);
+
if(opt_programid) {
int i, j;
int found=0;
ic->loop_input = loop_input;
}
+ /* Set AVCodecContext options for avformat_find_stream_info */
+ opts = setup_find_stream_info_opts(ic);
+ orig_nb_streams = ic->nb_streams;
+
/* If not enough info to get the stream parameters, we decode the
first frames to get it. (used in mpeg case for example) */
- ret = av_find_stream_info(ic);
+ ret = avformat_find_stream_info(ic, opts);
if (ret < 0 && verbose >= 0) {
fprintf(stderr, "%s: could not find codec parameters\n", filename);
av_close_input_file(ic);
ist->st = st;
ist->file_index = nb_input_files;
ist->discard = 1;
+ ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, 0);
if (i < nb_ts_scale)
ist->ts_scale = ts_scale[i];
ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
if(!ist->dec)
ist->dec = avcodec_find_decoder(dec->codec_id);
- set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, ist->dec);
if(audio_disable)
st->discard= AVDISCARD_ALL;
break;
ist->dec= avcodec_find_decoder_by_name(video_codec_name);
if(!ist->dec)
ist->dec = avcodec_find_decoder(dec->codec_id);
- set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, ist->dec);
rfps = ic->streams[i]->r_frame_rate.num;
rfps_base = ic->streams[i]->r_frame_rate.den;
if (dec->lowres) {
dec->flags |= CODEC_FLAG_EMU_EDGE;
- dec->height >>= dec->lowres;
- dec->width >>= dec->lowres;
}
if(me_threshold)
dec->debug |= FF_DEBUG_MV;
input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
top_field_first = -1;
- video_channel = 0;
frame_rate = (AVRational){0, 0};
frame_pix_fmt = PIX_FMT_NONE;
frame_height = 0;
av_freep(&ts_scale);
nb_ts_scale = 0;
+ for (i = 0; i < orig_nb_streams; i++)
+ av_dict_free(&opts[i]);
+ av_freep(&opts);
av_freep(&video_codec_name);
av_freep(&audio_codec_name);
av_freep(&subtitle_codec_name);
if(!video_stream_copy){
if (video_codec_name) {
- codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
- avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
+ codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
codec = avcodec_find_encoder_by_name(video_codec_name);
} else {
codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
- avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
}
+ video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
if (video_stream_copy) {
st->stream_copy = 1;
- video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
video_enc->sample_aspect_ratio =
st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
} else {
if (frame_rate.num)
ost->frame_rate = frame_rate;
video_enc->codec_id = codec_id;
- set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
video_enc->width = frame_width;
video_enc->height = frame_height;
if(!audio_stream_copy){
if (audio_codec_name) {
- codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
- avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
+ codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
codec = avcodec_find_encoder_by_name(audio_codec_name);
} else {
codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
- avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
}
if (audio_stream_copy) {
st->stream_copy = 1;
} else {
audio_enc->codec_id = codec_id;
- set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
if (audio_qscale > QSCALE_NONE) {
audio_enc->flags |= CODEC_FLAG_QSCALE;
if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
- avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
if (data_stream_copy) {
st->stream_copy = 1;
if(!subtitle_stream_copy){
if (subtitle_codec_name) {
- codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
- avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
+ codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
codec = avcodec_find_encoder_by_name(subtitle_codec_name);
} else {
codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
- avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
if (subtitle_stream_copy) {
st->stream_copy = 1;
} else {
subtitle_enc->codec_id = codec_id;
- set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
}
if (subtitle_language) {
ffmpeg_exit(1);
}
*p++ = '\0';
- idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
+ idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
return 0;
AVFormatContext *oc;
int err, use_video, use_audio, use_subtitle, use_data;
int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
- AVFormatParameters params, *ap = ¶ms;
AVOutputFormat *file_oformat;
if(nb_output_files >= FF_ARRAY_ELEMS(output_files)){
av_dict_free(&metadata);
}
+ av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
output_files[nb_output_files++] = oc;
/* check filename in case of an image number is expected */
}
}
- memset(ap, 0, sizeof(*ap));
- if (av_set_parameters(oc, ap) < 0) {
- fprintf(stderr, "%s: Invalid encoding parameters\n",
- oc->filename);
- ffmpeg_exit(1);
- }
-
oc->preload= (int)(mux_preload*AV_TIME_BASE);
oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
- set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
if (loop_output >= 0) {
av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
oc->loop_output = loop_output;
}
- oc->flags |= AVFMT_FLAG_NONBLOCK;
frame_rate = (AVRational){0, 0};
frame_width = 0;
{
AVCodec *c;
AVOutputFormat *oformat = NULL;
+ AVInputFormat *iformat = NULL;
av_log_set_callback(log_callback_help);
show_usage();
}
}
+ /* individual demuxer options */
+ while ((iformat = av_iformat_next(iformat))) {
+ if (iformat->priv_class) {
+ av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
+ printf("\n");
+ }
+ }
+
av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
return 0;
}
{ "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
/* video options */
- { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
- { "vb", HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
{ "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
{ "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
{ "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
{ "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
/* audio options */
- { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
{ "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
{ "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
{ "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
{ "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
/* grab options */
- { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
- { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
+ { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
+ { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
{ "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
/* muxer options */
projects / ffmpeg / blobdiff