mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-11-03 09:01:50 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

optimize volume changing a bit by only using a single counter for the inner loops instead of two

Browse source
This commit is contained in:
Lennart Poettering 2008-08-11 15:19:52 +02:00
parent b604290803
commit 5b2a83733d
1 changed files with 37 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

69
src/pulsecore/sample-util.c
View file

@ -620,14 +620,15 @@ void pa_volume_memchunk(
switch (spec->format) { switch (spec->format) {
case PA_SAMPLE_S16NE: { case PA_SAMPLE_S16NE: {
int16_t *d; int16_t *d, *e;
size_t n;
unsigned channel; unsigned channel;
int32_t linear[PA_CHANNELS_MAX]; int32_t linear[PA_CHANNELS_MAX];
calc_linear_integer_volume(linear, volume); calc_linear_integer_volume(linear, volume);
for (channel = 0, d = ptr, n = c->length/sizeof(int16_t); n > 0; d++, n--) { e = (int16_t*) ptr + c->length/sizeof(int16_t);
for (channel = 0, d = ptr; d < e; d++) {
int32_t t; int32_t t;
t = (int32_t)(*d); t = (int32_t)(*d);
@ -642,17 +643,18 @@ void pa_volume_memchunk(
} }
case PA_SAMPLE_S16RE: { case PA_SAMPLE_S16RE: {
int16_t *d; int16_t *d, *e;
size_t n;
unsigned channel; unsigned channel;
int32_t linear[PA_CHANNELS_MAX]; int32_t linear[PA_CHANNELS_MAX];
calc_linear_integer_volume(linear, volume); calc_linear_integer_volume(linear, volume);
for (channel = 0, d = ptr, n = c->length/sizeof(int16_t); n > 0; d++, n--) { e = (int16_t*) ptr + c->length/sizeof(int16_t);
for (channel = 0, d = ptr; d < e; d++) {
int32_t t; int32_t t;
t = (int32_t)(PA_INT16_SWAP(*d)); t = (int32_t) PA_INT16_SWAP(*d);
t = (t * linear[channel]) / 0x10000; t = (t * linear[channel]) / 0x10000;
t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF); t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF);
*d = PA_INT16_SWAP((int16_t) t); *d = PA_INT16_SWAP((int16_t) t);
@ -665,14 +667,15 @@ void pa_volume_memchunk(
} }
case PA_SAMPLE_S32NE: { case PA_SAMPLE_S32NE: {
int32_t *d; int32_t *d, *e;
size_t n;
unsigned channel; unsigned channel;
int32_t linear[PA_CHANNELS_MAX]; int32_t linear[PA_CHANNELS_MAX];
calc_linear_integer_volume(linear, volume); calc_linear_integer_volume(linear, volume);
for (channel = 0, d = ptr, n = c->length/sizeof(int32_t); n > 0; d++, n--) { e = (int32_t*) ptr + c->length/sizeof(int32_t);
for (channel = 0, d = ptr; d < e; d++) {
int64_t t; int64_t t;
t = (int64_t)(*d); t = (int64_t)(*d);
@ -687,17 +690,18 @@ void pa_volume_memchunk(
} }
case PA_SAMPLE_S32RE: { case PA_SAMPLE_S32RE: {
int32_t *d; int32_t *d, *e;
size_t n;
unsigned channel; unsigned channel;
int32_t linear[PA_CHANNELS_MAX]; int32_t linear[PA_CHANNELS_MAX];
calc_linear_integer_volume(linear, volume); calc_linear_integer_volume(linear, volume);
for (channel = 0, d = ptr, n = c->length/sizeof(int32_t); n > 0; d++, n--) { e = (int32_t*) ptr + c->length/sizeof(int32_t);
for (channel = 0, d = ptr; d < e; d++) {
int64_t t; int64_t t;
t = (int64_t)(PA_INT32_SWAP(*d)); t = (int64_t) PA_INT32_SWAP(*d);
t = (t * linear[channel]) / 0x10000; t = (t * linear[channel]) / 0x10000;
t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL); t = PA_CLAMP_UNLIKELY(t, -0x80000000LL, 0x7FFFFFFFLL);
*d = PA_INT32_SWAP((int32_t) t); *d = PA_INT32_SWAP((int32_t) t);
@ -710,14 +714,15 @@ void pa_volume_memchunk(
} }
case PA_SAMPLE_U8: { case PA_SAMPLE_U8: {
uint8_t *d; uint8_t *d, *e;
size_t n;
unsigned channel; unsigned channel;
int32_t linear[PA_CHANNELS_MAX]; int32_t linear[PA_CHANNELS_MAX];
calc_linear_integer_volume(linear, volume); calc_linear_integer_volume(linear, volume);
for (channel = 0, d = ptr, n = c->length; n > 0; d++, n--) { e = (uint8_t*) ptr + c->length;
for (channel = 0, d = ptr; d < e; d++) {
int32_t t; int32_t t;
t = (int32_t) *d - 0x80; t = (int32_t) *d - 0x80;
@ -732,14 +737,15 @@ void pa_volume_memchunk(
} }
case PA_SAMPLE_ULAW: { case PA_SAMPLE_ULAW: {
uint8_t *d; uint8_t *d, *e;
size_t n;
unsigned channel; unsigned channel;
int32_t linear[PA_CHANNELS_MAX]; int32_t linear[PA_CHANNELS_MAX];
calc_linear_integer_volume(linear, volume); calc_linear_integer_volume(linear, volume);
for (channel = 0, d = ptr, n = c->length; n > 0; d++, n--) { e = (uint8_t*) ptr + c->length;
for (channel = 0, d = ptr; d < e; d++) {
int32_t t; int32_t t;
t = (int32_t) st_ulaw2linear16(*d); t = (int32_t) st_ulaw2linear16(*d);
@ -754,14 +760,15 @@ void pa_volume_memchunk(
} }
case PA_SAMPLE_ALAW: { case PA_SAMPLE_ALAW: {
uint8_t *d; uint8_t *d, *e;
size_t n;
unsigned channel; unsigned channel;
int32_t linear[PA_CHANNELS_MAX]; int32_t linear[PA_CHANNELS_MAX];
calc_linear_integer_volume(linear, volume); calc_linear_integer_volume(linear, volume);
for (channel = 0, d = ptr, n = c->length; n > 0; d++, n--) { e = (uint8_t*) ptr + c->length;
for (channel = 0, d = ptr; d < e; d++) {
int32_t t; int32_t t;
t = (int32_t) st_alaw2linear16(*d); t = (int32_t) st_alaw2linear16(*d);
@ -799,22 +806,20 @@ void pa_volume_memchunk(
} }
case PA_SAMPLE_FLOAT32RE: { case PA_SAMPLE_FLOAT32RE: {
uint32_t *d; float *d, *e;
size_t n;
unsigned channel; unsigned channel;
float linear[PA_CHANNELS_MAX]; float linear[PA_CHANNELS_MAX];
calc_linear_float_volume(linear, volume); calc_linear_float_volume(linear, volume);
for (channel = 0, d = ptr, n = c->length/sizeof(float); n > 0; d++, n--) { e = (float*) ptr + c->length/sizeof(float);
float t;
uint32_t z;
z = PA_UINT32_SWAP(*d); for (channel = 0, d = ptr; d < e; d++) {
t = *(float*) &z; float t;
t = PA_FLOAT32_SWAP(*d);
t *= linear[channel]; t *= linear[channel];
z = *(uint32_t*) &t; *d = PA_FLOAT32_SWAP(t);
*d = PA_UINT32_SWAP(z);
if (PA_UNLIKELY(++channel >= spec->channels)) if (PA_UNLIKELY(++channel >= spec->channels))
channel = 0; channel = 0;