#include "libavutil/avassert.h"
#include "libavutil/avstring.h"
+#include "libavutil/common.h"
#include "libavutil/mathematics.h"
#include "libavutil/opt.h"
#include "audio.h"
#include "avfilter.h"
+#include "formats.h"
#include "internal.h"
typedef struct ResampleContext {
AVAudioResampleContext *avr;
int64_t next_pts;
+
+ /* set by filter_frame() to signal an output frame to request_frame() */
+ int got_output;
} ResampleContext;
static av_cold void uninit(AVFilterContext *ctx)
AVFilterLink *inlink = ctx->inputs[0];
AVFilterLink *outlink = ctx->outputs[0];
- AVFilterFormats *in_formats = avfilter_all_formats(AVMEDIA_TYPE_AUDIO);
- AVFilterFormats *out_formats = avfilter_all_formats(AVMEDIA_TYPE_AUDIO);
+ AVFilterFormats *in_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
+ AVFilterFormats *out_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
+ AVFilterFormats *in_samplerates = ff_all_samplerates();
+ AVFilterFormats *out_samplerates = ff_all_samplerates();
+ AVFilterChannelLayouts *in_layouts = ff_all_channel_layouts();
+ AVFilterChannelLayouts *out_layouts = ff_all_channel_layouts();
+
+ ff_formats_ref(in_formats, &inlink->out_formats);
+ ff_formats_ref(out_formats, &outlink->in_formats);
+
+ ff_formats_ref(in_samplerates, &inlink->out_samplerates);
+ ff_formats_ref(out_samplerates, &outlink->in_samplerates);
- avfilter_formats_ref(in_formats, &inlink->out_formats);
- avfilter_formats_ref(out_formats, &outlink->in_formats);
+ ff_channel_layouts_ref(in_layouts, &inlink->out_channel_layouts);
+ ff_channel_layouts_ref(out_layouts, &outlink->in_channel_layouts);
return 0;
}
if (inlink->channel_layout == outlink->channel_layout &&
inlink->sample_rate == outlink->sample_rate &&
- inlink->format == outlink->format)
+ (inlink->format == outlink->format ||
+ (av_get_channel_layout_nb_channels(inlink->channel_layout) == 1 &&
+ av_get_channel_layout_nb_channels(outlink->channel_layout) == 1 &&
+ av_get_planar_sample_fmt(inlink->format) ==
+ av_get_planar_sample_fmt(outlink->format))))
return 0;
if (!(s->avr = avresample_alloc_context()))
av_opt_set_int(s->avr, "in_sample_rate", inlink ->sample_rate, 0);
av_opt_set_int(s->avr, "out_sample_rate", outlink->sample_rate, 0);
- /* if both the input and output formats are s16 or u8, use s16 as
- the internal sample format */
- if (av_get_bytes_per_sample(inlink->format) <= 2 &&
- av_get_bytes_per_sample(outlink->format) <= 2)
- av_opt_set_int(s->avr, "internal_sample_fmt", AV_SAMPLE_FMT_S16P, 0);
-
if ((ret = avresample_open(s->avr)) < 0)
return ret;
av_get_channel_layout_string(buf2, sizeof(buf2),
-1, outlink->channel_layout);
av_log(ctx, AV_LOG_VERBOSE,
- "fmt:%s srate: %d cl:%s -> fmt:%s srate: %d cl:%s\n",
+ "fmt:%s srate:%d cl:%s -> fmt:%s srate:%d cl:%s\n",
av_get_sample_fmt_name(inlink ->format), inlink ->sample_rate, buf1,
av_get_sample_fmt_name(outlink->format), outlink->sample_rate, buf2);
{
AVFilterContext *ctx = outlink->src;
ResampleContext *s = ctx->priv;
- int ret = avfilter_request_frame(ctx->inputs[0]);
+ int ret = 0;
+
+ s->got_output = 0;
+ while (ret >= 0 && !s->got_output)
+ ret = ff_request_frame(ctx->inputs[0]);
/* flush the lavr delay buffer */
if (ret == AVERROR_EOF && s->avr) {
if (!buf)
return AVERROR(ENOMEM);
- ret = avresample_convert(s->avr, (void**)buf->extended_data,
+ ret = avresample_convert(s->avr, buf->extended_data,
buf->linesize[0], nb_samples,
NULL, 0, 0);
if (ret <= 0) {
}
buf->pts = s->next_pts;
- ff_filter_samples(outlink, buf);
- return 0;
+ return ff_filter_frame(outlink, buf);
}
return ret;
}
-static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
+static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)
{
AVFilterContext *ctx = inlink->dst;
ResampleContext *s = ctx->priv;
AVFilterLink *outlink = ctx->outputs[0];
+ int ret;
if (s->avr) {
AVFilterBufferRef *buf_out;
- int delay, nb_samples, ret;
+ int delay, nb_samples;
/* maximum possible samples lavr can output */
delay = avresample_get_delay(s->avr);
AV_ROUND_UP);
buf_out = ff_get_audio_buffer(outlink, AV_PERM_WRITE, nb_samples);
- ret = avresample_convert(s->avr, (void**)buf_out->extended_data,
+ if (!buf_out) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+
+ ret = avresample_convert(s->avr, buf_out->extended_data,
buf_out->linesize[0], nb_samples,
- (void**)buf->extended_data, buf->linesize[0],
+ buf->extended_data, buf->linesize[0],
buf->audio->nb_samples);
+ if (ret <= 0) {
+ avfilter_unref_buffer(buf_out);
+ if (ret < 0)
+ goto fail;
+ }
av_assert0(!avresample_available(s->avr));
s->next_pts = buf_out->pts + buf_out->audio->nb_samples;
- ff_filter_samples(outlink, buf_out);
+ ret = ff_filter_frame(outlink, buf_out);
+ s->got_output = 1;
}
+
+fail:
avfilter_unref_buffer(buf);
- } else
- ff_filter_samples(outlink, buf);
+ } else {
+ buf->format = outlink->format;
+ ret = ff_filter_frame(outlink, buf);
+ s->got_output = 1;
+ }
+
+ return ret;
}
+static const AVFilterPad avfilter_af_resample_inputs[] = {
+ {
+ .name = "default",
+ .type = AVMEDIA_TYPE_AUDIO,
+ .filter_frame = filter_frame,
+ .min_perms = AV_PERM_READ
+ },
+ { NULL }
+};
+
+static const AVFilterPad avfilter_af_resample_outputs[] = {
+ {
+ .name = "default",
+ .type = AVMEDIA_TYPE_AUDIO,
+ .config_props = config_output,
+ .request_frame = request_frame
+ },
+ { NULL }
+};
+
AVFilter avfilter_af_resample = {
.name = "resample",
.description = NULL_IF_CONFIG_SMALL("Audio resampling and conversion."),
.uninit = uninit,
.query_formats = query_formats,
- .inputs = (const AVFilterPad[]) {{ .name = "default",
- .type = AVMEDIA_TYPE_AUDIO,
- .filter_samples = filter_samples,
- .min_perms = AV_PERM_READ },
- { .name = NULL}},
- .outputs = (const AVFilterPad[]) {{ .name = "default",
- .type = AVMEDIA_TYPE_AUDIO,
- .config_props = config_output,
- .request_frame = request_frame },
- { .name = NULL}},
+ .inputs = avfilter_af_resample_inputs,
+ .outputs = avfilter_af_resample_outputs,
};
projects / ffmpeg / blobdiff