288 lines
17 KiB
C++
288 lines
17 KiB
C++
/* _______ ____ __ ___ ___
|
|
* \ _ \ \ / \ / \ \ / / ' ' '
|
|
* | | \ \ | | || | \/ | . .
|
|
* | | | | | | || ||\ /| |
|
|
* | | | | | | || || \/ | | ' ' '
|
|
* | | | | | | || || | | . .
|
|
* | |_/ / \ \__// || | |
|
|
* /_______/ynamic \____/niversal /__\ /____\usic /| . . ibliotheque
|
|
* / \
|
|
* / . \
|
|
* resample.inc - Resampling helper template. / / \ \
|
|
* | < / \_
|
|
* 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.
|
|
*/
|
|
|
|
void dumb_reset_resampler(DUMB_RESAMPLER *resampler, SRCTYPE *src,
|
|
int src_channels, long pos, long start, long end,
|
|
int quality) {
|
|
int i;
|
|
resampler->src = src;
|
|
resampler->pos = pos;
|
|
resampler->subpos = 0;
|
|
resampler->start = start;
|
|
resampler->end = end;
|
|
resampler->dir = 1;
|
|
resampler->pickup = NULL;
|
|
resampler->pickup_data = NULL;
|
|
if (quality < 0) {
|
|
resampler->quality = 0;
|
|
} else if (quality > DUMB_RQ_N_LEVELS - 1) {
|
|
resampler->quality = DUMB_RQ_N_LEVELS - 1;
|
|
} else {
|
|
resampler->quality = quality;
|
|
}
|
|
for (i = 0; i < src_channels * 3; i++)
|
|
resampler->X[i] = 0;
|
|
resampler->overshot = -1;
|
|
resampler->fir_resampler_ratio = 0;
|
|
resampler_clear(resampler->fir_resampler[0]);
|
|
resampler_clear(resampler->fir_resampler[1]);
|
|
resampler_set_quality(resampler->fir_resampler[0], resampler->quality);
|
|
resampler_set_quality(resampler->fir_resampler[1], resampler->quality);
|
|
}
|
|
|
|
DUMB_RESAMPLER *dumb_start_resampler(SRCTYPE *src, int src_channels, long pos,
|
|
long start, long end, int quality) {
|
|
DUMB_RESAMPLER *resampler = malloc(sizeof(*resampler));
|
|
if (!resampler)
|
|
return NULL;
|
|
dumb_reset_resampler(resampler, src, src_channels, pos, start, end,
|
|
quality);
|
|
return resampler;
|
|
}
|
|
|
|
#define UPDATE_VOLUME(pvol, vol) \
|
|
{ \
|
|
if (pvol) { \
|
|
vol##r += vol##d; \
|
|
if ((vol##d < 0 && vol##r <= vol##t) || \
|
|
(vol##d > 0 && vol##r >= vol##t)) { \
|
|
pvol->volume = pvol->target; \
|
|
if (pvol->declick_stage == 0 || pvol->declick_stage >= 3) \
|
|
pvol->declick_stage++; \
|
|
pvol = NULL; \
|
|
vol = vol##t * vol##m; \
|
|
} else { \
|
|
vol = vol##r * vol##m; \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
/* Create mono source resampler. */
|
|
#define SUFFIX2 _1
|
|
#define SRC_CHANNELS 1
|
|
#define DIVIDE_BY_SRC_CHANNELS(x) (x)
|
|
#define COPYSRC(dstarray, dstindex, srcarray, srcindex) \
|
|
(dstarray)[dstindex] = (srcarray)[srcindex]
|
|
#define COPYSRC2(dstarray, dstindex, condition, srcarray, srcindex) \
|
|
(dstarray)[dstindex] = condition ? (srcarray)[srcindex] : 0
|
|
#define MONO_DEST_VOLUME_PARAMETERS DUMB_VOLUME_RAMP_INFO *volume
|
|
#define MONO_DEST_VOLUME_VARIABLES vol, volr, vold, volt, volm
|
|
#define MONO_DEST_VOLUME_ZEROS 0
|
|
#define SET_MONO_DEST_VOLUME_VARIABLES \
|
|
{ \
|
|
if (volume) { \
|
|
volr = volume->volume; \
|
|
vold = volume->delta; \
|
|
volt = volume->target; \
|
|
volm = volume->mix; \
|
|
vol = volr * volm; \
|
|
if (volr == volt) \
|
|
volume = NULL; \
|
|
} else { \
|
|
vol = 0; \
|
|
volr = 0; \
|
|
vold = 0; \
|
|
volt = 0; \
|
|
volm = 0; \
|
|
} \
|
|
}
|
|
#define RETURN_MONO_DEST_VOLUME_VARIABLES \
|
|
if (volume) \
|
|
volume->volume = volr
|
|
#define MONO_DEST_VOLUMES_ARE_ZERO (vol == 0 && volt == 0)
|
|
#define POKE_FIR(offset) \
|
|
{ \
|
|
resampler_write_sample_float(resampler->fir_resampler[0], \
|
|
FIR(x[offset])); \
|
|
}
|
|
#define MONO_DEST_PEEK_FIR \
|
|
*dst = resampler_get_sample_float(resampler->fir_resampler[0]) * vol * \
|
|
16777216.0f
|
|
#define MONO_DEST_MIX_FIR \
|
|
{ \
|
|
*dst++ += resampler_get_sample_float(resampler->fir_resampler[0]) * \
|
|
vol * 16777216.0f; \
|
|
UPDATE_VOLUME(volume, vol); \
|
|
}
|
|
#define ADVANCE_FIR resampler_remove_sample(resampler->fir_resampler[0], 1)
|
|
#define STEREO_DEST_PEEK_FIR \
|
|
{ \
|
|
float sample = \
|
|
resampler_get_sample_float(resampler->fir_resampler[0]); \
|
|
*dst++ = sample * lvol * 16777216.0f; \
|
|
*dst++ = sample * rvol * 16777216.0f; \
|
|
}
|
|
#define STEREO_DEST_MIX_FIR \
|
|
{ \
|
|
float sample = \
|
|
resampler_get_sample_float(resampler->fir_resampler[0]); \
|
|
*dst++ += sample * lvol * 16777216.0f; \
|
|
*dst++ += sample * rvol * 16777216.0f; \
|
|
UPDATE_VOLUME(volume_left, lvol); \
|
|
UPDATE_VOLUME(volume_right, rvol); \
|
|
}
|
|
#include "resamp2.inc"
|
|
|
|
/* Create stereo source resampler. */
|
|
#define SUFFIX2 _2
|
|
#define SRC_CHANNELS 2
|
|
#define DIVIDE_BY_SRC_CHANNELS(x) ((x) >> 1)
|
|
#define COPYSRC(dstarray, dstindex, srcarray, srcindex) \
|
|
{ \
|
|
(dstarray)[(dstindex)*2] = (srcarray)[(srcindex)*2]; \
|
|
(dstarray)[(dstindex)*2 + 1] = (srcarray)[(srcindex)*2 + 1]; \
|
|
}
|
|
#define COPYSRC2(dstarray, dstindex, condition, srcarray, srcindex) \
|
|
{ \
|
|
if (condition) { \
|
|
(dstarray)[(dstindex)*2] = (srcarray)[(srcindex)*2]; \
|
|
(dstarray)[(dstindex)*2 + 1] = (srcarray)[(srcindex)*2 + 1]; \
|
|
} else { \
|
|
(dstarray)[(dstindex)*2] = 0; \
|
|
(dstarray)[(dstindex)*2 + 1] = 0; \
|
|
} \
|
|
}
|
|
|
|
#define MONO_DEST_VOLUME_PARAMETERS \
|
|
DUMB_VOLUME_RAMP_INFO *volume_left, DUMB_VOLUME_RAMP_INFO *volume_right
|
|
#define MONO_DEST_VOLUME_VARIABLES \
|
|
lvol, lvolr, lvold, lvolt, lvolm, rvol, rvolr, rvold, rvolt, rvolm
|
|
#define MONO_DEST_VOLUME_ZEROS 0, 0
|
|
#define SET_MONO_DEST_VOLUME_VARIABLES \
|
|
{ \
|
|
if (volume_left) { \
|
|
lvolr = volume_left->volume; \
|
|
lvold = volume_left->delta; \
|
|
lvolt = volume_left->target; \
|
|
lvolm = volume_left->mix; \
|
|
lvol = lvolr * lvolm; \
|
|
if (lvolr == lvolt) \
|
|
volume_left = NULL; \
|
|
} else { \
|
|
lvol = 0; \
|
|
lvolr = 0; \
|
|
lvold = 0; \
|
|
lvolt = 0; \
|
|
lvolm = 0; \
|
|
} \
|
|
if (volume_right) { \
|
|
rvolr = volume_right->volume; \
|
|
rvold = volume_right->delta; \
|
|
rvolt = volume_right->target; \
|
|
rvolm = volume_right->mix; \
|
|
rvol = rvolr * rvolm; \
|
|
if (rvolr == rvolt) \
|
|
volume_right = NULL; \
|
|
} else { \
|
|
rvol = 0; \
|
|
rvolr = 0; \
|
|
rvold = 0; \
|
|
rvolt = 0; \
|
|
rvolm = 0; \
|
|
} \
|
|
}
|
|
#define RETURN_MONO_DEST_VOLUME_VARIABLES \
|
|
{ \
|
|
if (volume_left) \
|
|
volume_left->volume = lvolr; \
|
|
if (volume_right) \
|
|
volume_right->volume = rvolr; \
|
|
}
|
|
#define MONO_DEST_VOLUMES_ARE_ZERO \
|
|
(lvol == 0 && lvolt == 0 && rvol == 0 && rvolt == 0)
|
|
#define POKE_FIR(offset) \
|
|
{ \
|
|
resampler_write_sample_float(resampler->fir_resampler[0], \
|
|
FIR(x[(offset)*2 + 0])); \
|
|
resampler_write_sample_float(resampler->fir_resampler[1], \
|
|
FIR(x[(offset)*2 + 1])); \
|
|
}
|
|
#define MONO_DEST_PEEK_FIR \
|
|
{ \
|
|
*dst = \
|
|
(resampler_get_sample_float(resampler->fir_resampler[0]) * lvol + \
|
|
resampler_get_sample_float(resampler->fir_resampler[1]) * rvol) * \
|
|
16777216.0f; \
|
|
}
|
|
#define MONO_DEST_MIX_FIR \
|
|
{ \
|
|
*dst++ += \
|
|
(resampler_get_sample_float(resampler->fir_resampler[0]) * lvol + \
|
|
resampler_get_sample_float(resampler->fir_resampler[1]) * rvol) * \
|
|
16777216.0f; \
|
|
UPDATE_VOLUME(volume_left, lvol); \
|
|
UPDATE_VOLUME(volume_right, rvol); \
|
|
}
|
|
#define ADVANCE_FIR \
|
|
{ \
|
|
resampler_remove_sample(resampler->fir_resampler[0], 1); \
|
|
resampler_remove_sample(resampler->fir_resampler[1], 1); \
|
|
}
|
|
#define STEREO_DEST_PEEK_FIR \
|
|
{ \
|
|
*dst++ = resampler_get_sample_float(resampler->fir_resampler[0]) * \
|
|
lvol * 16777216.0f; \
|
|
*dst++ = resampler_get_sample_float(resampler->fir_resampler[1]) * \
|
|
rvol * 16777216.0f; \
|
|
}
|
|
#define STEREO_DEST_MIX_FIR \
|
|
{ \
|
|
*dst++ += resampler_get_sample_float(resampler->fir_resampler[0]) * \
|
|
lvol * 16777216.0f; \
|
|
*dst++ += resampler_get_sample_float(resampler->fir_resampler[1]) * \
|
|
rvol * 16777216.0f; \
|
|
UPDATE_VOLUME(volume_left, lvol); \
|
|
UPDATE_VOLUME(volume_right, rvol); \
|
|
}
|
|
#include "resamp2.inc"
|
|
|
|
void dumb_end_resampler(DUMB_RESAMPLER *resampler) {
|
|
if (resampler)
|
|
free(resampler);
|
|
}
|
|
|
|
#undef FIR
|
|
#undef SRCBITS
|
|
#undef SRCTYPE
|
|
#undef SUFFIX
|