xref: /third_party/pulseaudio/src/pulsecore/resampler/soxr.c

/***
  This file is part of PulseAudio.

  Copyright 2014, 2015 Andrey Semashev

  PulseAudio 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.

  PulseAudio 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
  General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
***/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stddef.h>
#include <soxr.h>

#include <pulsecore/resampler.h>

static unsigned resampler_soxr_resample(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames,
                                        pa_memchunk *output, unsigned *out_n_frames) {
    soxr_t state;
    void *in, *out;
    size_t consumed = 0, produced = 0;

    pa_assert(r);
    pa_assert(input);
    pa_assert(output);
    pa_assert(out_n_frames);

    state = r->impl.data;
    pa_assert(state);

    in = pa_memblock_acquire_chunk(input);
    out = pa_memblock_acquire_chunk(output);

    pa_assert_se(soxr_process(state, in, in_n_frames, &consumed, out, *out_n_frames, &produced) == 0);

    pa_memblock_release(input->memblock);
    pa_memblock_release(output->memblock);

    *out_n_frames = produced;

    return in_n_frames - consumed;
}

static void resampler_soxr_free(pa_resampler *r) {
    pa_assert(r);

    if (!r->impl.data)
        return;

    soxr_delete(r->impl.data);
    r->impl.data = NULL;
}

static void resampler_soxr_reset(pa_resampler *r) {
#if SOXR_THIS_VERSION >= SOXR_VERSION(0, 1, 2)
    double ratio;

    pa_assert(r);

    soxr_clear(r->impl.data);

    ratio = (double)r->i_ss.rate / (double)r->o_ss.rate;
    soxr_set_io_ratio(r->impl.data, ratio, 0);
#else
    /* With libsoxr prior to 0.1.2 soxr_clear() makes soxr_process() crash afterwards,
     * so don't use this function and re-create the context instead. */
    soxr_t old_state;

    pa_assert(r);

    old_state = r->impl.data;
    r->impl.data = NULL;

    if (pa_resampler_soxr_init(r) == 0) {
        if (old_state)
            soxr_delete(old_state);
    } else {
        r->impl.data = old_state;
        pa_log_error("Failed to reset libsoxr context");
    }
#endif
}

static void resampler_soxr_update_rates(pa_resampler *r) {
    double ratio;

    pa_assert(r);

    ratio = (double)r->i_ss.rate / (double)r->o_ss.rate;
    soxr_set_io_ratio(r->impl.data, ratio, 0);
}

int pa_resampler_soxr_init(pa_resampler *r) {
    soxr_t state;
    soxr_datatype_t io_format;
    soxr_io_spec_t io_spec;
    soxr_runtime_spec_t runtime_spec;
    unsigned long quality_recipe;
    soxr_quality_spec_t quality;
    soxr_error_t err = NULL;
    double ratio;

    pa_assert(r);

    switch (r->work_format) {
        case PA_SAMPLE_S16NE:
            io_format = SOXR_INT16_I;
            break;
        case PA_SAMPLE_FLOAT32NE:
            io_format = SOXR_FLOAT32_I;
            break;
        default:
            pa_assert_not_reached();
    }

    io_spec = soxr_io_spec(io_format, io_format);

    /* Resample in one thread. Multithreading makes
     * performance worse with small chunks of audio. */
    runtime_spec = soxr_runtime_spec(1);

    switch (r->method) {
        case PA_RESAMPLER_SOXR_MQ:
            quality_recipe = SOXR_MQ | SOXR_LINEAR_PHASE;
            break;
        case PA_RESAMPLER_SOXR_HQ:
            quality_recipe = SOXR_HQ | SOXR_LINEAR_PHASE;
            break;
        case PA_RESAMPLER_SOXR_VHQ:
            quality_recipe = SOXR_VHQ | SOXR_LINEAR_PHASE;
            break;
        default:
            pa_assert_not_reached();
    }

    quality = soxr_quality_spec(quality_recipe, SOXR_VR);

    /* Maximum resample ratio is 100:1 */
    state = soxr_create(100, 1, r->work_channels, &err, &io_spec, &quality, &runtime_spec);
    if (!state) {
        pa_log_error("Failed to create libsoxr resampler context: %s.", (err ? err : "[unknown error]"));
        return -1;
    }

    ratio = (double)r->i_ss.rate / (double)r->o_ss.rate;
    soxr_set_io_ratio(state, ratio, 0);

    r->impl.free = resampler_soxr_free;
    r->impl.reset = resampler_soxr_reset;
    r->impl.update_rates = resampler_soxr_update_rates;
    r->impl.resample = resampler_soxr_resample;
    r->impl.data = state;

    return 0;
}