static int audio_sync_method= 0;
static float audio_drift_threshold= 0.1;
static int copy_ts= 0;
+static int copy_tb;
static int opt_shortest = 0;
static int video_global_header = 0;
static char *vstats_filename;
/* audio only */
int audio_resample;
ReSampleContext *resample; /* for audio resampling */
+ int resample_sample_fmt;
+ int resample_channels;
+ int resample_sample_rate;
int reformat_pair;
AVAudioConvert *reformat_ctx;
AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
graph = avfilter_graph_alloc();
- if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
- return ret;
- if ((ret = avfilter_open(&ist->output_video_filter, &ffsink, "out")) < 0)
- return ret;
-
snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
- if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
+ ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
+ "src", args, NULL, graph);
+ if (ret < 0)
return ret;
- if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &ffsink_ctx)) < 0)
+ ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
+ "out", NULL, &ffsink_ctx, graph);
+ if (ret < 0)
return ret;
-
- /* add input and output filters to the overall graph */
- avfilter_graph_add_filter(graph, ist->input_video_filter);
- avfilter_graph_add_filter(graph, ist->output_video_filter);
-
last_filter = ist->input_video_filter;
if (codec->width != icodec->width || codec->height != icodec->height) {
codec->width,
codec->height,
(int)av_get_int(sws_opts, "sws_flags", NULL));
- if ((ret = avfilter_open(&filter, avfilter_get_by_name("scale"), NULL)) < 0)
- return ret;
- if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
+ if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
+ NULL, args, NULL, graph)) < 0)
return ret;
if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
return ret;
last_filter = filter;
- avfilter_graph_add_filter(graph, last_filter);
}
snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
{
if(codec && codec->pix_fmts){
const enum PixelFormat *p= codec->pix_fmts;
+ if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
+ if(st->codec->codec_id==CODEC_ID_MJPEG){
+ p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
+ }else if(st->codec->codec_id==CODEC_ID_LJPEG){
+ p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
+ }
+ }
for(; *p!=-1; p++){
if(*p == st->codec->pix_fmt)
break;
}
- if(*p == -1
- && !( st->codec->codec_id==CODEC_ID_MJPEG
- && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL
- && ( st->codec->pix_fmt == PIX_FMT_YUV420P
- || st->codec->pix_fmt == PIX_FMT_YUV422P)))
+ if(*p == -1)
st->codec->pix_fmt = codec->pix_fmts[0];
}
}
int64_t audio_out_size, audio_buf_size;
int64_t allocated_for_size= size;
- int size_out, frame_bytes, ret;
+ int size_out, frame_bytes, ret, resample_changed;
AVCodecContext *enc= ost->st->codec;
AVCodecContext *dec= ist->st->codec;
int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
if (enc->channels != dec->channels)
ost->audio_resample = 1;
- if (ost->audio_resample && !ost->resample) {
- if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
- fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
- ost->resample = av_audio_resample_init(enc->channels, dec->channels,
- enc->sample_rate, dec->sample_rate,
- enc->sample_fmt, dec->sample_fmt,
- 16, 10, 0, 0.8);
- if (!ost->resample) {
- fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
- dec->channels, dec->sample_rate,
- enc->channels, enc->sample_rate);
- ffmpeg_exit(1);
+ resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
+ ost->resample_channels != dec->channels ||
+ ost->resample_sample_rate != dec->sample_rate;
+
+ if ((ost->audio_resample && !ost->resample) || resample_changed) {
+ if (resample_changed) {
+ av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
+ ist->file_index, ist->index,
+ ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
+ dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
+ ost->resample_sample_fmt = dec->sample_fmt;
+ ost->resample_channels = dec->channels;
+ ost->resample_sample_rate = dec->sample_rate;
+ if (ost->resample)
+ audio_resample_close(ost->resample);
+ }
+ if (ost->resample_sample_fmt == enc->sample_fmt &&
+ ost->resample_channels == enc->channels &&
+ ost->resample_sample_rate == enc->sample_rate) {
+ ost->resample = NULL;
+ ost->audio_resample = 0;
+ } else {
+ if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
+ fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
+ ost->resample = av_audio_resample_init(enc->channels, dec->channels,
+ enc->sample_rate, dec->sample_rate,
+ enc->sample_fmt, dec->sample_fmt,
+ 16, 10, 0, 0.8);
+ if (!ost->resample) {
+ fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
+ dec->channels, dec->sample_rate,
+ enc->channels, enc->sample_rate);
+ ffmpeg_exit(1);
+ }
}
}
av_free(buffer_to_free);
/* XXX: allocate the subtitles in the codec ? */
if (subtitle_to_free) {
- if (subtitle_to_free->rects != NULL) {
- for (i = 0; i < subtitle_to_free->num_rects; i++) {
- av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
- av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
- av_freep(&subtitle_to_free->rects[i]);
- }
- av_freep(&subtitle_to_free->rects);
- }
- subtitle_to_free->num_rects = 0;
+ avsubtitle_free(subtitle_to_free);
subtitle_to_free = NULL;
}
}
for (i = 0; i < is->nb_chapters; i++) {
AVChapter *in_ch = is->chapters[i], *out_ch;
- AVMetadataTag *t = NULL;
int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile],
AV_TIME_BASE_Q, in_ch->time_base);
int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
out_ch->end = FFMIN(rt, in_ch->end - ts_off);
if (metadata_chapters_autocopy)
- while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
- av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
+ av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
os->nb_chapters++;
os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
nb_ostreams = 0;
for(i=0;i<nb_output_files;i++) {
os = output_files[i];
- if (!os->nb_streams) {
+ if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
dump_format(output_files[i], i, output_files[i]->filename, 1);
fprintf(stderr, "Output file #%d does not contain any stream\n", i);
ret = AVERROR(EINVAL);
/* for each output stream, we compute the right encoding parameters */
for(i=0;i<nb_ostreams;i++) {
- AVMetadataTag *t = NULL;
ost = ost_table[i];
os = output_files[ost->file_index];
ist = ist_table[ost->source_index];
icodec = ist->st->codec;
if (metadata_streams_autocopy)
- while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
- av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
- }
+ av_metadata_copy(&ost->st->metadata, ist->st->metadata,
+ AV_METADATA_DONT_OVERWRITE);
ost->st->disposition = ist->st->disposition;
codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
goto fail;
memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
codec->extradata_size= icodec->extradata_size;
- if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
+ 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/1000){
codec->time_base = icodec->time_base;
codec->time_base.num *= icodec->ticks_per_frame;
av_reduce(&codec->time_base.num, &codec->time_base.den,
icodec->request_channels = codec->channels;
ist->decoding_needed = 1;
ost->encoding_needed = 1;
+ ost->resample_sample_fmt = icodec->sample_fmt;
+ ost->resample_sample_rate = icodec->sample_rate;
+ ost->resample_channels = icodec->channels;
break;
case AVMEDIA_TYPE_VIDEO:
if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
codec->height != icodec->height ||
(codec->pix_fmt != icodec->pix_fmt));
if (ost->video_resample) {
+#if !CONFIG_AVFILTER
avcodec_get_frame_defaults(&ost->pict_tmp);
if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
codec->width, codec->height)) {
ffmpeg_exit(1);
}
-#if !CONFIG_AVFILTER
ost->original_height = icodec->height;
ost->original_width = icodec->width;
#endif
for (i=0;i<nb_meta_data_maps;i++) {
AVFormatContext *files[2];
AVMetadata **meta[2];
- AVMetadataTag *mtag;
int j;
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
}
}
- mtag=NULL;
- while((mtag=av_metadata_get(*meta[1], "", mtag, AV_METADATA_IGNORE_SUFFIX)))
- av_metadata_set2(meta[0], mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
+ av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
}
/* copy global metadata by default */
if (metadata_global_autocopy) {
- AVMetadataTag *t = NULL;
- while ((t = av_metadata_get(input_files[0]->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
- for (i = 0; i < nb_output_files; i++)
- av_metadata_set2(&output_files[i]->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
+ for (i = 0; i < nb_output_files; i++)
+ av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
+ AV_METADATA_DONT_OVERWRITE);
}
/* copy chapters according to chapter maps */
static void opt_audio_sample_fmt(const char *arg)
{
- if (strcmp(arg, "list"))
+ if (strcmp(arg, "list")) {
audio_sample_fmt = av_get_sample_fmt(arg);
- else {
+ if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
+ av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
+ ffmpeg_exit(1);
+ }
+ } else {
list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
ffmpeg_exit(0);
}
}
}
-static void parse_meta_type(const char *arg, char *type, int *index, char **endptr)
+static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
{
*endptr = arg;
if (*arg == ',') {
dec->flags |= CODEC_FLAG_EMU_EDGE;
frame_height >>= dec->lowres;
frame_width >>= dec->lowres;
+ dec->height = frame_height;
+ dec->width = frame_width;
}
if(me_threshold)
dec->debug |= FF_DEBUG_MV;
AVStream *st;
AVOutputStream *ost;
AVCodecContext *video_enc;
- enum CodecID codec_id;
+ enum CodecID codec_id = CODEC_ID_NONE;
AVCodec *codec= NULL;
st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
AVOutputStream *ost;
AVCodec *codec= NULL;
AVCodecContext *audio_enc;
- enum CodecID codec_id;
+ enum CodecID codec_id = CODEC_ID_NONE;
st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
if (!st) {
AVOutputStream *ost;
AVCodec *codec=NULL;
AVCodecContext *subtitle_enc;
+ enum CodecID codec_id = CODEC_ID_NONE;
st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
if (!st) {
subtitle_enc = st->codec;
output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
if(!subtitle_stream_copy){
- subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
- avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
- codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
+ 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= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
+ } else {
+ codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
+ codec = avcodec_find_encoder(codec_id);
+ }
}
avcodec_get_context_defaults3(st->codec, codec);
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);
}
int input_has_video, input_has_audio, input_has_subtitle;
AVFormatParameters params, *ap = ¶ms;
AVOutputFormat *file_oformat;
- AVMetadataTag *tag = NULL;
if (!strcmp(filename, "-"))
filename = "pipe:";
oc->timestamp = recording_timestamp;
- while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
- av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
+ av_metadata_copy(&oc->metadata, metadata, 0);
av_metadata_free(&metadata);
}
static void show_help(void)
{
+ AVCodec *c;
+ AVOutputFormat *oformat = NULL;
+
av_log_set_callback(log_callback_help);
show_usage();
show_help_options(options, "Main options:\n",
printf("\n");
av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
printf("\n");
+
+ /* individual codec options */
+ c = NULL;
+ while ((c = av_codec_next(c))) {
+ if (c->priv_class) {
+ av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
+ printf("\n");
+ }
+ }
+
av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
printf("\n");
+
+ /* individual muxer options */
+ while ((oformat = av_oformat_next(oformat))) {
+ if (oformat->priv_class) {
+ av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
+ printf("\n");
+ }
+ }
+
av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
}
{ "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
{ "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
{ "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
+ { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
{ "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
{ "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
{ "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
projects / ffmpeg / blobdiff