From 26839c4b9eb549eebf8db6eae2399ed6fd94efa8 Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Tue, 11 Aug 2009 15:15:57 +0200 Subject: sample-utils: split out functions from case Move the volume functions out of the switch case and use a table indexed by the sample format to find the volume function. --- src/pulsecore/sample-util.c | 586 +++++++++++++++++++++++--------------------- 1 file changed, 303 insertions(+), 283 deletions(-) (limited to 'src/pulsecore/sample-util.c') diff --git a/src/pulsecore/sample-util.c b/src/pulsecore/sample-util.c index 5b8ccf59..ef435673 100644 --- a/src/pulsecore/sample-util.c +++ b/src/pulsecore/sample-util.c @@ -690,361 +690,381 @@ size_t pa_mix( return length; } +typedef struct pa_volume_funcs { + void (*u8) (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length); + void (*alaw) (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length); + void (*ulaw) (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length); + void (*s16ne) (int16_t *samples, int32_t *volumes, unsigned channels, unsigned length); + void (*s16re) (int16_t *samples, int32_t *volumes, unsigned channels, unsigned length); + void (*float32ne) (float *samples, float *volumes, unsigned channels, unsigned length); + void (*float32re) (float *samples, float *volumes, unsigned channels, unsigned length); + void (*s32ne) (int32_t *samples, int32_t *volumes, unsigned channels, unsigned length); + void (*s32re) (int32_t *samples, int32_t *volumes, unsigned channels, unsigned length); + void (*s24ne) (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length); + void (*s24re) (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length); + void (*s24_32ne) (uint32_t *samples, int32_t *volumes, unsigned channels, unsigned length); + void (*s24_32re) (uint32_t *samples, int32_t *volumes, unsigned channels, unsigned length); +} pa_volume_funcs; + +static void +pa_volume_u8_c (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length) +{ + unsigned channel; + + for (channel = 0; length; length--) { + int32_t t, hi, lo; + + hi = volumes[channel] >> 16; + lo = volumes[channel] & 0xFFFF; + + t = (int32_t) *samples - 0x80; + t = ((t * lo) >> 16) + (t * hi); + t = PA_CLAMP_UNLIKELY(t, -0x80, 0x7F); + *samples++ = (uint8_t) (t + 0x80); + + if (PA_UNLIKELY(++channel >= channels)) + channel = 0; + } +} -void pa_volume_memchunk( - pa_memchunk*c, - const pa_sample_spec *spec, - const pa_cvolume *volume) { - - void *ptr; - - pa_assert(c); - pa_assert(spec); - pa_assert(c->length % pa_frame_size(spec) == 0); - pa_assert(volume); - - if (pa_memblock_is_silence(c->memblock)) - return; - - if (pa_cvolume_channels_equal_to(volume, PA_VOLUME_NORM)) - return; - - if (pa_cvolume_channels_equal_to(volume, PA_VOLUME_MUTED)) { - pa_silence_memchunk(c, spec); - return; - } - - ptr = (uint8_t*) pa_memblock_acquire(c->memblock) + c->index; - - switch (spec->format) { - - case PA_SAMPLE_S16NE: { - int16_t *d, *e; - unsigned channel; - int32_t linear[PA_CHANNELS_MAX]; - - calc_linear_integer_volume(linear, volume); - - e = (int16_t*) ptr + c->length/sizeof(int16_t); - - for (channel = 0, d = ptr; d < e; d++) { - int32_t t, hi, lo; - - /* Multiplying the 32bit volume factor with the 16bit - * sample might result in an 48bit value. We want to - * do without 64 bit integers and hence do the - * multiplication independantly for the HI and LO part - * of the volume. */ - - hi = linear[channel] >> 16; - lo = linear[channel] & 0xFFFF; - - t = (int32_t)(*d); - t = ((t * lo) >> 16) + (t * hi); - t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF); - *d = (int16_t) t; - - if (PA_UNLIKELY(++channel >= spec->channels)) - channel = 0; - } - - break; - } - - case PA_SAMPLE_S16RE: { - int16_t *d, *e; - unsigned channel; - int32_t linear[PA_CHANNELS_MAX]; - - calc_linear_integer_volume(linear, volume); - - e = (int16_t*) ptr + c->length/sizeof(int16_t); - - for (channel = 0, d = ptr; d < e; d++) { - int32_t t, hi, lo; +static void +pa_volume_alaw_c (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length) +{ + unsigned channel; - hi = linear[channel] >> 16; - lo = linear[channel] & 0xFFFF; + for (channel = 0; length; length--) { + int32_t t, hi, lo; - t = (int32_t) PA_INT16_SWAP(*d); - t = ((t * lo) >> 16) + (t * hi); - t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF); - *d = PA_INT16_SWAP((int16_t) t); + hi = volumes[channel] >> 16; + lo = volumes[channel] & 0xFFFF; - if (PA_UNLIKELY(++channel >= spec->channels)) - channel = 0; - } + t = (int32_t) st_alaw2linear16(*samples); + t = ((t * lo) >> 16) + (t * hi); + t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF); + *samples++ = (uint8_t) st_13linear2alaw((int16_t) t >> 3); - break; - } - - case PA_SAMPLE_S32NE: { - int32_t *d, *e; - unsigned channel; - int32_t linear[PA_CHANNELS_MAX]; + if (PA_UNLIKELY(++channel >= channels)) + channel = 0; + } +} - calc_linear_integer_volume(linear, volume); +static void +pa_volume_ulaw_c (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length) +{ + unsigned channel; - e = (int32_t*) ptr + c->length/sizeof(int32_t); + for (channel = 0; length; length--) { + int32_t t, hi, lo; - for (channel = 0, d = ptr; d < e; d++) { - int64_t t; + hi = volumes[channel] >> 16; + lo = volumes[channel] & 0xFFFF; - t = (int64_t)(*d); - t = (t * linear[channel]) >> 16; - t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); - *d = (int32_t) t; + t = (int32_t) st_ulaw2linear16(*samples); + t = ((t * lo) >> 16) + (t * hi); + t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF); + *samples++ = (uint8_t) st_14linear2ulaw((int16_t) t >> 2); - if (PA_UNLIKELY(++channel >= spec->channels)) - channel = 0; - } - break; - } - - case PA_SAMPLE_S32RE: { - int32_t *d, *e; - unsigned channel; - int32_t linear[PA_CHANNELS_MAX]; - - calc_linear_integer_volume(linear, volume); - - e = (int32_t*) ptr + c->length/sizeof(int32_t); + if (PA_UNLIKELY(++channel >= channels)) + channel = 0; + } +} - for (channel = 0, d = ptr; d < e; d++) { - int64_t t; +static void +pa_volume_s16ne_c (int16_t *samples, int32_t *volumes, unsigned channels, unsigned length) +{ + unsigned channel; - t = (int64_t) PA_INT32_SWAP(*d); - t = (t * linear[channel]) >> 16; - t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); - *d = PA_INT32_SWAP((int32_t) t); + length /= sizeof (int16_t); - if (PA_UNLIKELY(++channel >= spec->channels)) - channel = 0; - } - break; - } + for (channel = 0; length; length--) { + int32_t t, hi, lo; - case PA_SAMPLE_S24NE: { - uint8_t *d, *e; - unsigned channel; - int32_t linear[PA_CHANNELS_MAX]; + /* Multiplying the 32bit volume factor with the 16bit + * sample might result in an 48bit value. We want to + * do without 64 bit integers and hence do the + * multiplication independantly for the HI and LO part + * of the volume. */ - calc_linear_integer_volume(linear, volume); + hi = volumes[channel] >> 16; + lo = volumes[channel] & 0xFFFF; - e = (uint8_t*) ptr + c->length; + t = (int32_t)(*samples); + t = ((t * lo) >> 16) + (t * hi); + t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF); + *samples++ = (int16_t) t; - for (channel = 0, d = ptr; d < e; d += 3) { - int64_t t; + if (PA_UNLIKELY(++channel >= channels)) + channel = 0; + } +} - t = (int64_t)((int32_t) (PA_READ24NE(d) << 8)); - t = (t * linear[channel]) >> 16; - t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); - PA_WRITE24NE(d, ((uint32_t) (int32_t) t) >> 8); +static void +pa_volume_s16re_c (int16_t *samples, int32_t *volumes, unsigned channels, unsigned length) +{ + unsigned channel; - if (PA_UNLIKELY(++channel >= spec->channels)) - channel = 0; - } - break; - } + length /= sizeof (int16_t); - case PA_SAMPLE_S24RE: { - uint8_t *d, *e; - unsigned channel; - int32_t linear[PA_CHANNELS_MAX]; + for (channel = 0; length; length--) { + int32_t t, hi, lo; - calc_linear_integer_volume(linear, volume); + hi = volumes[channel] >> 16; + lo = volumes[channel] & 0xFFFF; - e = (uint8_t*) ptr + c->length; + t = (int32_t) PA_INT16_SWAP(*samples); + t = ((t * lo) >> 16) + (t * hi); + t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF); + *samples++ = PA_INT16_SWAP((int16_t) t); - for (channel = 0, d = ptr; d < e; d += 3) { - int64_t t; + if (PA_UNLIKELY(++channel >= channels)) + channel = 0; + } +} - t = (int64_t)((int32_t) (PA_READ24RE(d) << 8)); - t = (t * linear[channel]) >> 16; - t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); - PA_WRITE24RE(d, ((uint32_t) (int32_t) t) >> 8); +static void +pa_volume_float32ne_c (float *samples, float *volumes, unsigned channels, unsigned length) +{ + unsigned channel; - if (PA_UNLIKELY(++channel >= spec->channels)) - channel = 0; - } - break; - } + length /= sizeof (float); - case PA_SAMPLE_S24_32NE: { - uint32_t *d, *e; - unsigned channel; - int32_t linear[PA_CHANNELS_MAX]; + for (channel = 0; length; length--) { + *samples++ *= volumes[channel]; - calc_linear_integer_volume(linear, volume); + if (PA_UNLIKELY(++channel >= channels)) + channel = 0; + } +} - e = (uint32_t*) ptr + c->length/sizeof(uint32_t); +static void +pa_volume_float32re_c (float *samples, float *volumes, unsigned channels, unsigned length) +{ + unsigned channel; - for (channel = 0, d = ptr; d < e; d++) { - int64_t t; + length /= sizeof (float); - t = (int64_t) ((int32_t) (*d << 8)); - t = (t * linear[channel]) >> 16; - t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); - *d = ((uint32_t) ((int32_t) t)) >> 8; + for (channel = 0; length; length--) { + float t; - if (PA_UNLIKELY(++channel >= spec->channels)) - channel = 0; - } - break; - } + t = PA_FLOAT32_SWAP(*samples); + t *= volumes[channel]; + *samples++ = PA_FLOAT32_SWAP(t); - case PA_SAMPLE_S24_32RE: { - uint32_t *d, *e; - unsigned channel; - int32_t linear[PA_CHANNELS_MAX]; + if (PA_UNLIKELY(++channel >= channels)) + channel = 0; + } +} - calc_linear_integer_volume(linear, volume); +static void +pa_volume_s32ne_c (int32_t *samples, int32_t *volumes, unsigned channels, unsigned length) +{ + unsigned channel; - e = (uint32_t*) ptr + c->length/sizeof(uint32_t); + length /= sizeof (int32_t); - for (channel = 0, d = ptr; d < e; d++) { - int64_t t; + for (channel = 0; length; length--) { + int64_t t; - t = (int64_t) ((int32_t) (PA_UINT32_SWAP(*d) << 8)); - t = (t * linear[channel]) >> 16; - t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); - *d = PA_UINT32_SWAP(((uint32_t) ((int32_t) t)) >> 8); + t = (int64_t)(*samples); + t = (t * volumes[channel]) >> 16; + t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); + *samples++ = (int32_t) t; - if (PA_UNLIKELY(++channel >= spec->channels)) - channel = 0; - } - break; - } + if (PA_UNLIKELY(++channel >= channels)) + channel = 0; + } +} - case PA_SAMPLE_U8: { - uint8_t *d, *e; - unsigned channel; - int32_t linear[PA_CHANNELS_MAX]; +static void +pa_volume_s32re_c (int32_t *samples, int32_t *volumes, unsigned channels, unsigned length) +{ + unsigned channel; - calc_linear_integer_volume(linear, volume); + length /= sizeof (int32_t); - e = (uint8_t*) ptr + c->length; + for (channel = 0; length; length--) { + int64_t t; - for (channel = 0, d = ptr; d < e; d++) { - int32_t t, hi, lo; + t = (int64_t) PA_INT32_SWAP(*samples); + t = (t * volumes[channel]) >> 16; + t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); + *samples++ = PA_INT32_SWAP((int32_t) t); - hi = linear[channel] >> 16; - lo = linear[channel] & 0xFFFF; + if (PA_UNLIKELY(++channel >= channels)) + channel = 0; + } +} - t = (int32_t) *d - 0x80; - t = ((t * lo) >> 16) + (t * hi); - t = PA_CLAMP_UNLIKELY(t, -0x80, 0x7F); - *d = (uint8_t) (t + 0x80); +static void +pa_volume_s24ne_c (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length) +{ + unsigned channel; + uint8_t *e; - if (PA_UNLIKELY(++channel >= spec->channels)) - channel = 0; - } - break; - } + e = samples + length; - case PA_SAMPLE_ULAW: { - uint8_t *d, *e; - unsigned channel; - int32_t linear[PA_CHANNELS_MAX]; + for (channel = 0; samples < e; samples += 3) { + int64_t t; - calc_linear_integer_volume(linear, volume); + t = (int64_t)((int32_t) (PA_READ24NE(samples) << 8)); + t = (t * volumes[channel]) >> 16; + t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); + PA_WRITE24NE(samples, ((uint32_t) (int32_t) t) >> 8); - e = (uint8_t*) ptr + c->length; + if (PA_UNLIKELY(++channel >= channels)) + channel = 0; + } +} - for (channel = 0, d = ptr; d < e; d++) { - int32_t t, hi, lo; +static void +pa_volume_s24re_c (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length) +{ + unsigned channel; + uint8_t *e; - hi = linear[channel] >> 16; - lo = linear[channel] & 0xFFFF; + e = samples + length; - t = (int32_t) st_ulaw2linear16(*d); - t = ((t * lo) >> 16) + (t * hi); - t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF); - *d = (uint8_t) st_14linear2ulaw((int16_t) t >> 2); + for (channel = 0; samples < e; samples += 3) { + int64_t t; - if (PA_UNLIKELY(++channel >= spec->channels)) - channel = 0; - } - break; - } + t = (int64_t)((int32_t) (PA_READ24RE(samples) << 8)); + t = (t * volumes[channel]) >> 16; + t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); + PA_WRITE24RE(samples, ((uint32_t) (int32_t) t) >> 8); - case PA_SAMPLE_ALAW: { - uint8_t *d, *e; - unsigned channel; - int32_t linear[PA_CHANNELS_MAX]; + if (PA_UNLIKELY(++channel >= channels)) + channel = 0; + } +} - calc_linear_integer_volume(linear, volume); +static void +pa_volume_s24_32ne_c (uint32_t *samples, int32_t *volumes, unsigned channels, unsigned length) +{ + unsigned channel; - e = (uint8_t*) ptr + c->length; + length /= sizeof (uint32_t); - for (channel = 0, d = ptr; d < e; d++) { - int32_t t, hi, lo; + for (channel = 0; length; length--) { + int64_t t; - hi = linear[channel] >> 16; - lo = linear[channel] & 0xFFFF; + t = (int64_t) ((int32_t) (*samples << 8)); + t = (t * volumes[channel]) >> 16; + t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); + *samples++ = ((uint32_t) ((int32_t) t)) >> 8; - t = (int32_t) st_alaw2linear16(*d); - t = ((t * lo) >> 16) + (t * hi); - t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF); - *d = (uint8_t) st_13linear2alaw((int16_t) t >> 3); + if (PA_UNLIKELY(++channel >= channels)) + channel = 0; + } +} - if (PA_UNLIKELY(++channel >= spec->channels)) - channel = 0; - } - break; - } +static void +pa_volume_s24_32re_c (uint32_t *samples, int32_t *volumes, unsigned channels, unsigned length) +{ + unsigned channel; - case PA_SAMPLE_FLOAT32NE: { - float *d; - int skip; - unsigned n; - unsigned channel; + length /= sizeof (uint32_t); - d = ptr; - skip = (int) (spec->channels * sizeof(float)); - n = (unsigned) (c->length/sizeof(float)/spec->channels); + for (channel = 0; length; length--) { + int64_t t; - for (channel = 0; channel < spec->channels; channel ++) { - float v, *t; + t = (int64_t) ((int32_t) (PA_UINT32_SWAP(*samples) << 8)); + t = (t * volumes[channel]) >> 16; + t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); + *samples++ = PA_UINT32_SWAP(((uint32_t) ((int32_t) t)) >> 8); - if (PA_UNLIKELY(volume->values[channel] == PA_VOLUME_NORM)) - continue; + if (PA_UNLIKELY(++channel >= channels)) + channel = 0; + } +} - v = (float) pa_sw_volume_to_linear(volume->values[channel]); - t = d + channel; - oil_scalarmult_f32(t, skip, t, skip, &v, (int) n); - } - break; - } +typedef void (*pa_do_volume_func) (void *samples, void *volumes, unsigned channels, unsigned length); +typedef void (*pa_calc_volume_func) (void *volumes, const pa_cvolume *volume); + +typedef union { + float f; + uint32_t i; +} volume_val; + +static pa_calc_volume_func calc_volume_funcs[] = +{ + (pa_calc_volume_func) calc_linear_integer_volume, + (pa_calc_volume_func) calc_linear_integer_volume, + (pa_calc_volume_func) calc_linear_integer_volume, + (pa_calc_volume_func) calc_linear_integer_volume, + (pa_calc_volume_func) calc_linear_integer_volume, + (pa_calc_volume_func) calc_linear_float_volume, + (pa_calc_volume_func) calc_linear_float_volume, + (pa_calc_volume_func) calc_linear_integer_volume, + (pa_calc_volume_func) calc_linear_integer_volume, + (pa_calc_volume_func) calc_linear_integer_volume, + (pa_calc_volume_func) calc_linear_integer_volume, + (pa_calc_volume_func) calc_linear_integer_volume, + (pa_calc_volume_func) calc_linear_integer_volume +}; + +static pa_do_volume_func do_volume_funcs[] = +{ + (pa_do_volume_func) pa_volume_u8_c, + (pa_do_volume_func) pa_volume_alaw_c, + (pa_do_volume_func) pa_volume_ulaw_c, +#ifdef WORDS_BIGENDIAN + (pa_do_volume_func) pa_volume_s16re_c, + (pa_do_volume_func) pa_volume_s16ne_c, + (pa_do_volume_func) pa_volume_float32re_c, + (pa_do_volume_func) pa_volume_float32ne_c, + (pa_do_volume_func) pa_volume_s32re_c, + (pa_do_volume_func) pa_volume_s32ne_c, + (pa_do_volume_func) pa_volume_s24re_c, + (pa_do_volume_func) pa_volume_s24ne_c, + (pa_do_volume_func) pa_volume_s24_32re_c + (pa_do_volume_func) pa_volume_s24_32ne_c, +#else + (pa_do_volume_func) pa_volume_s16ne_c, + (pa_do_volume_func) pa_volume_s16re_c, + (pa_do_volume_func) pa_volume_float32ne_c, + (pa_do_volume_func) pa_volume_float32re_c, + (pa_do_volume_func) pa_volume_s32ne_c, + (pa_do_volume_func) pa_volume_s32re_c, + (pa_do_volume_func) pa_volume_s24ne_c, + (pa_do_volume_func) pa_volume_s24re_c, + (pa_do_volume_func) pa_volume_s24_32ne_c, + (pa_do_volume_func) pa_volume_s24_32re_c +#endif +}; - case PA_SAMPLE_FLOAT32RE: { - float *d, *e; - unsigned channel; - float linear[PA_CHANNELS_MAX]; +void pa_volume_memchunk( + pa_memchunk*c, + const pa_sample_spec *spec, + const pa_cvolume *volume) { - calc_linear_float_volume(linear, volume); + void *ptr; + volume_val linear[PA_CHANNELS_MAX]; - e = (float*) ptr + c->length/sizeof(float); + pa_assert(c); + pa_assert(spec); + pa_assert(c->length % pa_frame_size(spec) == 0); + pa_assert(volume); - for (channel = 0, d = ptr; d < e; d++) { - float t; + if (pa_memblock_is_silence(c->memblock)) + return; - t = PA_FLOAT32_SWAP(*d); - t *= linear[channel]; - *d = PA_FLOAT32_SWAP(t); + if (pa_cvolume_channels_equal_to(volume, PA_VOLUME_NORM)) + return; - if (PA_UNLIKELY(++channel >= spec->channels)) - channel = 0; - } + if (pa_cvolume_channels_equal_to(volume, PA_VOLUME_MUTED)) { + pa_silence_memchunk(c, spec); + return; + } - break; - } + if (spec->format < 0 || spec->format > PA_SAMPLE_MAX) { + pa_log_warn(" Unable to change volume of format %s.", pa_sample_format_to_string(spec->format)); + return; + } + ptr = (uint8_t*) pa_memblock_acquire(c->memblock) + c->index; - default: - pa_log_warn(" Unable to change volume of format %s.", pa_sample_format_to_string(spec->format)); - /* If we cannot change the volume, we just don't do it */ - } + calc_volume_funcs[spec->format] ((void *)linear, volume); + do_volume_funcs[spec->format] (ptr, (void *)linear, spec->channels, c->length); pa_memblock_release(c->memblock); } -- cgit From 5b8b6544e205237d41bc502a7fd9f79051af78ec Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Tue, 11 Aug 2009 16:25:44 +0200 Subject: sample-utils: coding style cleanup Make the coding style match the rest of pulseaudio more. Remove some liboil functions, they seem unoptimized and likely slower than our handrolled versions here. --- src/pulsecore/sample-util.c | 99 +++++++++++++++++++++------------------------ 1 file changed, 46 insertions(+), 53 deletions(-) (limited to 'src/pulsecore/sample-util.c') diff --git a/src/pulsecore/sample-util.c b/src/pulsecore/sample-util.c index ef435673..0d4e01ef 100644 --- a/src/pulsecore/sample-util.c +++ b/src/pulsecore/sample-util.c @@ -30,9 +30,6 @@ #include #include -#include -#include - #include #include @@ -977,59 +974,50 @@ pa_volume_s24_32re_c (uint32_t *samples, int32_t *volumes, unsigned channels, un } } -typedef void (*pa_do_volume_func) (void *samples, void *volumes, unsigned channels, unsigned length); -typedef void (*pa_calc_volume_func) (void *volumes, const pa_cvolume *volume); +typedef void (*pa_do_volume_func_t) (void *samples, void *volumes, unsigned channels, unsigned length); +typedef void (*pa_calc_volume_func_t) (void *volumes, const pa_cvolume *volume); typedef union { float f; uint32_t i; } volume_val; -static pa_calc_volume_func calc_volume_funcs[] = -{ - (pa_calc_volume_func) calc_linear_integer_volume, - (pa_calc_volume_func) calc_linear_integer_volume, - (pa_calc_volume_func) calc_linear_integer_volume, - (pa_calc_volume_func) calc_linear_integer_volume, - (pa_calc_volume_func) calc_linear_integer_volume, - (pa_calc_volume_func) calc_linear_float_volume, - (pa_calc_volume_func) calc_linear_float_volume, - (pa_calc_volume_func) calc_linear_integer_volume, - (pa_calc_volume_func) calc_linear_integer_volume, - (pa_calc_volume_func) calc_linear_integer_volume, - (pa_calc_volume_func) calc_linear_integer_volume, - (pa_calc_volume_func) calc_linear_integer_volume, - (pa_calc_volume_func) calc_linear_integer_volume +typedef struct pa_sample_func_t { + pa_calc_volume_func_t calc_volume; + pa_do_volume_func_t do_volume; +} pa_sample_func_t; + +static const pa_calc_volume_func_t calc_volume_table[] = { + [PA_SAMPLE_U8] = (pa_calc_volume_func_t) calc_linear_integer_volume, + [PA_SAMPLE_ALAW] = (pa_calc_volume_func_t) calc_linear_integer_volume, + [PA_SAMPLE_ULAW] = (pa_calc_volume_func_t) calc_linear_integer_volume, + [PA_SAMPLE_S16LE] = (pa_calc_volume_func_t) calc_linear_integer_volume, + [PA_SAMPLE_S16BE] = (pa_calc_volume_func_t) calc_linear_integer_volume, + [PA_SAMPLE_FLOAT32LE] = (pa_calc_volume_func_t) calc_linear_float_volume, + [PA_SAMPLE_FLOAT32BE] = (pa_calc_volume_func_t) calc_linear_float_volume, + [PA_SAMPLE_S32LE] = (pa_calc_volume_func_t) calc_linear_integer_volume, + [PA_SAMPLE_S32BE] = (pa_calc_volume_func_t) calc_linear_integer_volume, + [PA_SAMPLE_S24LE] = (pa_calc_volume_func_t) calc_linear_integer_volume, + [PA_SAMPLE_S24BE] = (pa_calc_volume_func_t) calc_linear_integer_volume, + [PA_SAMPLE_S24_32LE] = (pa_calc_volume_func_t) calc_linear_integer_volume, + [PA_SAMPLE_S24_32BE] = (pa_calc_volume_func_t) calc_linear_integer_volume }; -static pa_do_volume_func do_volume_funcs[] = +static pa_do_volume_func_t do_volume_table[] = { - (pa_do_volume_func) pa_volume_u8_c, - (pa_do_volume_func) pa_volume_alaw_c, - (pa_do_volume_func) pa_volume_ulaw_c, -#ifdef WORDS_BIGENDIAN - (pa_do_volume_func) pa_volume_s16re_c, - (pa_do_volume_func) pa_volume_s16ne_c, - (pa_do_volume_func) pa_volume_float32re_c, - (pa_do_volume_func) pa_volume_float32ne_c, - (pa_do_volume_func) pa_volume_s32re_c, - (pa_do_volume_func) pa_volume_s32ne_c, - (pa_do_volume_func) pa_volume_s24re_c, - (pa_do_volume_func) pa_volume_s24ne_c, - (pa_do_volume_func) pa_volume_s24_32re_c - (pa_do_volume_func) pa_volume_s24_32ne_c, -#else - (pa_do_volume_func) pa_volume_s16ne_c, - (pa_do_volume_func) pa_volume_s16re_c, - (pa_do_volume_func) pa_volume_float32ne_c, - (pa_do_volume_func) pa_volume_float32re_c, - (pa_do_volume_func) pa_volume_s32ne_c, - (pa_do_volume_func) pa_volume_s32re_c, - (pa_do_volume_func) pa_volume_s24ne_c, - (pa_do_volume_func) pa_volume_s24re_c, - (pa_do_volume_func) pa_volume_s24_32ne_c, - (pa_do_volume_func) pa_volume_s24_32re_c -#endif + [PA_SAMPLE_U8] = (pa_do_volume_func_t) pa_volume_u8_c, + [PA_SAMPLE_ALAW] = (pa_do_volume_func_t) pa_volume_alaw_c, + [PA_SAMPLE_ULAW] = (pa_do_volume_func_t) pa_volume_ulaw_c, + [PA_SAMPLE_S16NE] = (pa_do_volume_func_t) pa_volume_s16ne_c, + [PA_SAMPLE_S16RE] = (pa_do_volume_func_t) pa_volume_s16re_c, + [PA_SAMPLE_FLOAT32NE] = (pa_do_volume_func_t) pa_volume_float32ne_c, + [PA_SAMPLE_FLOAT32RE] = (pa_do_volume_func_t) pa_volume_float32re_c, + [PA_SAMPLE_S32NE] = (pa_do_volume_func_t) pa_volume_s32ne_c, + [PA_SAMPLE_S32RE] = (pa_do_volume_func_t) pa_volume_s32re_c, + [PA_SAMPLE_S24NE] = (pa_do_volume_func_t) pa_volume_s24ne_c, + [PA_SAMPLE_S24RE] = (pa_do_volume_func_t) pa_volume_s24re_c, + [PA_SAMPLE_S24_32NE] = (pa_do_volume_func_t) pa_volume_s24_32ne_c, + [PA_SAMPLE_S24_32RE] = (pa_do_volume_func_t) pa_volume_s24_32re_c }; void pa_volume_memchunk( @@ -1063,8 +1051,8 @@ void pa_volume_memchunk( ptr = (uint8_t*) pa_memblock_acquire(c->memblock) + c->index; - calc_volume_funcs[spec->format] ((void *)linear, volume); - do_volume_funcs[spec->format] (ptr, (void *)linear, spec->channels, c->length); + calc_volume_table[spec->format] ((void *)linear, volume); + do_volume_table[spec->format] (ptr, (void *)linear, spec->channels, c->length); pa_memblock_release(c->memblock); } @@ -1110,7 +1098,7 @@ void pa_interleave(const void *src[], unsigned channels, void *dst, size_t ss, u d = (uint8_t*) dst + c * ss; for (j = 0; j < n; j ++) { - oil_memcpy(d, s, (int) ss); + memcpy(d, s, (int) ss); s = (uint8_t*) s + ss; d = (uint8_t*) d + fs; } @@ -1138,7 +1126,7 @@ void pa_deinterleave(const void *src, void *dst[], unsigned channels, size_t ss, d = dst[c]; for (j = 0; j < n; j ++) { - oil_memcpy(d, s, (int) ss); + memcpy(d, s, (int) ss); s = (uint8_t*) s + fs; d = (uint8_t*) d + ss; } @@ -1247,10 +1235,15 @@ void pa_sample_clamp(pa_sample_format_t format, void *dst, size_t dstr, const vo s = src; d = dst; if (format == PA_SAMPLE_FLOAT32NE) { + for (; n > 0; n--) { + float f; - float minus_one = -1.0, plus_one = 1.0; - oil_clip_f32(d, (int) dstr, s, (int) sstr, (int) n, &minus_one, &plus_one); + f = *s; + *d = PA_CLAMP_UNLIKELY(f, -1.0f, 1.0f); + s = (const float*) ((const uint8_t*) s + sstr); + d = (float*) ((uint8_t*) d + dstr); + } } else { pa_assert(format == PA_SAMPLE_FLOAT32RE); -- cgit From e71e644eb668b6336dd48d2730839aa3e9f7278e Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Tue, 11 Aug 2009 16:43:46 +0200 Subject: sample-util: move some functions around Move some stuff around before splitting it into a separate file. --- src/pulsecore/sample-util.c | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) (limited to 'src/pulsecore/sample-util.c') diff --git a/src/pulsecore/sample-util.c b/src/pulsecore/sample-util.c index 0d4e01ef..f8a4c70a 100644 --- a/src/pulsecore/sample-util.c +++ b/src/pulsecore/sample-util.c @@ -975,17 +975,34 @@ pa_volume_s24_32re_c (uint32_t *samples, int32_t *volumes, unsigned channels, un } typedef void (*pa_do_volume_func_t) (void *samples, void *volumes, unsigned channels, unsigned length); -typedef void (*pa_calc_volume_func_t) (void *volumes, const pa_cvolume *volume); + +typedef struct pa_sample_func_t { + pa_do_volume_func_t do_volume; +} pa_sample_func_t; + +static pa_do_volume_func_t do_volume_table[] = +{ + [PA_SAMPLE_U8] = (pa_do_volume_func_t) pa_volume_u8_c, + [PA_SAMPLE_ALAW] = (pa_do_volume_func_t) pa_volume_alaw_c, + [PA_SAMPLE_ULAW] = (pa_do_volume_func_t) pa_volume_ulaw_c, + [PA_SAMPLE_S16NE] = (pa_do_volume_func_t) pa_volume_s16ne_c, + [PA_SAMPLE_S16RE] = (pa_do_volume_func_t) pa_volume_s16re_c, + [PA_SAMPLE_FLOAT32NE] = (pa_do_volume_func_t) pa_volume_float32ne_c, + [PA_SAMPLE_FLOAT32RE] = (pa_do_volume_func_t) pa_volume_float32re_c, + [PA_SAMPLE_S32NE] = (pa_do_volume_func_t) pa_volume_s32ne_c, + [PA_SAMPLE_S32RE] = (pa_do_volume_func_t) pa_volume_s32re_c, + [PA_SAMPLE_S24NE] = (pa_do_volume_func_t) pa_volume_s24ne_c, + [PA_SAMPLE_S24RE] = (pa_do_volume_func_t) pa_volume_s24re_c, + [PA_SAMPLE_S24_32NE] = (pa_do_volume_func_t) pa_volume_s24_32ne_c, + [PA_SAMPLE_S24_32RE] = (pa_do_volume_func_t) pa_volume_s24_32re_c +}; typedef union { float f; uint32_t i; } volume_val; -typedef struct pa_sample_func_t { - pa_calc_volume_func_t calc_volume; - pa_do_volume_func_t do_volume; -} pa_sample_func_t; +typedef void (*pa_calc_volume_func_t) (void *volumes, const pa_cvolume *volume); static const pa_calc_volume_func_t calc_volume_table[] = { [PA_SAMPLE_U8] = (pa_calc_volume_func_t) calc_linear_integer_volume, @@ -1003,23 +1020,6 @@ static const pa_calc_volume_func_t calc_volume_table[] = { [PA_SAMPLE_S24_32BE] = (pa_calc_volume_func_t) calc_linear_integer_volume }; -static pa_do_volume_func_t do_volume_table[] = -{ - [PA_SAMPLE_U8] = (pa_do_volume_func_t) pa_volume_u8_c, - [PA_SAMPLE_ALAW] = (pa_do_volume_func_t) pa_volume_alaw_c, - [PA_SAMPLE_ULAW] = (pa_do_volume_func_t) pa_volume_ulaw_c, - [PA_SAMPLE_S16NE] = (pa_do_volume_func_t) pa_volume_s16ne_c, - [PA_SAMPLE_S16RE] = (pa_do_volume_func_t) pa_volume_s16re_c, - [PA_SAMPLE_FLOAT32NE] = (pa_do_volume_func_t) pa_volume_float32ne_c, - [PA_SAMPLE_FLOAT32RE] = (pa_do_volume_func_t) pa_volume_float32re_c, - [PA_SAMPLE_S32NE] = (pa_do_volume_func_t) pa_volume_s32ne_c, - [PA_SAMPLE_S32RE] = (pa_do_volume_func_t) pa_volume_s32re_c, - [PA_SAMPLE_S24NE] = (pa_do_volume_func_t) pa_volume_s24ne_c, - [PA_SAMPLE_S24RE] = (pa_do_volume_func_t) pa_volume_s24re_c, - [PA_SAMPLE_S24_32NE] = (pa_do_volume_func_t) pa_volume_s24_32ne_c, - [PA_SAMPLE_S24_32RE] = (pa_do_volume_func_t) pa_volume_s24_32re_c -}; - void pa_volume_memchunk( pa_memchunk*c, const pa_sample_spec *spec, -- cgit From 3d008961c095cf8d41d2c61d13d446c98c892136 Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Tue, 11 Aug 2009 17:10:44 +0200 Subject: sample-util: move volume code to separate file Move the volume code into a separate file with the reference C implementations. Add a function to retrieve the volume function and one to install a new one. --- src/pulsecore/sample-util.c | 316 +------------------------------------------- 1 file changed, 5 insertions(+), 311 deletions(-) (limited to 'src/pulsecore/sample-util.c') diff --git a/src/pulsecore/sample-util.c b/src/pulsecore/sample-util.c index f8a4c70a..0bbd5192 100644 --- a/src/pulsecore/sample-util.c +++ b/src/pulsecore/sample-util.c @@ -687,316 +687,6 @@ size_t pa_mix( return length; } -typedef struct pa_volume_funcs { - void (*u8) (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length); - void (*alaw) (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length); - void (*ulaw) (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length); - void (*s16ne) (int16_t *samples, int32_t *volumes, unsigned channels, unsigned length); - void (*s16re) (int16_t *samples, int32_t *volumes, unsigned channels, unsigned length); - void (*float32ne) (float *samples, float *volumes, unsigned channels, unsigned length); - void (*float32re) (float *samples, float *volumes, unsigned channels, unsigned length); - void (*s32ne) (int32_t *samples, int32_t *volumes, unsigned channels, unsigned length); - void (*s32re) (int32_t *samples, int32_t *volumes, unsigned channels, unsigned length); - void (*s24ne) (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length); - void (*s24re) (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length); - void (*s24_32ne) (uint32_t *samples, int32_t *volumes, unsigned channels, unsigned length); - void (*s24_32re) (uint32_t *samples, int32_t *volumes, unsigned channels, unsigned length); -} pa_volume_funcs; - -static void -pa_volume_u8_c (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length) -{ - unsigned channel; - - for (channel = 0; length; length--) { - int32_t t, hi, lo; - - hi = volumes[channel] >> 16; - lo = volumes[channel] & 0xFFFF; - - t = (int32_t) *samples - 0x80; - t = ((t * lo) >> 16) + (t * hi); - t = PA_CLAMP_UNLIKELY(t, -0x80, 0x7F); - *samples++ = (uint8_t) (t + 0x80); - - if (PA_UNLIKELY(++channel >= channels)) - channel = 0; - } -} - -static void -pa_volume_alaw_c (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length) -{ - unsigned channel; - - for (channel = 0; length; length--) { - int32_t t, hi, lo; - - hi = volumes[channel] >> 16; - lo = volumes[channel] & 0xFFFF; - - t = (int32_t) st_alaw2linear16(*samples); - t = ((t * lo) >> 16) + (t * hi); - t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF); - *samples++ = (uint8_t) st_13linear2alaw((int16_t) t >> 3); - - if (PA_UNLIKELY(++channel >= channels)) - channel = 0; - } -} - -static void -pa_volume_ulaw_c (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length) -{ - unsigned channel; - - for (channel = 0; length; length--) { - int32_t t, hi, lo; - - hi = volumes[channel] >> 16; - lo = volumes[channel] & 0xFFFF; - - t = (int32_t) st_ulaw2linear16(*samples); - t = ((t * lo) >> 16) + (t * hi); - t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF); - *samples++ = (uint8_t) st_14linear2ulaw((int16_t) t >> 2); - - if (PA_UNLIKELY(++channel >= channels)) - channel = 0; - } -} - -static void -pa_volume_s16ne_c (int16_t *samples, int32_t *volumes, unsigned channels, unsigned length) -{ - unsigned channel; - - length /= sizeof (int16_t); - - for (channel = 0; length; length--) { - int32_t t, hi, lo; - - /* Multiplying the 32bit volume factor with the 16bit - * sample might result in an 48bit value. We want to - * do without 64 bit integers and hence do the - * multiplication independantly for the HI and LO part - * of the volume. */ - - hi = volumes[channel] >> 16; - lo = volumes[channel] & 0xFFFF; - - t = (int32_t)(*samples); - t = ((t * lo) >> 16) + (t * hi); - t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF); - *samples++ = (int16_t) t; - - if (PA_UNLIKELY(++channel >= channels)) - channel = 0; - } -} - -static void -pa_volume_s16re_c (int16_t *samples, int32_t *volumes, unsigned channels, unsigned length) -{ - unsigned channel; - - length /= sizeof (int16_t); - - for (channel = 0; length; length--) { - int32_t t, hi, lo; - - hi = volumes[channel] >> 16; - lo = volumes[channel] & 0xFFFF; - - t = (int32_t) PA_INT16_SWAP(*samples); - t = ((t * lo) >> 16) + (t * hi); - t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF); - *samples++ = PA_INT16_SWAP((int16_t) t); - - if (PA_UNLIKELY(++channel >= channels)) - channel = 0; - } -} - -static void -pa_volume_float32ne_c (float *samples, float *volumes, unsigned channels, unsigned length) -{ - unsigned channel; - - length /= sizeof (float); - - for (channel = 0; length; length--) { - *samples++ *= volumes[channel]; - - if (PA_UNLIKELY(++channel >= channels)) - channel = 0; - } -} - -static void -pa_volume_float32re_c (float *samples, float *volumes, unsigned channels, unsigned length) -{ - unsigned channel; - - length /= sizeof (float); - - for (channel = 0; length; length--) { - float t; - - t = PA_FLOAT32_SWAP(*samples); - t *= volumes[channel]; - *samples++ = PA_FLOAT32_SWAP(t); - - if (PA_UNLIKELY(++channel >= channels)) - channel = 0; - } -} - -static void -pa_volume_s32ne_c (int32_t *samples, int32_t *volumes, unsigned channels, unsigned length) -{ - unsigned channel; - - length /= sizeof (int32_t); - - for (channel = 0; length; length--) { - int64_t t; - - t = (int64_t)(*samples); - t = (t * volumes[channel]) >> 16; - t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); - *samples++ = (int32_t) t; - - if (PA_UNLIKELY(++channel >= channels)) - channel = 0; - } -} - -static void -pa_volume_s32re_c (int32_t *samples, int32_t *volumes, unsigned channels, unsigned length) -{ - unsigned channel; - - length /= sizeof (int32_t); - - for (channel = 0; length; length--) { - int64_t t; - - t = (int64_t) PA_INT32_SWAP(*samples); - t = (t * volumes[channel]) >> 16; - t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); - *samples++ = PA_INT32_SWAP((int32_t) t); - - if (PA_UNLIKELY(++channel >= channels)) - channel = 0; - } -} - -static void -pa_volume_s24ne_c (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length) -{ - unsigned channel; - uint8_t *e; - - e = samples + length; - - for (channel = 0; samples < e; samples += 3) { - int64_t t; - - t = (int64_t)((int32_t) (PA_READ24NE(samples) << 8)); - t = (t * volumes[channel]) >> 16; - t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); - PA_WRITE24NE(samples, ((uint32_t) (int32_t) t) >> 8); - - if (PA_UNLIKELY(++channel >= channels)) - channel = 0; - } -} - -static void -pa_volume_s24re_c (uint8_t *samples, int32_t *volumes, unsigned channels, unsigned length) -{ - unsigned channel; - uint8_t *e; - - e = samples + length; - - for (channel = 0; samples < e; samples += 3) { - int64_t t; - - t = (int64_t)((int32_t) (PA_READ24RE(samples) << 8)); - t = (t * volumes[channel]) >> 16; - t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); - PA_WRITE24RE(samples, ((uint32_t) (int32_t) t) >> 8); - - if (PA_UNLIKELY(++channel >= channels)) - channel = 0; - } -} - -static void -pa_volume_s24_32ne_c (uint32_t *samples, int32_t *volumes, unsigned channels, unsigned length) -{ - unsigned channel; - - length /= sizeof (uint32_t); - - for (channel = 0; length; length--) { - int64_t t; - - t = (int64_t) ((int32_t) (*samples << 8)); - t = (t * volumes[channel]) >> 16; - t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); - *samples++ = ((uint32_t) ((int32_t) t)) >> 8; - - if (PA_UNLIKELY(++channel >= channels)) - channel = 0; - } -} - -static void -pa_volume_s24_32re_c (uint32_t *samples, int32_t *volumes, unsigned channels, unsigned length) -{ - unsigned channel; - - length /= sizeof (uint32_t); - - for (channel = 0; length; length--) { - int64_t t; - - t = (int64_t) ((int32_t) (PA_UINT32_SWAP(*samples) << 8)); - t = (t * volumes[channel]) >> 16; - t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); - *samples++ = PA_UINT32_SWAP(((uint32_t) ((int32_t) t)) >> 8); - - if (PA_UNLIKELY(++channel >= channels)) - channel = 0; - } -} - -typedef void (*pa_do_volume_func_t) (void *samples, void *volumes, unsigned channels, unsigned length); - -typedef struct pa_sample_func_t { - pa_do_volume_func_t do_volume; -} pa_sample_func_t; - -static pa_do_volume_func_t do_volume_table[] = -{ - [PA_SAMPLE_U8] = (pa_do_volume_func_t) pa_volume_u8_c, - [PA_SAMPLE_ALAW] = (pa_do_volume_func_t) pa_volume_alaw_c, - [PA_SAMPLE_ULAW] = (pa_do_volume_func_t) pa_volume_ulaw_c, - [PA_SAMPLE_S16NE] = (pa_do_volume_func_t) pa_volume_s16ne_c, - [PA_SAMPLE_S16RE] = (pa_do_volume_func_t) pa_volume_s16re_c, - [PA_SAMPLE_FLOAT32NE] = (pa_do_volume_func_t) pa_volume_float32ne_c, - [PA_SAMPLE_FLOAT32RE] = (pa_do_volume_func_t) pa_volume_float32re_c, - [PA_SAMPLE_S32NE] = (pa_do_volume_func_t) pa_volume_s32ne_c, - [PA_SAMPLE_S32RE] = (pa_do_volume_func_t) pa_volume_s32re_c, - [PA_SAMPLE_S24NE] = (pa_do_volume_func_t) pa_volume_s24ne_c, - [PA_SAMPLE_S24RE] = (pa_do_volume_func_t) pa_volume_s24re_c, - [PA_SAMPLE_S24_32NE] = (pa_do_volume_func_t) pa_volume_s24_32ne_c, - [PA_SAMPLE_S24_32RE] = (pa_do_volume_func_t) pa_volume_s24_32re_c -}; - typedef union { float f; uint32_t i; @@ -1027,6 +717,7 @@ void pa_volume_memchunk( void *ptr; volume_val linear[PA_CHANNELS_MAX]; + pa_do_volume_func_t do_volume; pa_assert(c); pa_assert(spec); @@ -1051,8 +742,11 @@ void pa_volume_memchunk( ptr = (uint8_t*) pa_memblock_acquire(c->memblock) + c->index; + do_volume = pa_get_volume_func (spec->format); + pa_assert(do_volume); + calc_volume_table[spec->format] ((void *)linear, volume); - do_volume_table[spec->format] (ptr, (void *)linear, spec->channels, c->length); + do_volume (ptr, (void *)linear, spec->channels, c->length); pa_memblock_release(c->memblock); } -- cgit From 2d73f13567ad03efe798d07eda87fa776b0505f2 Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Wed, 12 Aug 2009 17:03:30 +0200 Subject: samples-util: add padding to volume array Pad the volume array with a copy of the start. We'll need this later to be able to write optimized functions. --- src/pulsecore/sample-util.c | 22 +++++++++++++++++----- 1 file changed, 17 insertions(+), 5 deletions(-) (limited to 'src/pulsecore/sample-util.c') diff --git a/src/pulsecore/sample-util.c b/src/pulsecore/sample-util.c index 0bbd5192..677f914a 100644 --- a/src/pulsecore/sample-util.c +++ b/src/pulsecore/sample-util.c @@ -103,24 +103,36 @@ void* pa_silence_memory(void *p, size_t length, const pa_sample_spec *spec) { return p; } +#define VOLUME_PADDING 32 + static void calc_linear_integer_volume(int32_t linear[], const pa_cvolume *volume) { - unsigned channel; + unsigned channel, nchannels, padding; pa_assert(linear); pa_assert(volume); - for (channel = 0; channel < volume->channels; channel++) + nchannels = volume->channels; + + for (channel = 0; channel < nchannels; channel++) linear[channel] = (int32_t) lrint(pa_sw_volume_to_linear(volume->values[channel]) * 0x10000); + + for (padding = 0; padding < VOLUME_PADDING; padding++, channel++) + linear[channel] = linear[padding]; } static void calc_linear_float_volume(float linear[], const pa_cvolume *volume) { - unsigned channel; + unsigned channel, nchannels, padding; pa_assert(linear); pa_assert(volume); - for (channel = 0; channel < volume->channels; channel++) + nchannels = volume->channels; + + for (channel = 0; channel < nchannels; channel++) linear[channel] = (float) pa_sw_volume_to_linear(volume->values[channel]); + + for (padding = 0; padding < VOLUME_PADDING; padding++, channel++) + linear[channel] = linear[padding]; } static void calc_linear_integer_stream_volumes(pa_mix_info streams[], unsigned nstreams, const pa_cvolume *volume, const pa_sample_spec *spec) { @@ -716,7 +728,7 @@ void pa_volume_memchunk( const pa_cvolume *volume) { void *ptr; - volume_val linear[PA_CHANNELS_MAX]; + volume_val linear[PA_CHANNELS_MAX + VOLUME_PADDING]; pa_do_volume_func_t do_volume; pa_assert(c); -- cgit From f09b51198f43d79b22cb92b5223d01a7ab339d9f Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Thu, 20 Aug 2009 10:56:20 +0200 Subject: whitespace fixes --- src/pulsecore/sample-util.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) (limited to 'src/pulsecore/sample-util.c') diff --git a/src/pulsecore/sample-util.c b/src/pulsecore/sample-util.c index 677f914a..6e97e5a9 100644 --- a/src/pulsecore/sample-util.c +++ b/src/pulsecore/sample-util.c @@ -752,12 +752,13 @@ void pa_volume_memchunk( return; } - ptr = (uint8_t*) pa_memblock_acquire(c->memblock) + c->index; - do_volume = pa_get_volume_func (spec->format); pa_assert(do_volume); - + calc_volume_table[spec->format] ((void *)linear, volume); + + ptr = (uint8_t*) pa_memblock_acquire(c->memblock) + c->index; + do_volume (ptr, (void *)linear, spec->channels, c->length); pa_memblock_release(c->memblock); @@ -944,12 +945,12 @@ void pa_sample_clamp(pa_sample_format_t format, void *dst, size_t dstr, const vo for (; n > 0; n--) { float f; - f = *s; + f = *s; *d = PA_CLAMP_UNLIKELY(f, -1.0f, 1.0f); s = (const float*) ((const uint8_t*) s + sstr); d = (float*) ((uint8_t*) d + dstr); - } + } } else { pa_assert(format == PA_SAMPLE_FLOAT32RE); -- cgit