/* * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com> * * Triangular with Noise Shaping is based on opusfile. * Copyright (c) 1994-2012 by the Xiph.Org Foundation and contributors * * This file is part of FFmpeg. * * FFmpeg 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. * * FFmpeg 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 FFmpeg; 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/attributes.h" #include "libavutil/common.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; unsigned int seed; AVLFG lfg; float *noise_buf; int noise_buf_size; int noise_buf_ptr; float dither_a[4]; float dither_b[4]; } DitherState; struct DitherContext { DitherDSPContext ddsp; enum AVResampleDitherMethod method; int apply_map; ChannelMapInfo *ch_map_info; 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 int channels; 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) void (*quantize)(int16_t *dst, const float *src, float *dither, int len); int samples_align; }; /* mute threshold, in seconds */ #define MUTE_THRESHOLD_SEC 0.000333 /* scale factor for 16-bit output. The signal is attenuated slightly to avoid clipping */ #define S16_SCALE 32753.0f /* scale to convert lfg from INT_MIN/INT_MAX to -0.5/0.5 */ #define LFG_SCALE (1.0f / (2.0f * INT32_MAX)) /* 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 void dither_int_to_float_rectangular_c(float *dst, int *src, int len) { int i; for (i = 0; i < len; i++) dst[i] = src[i] * LFG_SCALE; } static void dither_int_to_float_triangular_c(float *dst, int *src0, int len) { int i; int *src1 = src0 + len; for (i = 0; i < len; i++) { float r = src0[i] * LFG_SCALE; r += src1[i] * LFG_SCALE; dst[i] = r; } } static void quantize_c(int16_t *dst, const float *src, float *dither, int len) { int i; for (i = 0; i < len; i++) dst[i] = av_clip_int16(lrintf(src[i] * S16_SCALE + dither[i])); } #define SQRT_1_6 0.40824829046386301723f static void dither_highpass_filter(float *src, int len) { int i; /* filter is from libswresample in FFmpeg */ for (i = 0; i < len - 2; i++) src[i] = (-src[i] + 2 * src[i + 1] - src[i + 2]) * SQRT_1_6; } static int generate_dither_noise(DitherContext *c, DitherState *state, int min_samples) { int i; int nb_samples = FFALIGN(min_samples, 16) + 16; int buf_samples = nb_samples * (c->method == AV_RESAMPLE_DITHER_RECTANGULAR ? 1 : 2); unsigned int *noise_buf_ui; av_freep(&state->noise_buf); state->noise_buf_size = state->noise_buf_ptr = 0; state->noise_buf = av_malloc(buf_samples * sizeof(*state->noise_buf)); if (!state->noise_buf) return AVERROR(ENOMEM); state->noise_buf_size = FFALIGN(min_samples, 16); noise_buf_ui = (unsigned int *)state->noise_buf; av_lfg_init(&state->lfg, state->seed); for (i = 0; i < buf_samples; i++) noise_buf_ui[i] = av_lfg_get(&state->lfg); c->ddsp.dither_int_to_float(state->noise_buf, noise_buf_ui, nb_samples); if (c->method == AV_RESAMPLE_DITHER_TRIANGULAR_HP) dither_highpass_filter(state->noise_buf, nb_samples); return 0; } static void quantize_triangular_ns(DitherContext *c, DitherState *state, int16_t *dst, const float *src, int nb_samples) { int i, j; float *dither = &state->noise_buf[state->noise_buf_ptr]; if (state->mute > c->mute_reset_threshold) memset(state->dither_a, 0, sizeof(state->dither_a)); for (i = 0; i < nb_samples; i++) { float err = 0; float sample = src[i] * S16_SCALE; for (j = 0; j < 4; j++) { err += c->ns_coef_b[j] * state->dither_b[j] - c->ns_coef_a[j] * state->dither_a[j]; } for (j = 3; j > 0; j--) { state->dither_a[j] = state->dither_a[j - 1]; state->dither_b[j] = state->dither_b[j - 1]; } state->dither_a[0] = err; sample -= err; if (state->mute > c->mute_dither_threshold) { dst[i] = av_clip_int16(lrintf(sample)); state->dither_b[0] = 0; } else { dst[i] = av_clip_int16(lrintf(sample + dither[i])); state->dither_b[0] = av_clipf(dst[i] - sample, -1.5f, 1.5f); } state->mute++; if (src[i]) state->mute = 0; } } static int convert_samples(DitherContext *c, int16_t **dst, float * const *src, int channels, int nb_samples) { int ch, ret; int aligned_samples = FFALIGN(nb_samples, 16); for (ch = 0; ch < channels; ch++) { DitherState *state = &c->state[ch]; if (state->noise_buf_size < aligned_samples) { ret = generate_dither_noise(c, state, nb_samples); if (ret < 0) return ret; } else if (state->noise_buf_size - state->noise_buf_ptr < aligned_samples) { state->noise_buf_ptr = 0; } if (c->method == AV_RESAMPLE_DITHER_TRIANGULAR_NS) { quantize_triangular_ns(c, state, dst[ch], src[ch], nb_samples); } else { c->quantize(dst[ch], src[ch], &state->noise_buf[state->noise_buf_ptr], FFALIGN(nb_samples, c->samples_align)); } state->noise_buf_ptr += aligned_samples; } return 0; } int ff_convert_dither(DitherContext *c, AudioData *dst, AudioData *src) { int 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; } if (src->sample_fmt != AV_SAMPLE_FMT_FLTP || c->apply_map) { /* make sure flt_data is large enough for the input */ ret = ff_audio_data_realloc(c->flt_data, src->nb_samples); if (ret < 0) return ret; flt_data = c->flt_data; } if (src->sample_fmt != AV_SAMPLE_FMT_FLTP) { /* convert input samples to fltp and scale to s16 range */ ret = ff_audio_convert(c->ac_in, flt_data, src); if (ret < 0) return ret; } else if (c->apply_map) { ret = ff_audio_data_copy(flt_data, src, c->ch_map_info); if (ret < 0) return ret; } else { flt_data = src; } /* check alignment and padding constraints */ if (c->method != AV_RESAMPLE_DITHER_TRIANGULAR_NS) { int ptr_align = FFMIN(flt_data->ptr_align, c->s16_data->ptr_align); int samples_align = FFMIN(flt_data->samples_align, c->s16_data->samples_align); int aligned_len = FFALIGN(src->nb_samples, c->ddsp.samples_align); if (!(ptr_align % c->ddsp.ptr_align) && samples_align >= aligned_len) { c->quantize = c->ddsp.quantize; c->samples_align = c->ddsp.samples_align; } else { c->quantize = quantize_c; c->samples_align = 1; } } ret = convert_samples(c, (int16_t **)c->s16_data->data, (float * const *)flt_data->data, src->channels, src->nb_samples); if (ret < 0) return ret; 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 **cp) { DitherContext *c = *cp; int ch; 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); for (ch = 0; ch < c->channels; ch++) av_free(c->state[ch].noise_buf); av_free(c->state); av_freep(cp); } static av_cold void dither_init(DitherDSPContext *ddsp, enum AVResampleDitherMethod method) { ddsp->quantize = quantize_c; ddsp->ptr_align = 1; ddsp->samples_align = 1; if (method == AV_RESAMPLE_DITHER_RECTANGULAR) ddsp->dither_int_to_float = dither_int_to_float_rectangular_c; else ddsp->dither_int_to_float = dither_int_to_float_triangular_c; if (ARCH_X86) ff_dither_init_x86(ddsp, method); } DitherContext *ff_dither_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AVLFG seed_gen; DitherContext *c; int ch; 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(*c)); if (!c) return NULL; c->apply_map = apply_map; if (apply_map) c->ch_map_info = &avr->ch_map_info; if (avr->dither_method == AV_RESAMPLE_DITHER_TRIANGULAR_NS && sample_rate != 48000 && sample_rate != 44100) { av_log(avr, AV_LOG_WARNING, "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; } c->method = avr->dither_method; dither_init(&c->ddsp, c->method); if (c->method == AV_RESAMPLE_DITHER_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; } } /* 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, 0); if (!c->ac_out) goto fail; } if (in_fmt != AV_SAMPLE_FMT_FLTP || c->apply_map) { c->flt_data = ff_audio_data_alloc(channels, 1024, AV_SAMPLE_FMT_FLTP, "dither flt buffer"); if (!c->flt_data) 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, c->apply_map); if (!c->ac_in) goto fail; } c->state = av_mallocz(channels * sizeof(*c->state)); if (!c->state) goto fail; c->channels = channels; /* 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; state->seed = av_lfg_get(&seed_gen); generate_dither_noise(c, state, FFMAX(32768, sample_rate / 2)); } return c; fail: ff_dither_free(&c); return NULL; }