void pa_sample_clamp(pa_sample_format_t format, void *dst, size_t dstr, const void *src, size_t sstr, unsigned n) {
const float *s;
float *d;
s = src; d = dst;
if (format == PA_SAMPLE_FLOAT32NE) {
for (; n > 0; n--) {
float f;
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);
for (; n > 0; n--) {
float f;
f = PA_FLOAT32_SWAP(*s);
f = PA_CLAMP_UNLIKELY(f, -1.0f, 1.0f);
*d = PA_FLOAT32_SWAP(f);
s = (const float*) ((const uint8_t*) s + sstr);
d = (float*) ((uint8_t*) d + dstr);
}
}
}
static void dump_block(const pa_sample_spec *ss, const pa_memchunk *chunk) {
void *d;
unsigned i;
d = pa_memblock_acquire(chunk->memblock);
switch (ss->format) {
case PA_SAMPLE_U8:
case PA_SAMPLE_ULAW:
case PA_SAMPLE_ALAW: {
uint8_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++)
printf(" 0x%02x ", *(u++));
break;
}
case PA_SAMPLE_S16NE:
case PA_SAMPLE_S16RE: {
uint16_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++)
printf(" 0x%04x ", *(u++));
break;
}
case PA_SAMPLE_S32NE:
case PA_SAMPLE_S32RE: {
uint32_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++)
printf("0x%08x ", *(u++));
break;
}
case PA_SAMPLE_S24_32NE:
case PA_SAMPLE_S24_32RE: {
uint32_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++)
printf("0x%08x ", *(u++));
break;
}
case PA_SAMPLE_FLOAT32NE:
case PA_SAMPLE_FLOAT32RE: {
float *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
printf("%4.3g ", ss->format == PA_SAMPLE_FLOAT32NE ? *u : PA_FLOAT32_SWAP(*u));
u++;
}
break;
}
case PA_SAMPLE_S24LE:
case PA_SAMPLE_S24BE: {
uint8_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
printf(" 0x%06x ", PA_READ24NE(u));
u += pa_frame_size(ss);
}
break;
}
default:
pa_assert_not_reached();
}
printf("\n");
pa_memblock_release(chunk->memblock);
}
static pa_memblock* generate_block(pa_mempool *pool, const pa_sample_spec *ss) {
pa_memblock *r;
void *d;
unsigned i;
pa_assert_se(r = pa_memblock_new(pool, pa_frame_size(ss) * 10));
d = pa_memblock_acquire(r);
switch (ss->format) {
case PA_SAMPLE_U8:
case PA_SAMPLE_ULAW:
case PA_SAMPLE_ALAW: {
uint8_t *u = d;
u[0] = 0x00;
u[1] = 0xFF;
u[2] = 0x7F;
u[3] = 0x80;
u[4] = 0x9f;
u[5] = 0x3f;
u[6] = 0x1;
u[7] = 0xF0;
u[8] = 0x20;
u[9] = 0x21;
break;
}
case PA_SAMPLE_S16NE:
case PA_SAMPLE_S16RE: {
uint16_t *u = d;
u[0] = 0x0000;
u[1] = 0xFFFF;
u[2] = 0x7FFF;
u[3] = 0x8000;
u[4] = 0x9fff;
u[5] = 0x3fff;
u[6] = 0x1;
u[7] = 0xF000;
u[8] = 0x20;
u[9] = 0x21;
break;
}
case PA_SAMPLE_S32NE:
case PA_SAMPLE_S32RE: {
uint32_t *u = d;
u[0] = 0x00000001;
u[1] = 0xFFFF0002;
u[2] = 0x7FFF0003;
u[3] = 0x80000004;
u[4] = 0x9fff0005;
u[5] = 0x3fff0006;
u[6] = 0x10007;
u[7] = 0xF0000008;
u[8] = 0x200009;
u[9] = 0x21000A;
break;
}
case PA_SAMPLE_S24_32NE:
case PA_SAMPLE_S24_32RE: {
uint32_t *u = d;
u[0] = 0x000001;
u[1] = 0xFF0002;
u[2] = 0x7F0003;
u[3] = 0x800004;
u[4] = 0x9f0005;
u[5] = 0x3f0006;
u[6] = 0x107;
u[7] = 0xF00008;
u[8] = 0x2009;
u[9] = 0x210A;
break;
}
case PA_SAMPLE_FLOAT32NE:
case PA_SAMPLE_FLOAT32RE: {
float *u = d;
u[0] = 0.0f;
u[1] = -1.0f;
u[2] = 1.0f;
u[3] = 4711.0f;
u[4] = 0.222f;
u[5] = 0.33f;
u[6] = -.3f;
u[7] = 99.0f;
u[8] = -0.555f;
u[9] = -.123f;
if (ss->format == PA_SAMPLE_FLOAT32RE)
for (i = 0; i < 10; i++)
u[i] = PA_FLOAT32_SWAP(u[i]);
break;
}
case PA_SAMPLE_S24NE:
case PA_SAMPLE_S24RE: {
uint8_t *u = d;
PA_WRITE24NE(u, 0x000001);
PA_WRITE24NE(u+3, 0xFF0002);
PA_WRITE24NE(u+6, 0x7F0003);
PA_WRITE24NE(u+9, 0x800004);
PA_WRITE24NE(u+12, 0x9f0005);
PA_WRITE24NE(u+15, 0x3f0006);
PA_WRITE24NE(u+18, 0x107);
PA_WRITE24NE(u+21, 0xF00008);
PA_WRITE24NE(u+24, 0x2009);
PA_WRITE24NE(u+27, 0x210A);
break;
}
default:
pa_assert_not_reached();
}
pa_memblock_release(r);
return r;
}
static pa_memblock* generate_block(pa_mempool *pool, const pa_sample_spec *ss) {
pa_memblock *r;
void *d;
unsigned i;
pa_assert_se(r = pa_memblock_new(pool, pa_frame_size(ss) * 10));
d = pa_memblock_acquire(r);
switch (ss->format) {
case PA_SAMPLE_U8:
case PA_SAMPLE_ULAW:
case PA_SAMPLE_ALAW: {
static const uint8_t u8_samples[] = {
0x00, 0xFF, 0x7F, 0x80, 0x9f,
0x3f, 0x01, 0xF0, 0x20, 0x21
};
memcpy(d, u8_samples, sizeof(u8_samples));
break;
}
case PA_SAMPLE_S16NE:
case PA_SAMPLE_S16RE: {
static const uint16_t u16_samples[] = {
0x0000, 0xFFFF, 0x7FFF, 0x8000, 0x9fff,
0x3fff, 0x0001, 0xF000, 0x0020, 0x0021
};
memcpy(d, u16_samples, sizeof(u16_samples));
break;
}
case PA_SAMPLE_S24_32NE:
case PA_SAMPLE_S24_32RE:
case PA_SAMPLE_S32NE:
case PA_SAMPLE_S32RE: {
static const uint32_t u32_samples[] = {
0x00000001, 0xFFFF0002, 0x7FFF0003, 0x80000004, 0x9fff0005,
0x3fff0006, 0x00010007, 0xF0000008, 0x00200009, 0x0021000A
};
memcpy(d, u32_samples, sizeof(u32_samples));
break;
}
case PA_SAMPLE_S24NE:
case PA_SAMPLE_S24RE: {
/* Need to be on a byte array because they are not aligned */
static const uint8_t u24_samples[] = {
0x00, 0x00, 0x01,
0xFF, 0xFF, 0x02,
0x7F, 0xFF, 0x03,
0x80, 0x00, 0x04,
0x9f, 0xff, 0x05,
0x3f, 0xff, 0x06,
0x01, 0x00, 0x07,
0xF0, 0x00, 0x08,
0x20, 0x00, 0x09,
0x21, 0x00, 0x0A
};
memcpy(d, u24_samples, sizeof(u24_samples));
break;
}
case PA_SAMPLE_FLOAT32NE:
case PA_SAMPLE_FLOAT32RE: {
float *u = d;
static const float float_samples[] = {
0.0f, -1.0f, 1.0f, 4711.0f, 0.222f,
0.33f, -.3f, 99.0f, -0.555f, -.123f
};
if (ss->format == PA_SAMPLE_FLOAT32RE) {
for (i = 0; i < 10; i++)
u[i] = PA_FLOAT32_SWAP(float_samples[i]);
} else
memcpy(d, float_samples, sizeof(float_samples));
break;
}
default:
pa_assert_not_reached();
}
pa_memblock_release(r);
return r;
}
static void compare_block(const pa_sample_spec *ss, const pa_memchunk *chunk, int iter) {
void *d;
unsigned i;
d = pa_memblock_acquire(chunk->memblock);
switch (ss->format) {
case PA_SAMPLE_U8: {
const uint8_t *v = u8_result[iter];
uint8_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
fail_unless(*u == *v, NULL);
++u;
++v;
}
break;
}
case PA_SAMPLE_ALAW: {
const uint8_t *v = alaw_result[iter];
uint8_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
fail_unless(*u == *v, NULL);
++u;
++v;
}
break;
}
case PA_SAMPLE_ULAW: {
const uint8_t *v = ulaw_result[iter];
uint8_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
fail_unless(*u == *v, NULL);
++u;
++v;
}
break;
}
case PA_SAMPLE_S16LE: {
const uint16_t *v = s16le_result[iter];
uint16_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
fail_unless(*u == *v, NULL);
++u;
++v;
}
break;
}
case PA_SAMPLE_S16BE: {
const uint16_t *v = s16be_result[iter];
uint16_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
fail_unless(*u == *v, NULL);
++u;
++v;
}
break;
}
case PA_SAMPLE_FLOAT32LE: {
const float *v = float32le_result[iter];
float *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
float uu = ss->format == PA_SAMPLE_FLOAT32NE ? *u : PA_FLOAT32_SWAP(*u);
fail_unless(fabs(uu - *v) <= 1e-6, NULL);
++u;
++v;
}
break;
}
case PA_SAMPLE_FLOAT32BE: {
const float *v = float32be_result[iter];
float *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
float uu = ss->format == PA_SAMPLE_FLOAT32NE ? *u : PA_FLOAT32_SWAP(*u);
fail_unless(fabs(uu - *v) <= 1e-6, NULL);
++u;
++v;
}
break;
}
case PA_SAMPLE_S32LE: {
const uint32_t *v = s32le_result[iter];
uint32_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
fail_unless(*u == *v, NULL);
++u;
++v;
}
break;
}
case PA_SAMPLE_S32BE: {
const uint32_t *v = s32be_result[iter];
uint32_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
fail_unless(*u == *v, NULL);
++u;
++v;
}
break;
}
case PA_SAMPLE_S24_32LE: {
const uint32_t *v = s24_32le_result[iter];
uint32_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
fail_unless(*u == *v, NULL);
++u;
++v;
}
break;
}
case PA_SAMPLE_S24_32BE: {
const uint32_t *v = s24_32be_result[iter];
uint32_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
fail_unless(*u == *v, NULL);
++u;
++v;
}
break;
}
case PA_SAMPLE_S24LE: {
const uint8_t *v = s24le_result[iter];
uint8_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
fail_unless(*u == *v, NULL);
fail_unless(*(u+1) == *(v+1), NULL);
fail_unless(*(u+2) == *(v+2), NULL);
u += 3;
v += 3;
}
break;
}
case PA_SAMPLE_S24BE: {
const uint8_t *v = s24be_result[iter];
uint8_t *u = d;
for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
fail_unless(*u == *v, NULL);
fail_unless(*(u+1) == *(v+1), NULL);
fail_unless(*(u+2) == *(v+2), NULL);
u += 3;
v += 3;
}
break;
}
default:
pa_assert_not_reached();
}
pa_memblock_release(chunk->memblock);
}
