oysteikt/mpd
0
0
Fork 0
Code Issues Pull Requests Releases Activity

pcm/Format: change parameters/return values to ConstBuffer

Browse Source
This commit is contained in:
Max Kellermann 2014-01-06 22:42:02 +01:00
parent b0b7244b3a
commit c75339edcc
5 changed files with 192 additions and 295 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
src/pcm/FormatConverter.cxx
View File

@ -50,9 +50,6 @@ PcmFormatConverter::Close()
ConstBuffer<void> ConstBuffer<void>
PcmFormatConverter::Convert(ConstBuffer<void> src, Error &error) PcmFormatConverter::Convert(ConstBuffer<void> src, Error &error)
{ {
const void *result = nullptr;
size_t result_size = 0;
switch (dest_format) { switch (dest_format) {
case SampleFormat::UNDEFINED: case SampleFormat::UNDEFINED:
assert(false); assert(false);
@ -60,45 +57,33 @@ PcmFormatConverter::Convert(ConstBuffer<void> src, Error &error)
case SampleFormat::S8: case SampleFormat::S8:
case SampleFormat::DSD: case SampleFormat::DSD:
result = nullptr;
break;
case SampleFormat::S16:
result = pcm_convert_to_16(buffer, dither,
src_format,
src.data, src.size,
&result_size);
break;
case SampleFormat::S24_P32:
result = pcm_convert_to_24(buffer,
src_format,
src.data, src.size,
&result_size);
break;
case SampleFormat::S32:
result = pcm_convert_to_32(buffer,
src_format,
src.data, src.size,
&result_size);
break;
case SampleFormat::FLOAT:
result = pcm_convert_to_float(buffer,
src_format,
src.data, src.size,
&result_size);
break;
}
if (result == nullptr) {
error.Format(pcm_domain, error.Format(pcm_domain,
"PCM conversion from %s to %s is not implemented", "PCM conversion from %s to %s is not implemented",
sample_format_to_string(src_format), sample_format_to_string(src_format),
sample_format_to_string(dest_format)); sample_format_to_string(dest_format));
return nullptr; return nullptr;
case SampleFormat::S16:
return pcm_convert_to_16(buffer, dither,
src_format,
src).ToVoid();
case SampleFormat::S24_P32:
return pcm_convert_to_24(buffer,
src_format,
src).ToVoid();
case SampleFormat::S32:
return pcm_convert_to_32(buffer,
src_format,
src).ToVoid();
case SampleFormat::FLOAT:
return pcm_convert_to_float(buffer,
src_format,
src).ToVoid();
} }
return { result, result_size }; assert(false);
gcc_unreachable();
} }

331
src/pcm/PcmFormat.cxx
View File

