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

audio_format: convert to C++

Browse Source
This commit is contained in:
Max Kellermann
2013-08-03 21:00:50 +02:00
parent 67f591a9ce
commit d1e7b4e381
121 changed files with 1251 additions and 1275 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
src/pcm/PcmConvert.cxx
View File

@@ -22,7 +22,7 @@
#include "PcmChannels.hxx"
#include "PcmFormat.hxx"
#include "pcm_pack.h"
#include "audio_format.h"
#include "AudioFormat.hxx"
#include <glib.h>
@@ -48,46 +48,46 @@ PcmConvert::Reset()
}
inline const int16_t *
PcmConvert::Convert16(const audio_format *src_format,
PcmConvert::Convert16(const AudioFormat src_format,
const void *src_buffer, size_t src_size,
const audio_format *dest_format, size_t *dest_size_r,
const AudioFormat dest_format, size_t *dest_size_r,
GError **error_r)
{
const int16_t *buf;
size_t len;
assert(dest_format->format == SAMPLE_FORMAT_S16);
assert(dest_format.format == SampleFormat::S16);
buf = pcm_convert_to_16(format_buffer, dither,
sample_format(src_format->format),
src_format.format,
src_buffer, src_size,
&len);
if (buf == NULL) {
g_set_error(error_r, pcm_convert_quark(), 0,
"Conversion from %s to 16 bit is not implemented",
sample_format_to_string(sample_format(src_format->format)));
sample_format_to_string(src_format.format));
return NULL;
}
if (src_format->channels != dest_format->channels) {
if (src_format.channels != dest_format.channels) {
buf = pcm_convert_channels_16(channels_buffer,
dest_format->channels,
src_format->channels,
dest_format.channels,
src_format.channels,
buf, len, &len);
if (buf == NULL) {
g_set_error(error_r, pcm_convert_quark(), 0,
"Conversion from %u to %u channels "
"is not implemented",
src_format->channels,
dest_format->channels);
src_format.channels,
dest_format.channels);
return NULL;
}
}
if (src_format->sample_rate != dest_format->sample_rate) {
buf = resampler.Resample16(dest_format->channels,
src_format->sample_rate, buf, len,
dest_format->sample_rate, &len,
if (src_format.sample_rate != dest_format.sample_rate) {
buf = resampler.Resample16(dest_format.channels,
src_format.sample_rate, buf, len,
dest_format.sample_rate, &len,
error_r);
if (buf == NULL)
return NULL;
@@ -98,45 +98,45 @@ PcmConvert::Convert16(const audio_format *src_format,
}
inline const int32_t *
PcmConvert::Convert24(const audio_format *src_format,
PcmConvert::Convert24(const AudioFormat src_format,
const void *src_buffer, size_t src_size,
const audio_format *dest_format, size_t *dest_size_r,
const AudioFormat dest_format, size_t *dest_size_r,
GError **error_r)
{
const int32_t *buf;
size_t len;
assert(dest_format->format == SAMPLE_FORMAT_S24_P32);
assert(dest_format.format == SampleFormat::S24_P32);
buf = pcm_convert_to_24(format_buffer,
sample_format(src_format->format),
src_format.format,
src_buffer, src_size, &len);
if (buf == NULL) {
g_set_error(error_r, pcm_convert_quark(), 0,
"Conversion from %s to 24 bit is not implemented",
sample_format_to_string(sample_format(src_format->format)));
sample_format_to_string(src_format.format));
return NULL;
}
if (src_format->channels != dest_format->channels) {
if (src_format.channels != dest_format.channels) {
buf = pcm_convert_channels_24(channels_buffer,
dest_format->channels,
src_format->channels,
dest_format.channels,
src_format.channels,
buf, len, &len);
if (buf == NULL) {
g_set_error(error_r, pcm_convert_quark(), 0,
"Conversion from %u to %u channels "
"is not implemented",
src_format->channels,
dest_format->channels);
src_format.channels,
dest_format.channels);
return NULL;
}
}
if (src_format->sample_rate != dest_format->sample_rate) {
buf = resampler.Resample24(dest_format->channels,
src_format->sample_rate, buf, len,
dest_format->sample_rate, &len,
if (src_format.sample_rate != dest_format.sample_rate) {
buf = resampler.Resample24(dest_format.channels,
src_format.sample_rate, buf, len,
dest_format.sample_rate, &len,
error_r);
if (buf == NULL)
return NULL;
@@ -147,45 +147,45 @@ PcmConvert::Convert24(const audio_format *src_format,
}
inline const int32_t *
PcmConvert::Convert32(const audio_format *src_format,
PcmConvert::Convert32(const AudioFormat src_format,
const void *src_buffer, size_t src_size,
const audio_format *dest_format, size_t *dest_size_r,
const AudioFormat dest_format, size_t *dest_size_r,
GError **error_r)
{
const int32_t *buf;
size_t len;
assert(dest_format->format == SAMPLE_FORMAT_S32);
assert(dest_format.format == SampleFormat::S32);
buf = pcm_convert_to_32(format_buffer,
sample_format(src_format->format),
src_format.format,
src_buffer, src_size, &len);
if (buf == NULL) {
g_set_error(error_r, pcm_convert_quark(), 0,
"Conversion from %s to 32 bit is not implemented",
sample_format_to_string(sample_format(src_format->format)));
sample_format_to_string(src_format.format));
return NULL;
}
if (src_format->channels != dest_format->channels) {
if (src_format.channels != dest_format.channels) {
buf = pcm_convert_channels_32(channels_buffer,
dest_format->channels,
src_format->channels,
dest_format.channels,
src_format.channels,
buf, len, &len);
if (buf == NULL) {
g_set_error(error_r, pcm_convert_quark(), 0,
"Conversion from %u to %u channels "
"is not implemented",
src_format->channels,
dest_format->channels);
src_format.channels,
dest_format.channels);
return NULL;
}
}
if (src_format->sample_rate != dest_format->sample_rate) {
buf = resampler.Resample32(dest_format->channels,
src_format->sample_rate, buf, len,
dest_format->sample_rate, &len,
if (src_format.sample_rate != dest_format.sample_rate) {
buf = resampler.Resample32(dest_format.channels,
src_format.sample_rate, buf, len,
dest_format.sample_rate, &len,
error_r);
if (buf == NULL)
return buf;
@@ -196,41 +196,41 @@ PcmConvert::Convert32(const audio_format *src_format,
}
inline const float *
PcmConvert::ConvertFloat(const audio_format *src_format,
PcmConvert::ConvertFloat(const AudioFormat src_format,
const void *src_buffer, size_t src_size,
const audio_format *dest_format, size_t *dest_size_r,
const AudioFormat dest_format, size_t *dest_size_r,
GError **error_r)
{
const float *buffer = (const float *)src_buffer;
size_t size = src_size;
assert(dest_format->format == SAMPLE_FORMAT_FLOAT);
assert(dest_format.format == SampleFormat::FLOAT);
/* convert to float now */
buffer = pcm_convert_to_float(format_buffer,
sample_format(src_format->format),
src_format.format,
buffer, size, &size);
if (buffer == NULL) {
g_set_error(error_r, pcm_convert_quark(), 0,
"Conversion from %s to float is not implemented",
sample_format_to_string(sample_format(src_format->format)));
sample_format_to_string(src_format.format));
return NULL;
}
/* convert channels */
if (src_format->channels != dest_format->channels) {
if (src_format.channels != dest_format.channels) {
buffer = pcm_convert_channels_float(channels_buffer,
dest_format->channels,
src_format->channels,
dest_format.channels,
src_format.channels,
buffer, size, &size);
if (buffer == NULL) {
g_set_error(error_r, pcm_convert_quark(), 0,
"Conversion from %u to %u channels "
"is not implemented",
src_format->channels,
dest_format->channels);
src_format.channels,
dest_format.channels);
return NULL;
}
}
@@ -238,11 +238,11 @@ PcmConvert::ConvertFloat(const audio_format *src_format,
/* resample with float, because this is the best format for
libsamplerate */
if (src_format->sample_rate != dest_format->sample_rate) {
buffer = resampler.ResampleFloat(dest_format->channels,
src_format->sample_rate,
if (src_format.sample_rate != dest_format.sample_rate) {
buffer = resampler.ResampleFloat(dest_format.channels,
src_format.sample_rate,
buffer, size,
dest_format->sample_rate,
dest_format.sample_rate,
&size, error_r);
if (buffer == NULL)
return NULL;
@@ -253,16 +253,16 @@ PcmConvert::ConvertFloat(const audio_format *src_format,
}
const void *
PcmConvert::Convert(const audio_format *src_format,
PcmConvert::Convert(AudioFormat src_format,
const void *src, size_t src_size,
const audio_format *dest_format,
const AudioFormat dest_format,
size_t *dest_size_r,
GError **error_r)
{
struct audio_format float_format;
if (src_format->format == SAMPLE_FORMAT_DSD) {
AudioFormat float_format;
if (src_format.format == SampleFormat::DSD) {
size_t f_size;
const float *f = dsd.ToFloat(src_format->channels,
const float *f = dsd.ToFloat(src_format.channels,
false, (const uint8_t *)src,
src_size, &f_size);
if (f == NULL) {
@@ -271,31 +271,31 @@ PcmConvert::Convert(const audio_format *src_format,
return NULL;
}
float_format = *src_format;
float_format.format = SAMPLE_FORMAT_FLOAT;
float_format = src_format;
float_format.format = SampleFormat::FLOAT;
src_format = &float_format;
src_format = float_format;
src = f;
src_size = f_size;
}
switch (sample_format(dest_format->format)) {
case SAMPLE_FORMAT_S16:
switch (dest_format.format) {
case SampleFormat::S16:
return Convert16(src_format, src, src_size,
dest_format, dest_size_r,
error_r);
case SAMPLE_FORMAT_S24_P32:
case SampleFormat::S24_P32:
return Convert24(src_format, src, src_size,
dest_format, dest_size_r,
error_r);
case SAMPLE_FORMAT_S32:
case SampleFormat::S32:
return Convert32(src_format, src, src_size,
dest_format, dest_size_r,
error_r);
case SAMPLE_FORMAT_FLOAT:
case SampleFormat::FLOAT:
return ConvertFloat(src_format, src, src_size,
dest_format, dest_size_r,
error_r);
@@ -303,7 +303,7 @@ PcmConvert::Convert(const audio_format *src_format,
default:
g_set_error(error_r, pcm_convert_quark(), 0,
"PCM conversion to %s is not implemented",
sample_format_to_string(sample_format(dest_format->format)));
sample_format_to_string(dest_format.format));
return NULL;
}
}

22
src/pcm/PcmConvert.hxx
View File

@@ -27,7 +27,7 @@
#include <glib.h>
struct audio_format;
struct AudioFormat;
/**
* This object is statically allocated (within another struct), and
@@ -71,34 +71,34 @@ public:
* ignore errors
* @return the destination buffer, or NULL on error
*/
const void *Convert(const audio_format *src_format,
const void *Convert(AudioFormat src_format,
const void *src, size_t src_size,
const audio_format *dest_format,
AudioFormat dest_format,
size_t *dest_size_r,
GError **error_r);
private:
const int16_t *Convert16(const audio_format *src_format,
const int16_t *Convert16(AudioFormat src_format,
const void *src_buffer, size_t src_size,
const audio_format *dest_format,
AudioFormat dest_format,
size_t *dest_size_r,
GError **error_r);
const int32_t *Convert24(const audio_format *src_format,
const int32_t *Convert24(AudioFormat src_format,
const void *src_buffer, size_t src_size,
const audio_format *dest_format,
AudioFormat dest_format,
size_t *dest_size_r,
GError **error_r);
const int32_t *Convert32(const audio_format *src_format,
const int32_t *Convert32(AudioFormat src_format,
const void *src_buffer, size_t src_size,
const audio_format *dest_format,
AudioFormat dest_format,
size_t *dest_size_r,
GError **error_r);
const float *ConvertFloat(const audio_format *src_format,
const float *ConvertFloat(AudioFormat src_format,
const void *src_buffer, size_t src_size,
const audio_format *dest_format,
AudioFormat dest_format,
size_t *dest_size_r,
GError **error_r);
};

2
src/pcm/PcmDsdUsb.cxx
View File

@@ -20,7 +20,7 @@
#include "config.h"
#include "PcmDsdUsb.hxx"
#include "PcmBuffer.hxx"
#include "audio_format.h"
#include "AudioFormat.hxx"
G_GNUC_CONST
static inline uint32_t

14
src/pcm/PcmExport.cxx
View File

@@ -27,21 +27,21 @@ extern "C" {
}
void
PcmExport::Open(enum sample_format sample_format, unsigned _channels,
PcmExport::Open(SampleFormat sample_format, unsigned _channels,
bool _dsd_usb, bool _shift8, bool _pack, bool _reverse_endian)
{
assert(audio_valid_sample_format(sample_format));
assert(!_dsd_usb || audio_valid_channel_count(_channels));
channels = _channels;
dsd_usb = _dsd_usb && sample_format == SAMPLE_FORMAT_DSD;
dsd_usb = _dsd_usb && sample_format == SampleFormat::DSD;
if (dsd_usb)
/* after the conversion to DSD-over-USB, the DSD
samples are stuffed inside fake 24 bit samples */
sample_format = SAMPLE_FORMAT_S24_P32;
sample_format = SampleFormat::S24_P32;
shift8 = _shift8 && sample_format == SAMPLE_FORMAT_S24_P32;
pack24 = _pack && sample_format == SAMPLE_FORMAT_S24_P32;
shift8 = _shift8 && sample_format == SampleFormat::S24_P32;
pack24 = _pack && sample_format == SampleFormat::S24_P32;
assert(!shift8 || !pack24);
@@ -58,7 +58,7 @@ PcmExport::Open(enum sample_format sample_format, unsigned _channels,
}
size_t
PcmExport::GetFrameSize(const struct audio_format &audio_format) const
PcmExport::GetFrameSize(const AudioFormat &audio_format) const
{
if (pack24)
/* packed 24 bit samples (3 bytes per sample) */
@@ -71,7 +71,7 @@ PcmExport::GetFrameSize(const struct audio_format &audio_format) const
bytes per sample) */
return channels * 4;
return audio_format_frame_size(&audio_format);
return audio_format.GetFrameSize();
}
const void *

12
src/pcm/PcmExport.hxx
View File

@@ -22,9 +22,9 @@
#include "check.h"
#include "PcmBuffer.hxx"
#include "audio_format.h"
#include "AudioFormat.hxx"
struct audio_format;
struct AudioFormat;
/**
* An object that handles export of PCM samples to some instance
@@ -61,8 +61,8 @@ struct PcmExport {
/**
* Convert DSD to DSD-over-USB? Input format must be
* SAMPLE_FORMAT_DSD and output format must be
* SAMPLE_FORMAT_S24_P32.
* SampleFormat::DSD and output format must be
* SampleFormat::S24_P32.
*/
bool dsd_usb;
@@ -94,14 +94,14 @@ struct PcmExport {
*
* @param channels the number of channels; ignored unless dsd_usb is set
*/
void Open(enum sample_format sample_format, unsigned channels,
void Open(SampleFormat sample_format, unsigned channels,
bool dsd_usb, bool shift8, bool pack, bool reverse_endian);
/**
* Calculate the size of one output frame.
*/
gcc_pure
size_t GetFrameSize(const struct audio_format &audio_format) const;
size_t GetFrameSize(const AudioFormat &audio_format) const;
/**
* Export a PCM buffer.

64
src/pcm/PcmFormat.cxx
View File

@@ -142,36 +142,36 @@ pcm_allocate_float_to_16(PcmBuffer &buffer,
const int16_t *
pcm_convert_to_16(PcmBuffer &buffer, PcmDither &dither,
enum sample_format src_format, const void *src,
SampleFormat src_format, const void *src,
size_t src_size, size_t *dest_size_r)
{
assert(src_size % sample_format_size(src_format) == 0);
switch (src_format) {
case SAMPLE_FORMAT_UNDEFINED:
case SAMPLE_FORMAT_DSD:
case SampleFormat::UNDEFINED:
case SampleFormat::DSD:
break;
case SAMPLE_FORMAT_S8:
case SampleFormat::S8:
return pcm_allocate_8_to_16(buffer,
(const int8_t *)src, src_size,
dest_size_r);
case SAMPLE_FORMAT_S16:
case SampleFormat::S16:
*dest_size_r = src_size;
return (const int16_t *)src;
case SAMPLE_FORMAT_S24_P32:
case SampleFormat::S24_P32:
return pcm_allocate_24p32_to_16(buffer, dither,
(const int32_t *)src, src_size,
dest_size_r);
case SAMPLE_FORMAT_S32:
case SampleFormat::S32:
return pcm_allocate_32_to_16(buffer, dither,
(const int32_t *)src, src_size,
dest_size_r);
case SAMPLE_FORMAT_FLOAT:
case SampleFormat::FLOAT:
return pcm_allocate_float_to_16(buffer,
(const float *)src, src_size,
dest_size_r);
@@ -247,36 +247,36 @@ pcm_allocate_float_to_24(PcmBuffer &buffer,
const int32_t *
pcm_convert_to_24(PcmBuffer &buffer,
enum sample_format src_format, const void *src,
SampleFormat src_format, const void *src,
size_t src_size, size_t *dest_size_r)
{
assert(src_size % sample_format_size(src_format) == 0);
switch (src_format) {
case SAMPLE_FORMAT_UNDEFINED:
case SAMPLE_FORMAT_DSD:
case SampleFormat::UNDEFINED:
case SampleFormat::DSD:
break;
case SAMPLE_FORMAT_S8:
case SampleFormat::S8:
return pcm_allocate_8_to_24(buffer,
(const int8_t *)src, src_size,
dest_size_r);
case SAMPLE_FORMAT_S16:
case SampleFormat::S16:
return pcm_allocate_16_to_24(buffer,
(const int16_t *)src, src_size,
dest_size_r);
case SAMPLE_FORMAT_S24_P32:
case SampleFormat::S24_P32:
*dest_size_r = src_size;
return (const int32_t *)src;
case SAMPLE_FORMAT_S32:
case SampleFormat::S32:
return pcm_allocate_32_to_24(buffer,
(const int32_t *)src, src_size,
dest_size_r);
case SAMPLE_FORMAT_FLOAT:
case SampleFormat::FLOAT:
return pcm_allocate_float_to_24(buffer,
(const float *)src, src_size,
dest_size_r);
@@ -358,36 +358,36 @@ pcm_allocate_float_to_32(PcmBuffer &buffer,
const int32_t *
pcm_convert_to_32(PcmBuffer &buffer,
enum sample_format src_format, const void *src,
SampleFormat src_format, const void *src,
size_t src_size, size_t *dest_size_r)
{
assert(src_size % sample_format_size(src_format) == 0);
switch (src_format) {
case SAMPLE_FORMAT_UNDEFINED:
case SAMPLE_FORMAT_DSD:
case SampleFormat::UNDEFINED:
case SampleFormat::DSD:
break;
case SAMPLE_FORMAT_S8:
case SampleFormat::S8:
return pcm_allocate_8_to_32(buffer,
(const int8_t *)src, src_size,
dest_size_r);
case SAMPLE_FORMAT_S16:
case SampleFormat::S16:
return pcm_allocate_16_to_32(buffer,
(const int16_t *)src, src_size,
dest_size_r);
case SAMPLE_FORMAT_S24_P32:
case SampleFormat::S24_P32:
return pcm_allocate_24p32_to_32(buffer,
(const int32_t *)src, src_size,
dest_size_r);
case SAMPLE_FORMAT_S32:
case SampleFormat::S32:
*dest_size_r = src_size;
return (const int32_t *)src;
case SAMPLE_FORMAT_FLOAT:
case SampleFormat::FLOAT:
return pcm_allocate_float_to_32(buffer,
(const float *)src, src_size,
dest_size_r);
@@ -463,35 +463,35 @@ pcm_allocate_32_to_float(PcmBuffer &buffer,
const float *
pcm_convert_to_float(PcmBuffer &buffer,
enum sample_format src_format, const void *src,
SampleFormat src_format, const void *src,
size_t src_size, size_t *dest_size_r)
{
switch (src_format) {
case SAMPLE_FORMAT_UNDEFINED:
case SAMPLE_FORMAT_DSD:
case SampleFormat::UNDEFINED:
case SampleFormat::DSD:
break;
case SAMPLE_FORMAT_S8:
case SampleFormat::S8:
return pcm_allocate_8_to_float(buffer,
(const int8_t *)src, src_size,
dest_size_r);
case SAMPLE_FORMAT_S16:
case SampleFormat::S16:
return pcm_allocate_16_to_float(buffer,
(const int16_t *)src, src_size,
dest_size_r);
case SAMPLE_FORMAT_S24_P32:
case SampleFormat::S24_P32:
return pcm_allocate_24p32_to_float(buffer,
(const int32_t *)src, src_size,
dest_size_r);
case SAMPLE_FORMAT_S32:
case SampleFormat::S32:
return pcm_allocate_32_to_float(buffer,
(const int32_t *)src, src_size,
dest_size_r);
case SAMPLE_FORMAT_FLOAT:
case SampleFormat::FLOAT:
*dest_size_r = src_size;
return (const float *)src;
}

10
src/pcm/PcmFormat.hxx
View File

@@ -20,7 +20,7 @@
#ifndef MPD_PCM_FORMAT_HXX
#define MPD_PCM_FORMAT_HXX
#include "audio_format.h"
#include "AudioFormat.hxx"
#include <stdint.h>
#include <stddef.h>
@@ -42,7 +42,7 @@ class PcmDither;
*/
const int16_t *
pcm_convert_to_16(PcmBuffer &buffer, PcmDither &dither,
enum sample_format src_format, const void *src,
SampleFormat src_format, const void *src,
size_t src_size, size_t *dest_size_r);
/**
@@ -57,7 +57,7 @@ pcm_convert_to_16(PcmBuffer &buffer, PcmDither &dither,
*/
const int32_t *
pcm_convert_to_24(PcmBuffer &buffer,
enum sample_format src_format, const void *src,
SampleFormat src_format, const void *src,
size_t src_size, size_t *dest_size_r);
/**
@@ -72,7 +72,7 @@ pcm_convert_to_24(PcmBuffer &buffer,
*/
const int32_t *
pcm_convert_to_32(PcmBuffer &buffer,
enum sample_format src_format, const void *src,
SampleFormat src_format, const void *src,
size_t src_size, size_t *dest_size_r);
/**
@@ -87,7 +87,7 @@ pcm_convert_to_32(PcmBuffer &buffer,
*/
const float *
pcm_convert_to_float(PcmBuffer &buffer,
enum sample_format src_format, const void *src,
SampleFormat src_format, const void *src,
size_t src_size, size_t *dest_size_r);
#endif

36
src/pcm/PcmMix.cxx
View File

@@ -21,7 +21,7 @@
#include "PcmMix.hxx"
#include "PcmVolume.hxx"
#include "PcmUtils.hxx"
#include "audio_format.h"
#include "AudioFormat.hxx"
#include <math.h>
@@ -74,35 +74,35 @@ pcm_add_vol_float(float *buffer1, const float *buffer2,
static bool
pcm_add_vol(void *buffer1, const void *buffer2, size_t size,
int vol1, int vol2,
enum sample_format format)
SampleFormat format)
{
switch (format) {
case SAMPLE_FORMAT_UNDEFINED:
case SAMPLE_FORMAT_DSD:
case SampleFormat::UNDEFINED:
case SampleFormat::DSD:
/* not implemented */
return false;
case SAMPLE_FORMAT_S8:
case SampleFormat::S8:
PcmAddVolumeVoid<int8_t, int32_t, 8>(buffer1, buffer2, size,
vol1, vol2);
return true;
case SAMPLE_FORMAT_S16:
case SampleFormat::S16:
PcmAddVolumeVoid<int16_t, int32_t, 16>(buffer1, buffer2, size,
vol1, vol2);
return true;
case SAMPLE_FORMAT_S24_P32:
case SampleFormat::S24_P32:
PcmAddVolumeVoid<int32_t, int64_t, 24>(buffer1, buffer2, size,
vol1, vol2);
return true;
case SAMPLE_FORMAT_S32:
case SampleFormat::S32:
PcmAddVolumeVoid<int32_t, int64_t, 32>(buffer1, buffer2, size,
vol1, vol2);
return true;
case SAMPLE_FORMAT_FLOAT:
case SampleFormat::FLOAT:
pcm_add_vol_float((float *)buffer1, (const float *)buffer2,
size / 4,
pcm_volume_to_float(vol1),
@@ -153,31 +153,31 @@ pcm_add_float(float *buffer1, const float *buffer2, unsigned num_samples)
static bool
pcm_add(void *buffer1, const void *buffer2, size_t size,
enum sample_format format)
SampleFormat format)
{
switch (format) {
case SAMPLE_FORMAT_UNDEFINED:
case SAMPLE_FORMAT_DSD:
case SampleFormat::UNDEFINED:
case SampleFormat::DSD:
/* not implemented */
return false;
case SAMPLE_FORMAT_S8:
case SampleFormat::S8:
PcmAddVoid<int8_t, int32_t, 8>(buffer1, buffer2, size);
return true;
case SAMPLE_FORMAT_S16:
case SampleFormat::S16:
PcmAddVoid<int16_t, int32_t, 16>(buffer1, buffer2, size);
return true;
case SAMPLE_FORMAT_S24_P32:
case SampleFormat::S24_P32:
PcmAddVoid<int32_t, int64_t, 24>(buffer1, buffer2, size);
return true;
case SAMPLE_FORMAT_S32:
case SampleFormat::S32:
PcmAddVoid<int32_t, int64_t, 32>(buffer1, buffer2, size);
return true;
case SAMPLE_FORMAT_FLOAT:
case SampleFormat::FLOAT:
pcm_add_float((float *)buffer1, (const float *)buffer2,
size / 4);
return true;
@@ -189,7 +189,7 @@ pcm_add(void *buffer1, const void *buffer2, size_t size,
bool
pcm_mix(void *buffer1, const void *buffer2, size_t size,
enum sample_format format, float portion1)
SampleFormat format, float portion1)
{
int vol1;
float s;

4
src/pcm/PcmMix.hxx
View File

@@ -20,7 +20,7 @@
#ifndef MPD_PCM_MIX_HXX
#define MPD_PCM_MIX_HXX
#include "audio_format.h"
#include "AudioFormat.hxx"
#include "gcc.h"
#include <stddef.h>
@@ -44,6 +44,6 @@
gcc_warn_unused_result
bool
pcm_mix(void *buffer1, const void *buffer2, size_t size,
enum sample_format format, float portion1);
SampleFormat format, float portion1);
#endif

18
src/pcm/PcmVolume.cxx
View File

@@ -20,7 +20,7 @@
#include "config.h"
#include "PcmVolume.hxx"
#include "PcmUtils.hxx"
#include "audio_format.h"
#include "AudioFormat.hxx"
#include <glib.h>
@@ -144,7 +144,7 @@ pcm_volume_change_float(float *buffer, const float *end, float volume)
bool
pcm_volume(void *buffer, size_t length,
enum sample_format format,
SampleFormat format,
int volume)
{
if (volume == PCM_VOLUME_1)
@@ -157,32 +157,32 @@ pcm_volume(void *buffer, size_t length,
const void *end = pcm_end_pointer(buffer, length);
switch (format) {
case SAMPLE_FORMAT_UNDEFINED:
case SAMPLE_FORMAT_DSD:
case SampleFormat::UNDEFINED:
case SampleFormat::DSD:
/* not implemented */
return false;
case SAMPLE_FORMAT_S8:
case SampleFormat::S8:
pcm_volume_change_8((int8_t *)buffer, (const int8_t *)end,
volume);
return true;
case SAMPLE_FORMAT_S16:
case SampleFormat::S16:
pcm_volume_change_16((int16_t *)buffer, (const int16_t *)end,
volume);
return true;
case SAMPLE_FORMAT_S24_P32:
case SampleFormat::S24_P32:
pcm_volume_change_24((int32_t *)buffer, (const int32_t *)end,
volume);
return true;
case SAMPLE_FORMAT_S32:
case SampleFormat::S32:
pcm_volume_change_32((int32_t *)buffer, (const int32_t *)end,
volume);
return true;
case SAMPLE_FORMAT_FLOAT:
case SampleFormat::FLOAT:
pcm_volume_change_float((float *)buffer, (const float *)end,
pcm_volume_to_float(volume));
return true;

6
src/pcm/PcmVolume.hxx
View File

@@ -21,7 +21,7 @@
#define MPD_PCM_VOLUME_HXX
#include "PcmPrng.hxx"
#include "audio_format.h"
#include "AudioFormat.hxx"
#include <stdint.h>
#include <stddef.h>
@@ -31,7 +31,7 @@ enum {
PCM_VOLUME_1 = 1024,
};
struct audio_format;
struct AudioFormat;
/**
* Converts a float value (0.0 = silence, 1.0 = 100% volume) to an
@@ -75,7 +75,7 @@ pcm_volume_dither(void)
*/
bool
pcm_volume(void *buffer, size_t length,
enum sample_format format,
SampleFormat format,
int volume);
#endif