ref: cab1803f1d6517754696b5c3d9b600e23ef9015e
dir: /src/helpers/resample.c/
/* _______ ____ __ ___ ___
* \ _ \ \ / \ / \ \ / / ' ' '
* | | \ \ | | || | \/ | . .
* | | | | | | || ||\ /| |
* | | | | | | || || \/ | | ' ' '
* | | | | | | || || | | . .
* | |_/ / \ \__// || | |
* /_______/ynamic \____/niversal /__\ /____\usic /| . . ibliotheque
* / \
* / . \
* resample.c - Resampling helpers. / / \ \
* | < / \_
* By Bob and entheh. | \/ /\ /
* \_ / > /
* In order to find a good trade-off between | \ / /
* speed and accuracy in this code, some tests | ' /
* were carried out regarding the behaviour of \__/
* long long ints with gcc. The following code
* was tested:
*
* int a, b, c;
* c = ((long long)a * b) >> 16;
*
* DJGPP GCC Version 3.0.3 generated the following assembly language code for
* the multiplication and scaling, leaving the 32-bit result in EAX.
*
* movl -8(%ebp), %eax ; read one int into EAX
* imull -4(%ebp) ; multiply by the other; result goes in EDX:EAX
* shrdl $16, %edx, %eax ; shift EAX right 16, shifting bits in from EDX
*
* Note that a 32*32->64 multiplication is performed, allowing for high
* accuracy. On the Pentium 2 and above, shrdl takes two cycles (generally),
* so it is a minor concern when four multiplications are being performed
* (the cubic resampler). On the Pentium MMX and earlier, it takes four or
* more cycles, so this method is unsuitable for use in the low-quality
* resamplers.
*
* Since "long long" is a gcc-specific extension, we use LONG_LONG instead,
* defined in dumb.h. We may investigate later what code MSVC generates, but
* if it seems too slow then we suggest you use a good compiler.
*
* FIXME: these comments are somewhat out of date now.
*/
#include <math.h>
#include "internal/resampler.h"
#include "internal/dumb.h"
/* Compile with -DHEAVYDEBUG if you want to make sure the pick-up function is
* called when it should be. There will be a considerable performance hit,
* since at least one condition has to be tested for every sample generated.
*/
#ifdef HEAVYDEBUG
#define HEAVYASSERT(cond) ASSERT(cond)
#else
#define HEAVYASSERT(cond)
#endif
/* Make MSVC shut the hell up about if ( upd ) UPDATE_VOLUME() conditions being
* constant */
#ifdef _MSC_VER
#pragma warning(disable : 4127 4701)
#endif
/* A global variable for controlling resampling quality wherever a local
* specification doesn't override it. The following values are valid:
*
* 0 - DUMB_RQ_ALIASING - fastest
* 1 - DUMB_RQ_BLEP - nicer than aliasing, but slower
* 2 - DUMB_RQ_LINEAR
* 3 - DUMB_RQ_BLAM - band-limited linear interpolation, nice but slower
* 4 - DUMB_RQ_CUBIC
* 5 - DUMB_RQ_FIR - nicest
*
* Values outside the range 0-4 will behave the same as the nearest
* value within the range.
*/
int dumb_resampling_quality = DUMB_RQ_CUBIC;
//#define MULSC(a, b) ((int)((LONG_LONG)(a) * (b) >> 16))
//#define MULSC(a, b) ((a) * ((b) >> 2) >> 14)
#define MULSCV(a, b) ((int)((LONG_LONG)(a) * (b) >> 32))
#define MULSC(a, b) ((int)((LONG_LONG)((a) << 4) * ((b) << 12) >> 32))
#define MULSC16(a, b) ((int)((LONG_LONG)((a) << 12) * ((b) << 12) >> 32))
/* Executes the content 'iterator' times.
* Clobbers the 'iterator' variable.
* The loop is unrolled by four.
*/
#if 0
#define LOOP4(iterator, CONTENT) \
{ \
if ((iterator)&2) { \
CONTENT; \
CONTENT; \
} \
if ((iterator)&1) { \
CONTENT; \
} \
(iterator) >>= 2; \
while (iterator) { \
CONTENT; \
CONTENT; \
CONTENT; \
CONTENT; \
(iterator)--; \
} \
}
#else
#define LOOP4(iterator, CONTENT) \
{ \
while ((iterator)--) { \
CONTENT; \
} \
}
#endif
#define PASTERAW(a, b) a##b /* This does not expand macros in b ... */
#define PASTE(a, b) \
PASTERAW(a, b) /* ... but b is expanded during this substitution. */
#define X PASTE(x.x, SRCBITS)
void _dumb_init_cubic(void) {
static int done = 0;
if (done)
return;
resampler_init();
done = 1;
}
/* Create resamplers for 24-in-32-bit source samples. */
/* #define SUFFIX
* MSVC warns if we try to paste a null SUFFIX, so instead we define
* special macros for the function names that don't bother doing the
* corresponding paste. The more generic definitions are further down.
*/
#define process_pickup PASTE(process_pickup, SUFFIX2)
#define dumb_resample PASTE(PASTE(dumb_resample, SUFFIX2), SUFFIX3)
#define dumb_resample_get_current_sample \
PASTE(PASTE(dumb_resample_get_current_sample, SUFFIX2), SUFFIX3)
#define SRCTYPE sample_t
#define SRCBITS 24
#define FIR(x) (x >> 8)
#include "resample.inc"
/* Undefine the simplified macros. */
#undef dumb_resample_get_current_sample
#undef dumb_resample
#undef process_pickup
/* Now define the proper ones that use SUFFIX. */
#define dumb_reset_resampler PASTE(dumb_reset_resampler, SUFFIX)
#define dumb_start_resampler PASTE(dumb_start_resampler, SUFFIX)
#define process_pickup PASTE(PASTE(process_pickup, SUFFIX), SUFFIX2)
#define dumb_resample \
PASTE(PASTE(PASTE(dumb_resample, SUFFIX), SUFFIX2), SUFFIX3)
#define dumb_resample_get_current_sample \
PASTE(PASTE(PASTE(dumb_resample_get_current_sample, SUFFIX), SUFFIX2), \
SUFFIX3)
#define dumb_end_resampler PASTE(dumb_end_resampler, SUFFIX)
/* Create resamplers for 16-bit source samples. */
#define SUFFIX _16
#define SRCTYPE short
#define SRCBITS 16
#define FIR(x) (x * (1.0f / 32768.0f))
#include "resample.inc"
/* Create resamplers for 8-bit source samples. */
#define SUFFIX _8
#define SRCTYPE signed char
#define SRCBITS 8
#define FIR(x) (x * (1.0f / 256.0f))
#include "resample.inc"
#undef dumb_reset_resampler
#undef dumb_start_resampler
#undef process_pickup
#undef dumb_resample
#undef dumb_resample_get_current_sample
#undef dumb_end_resampler
void dumb_reset_resampler_n(int n, DUMB_RESAMPLER *resampler, void *src,
int src_channels, long pos, long start, long end,
int quality) {
if (n == 8)
dumb_reset_resampler_8(resampler, src, src_channels, pos, start, end,
quality);
else if (n == 16)
dumb_reset_resampler_16(resampler, src, src_channels, pos, start, end,
quality);
else
dumb_reset_resampler(resampler, src, src_channels, pos, start, end,
quality);
}
DUMB_RESAMPLER *dumb_start_resampler_n(int n, void *src, int src_channels,
long pos, long start, long end,
int quality) {
if (n == 8)
return dumb_start_resampler_8(src, src_channels, pos, start, end,
quality);
else if (n == 16)
return dumb_start_resampler_16(src, src_channels, pos, start, end,
quality);
else
return dumb_start_resampler(src, src_channels, pos, start, end,
quality);
}
long dumb_resample_n_1_1(int n, DUMB_RESAMPLER *resampler, sample_t *dst,
long dst_size, DUMB_VOLUME_RAMP_INFO *volume,
float delta) {
if (n == 8)
return dumb_resample_8_1_1(resampler, dst, dst_size, volume, delta);
else if (n == 16)
return dumb_resample_16_1_1(resampler, dst, dst_size, volume, delta);
else
return dumb_resample_1_1(resampler, dst, dst_size, volume, delta);
}
long dumb_resample_n_1_2(int n, DUMB_RESAMPLER *resampler, sample_t *dst,
long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left,
DUMB_VOLUME_RAMP_INFO *volume_right, float delta) {
if (n == 8)
return dumb_resample_8_1_2(resampler, dst, dst_size, volume_left,
volume_right, delta);
else if (n == 16)
return dumb_resample_16_1_2(resampler, dst, dst_size, volume_left,
volume_right, delta);
else
return dumb_resample_1_2(resampler, dst, dst_size, volume_left,
volume_right, delta);
}
long dumb_resample_n_2_1(int n, DUMB_RESAMPLER *resampler, sample_t *dst,
long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left,
DUMB_VOLUME_RAMP_INFO *volume_right, float delta) {
if (n == 8)
return dumb_resample_8_2_1(resampler, dst, dst_size, volume_left,
volume_right, delta);
else if (n == 16)
return dumb_resample_16_2_1(resampler, dst, dst_size, volume_left,
volume_right, delta);
else
return dumb_resample_2_1(resampler, dst, dst_size, volume_left,
volume_right, delta);
}
long dumb_resample_n_2_2(int n, DUMB_RESAMPLER *resampler, sample_t *dst,
long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left,
DUMB_VOLUME_RAMP_INFO *volume_right, float delta) {
if (n == 8)
return dumb_resample_8_2_2(resampler, dst, dst_size, volume_left,
volume_right, delta);
else if (n == 16)
return dumb_resample_16_2_2(resampler, dst, dst_size, volume_left,
volume_right, delta);
else
return dumb_resample_2_2(resampler, dst, dst_size, volume_left,
volume_right, delta);
}
void dumb_resample_get_current_sample_n_1_1(int n, DUMB_RESAMPLER *resampler,
DUMB_VOLUME_RAMP_INFO *volume,
sample_t *dst) {
if (n == 8)
dumb_resample_get_current_sample_8_1_1(resampler, volume, dst);
else if (n == 16)
dumb_resample_get_current_sample_16_1_1(resampler, volume, dst);
else
dumb_resample_get_current_sample_1_1(resampler, volume, dst);
}
void dumb_resample_get_current_sample_n_1_2(int n, DUMB_RESAMPLER *resampler,
DUMB_VOLUME_RAMP_INFO *volume_left,
DUMB_VOLUME_RAMP_INFO *volume_right,
sample_t *dst) {
if (n == 8)
dumb_resample_get_current_sample_8_1_2(resampler, volume_left,
volume_right, dst);
else if (n == 16)
dumb_resample_get_current_sample_16_1_2(resampler, volume_left,
volume_right, dst);
else
dumb_resample_get_current_sample_1_2(resampler, volume_left,
volume_right, dst);
}
void dumb_resample_get_current_sample_n_2_1(int n, DUMB_RESAMPLER *resampler,
DUMB_VOLUME_RAMP_INFO *volume_left,
DUMB_VOLUME_RAMP_INFO *volume_right,
sample_t *dst) {
if (n == 8)
dumb_resample_get_current_sample_8_2_1(resampler, volume_left,
volume_right, dst);
else if (n == 16)
dumb_resample_get_current_sample_16_2_1(resampler, volume_left,
volume_right, dst);
else
dumb_resample_get_current_sample_2_1(resampler, volume_left,
volume_right, dst);
}
void dumb_resample_get_current_sample_n_2_2(int n, DUMB_RESAMPLER *resampler,
DUMB_VOLUME_RAMP_INFO *volume_left,
DUMB_VOLUME_RAMP_INFO *volume_right,
sample_t *dst) {
if (n == 8)
dumb_resample_get_current_sample_8_2_2(resampler, volume_left,
volume_right, dst);
else if (n == 16)
dumb_resample_get_current_sample_16_2_2(resampler, volume_left,
volume_right, dst);
else
dumb_resample_get_current_sample_2_2(resampler, volume_left,
volume_right, dst);
}
void dumb_end_resampler_n(int n, DUMB_RESAMPLER *resampler) {
if (n == 8)
dumb_end_resampler_8(resampler);
else if (n == 16)
dumb_end_resampler_16(resampler);
else
dumb_end_resampler(resampler);
}