---
libavresample/Makefile | 1 +
libavresample/audio_convert.c | 33 ++++-
libavresample/audio_convert.h | 22 ++-
libavresample/avresample.h | 9 +
libavresample/dither.c | 392 +++++++++++++++++++++++++++++++++++++++++
libavresample/dither.h | 60 +++++++
libavresample/internal.h | 1 +
libavresample/options.c | 6 +
libavresample/utils.c | 10 +-
9 files changed, 523 insertions(+), 11 deletions(-)
create mode 100644 libavresample/dither.c
create mode 100644 libavresample/dither.h
diff --git a/libavresample/Makefile b/libavresample/Makefile
index c0c20a9..6805280 100644
--- a/libavresample/Makefile
+++ b/libavresample/Makefile
@@ -8,6 +8,7 @@ OBJS = audio_convert.o
\
audio_data.o \
audio_mix.o \
audio_mix_matrix.o \
+ dither.o \
options.o \
resample.o \
utils.o \
diff --git a/libavresample/audio_convert.c b/libavresample/audio_convert.c
index dcf8a39..eb3bc1f 100644
--- a/libavresample/audio_convert.c
+++ b/libavresample/audio_convert.c
@@ -29,6 +29,8 @@
#include "libavutil/samplefmt.h"
#include "audio_convert.h"
#include "audio_data.h"
+#include "dither.h"
+#include "internal.h"
enum ConvFuncType {
CONV_FUNC_TYPE_FLAT,
@@ -46,6 +48,7 @@ typedef void (conv_func_deinterleave)(uint8_t **out, const
uint8_t *in, int len,
struct AudioConvert {
AVAudioResampleContext *avr;
+ DitherContext *dc;
enum AVSampleFormat in_fmt;
enum AVSampleFormat out_fmt;
int channels;
@@ -246,10 +249,18 @@ static void set_generic_function(AudioConvert *ac)
SET_CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL)
}
+void ff_audio_convert_free(AudioConvert **ac)
+{
+ if (!*ac)
+ return;
+ ff_dither_free(&(*ac)->dc);
+ av_freep(ac);
+}
+
AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr,
enum AVSampleFormat out_fmt,
enum AVSampleFormat in_fmt,
- int channels)
+ int channels, int sample_rate)
{
AudioConvert *ac;
int in_planar, out_planar;
@@ -263,6 +274,17 @@ AudioConvert
*ff_audio_convert_alloc(AVAudioResampleContext *avr,
ac->in_fmt = in_fmt;
ac->channels = channels;
+ if (avr->dither_method != AV_RESAMPLE_DITHER_NONE &&
+ av_get_packed_sample_fmt(out_fmt) == AV_SAMPLE_FMT_S16 &&
+ av_get_bytes_per_sample(in_fmt) > 2) {
+ ac->dc = ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate);
+ if (!ac->dc) {
+ av_free(ac);
+ return NULL;
+ }
+ return ac;
+ }
+
in_planar = av_sample_fmt_is_planar(in_fmt);
out_planar = av_sample_fmt_is_planar(out_fmt);
@@ -289,6 +311,15 @@ int ff_audio_convert(AudioConvert *ac, AudioData *out,
AudioData *in)
int use_generic = 1;
int len = in->nb_samples;
+ if (ac->dc) {
+ /* dithered conversion */
+ av_dlog(ac->avr, "%d samples - audio_convert: %s to %s (dithered)\n",
+ len, av_get_sample_fmt_name(ac->in_fmt),
+ av_get_sample_fmt_name(ac->out_fmt));
+
+ return ff_convert_dither(ac->dc, out, in);
+ }
+
/* determine whether to use the optimized function based on pointer and
samples alignment in both the input and output */
if (ac->has_optimized_func) {
diff --git a/libavresample/audio_convert.h b/libavresample/audio_convert.h
index bc27223..b8808f1 100644
--- a/libavresample/audio_convert.h
+++ b/libavresample/audio_convert.h
@@ -54,16 +54,26 @@ void ff_audio_convert_set_func(AudioConvert *ac, enum
AVSampleFormat out_fmt,
/**
* Allocate and initialize AudioConvert context for sample format conversion.
*
- * @param avr AVAudioResampleContext
- * @param out_fmt output sample format
- * @param in_fmt input sample format
- * @param channels number of channels
- * @return newly-allocated AudioConvert context
+ * @param avr AVAudioResampleContext
+ * @param out_fmt output sample format
+ * @param in_fmt input sample format
+ * @param channels number of channels
+ * @param sample_rate sample rate (used for dithering)
+ * @return newly-allocated AudioConvert context
*/
AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr,
enum AVSampleFormat out_fmt,
enum AVSampleFormat in_fmt,
- int channels);
+ int channels, int sample_rate);
+
+/**
+ * Free AudioConvert.
+ *
+ * The AudioConvert must have been previously allocated with
ff_audio_convert_alloc().
+ *
+ * @param ac AudioConvert struct
+ */
+void ff_audio_convert_free(AudioConvert **ac);
/**
* Convert audio data from one sample format to another.
diff --git a/libavresample/avresample.h b/libavresample/avresample.h
index affeeeb..fc7f138 100644
--- a/libavresample/avresample.h
+++ b/libavresample/avresample.h
@@ -119,6 +119,15 @@ enum AVResampleFilterType {
AV_RESAMPLE_FILTER_TYPE_KAISER, /**< Kaiser Windowed Sinc */
};
+enum AVResampleDitherMethod {
+ AV_RESAMPLE_DITHER_NONE, /**< Do not use dithering */
+ AV_RESAMPLE_DITHER_RECTANGULAR, /**< Rectangular Dither */
+ AV_RESAMPLE_DITHER_TRIANGULAR, /**< Triangular Dither*/
+ AV_RESAMPLE_DITHER_TRIANGULAR_HP, /**< Triangular Dither with High Pass
*/
+ AV_RESAMPLE_DITHER_TRIANGULAR_NS, /**< Triangular Dither with Noise
Shaping */
+ AV_RESAMPLE_DITHER_NB, /**< Number of dither types. Not part
of ABI. */
+};
+
/**
* Return the LIBAVRESAMPLE_VERSION_INT constant.
*/
diff --git a/libavresample/dither.c b/libavresample/dither.c
new file mode 100644
index 0000000..450a9b0
--- /dev/null
+++ b/libavresample/dither.c
@@ -0,0 +1,392 @@
+/*
+ * Copyright (c) 2012 Justin Ruggles <[email protected]>
+ *
+ * Triangular with Noise Shaping is based on opusfile.
+ * Copyright (c) 1994-2012 by the Xiph.Org Foundation and contributors
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * Dithered Audio Sample Quantization
+ *
+ * Converts from dbl, flt, or s32 to s16 using dithering.
+ */
+
+#include <math.h>
+#include <stdint.h>
+
+#include "libavutil/common.h"
+#include "libavutil/float_dsp.h"
+#include "libavutil/lfg.h"
+#include "libavutil/mem.h"
+#include "libavutil/samplefmt.h"
+#include "audio_convert.h"
+#include "dither.h"
+#include "internal.h"
+
+typedef struct DitherState {
+ int mute;
+ AVLFG lfg;
+ float dither_a[4];
+ float dither_b[4];
+} DitherState;
+
+struct DitherContext {
+ AVFloatDSPContext fdsp;
+
+ int mute_dither_threshold; // threshold for disabling dither
+ int mute_reset_threshold; // threshold for resetting noise shaping
+ const float *ns_coef_b; // noise shaping coeffs
+ const float *ns_coef_a; // noise shaping coeffs
+
+ DitherState *state; // dither states for each channel
+
+ AudioData *flt_data; // input data in fltp
+ AudioData *s16_data; // dithered output in s16p
+ AudioConvert *ac_in; // converter for input to fltp
+ AudioConvert *ac_out; // converter for s16p to s16 (if needed)
+
+ int16_t (*quantize)(DitherContext *c, DitherState *state, float sample);
+};
+
+/* mute threshold, in seconds */
+#define MUTE_THRESHOLD_SEC 0.000333
+
+/* noise shaping coefficients */
+
+static const float ns_48_coef_b[4] = {
+ 2.2374f, -0.7339f, -0.1251f, -0.6033f
+};
+
+static const float ns_48_coef_a[4] = {
+ 0.9030f, 0.0116f, -0.5853f, -0.2571f
+};
+
+static const float ns_44_coef_b[4] = {
+ 2.2061f, -0.4707f, -0.2534f, -0.6213f
+};
+
+static const float ns_44_coef_a[4] = {
+ 1.0587f, 0.0676f, -0.6054f, -0.2738f
+};
+
+static inline float lfg_get_flt(AVLFG *lfg)
+{
+ return av_lfg_get(lfg) / (float)UINT32_MAX;
+}
+
+static int16_t quantize_rectangular(DitherContext *c, DitherState *state,
+ float sample)
+{
+ float r;
+
+ if (state->mute > c->mute_dither_threshold)
+ return 0;
+
+ r = lfg_get_flt(&state->lfg) - 0.5f;
+
+ return av_clip_int16(lrintf(sample + r));
+}
+
+static int16_t quantize_triangular(DitherContext *c, DitherState *state,
+ float sample)
+{
+ float r;
+
+ if (state->mute > c->mute_dither_threshold)
+ return 0;
+
+ r = lfg_get_flt(&state->lfg);
+ r -= lfg_get_flt(&state->lfg);
+
+ return av_clip_int16(lrintf(sample + r));
+}
+
+#define SQRT_1_6 0.40824829046386301723f
+
+static int16_t quantize_triangular_hp(DitherContext *c, DitherState *state,
+ float sample)
+{
+ float tmp, r;
+
+ if (state->mute > c->mute_dither_threshold)
+ return 0;
+
+ r = lfg_get_flt(&state->lfg);
+ r -= lfg_get_flt(&state->lfg);
+
+ /* filter is from libswresample in FFmpeg */
+ tmp = r;
+ r = ( -state->dither_a[0] +
+ 2 * state->dither_a[1] - r) * SQRT_1_6;
+
+ state->dither_a[0] = state->dither_a[1];
+ state->dither_a[1] = tmp;
+
+ return av_clip_int16(lrintf(sample + r));
+}
+
+static int16_t quantize_triangular_ns(DitherContext *c, DitherState *state,
+ float sample)
+{
+ int i;
+ float err = 0;
+ int16_t sample_s16;
+
+ for (i = 0; i < 4; i++) {
+ err += c->ns_coef_b[i] * state->dither_b[i] -
+ c->ns_coef_a[i] * state->dither_a[i];
+ }
+ for (i = 3; i > 0; i--) {
+ state->dither_a[i] = state->dither_a[i - 1];
+ state->dither_b[i] = state->dither_b[i - 1];
+ }
+ state->dither_a[0] = err;
+ sample -= err;
+
+ if (state->mute > c->mute_dither_threshold) {
+ sample_s16 = sample;
+
+ state->dither_b[0] = 0;
+ } else {
+ sample_s16 = quantize_triangular(c, state, sample);
+
+ state->dither_b[0] = av_clipf(sample_s16 - sample, -1.5f, 1.5f);
+ }
+
+ return sample_s16;
+}
+
+/*
+ * Scale the samples to s16 range.
+ * The signal is attenuated slightly to avoid clipping.
+ */
+static void scale_flt_data(AVFloatDSPContext *fdsp, AudioData *flt_data)
+{
+ int ch;
+ int aligned_len = FFALIGN(flt_data->nb_samples, 4);
+
+ if (flt_data->ptr_align & 15 || flt_data->samples_align < aligned_len) {
+ int i;
+ for (ch = 0; ch < flt_data->channels; ch++) {
+ float *samples = (float *)flt_data->data[ch];
+ for (i = 0; i < flt_data->nb_samples; i++)
+ samples[i] *= 32753.0f;
+ }
+ } else {
+ for (ch = 0; ch < flt_data->channels; ch++) {
+ fdsp->vector_fmul_scalar((float *)flt_data->data[ch],
+ (float *)flt_data->data[ch], 32753.0f,
+ aligned_len);
+ }
+ }
+
+}
+
+int ff_convert_dither(DitherContext *c, AudioData *dst, AudioData *src)
+{
+ int ch, i, ret;
+ AudioData *flt_data;
+
+ /* output directly to dst if it is planar */
+ if (dst->sample_fmt == AV_SAMPLE_FMT_S16P)
+ c->s16_data = dst;
+ else {
+ /* make sure s16_data is large enough for the output */
+ ret = ff_audio_data_realloc(c->s16_data, src->nb_samples);
+ if (ret < 0)
+ return ret;
+ }
+
+ /* make sure flt_data is large enough for the input */
+ if (src->sample_fmt != AV_SAMPLE_FMT_FLTP || src->read_only) {
+ ret = ff_audio_data_realloc(c->flt_data, src->nb_samples);
+ if (ret < 0)
+ return ret;
+ flt_data = c->flt_data;
+ } else {
+ flt_data = src;
+ }
+
+ /* convert input samples to fltp and scale to s16 range */
+ if (src->sample_fmt != AV_SAMPLE_FMT_FLTP) {
+ ret = ff_audio_convert(c->ac_in, flt_data, src);
+ if (ret < 0)
+ return ret;
+ } else if (src->read_only) {
+ ret = ff_audio_data_copy(flt_data, src);
+ if (ret < 0)
+ return ret;
+ }
+ scale_flt_data(&c->fdsp, flt_data);
+
+ /* convert/dither from fltp to s16p */
+ for (ch = 0; ch < src->channels; ch++) {
+ DitherState *state = &c->state[ch];
+ int16_t *s16_smp = (int16_t *)c->s16_data->data[ch];
+ float *flt_smp = (float *)flt_data->data[ch];
+
+ if (state->mute > c->mute_reset_threshold)
+ memset(state->dither_a, 0, sizeof(state->dither_a));
+
+ for (i = 0; i < src->nb_samples; i++) {
+ if (flt_smp[i] == 0)
+ state->mute++;
+ else
+ state->mute = 0;
+ s16_smp[i] = c->quantize(c, state, flt_smp[i]);
+ }
+ }
+ c->s16_data->nb_samples = src->nb_samples;
+
+ /* interleave output to dst if needed */
+ if (dst->sample_fmt == AV_SAMPLE_FMT_S16) {
+ ret = ff_audio_convert(c->ac_out, dst, c->s16_data);
+ if (ret < 0)
+ return ret;
+ } else
+ c->s16_data = NULL;
+
+ return 0;
+}
+
+void ff_dither_free(DitherContext **c)
+{
+ if (!*c)
+ return;
+ ff_audio_data_free(&(*c)->flt_data);
+ ff_audio_data_free(&(*c)->s16_data);
+ ff_audio_convert_free(&(*c)->ac_in);
+ ff_audio_convert_free(&(*c)->ac_out);
+ av_free((*c)->state);
+ av_freep(c);
+}
+
+DitherContext *ff_dither_alloc(AVAudioResampleContext *avr,
+ enum AVSampleFormat out_fmt,
+ enum AVSampleFormat in_fmt,
+ int channels, int sample_rate)
+{
+ AVLFG seed_gen;
+ DitherContext *c;
+ int ch, i;
+
+ if (av_get_packed_sample_fmt(out_fmt) != AV_SAMPLE_FMT_S16 ||
+ av_get_bytes_per_sample(in_fmt) <= 2) {
+ av_log(avr, AV_LOG_ERROR, "dithering %s to %s is not supported\n",
+ av_get_sample_fmt_name(in_fmt),
av_get_sample_fmt_name(out_fmt));
+ return NULL;
+ }
+
+ c = av_mallocz(sizeof(DitherContext));
+ if (!c)
+ return NULL;
+
+ if (avr->dither_method == AV_RESAMPLE_DITHER_TRIANGULAR_NS &&
+ sample_rate != 48000 && sample_rate != 44100) {
+ av_log(avr, AV_LOG_VERBOSE, "sample rate must be 48000 or 44100 Hz "
+ "for triangular_ns dither. using triangular_hp instead.\n");
+ avr->dither_method = AV_RESAMPLE_DITHER_TRIANGULAR_HP;
+ }
+ switch (avr->dither_method) {
+ case AV_RESAMPLE_DITHER_RECTANGULAR:
+ c->quantize = quantize_rectangular;
+ break;
+ case AV_RESAMPLE_DITHER_TRIANGULAR:
+ c->quantize = quantize_triangular;
+ break;
+ case AV_RESAMPLE_DITHER_TRIANGULAR_HP:
+ c->quantize = quantize_triangular_hp;
+ break;
+ case AV_RESAMPLE_DITHER_TRIANGULAR_NS:
+ c->quantize = quantize_triangular_ns;
+ if (sample_rate == 48000) {
+ c->ns_coef_b = ns_48_coef_b;
+ c->ns_coef_a = ns_48_coef_a;
+ } else {
+ c->ns_coef_b = ns_44_coef_b;
+ c->ns_coef_a = ns_44_coef_a;
+ }
+ break;
+ default:
+ goto fail;
+ }
+
+ c->flt_data = ff_audio_data_alloc(channels, 1024, AV_SAMPLE_FMT_FLTP,
+ "dither flt buffer");
+ if (!c->flt_data)
+ goto fail;
+
+ /* Either s16 or s16p output format is allowed, but s16p is used
+ internally, so we need to use a temp buffer and interleave if the output
+ format is s16 */
+ if (out_fmt != AV_SAMPLE_FMT_S16P) {
+ c->s16_data = ff_audio_data_alloc(channels, 1024, AV_SAMPLE_FMT_S16P,
+ "dither s16 buffer");
+ if (!c->s16_data)
+ goto fail;
+
+ c->ac_out = ff_audio_convert_alloc(avr, out_fmt, AV_SAMPLE_FMT_S16P,
+ channels, sample_rate);
+ if (!c->ac_out)
+ goto fail;
+ }
+
+ if (in_fmt != AV_SAMPLE_FMT_FLTP) {
+ c->ac_in = ff_audio_convert_alloc(avr, AV_SAMPLE_FMT_FLTP, in_fmt,
+ channels, sample_rate);
+ if (!c->ac_in)
+ goto fail;
+ }
+
+ c->state = av_mallocz(channels * sizeof(DitherState));
+ if (!c->state) {
+ av_free(c);
+ return NULL;
+ }
+
+ /* calculate thresholds for turning off dithering during periods of
+ silence to avoid replacing digital silence with quiet dither noise */
+ c->mute_dither_threshold = lrintf(sample_rate * MUTE_THRESHOLD_SEC);
+ c->mute_reset_threshold = c->mute_dither_threshold * 4;
+
+ /* initialize dither states */
+ av_lfg_init(&seed_gen, 0xC0FFEE);
+ for (ch = 0; ch < channels; ch++) {
+ DitherState *state = &c->state[ch];
+ state->mute = c->mute_reset_threshold + 1;
+ av_lfg_init(&state->lfg, av_lfg_get(&seed_gen));
+ /* prime the noise buffer for triangular high pass */
+ if (avr->dither_method == AV_RESAMPLE_DITHER_TRIANGULAR_HP) {
+ for (i = 0; i < 2; i++) {
+ float r = lfg_get_flt(&state->lfg);
+ r -= lfg_get_flt(&state->lfg);
+ state->dither_a[i] = r;
+ }
+ }
+ }
+
+ avpriv_float_dsp_init(&c->fdsp, 0);
+
+ return c;
+
+fail:
+ ff_dither_free(&c);
+ return NULL;
+}
diff --git a/libavresample/dither.h b/libavresample/dither.h
new file mode 100644
index 0000000..d2fef0c
--- /dev/null
+++ b/libavresample/dither.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2012 Justin Ruggles <[email protected]>
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVRESAMPLE_DITHER_H
+#define AVRESAMPLE_DITHER_H
+
+#include "avresample.h"
+#include "audio_data.h"
+
+typedef struct DitherContext DitherContext;
+
+/**
+ * Allocate and initialize a DitherContext.
+ *
+ * The parameters in the AVAudioResampleContext are used to initialize the
+ * DitherContext.
+ *
+ * @param avr AVAudioResampleContext
+ * @return newly-allocated DitherContext
+ */
+DitherContext *ff_dither_alloc(AVAudioResampleContext *avr,
+ enum AVSampleFormat out_fmt,
+ enum AVSampleFormat in_fmt,
+ int channels, int sample_rate);
+
+/**
+ * Free a DitherContext.
+ *
+ * @param c DitherContext
+ */
+void ff_dither_free(DitherContext **c);
+
+/**
+ * Convert audio sample format with dithering.
+ *
+ * @param c DitherContext
+ * @param dst destination audio data
+ * @param src source audio data
+ * @return 0 if ok, negative AVERROR code on failure
+ */
+int ff_convert_dither(DitherContext *c, AudioData *dst, AudioData *src);
+
+#endif /* AVRESAMPLE_DITHER_H */
diff --git a/libavresample/internal.h b/libavresample/internal.h
index 006b6fd..e76240c 100644
--- a/libavresample/internal.h
+++ b/libavresample/internal.h
@@ -74,6 +74,7 @@ struct AVAudioResampleContext {
ResampleContext *resample; /**< resampling context */
AudioMix *am; /**< channel mixing context */
enum AVMatrixEncoding matrix_encoding; /**< matrixed stereo encoding
*/
+ enum AVResampleDitherMethod dither_method; /**< dither method */
};
#endif /* AVRESAMPLE_INTERNAL_H */
diff --git a/libavresample/options.c b/libavresample/options.c
index 8f64370..1097f12 100644
--- a/libavresample/options.c
+++ b/libavresample/options.c
@@ -63,6 +63,12 @@ static const AVOption options[] = {
{ "blackman_nuttall", "Blackman Nuttall Windowed Sinc", 0,
AV_OPT_TYPE_CONST, { .i64 = AV_RESAMPLE_FILTER_TYPE_BLACKMAN_NUTTALL },
INT_MIN, INT_MAX, PARAM, "filter_type" },
{ "kaiser", "Kaiser Windowed Sinc", 0,
AV_OPT_TYPE_CONST, { .i64 = AV_RESAMPLE_FILTER_TYPE_KAISER },
INT_MIN, INT_MAX, PARAM, "filter_type" },
{ "kaiser_beta", "Kaiser Window Beta",
OFFSET(kaiser_beta), AV_OPT_TYPE_INT, { .i64 = 9 },
2, 16, PARAM },
+ { "dither_method", "Dither Method",
OFFSET(dither_method), AV_OPT_TYPE_INT, { .i64 =
AV_RESAMPLE_DITHER_NONE }, 0, AV_RESAMPLE_DITHER_NB-1, PARAM, "dither_method"},
+ {"none", "No Dithering", 0,
AV_OPT_TYPE_CONST, { .i64 = AV_RESAMPLE_DITHER_NONE }, INT_MIN,
INT_MAX, PARAM, "dither_method"},
+ {"rectangular", "Rectangular Dither", 0,
AV_OPT_TYPE_CONST, { .i64 = AV_RESAMPLE_DITHER_RECTANGULAR }, INT_MIN,
INT_MAX, PARAM, "dither_method"},
+ {"triangular", "Triangular Dither", 0,
AV_OPT_TYPE_CONST, { .i64 = AV_RESAMPLE_DITHER_TRIANGULAR }, INT_MIN,
INT_MAX, PARAM, "dither_method"},
+ {"triangular_hp", "Triangular Dither With High Pass", 0,
AV_OPT_TYPE_CONST, { .i64 = AV_RESAMPLE_DITHER_TRIANGULAR_HP }, INT_MIN,
INT_MAX, PARAM, "dither_method"},
+ {"triangular_ns", "Triangular Dither With Noise Shaping", 0,
AV_OPT_TYPE_CONST, { .i64 = AV_RESAMPLE_DITHER_TRIANGULAR_NS }, INT_MIN,
INT_MAX, PARAM, "dither_method"},
{ NULL },
};
diff --git a/libavresample/utils.c b/libavresample/utils.c
index 3fdeeb8..e46029f 100644
--- a/libavresample/utils.c
+++ b/libavresample/utils.c
@@ -142,7 +142,8 @@ int avresample_open(AVAudioResampleContext *avr)
/* setup contexts */
if (avr->in_convert_needed) {
avr->ac_in = ff_audio_convert_alloc(avr, avr->internal_sample_fmt,
- avr->in_sample_fmt,
avr->in_channels);
+ avr->in_sample_fmt,
avr->in_channels,
+ avr->in_sample_rate);
if (!avr->ac_in) {
ret = AVERROR(ENOMEM);
goto error;
@@ -155,7 +156,8 @@ int avresample_open(AVAudioResampleContext *avr)
else
src_fmt = avr->in_sample_fmt;
avr->ac_out = ff_audio_convert_alloc(avr, avr->out_sample_fmt, src_fmt,
- avr->out_channels);
+ avr->out_channels,
+ avr->out_sample_rate);
if (!avr->ac_out) {
ret = AVERROR(ENOMEM);
goto error;
@@ -188,8 +190,8 @@ void avresample_close(AVAudioResampleContext *avr)
ff_audio_data_free(&avr->out_buffer);
av_audio_fifo_free(avr->out_fifo);
avr->out_fifo = NULL;
- av_freep(&avr->ac_in);
- av_freep(&avr->ac_out);
+ ff_audio_convert_free(&avr->ac_in);
+ ff_audio_convert_free(&avr->ac_out);
ff_audio_resample_free(&avr->resample);
ff_audio_mix_close(avr->am);
return;
--
1.7.1
_______________________________________________
libav-devel mailing list
[email protected]
https://lists.libav.org/mailman/listinfo/libav-devel
