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); }