@ -22,9 +22,18 @@
#include "PcmBuffer.hxx" #include "PcmBuffer.hxx"
#include "PcmUtils.hxx" #include "PcmUtils.hxx"
#include "Traits.hxx" #include "Traits.hxx"
#include "util/ConstBuffer.hxx"
#include "util/WritableBuffer.hxx"
#include "PcmDither.cxx" // including the .cxx file to get inlined templates #include "PcmDither.cxx" // including the .cxx file to get inlined templates
template<typename T>
static inline ConstBuffer<T>
ToConst(WritableBuffer<T> b)
{
return { b.data, b.size };
}
static void static void
pcm_convert_8_to_16(int16_t *out, const int8_t *in, size_t n) pcm_convert_8_to_16(int16_t *out, const int8_t *in, size_t n)
{ {
@ -76,61 +85,51 @@ AllocateFromFloat(PcmBuffer &buffer, const float *src, size_t src_size,
return dest; return dest;
} }
static int16_t * template<SampleFormat F, class Traits=SampleTraits<F>>
pcm_allocate_8_to_16(PcmBuffer &buffer, static WritableBuffer<typename Traits::value_type>
const int8_t *src, size_t src_size, size_t *dest_size_r) AllocateFromFloat(PcmBuffer &buffer, ConstBuffer<float> src)
{ {
int16_t *dest; auto dest = buffer.GetT<typename Traits::value_type>(src.size);
*dest_size_r = src_size / sizeof(*src) * sizeof(*dest); ConvertFromFloat<F, Traits>(dest, src.data, src.size);
dest = (int16_t *)buffer.Get(*dest_size_r); return { dest, src.size };
pcm_convert_8_to_16(dest, src, src_size / sizeof(*src));
return dest;
} }
static int16_t * static ConstBuffer<int16_t>
pcm_allocate_8_to_16(PcmBuffer &buffer, ConstBuffer<int8_t> src)
{
auto dest = buffer.GetT<int16_t>(src.size);
pcm_convert_8_to_16(dest, src.data, src.size);
return { dest, src.size };
}
static ConstBuffer<int16_t>
pcm_allocate_24p32_to_16(PcmBuffer &buffer, PcmDither &dither, pcm_allocate_24p32_to_16(PcmBuffer &buffer, PcmDither &dither,
const int32_t *src, size_t src_size, ConstBuffer<int32_t> src)
size_t *dest_size_r)
{ {
int16_t *dest; auto dest = buffer.GetT<int16_t>(src.size);
*dest_size_r = src_size / 2; pcm_convert_24_to_16(dither, dest, src.data, src.end());
assert(*dest_size_r == src_size / sizeof(*src) * sizeof(*dest)); return { dest, src.size };
dest = (int16_t *)buffer.Get(*dest_size_r);
pcm_convert_24_to_16(dither, dest, src,
pcm_end_pointer(src, src_size));
return dest;
} }
static int16_t * static ConstBuffer<int16_t>
pcm_allocate_32_to_16(PcmBuffer &buffer, PcmDither &dither, pcm_allocate_32_to_16(PcmBuffer &buffer, PcmDither &dither,
const int32_t *src, size_t src_size, ConstBuffer<int32_t> src)
size_t *dest_size_r)
{ {
int16_t *dest; auto dest = buffer.GetT<int16_t>(src.size);
*dest_size_r = src_size / 2; pcm_convert_32_to_16(dither, dest, src.data, src.end());
assert(*dest_size_r == src_size / sizeof(*src) * sizeof(*dest)); return { dest, src.size };
dest = (int16_t *)buffer.Get(*dest_size_r);
pcm_convert_32_to_16(dither, dest, src,
pcm_end_pointer(src, src_size));
return dest;
} }
static int16_t * static ConstBuffer<int16_t>
pcm_allocate_float_to_16(PcmBuffer &buffer, pcm_allocate_float_to_16(PcmBuffer &buffer, ConstBuffer<float> src)
const float *src, size_t src_size,
size_t *dest_size_r)
{ {
return AllocateFromFloat<SampleFormat::S16>(buffer, src, src_size, return ToConst(AllocateFromFloat<SampleFormat::S16>(buffer, src));
dest_size_r);
} }
const int16_t * ConstBuffer<int16_t>
pcm_convert_to_16(PcmBuffer &buffer, PcmDither &dither, pcm_convert_to_16(PcmBuffer &buffer, PcmDither &dither,
SampleFormat src_format, const void *src, SampleFormat src_format, ConstBuffer<void> src)
size_t src_size, size_t *dest_size_r)
{ {
assert(src_size % sample_format_size(src_format) == 0);
switch (src_format) { switch (src_format) {
case SampleFormat::UNDEFINED: case SampleFormat::UNDEFINED:
case SampleFormat::DSD: case SampleFormat::DSD:
@ -138,27 +137,22 @@ pcm_convert_to_16(PcmBuffer &buffer, PcmDither &dither,
case SampleFormat::S8: case SampleFormat::S8:
return pcm_allocate_8_to_16(buffer, return pcm_allocate_8_to_16(buffer,
(const int8_t *)src, src_size, ConstBuffer<int8_t>::FromVoid(src));
dest_size_r);
case SampleFormat::S16: case SampleFormat::S16:
*dest_size_r = src_size; return ConstBuffer<int16_t>::FromVoid(src);
return (const int16_t *)src;
case SampleFormat::S24_P32: case SampleFormat::S24_P32:
return pcm_allocate_24p32_to_16(buffer, dither, return pcm_allocate_24p32_to_16(buffer, dither,
(const int32_t *)src, src_size, ConstBuffer<int32_t>::FromVoid(src));
dest_size_r);
case SampleFormat::S32: case SampleFormat::S32:
return pcm_allocate_32_to_16(buffer, dither, return pcm_allocate_32_to_16(buffer, dither,
(const int32_t *)src, src_size, ConstBuffer<int32_t>::FromVoid(src));
dest_size_r);
case SampleFormat::FLOAT: case SampleFormat::FLOAT:
return pcm_allocate_float_to_16(buffer, return pcm_allocate_float_to_16(buffer,
(const float *)src, src_size, ConstBuffer<float>::FromVoid(src));
dest_size_r);
} }
return nullptr; return nullptr;
@ -187,55 +181,40 @@ pcm_convert_32_to_24(int32_t *gcc_restrict out,
out[i] = in[i] >> 8; out[i] = in[i] >> 8;
} }
static int32_t * static ConstBuffer<int32_t>
pcm_allocate_8_to_24(PcmBuffer &buffer, pcm_allocate_8_to_24(PcmBuffer &buffer, ConstBuffer<int8_t> src)
const int8_t *src, size_t src_size, size_t *dest_size_r)
{ {
int32_t *dest; auto dest = buffer.GetT<int32_t>(src.size);
*dest_size_r = src_size / sizeof(*src) * sizeof(*dest); pcm_convert_8_to_24(dest, src.data, src.size);
dest = (int32_t *)buffer.Get(*dest_size_r); return { dest, src.size };
pcm_convert_8_to_24(dest, src, src_size / sizeof(*src));
return dest;
} }
static int32_t * static ConstBuffer<int32_t>
pcm_allocate_16_to_24(PcmBuffer &buffer, pcm_allocate_16_to_24(PcmBuffer &buffer, ConstBuffer<int16_t> src)
const int16_t *src, size_t src_size, size_t *dest_size_r)
{ {
int32_t *dest; auto dest = buffer.GetT<int32_t>(src.size);
*dest_size_r = src_size * 2; pcm_convert_16_to_24(dest, src.data, src.size);
assert(*dest_size_r == src_size / sizeof(*src) * sizeof(*dest)); return { dest, src.size };
dest = (int32_t *)buffer.Get(*dest_size_r);
pcm_convert_16_to_24(dest, src, src_size / sizeof(*src));
return dest;
} }
static int32_t * static ConstBuffer<int32_t>
pcm_allocate_32_to_24(PcmBuffer &buffer, pcm_allocate_32_to_24(PcmBuffer &buffer, ConstBuffer<int32_t> src)
const int32_t *src, size_t src_size, size_t *dest_size_r)
{ {
*dest_size_r = src_size; auto dest = buffer.GetT<int32_t>(src.size);
int32_t *dest = (int32_t *)buffer.Get(*dest_size_r); pcm_convert_32_to_24(dest, src.data, src.size);
pcm_convert_32_to_24(dest, src, src_size / sizeof(*src)); return { dest, src.size };
return dest;
} }
static int32_t * static WritableBuffer<int32_t>
pcm_allocate_float_to_24(PcmBuffer &buffer, pcm_allocate_float_to_24(PcmBuffer &buffer, ConstBuffer<float> src)
const float *src, size_t src_size,
size_t *dest_size_r)
{ {
return AllocateFromFloat<SampleFormat::S24_P32>(buffer, src, src_size, return AllocateFromFloat<SampleFormat::S24_P32>(buffer, src);
dest_size_r);
} }
const int32_t * ConstBuffer<int32_t>
pcm_convert_to_24(PcmBuffer &buffer, pcm_convert_to_24(PcmBuffer &buffer,
SampleFormat src_format, const void *src, SampleFormat src_format, ConstBuffer<void> src)
size_t src_size, size_t *dest_size_r)
{ {
assert(src_size % sample_format_size(src_format) == 0);
switch (src_format) { switch (src_format) {
case SampleFormat::UNDEFINED: case SampleFormat::UNDEFINED:
case SampleFormat::DSD: case SampleFormat::DSD:
@ -243,27 +222,22 @@ pcm_convert_to_24(PcmBuffer &buffer,
case SampleFormat::S8: case SampleFormat::S8:
return pcm_allocate_8_to_24(buffer, return pcm_allocate_8_to_24(buffer,
(const int8_t *)src, src_size, ConstBuffer<int8_t>::FromVoid(src));
dest_size_r);
case SampleFormat::S16: case SampleFormat::S16:
return pcm_allocate_16_to_24(buffer, return pcm_allocate_16_to_24(buffer,
(const int16_t *)src, src_size, ConstBuffer<int16_t>::FromVoid(src));
dest_size_r);
case SampleFormat::S24_P32: case SampleFormat::S24_P32:
*dest_size_r = src_size; return ConstBuffer<int32_t>::FromVoid(src);
return (const int32_t *)src;
case SampleFormat::S32: case SampleFormat::S32:
return pcm_allocate_32_to_24(buffer, return pcm_allocate_32_to_24(buffer,
(const int32_t *)src, src_size, ConstBuffer<int32_t>::FromVoid(src));
dest_size_r);
case SampleFormat::FLOAT: case SampleFormat::FLOAT:
return pcm_allocate_float_to_24(buffer, return ToConst(pcm_allocate_float_to_24(buffer,
(const float *)src, src_size, ConstBuffer<float>::FromVoid(src)));
dest_size_r);
} }
return nullptr; return nullptr;
@ -292,61 +266,45 @@ pcm_convert_24_to_32(int32_t *gcc_restrict out,
out[i] = in[i] << 8; out[i] = in[i] << 8;
} }
static int32_t * static ConstBuffer<int32_t>
pcm_allocate_8_to_32(PcmBuffer &buffer, pcm_allocate_8_to_32(PcmBuffer &buffer, ConstBuffer<int8_t> src)
const int8_t *src, size_t src_size, size_t *dest_size_r)
{ {
int32_t *dest; auto dest = buffer.GetT<int32_t>(src.size);
*dest_size_r = src_size / sizeof(*src) * sizeof(*dest); pcm_convert_8_to_32(dest, src.data, src.size);
dest = (int32_t *)buffer.Get(*dest_size_r); return { dest, src.size };
pcm_convert_8_to_32(dest, src, src_size / sizeof(*src));
return dest;
} }
static int32_t * static ConstBuffer<int32_t>
pcm_allocate_16_to_32(PcmBuffer &buffer, pcm_allocate_16_to_32(PcmBuffer &buffer, ConstBuffer<int16_t> src)
const int16_t *src, size_t src_size, size_t *dest_size_r)
{ {
int32_t *dest; auto dest = buffer.GetT<int32_t>(src.size);
*dest_size_r = src_size * 2; pcm_convert_16_to_32(dest, src.data, src.size);
assert(*dest_size_r == src_size / sizeof(*src) * sizeof(*dest)); return { dest, src.size };
dest = (int32_t *)buffer.Get(*dest_size_r);
pcm_convert_16_to_32(dest, src, src_size / sizeof(*src));
return dest;
} }
static int32_t * static ConstBuffer<int32_t>
pcm_allocate_24p32_to_32(PcmBuffer &buffer, pcm_allocate_24p32_to_32(PcmBuffer &buffer, ConstBuffer<int32_t> src)
const int32_t *src, size_t src_size,
size_t *dest_size_r)
{ {
*dest_size_r = src_size; auto dest = buffer.GetT<int32_t>(src.size);
int32_t *dest = (int32_t *)buffer.Get(*dest_size_r); pcm_convert_24_to_32(dest, src.data, src.size);
pcm_convert_24_to_32(dest, src, src_size / sizeof(*src)); return { dest, src.size };
return dest;
} }
static int32_t * static ConstBuffer<int32_t>
pcm_allocate_float_to_32(PcmBuffer &buffer, pcm_allocate_float_to_32(PcmBuffer &buffer, ConstBuffer<float> src)
const float *src, size_t src_size,
size_t *dest_size_r)
{ {
/* convert to S24_P32 first */ /* convert to S24_P32 first */
int32_t *dest = pcm_allocate_float_to_24(buffer, src, src_size, auto dest = pcm_allocate_float_to_24(buffer, src);
dest_size_r);
/* convert to 32 bit in-place */ /* convert to 32 bit in-place */
pcm_convert_24_to_32(dest, dest, src_size / sizeof(*src)); pcm_convert_24_to_32(dest.data, dest.data, src.size);
return dest; return ToConst(dest);
} }
const int32_t * ConstBuffer<int32_t>
pcm_convert_to_32(PcmBuffer &buffer, pcm_convert_to_32(PcmBuffer &buffer,
SampleFormat src_format, const void *src, SampleFormat src_format, ConstBuffer<void> src)
size_t src_size, size_t *dest_size_r)
{ {
assert(src_size % sample_format_size(src_format) == 0);
switch (src_format) { switch (src_format) {
case SampleFormat::UNDEFINED: case SampleFormat::UNDEFINED:
case SampleFormat::DSD: case SampleFormat::DSD:
@ -354,27 +312,22 @@ pcm_convert_to_32(PcmBuffer &buffer,
case SampleFormat::S8: case SampleFormat::S8:
return pcm_allocate_8_to_32(buffer, return pcm_allocate_8_to_32(buffer,
(const int8_t *)src, src_size, ConstBuffer<int8_t>::FromVoid(src));
dest_size_r);
case SampleFormat::S16: case SampleFormat::S16:
return pcm_allocate_16_to_32(buffer, return pcm_allocate_16_to_32(buffer,
(const int16_t *)src, src_size, ConstBuffer<int16_t>::FromVoid(src));
dest_size_r);
case SampleFormat::S24_P32: case SampleFormat::S24_P32:
return pcm_allocate_24p32_to_32(buffer, return pcm_allocate_24p32_to_32(buffer,
(const int32_t *)src, src_size, ConstBuffer<int32_t>::FromVoid(src));
dest_size_r);
case SampleFormat::S32: case SampleFormat::S32:
*dest_size_r = src_size; return ConstBuffer<int32_t>::FromVoid(src);
return (const int32_t *)src;
case SampleFormat::FLOAT: case SampleFormat::FLOAT:
return pcm_allocate_float_to_32(buffer, return pcm_allocate_float_to_32(buffer,
(const float *)src, src_size, ConstBuffer<float>::FromVoid(src));
dest_size_r);
} }
return nullptr; return nullptr;
@ -384,77 +337,50 @@ template<SampleFormat F, class Traits=SampleTraits<F>>
static void static void
ConvertToFloat(float *dest, ConvertToFloat(float *dest,
typename Traits::const_pointer_type src, typename Traits::const_pointer_type src,
typename Traits::const_pointer_type end) size_t n)
{ {
constexpr float factor = 0.5 / (1 << (Traits::BITS - 2)); constexpr float factor = 0.5 / (1 << (Traits::BITS - 2));
while (src != end) for (size_t i = 0; i != n; ++i)
*dest++ = float(*src++) * factor; dest[i] = float(src[i]) * factor;
} }
template<SampleFormat F, class Traits=SampleTraits<F>> template<SampleFormat F, class Traits=SampleTraits<F>>
static void static ConstBuffer<float>
ConvertToFloat(float *dest,
typename Traits::const_pointer_type src, size_t size)
{
ConvertToFloat<F, Traits>(dest, src, pcm_end_pointer(src, size));
}
template<SampleFormat F, class Traits=SampleTraits<F>>
static float *
AllocateToFloat(PcmBuffer &buffer, AllocateToFloat(PcmBuffer &buffer,
typename Traits::const_pointer_type src, size_t src_size, ConstBuffer<typename Traits::value_type> src)
size_t *dest_size_r)
{ {
constexpr size_t src_sample_size = Traits::SAMPLE_SIZE; float *dest = buffer.GetT<float>(src.size);
assert(src_size % src_sample_size == 0); ConvertToFloat<F, Traits>(dest, src.data, src.size);
return { dest, src.size };
const size_t num_samples = src_size / src_sample_size;
*dest_size_r = num_samples * sizeof(float);
float *dest = (float *)buffer.Get(*dest_size_r);
ConvertToFloat<F, Traits>(dest, src, src_size);
return dest;
} }
static float * static ConstBuffer<float>
pcm_allocate_8_to_float(PcmBuffer &buffer, pcm_allocate_8_to_float(PcmBuffer &buffer, ConstBuffer<int8_t> src)
const int8_t *src, size_t src_size,
size_t *dest_size_r)
{ {
return AllocateToFloat<SampleFormat::S8>(buffer, src, src_size, return AllocateToFloat<SampleFormat::S8>(buffer, src);
dest_size_r);
} }
static float * static ConstBuffer<float>
pcm_allocate_16_to_float(PcmBuffer &buffer, pcm_allocate_16_to_float(PcmBuffer &buffer, ConstBuffer<int16_t> src)
const int16_t *src, size_t src_size,
size_t *dest_size_r)
{ {
return AllocateToFloat<SampleFormat::S16>(buffer, src, src_size, return AllocateToFloat<SampleFormat::S16>(buffer, src);
dest_size_r);
} }
static float * static ConstBuffer<float>
pcm_allocate_24p32_to_float(PcmBuffer &buffer, pcm_allocate_24p32_to_float(PcmBuffer &buffer, ConstBuffer<int32_t> src)
const int32_t *src, size_t src_size,
size_t *dest_size_r)
{ {
return AllocateToFloat<SampleFormat::S24_P32>(buffer, src, src_size, return AllocateToFloat<SampleFormat::S24_P32>(buffer, src);
dest_size_r);
} }
static float * static ConstBuffer<float>
pcm_allocate_32_to_float(PcmBuffer &buffer, pcm_allocate_32_to_float(PcmBuffer &buffer, ConstBuffer<int32_t> src)
const int32_t *src, size_t src_size,
size_t *dest_size_r)
{ {
return AllocateToFloat<SampleFormat::S32>(buffer, src, src_size, return AllocateToFloat<SampleFormat::S32>(buffer, src);
dest_size_r);
} }
const float * ConstBuffer<float>
pcm_convert_to_float(PcmBuffer &buffer, pcm_convert_to_float(PcmBuffer &buffer,
SampleFormat src_format, const void *src, SampleFormat src_format, ConstBuffer<void> src)
size_t src_size, size_t *dest_size_r)
{ {
switch (src_format) { switch (src_format) {
case SampleFormat::UNDEFINED: case SampleFormat::UNDEFINED:
@ -463,27 +389,22 @@ pcm_convert_to_float(PcmBuffer &buffer,
case SampleFormat::S8: case SampleFormat::S8:
return pcm_allocate_8_to_float(buffer, return pcm_allocate_8_to_float(buffer,
(const int8_t *)src, src_size, ConstBuffer<int8_t>::FromVoid(src));
dest_size_r);
case SampleFormat::S16: case SampleFormat::S16:
return pcm_allocate_16_to_float(buffer, return pcm_allocate_16_to_float(buffer,
(const int16_t *)src, src_size, ConstBuffer<int16_t>::FromVoid(src));
dest_size_r);
case SampleFormat::S24_P32:
return pcm_allocate_24p32_to_float(buffer,
(const int32_t *)src, src_size,
dest_size_r);
case SampleFormat::S32: case SampleFormat::S32:
return pcm_allocate_32_to_float(buffer, return pcm_allocate_32_to_float(buffer,
(const int32_t *)src, src_size, ConstBuffer<int32_t>::FromVoid(src));
dest_size_r);
case SampleFormat::S24_P32:
return pcm_allocate_24p32_to_float(buffer,
ConstBuffer<int32_t>::FromVoid(src));
case SampleFormat::FLOAT: case SampleFormat::FLOAT:
*dest_size_r = src_size; return ConstBuffer<float>::FromVoid(src);
return (const float *)src;
} }
return nullptr; return nullptr;

31
src/pcm/PcmFormat.hxx
View File

@ -25,6 +25,7 @@
#include <stdint.h> #include <stdint.h>
#include <stddef.h> #include <stddef.h>
template<typename T> struct ConstBuffer;
class PcmBuffer; class PcmBuffer;
class PcmDither; class PcmDither;
@ -36,14 +37,12 @@ class PcmDither;
* @param dither a pcm_dither object for 24-to-16 conversion * @param dither a pcm_dither object for 24-to-16 conversion
* @param bits the number of in the source buffer * @param bits the number of in the source buffer
* @param src the source PCM buffer * @param src the source PCM buffer
* @param src_size the size of #src in bytes
* @param dest_size_r returns the number of bytes of the destination buffer
* @return the destination buffer * @return the destination buffer
*/ */
const int16_t * gcc_pure
ConstBuffer<int16_t>
pcm_convert_to_16(PcmBuffer &buffer, PcmDither &dither, pcm_convert_to_16(PcmBuffer &buffer, PcmDither &dither,
SampleFormat src_format, const void *src, SampleFormat src_format, ConstBuffer<void> src);
size_t src_size, size_t *dest_size_r);
/** /**
* Converts PCM samples to 24 bit (32 bit alignment). * Converts PCM samples to 24 bit (32 bit alignment).
@ -51,14 +50,12 @@ pcm_convert_to_16(PcmBuffer &buffer, PcmDither &dither,
* @param buffer a PcmBuffer object * @param buffer a PcmBuffer object
* @param bits the number of in the source buffer * @param bits the number of in the source buffer
* @param src the source PCM buffer * @param src the source PCM buffer
* @param src_size the size of #src in bytes
* @param dest_size_r returns the number of bytes of the destination buffer
* @return the destination buffer * @return the destination buffer
*/ */
const int32_t * gcc_pure
ConstBuffer<int32_t>
pcm_convert_to_24(PcmBuffer &buffer, pcm_convert_to_24(PcmBuffer &buffer,
SampleFormat src_format, const void *src, SampleFormat src_format, ConstBuffer<void> src);
size_t src_size, size_t *dest_size_r);
/** /**
* Converts PCM samples to 32 bit. * Converts PCM samples to 32 bit.
@ -66,14 +63,12 @@ pcm_convert_to_24(PcmBuffer &buffer,
* @param buffer a PcmBuffer object * @param buffer a PcmBuffer object
* @param bits the number of in the source buffer * @param bits the number of in the source buffer
* @param src the source PCM buffer * @param src the source PCM buffer
* @param src_size the size of #src in bytes
* @param dest_size_r returns the number of bytes of the destination buffer
* @return the destination buffer * @return the destination buffer
*/ */
const int32_t * gcc_pure
ConstBuffer<int32_t>
pcm_convert_to_32(PcmBuffer &buffer, pcm_convert_to_32(PcmBuffer &buffer,
SampleFormat src_format, const void *src, SampleFormat src_format, ConstBuffer<void> src);
size_t src_size, size_t *dest_size_r);
/** /**
* Converts PCM samples to 32 bit floating point. * Converts PCM samples to 32 bit floating point.
@ -85,9 +80,9 @@ pcm_convert_to_32(PcmBuffer &buffer,
* @param dest_size_r returns the number of bytes of the destination buffer * @param dest_size_r returns the number of bytes of the destination buffer
* @return the destination buffer * @return the destination buffer
*/ */
const float * gcc_pure
ConstBuffer<float>
pcm_convert_to_float(PcmBuffer &buffer, pcm_convert_to_float(PcmBuffer &buffer,
SampleFormat src_format, const void *src, SampleFormat src_format, ConstBuffer<void> src);
size_t src_size, size_t *dest_size_r);
#endif #endif

56
test/test_pcm_format.cxx
View File

@ -29,86 +29,72 @@
void void
PcmFormatTest::TestFormat8to16() PcmFormatTest::TestFormat8to16()
{ {
constexpr unsigned N = 256; constexpr size_t N = 256;
const auto src = TestDataBuffer<int8_t, N>(); const auto src = TestDataBuffer<int8_t, N>();
PcmBuffer buffer; PcmBuffer buffer;
size_t d_size;
PcmDither dither; PcmDither dither;
auto d = pcm_convert_to_16(buffer, dither, SampleFormat::S8, auto d = pcm_convert_to_16(buffer, dither, SampleFormat::S8, src);
src, sizeof(src), &d_size); CPPUNIT_ASSERT_EQUAL(N, d.size);
auto d_end = pcm_end_pointer(d, d_size);
CPPUNIT_ASSERT_EQUAL(N, unsigned(d_end - d));
for (size_t i = 0; i < N; ++i) for (size_t i = 0; i < N; ++i)
CPPUNIT_ASSERT_EQUAL(int(src[i]), d[i] >> 8); CPPUNIT_ASSERT_EQUAL(int(src[i]), d.data[i] >> 8);
} }
void void
PcmFormatTest::TestFormat16to24() PcmFormatTest::TestFormat16to24()
{ {
constexpr unsigned N = 256; constexpr size_t N = 256;
const auto src = TestDataBuffer<int16_t, N>(); const auto src = TestDataBuffer<int16_t, N>();
PcmBuffer buffer; PcmBuffer buffer;
size_t d_size; auto d = pcm_convert_to_24(buffer, SampleFormat::S16, src);
auto d = pcm_convert_to_24(buffer, SampleFormat::S16, CPPUNIT_ASSERT_EQUAL(N, d.size);
src, sizeof(src), &d_size);
auto d_end = pcm_end_pointer(d, d_size);
CPPUNIT_ASSERT_EQUAL(N, unsigned(d_end - d));
for (size_t i = 0; i < N; ++i) for (size_t i = 0; i < N; ++i)
CPPUNIT_ASSERT_EQUAL(int(src[i]), d[i] >> 8); CPPUNIT_ASSERT_EQUAL(int(src[i]), d.data[i] >> 8);
} }
void void
PcmFormatTest::TestFormat16to32() PcmFormatTest::TestFormat16to32()
{ {
constexpr unsigned N = 256; constexpr size_t N = 256;
const auto src = TestDataBuffer<int16_t, N>(); const auto src = TestDataBuffer<int16_t, N>();
PcmBuffer buffer; PcmBuffer buffer;
size_t d_size; auto d = pcm_convert_to_32(buffer, SampleFormat::S16, src);
auto d = pcm_convert_to_32(buffer, SampleFormat::S16, CPPUNIT_ASSERT_EQUAL(N, d.size);
src, sizeof(src), &d_size);
auto d_end = pcm_end_pointer(d, d_size);
CPPUNIT_ASSERT_EQUAL(N, unsigned(d_end - d));
for (size_t i = 0; i < N; ++i) for (size_t i = 0; i < N; ++i)
CPPUNIT_ASSERT_EQUAL(int(src[i]), d[i] >> 16); CPPUNIT_ASSERT_EQUAL(int(src[i]), d.data[i] >> 16);
} }
void void
PcmFormatTest::TestFormatFloat() PcmFormatTest::TestFormatFloat()
{ {
constexpr unsigned N = 256; constexpr size_t N = 256;
const auto src = TestDataBuffer<int16_t, N>(); const auto src = TestDataBuffer<int16_t, N>();
PcmBuffer buffer1, buffer2; PcmBuffer buffer1, buffer2;
size_t f_size; auto f = pcm_convert_to_float(buffer1, SampleFormat::S16, src);
auto f = pcm_convert_to_float(buffer1, SampleFormat::S16, CPPUNIT_ASSERT_EQUAL(N, f.size);
src, sizeof(src), &f_size);
auto f_end = pcm_end_pointer(f, f_size);
CPPUNIT_ASSERT_EQUAL(N, unsigned(f_end - f));
for (auto i = f; i != f_end; ++i) { for (size_t i = 0; i != f.size; ++i) {
CPPUNIT_ASSERT(*i >= -1.); CPPUNIT_ASSERT(f.data[i] >= -1.);
CPPUNIT_ASSERT(*i <= 1.); CPPUNIT_ASSERT(f.data[i] <= 1.);
} }
PcmDither dither; PcmDither dither;
size_t d_size;
auto d = pcm_convert_to_16(buffer2, dither, auto d = pcm_convert_to_16(buffer2, dither,
SampleFormat::FLOAT, SampleFormat::FLOAT,
f, f_size, &d_size); f.ToVoid());
auto d_end = pcm_end_pointer(d, d_size); CPPUNIT_ASSERT_EQUAL(N, d.size);
CPPUNIT_ASSERT_EQUAL(N, unsigned(d_end - d));
for (size_t i = 0; i < N; ++i) for (size_t i = 0; i < N; ++i)
CPPUNIT_ASSERT_EQUAL(src[i], d[i]); CPPUNIT_ASSERT_EQUAL(src[i], d.data[i]);
} }

10
test/test_pcm_util.hxx
View File

@ -17,6 +17,8 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/ */
#include "util/ConstBuffer.hxx"
#include <array> #include <array>
#include <random> #include <random>
@ -76,6 +78,14 @@ public:
operator typename std::array<T, N>::const_pointer() const { operator typename std::array<T, N>::const_pointer() const {
return begin(); return begin();
} }
operator ConstBuffer<T>() const {
return { begin(), size() };
}
operator ConstBuffer<void>() const {
return { begin(), size() * sizeof(T) };
}
}; };
template<typename T> template<typename T>