aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/filter/ReplayGainFilterPlugin.cxx59
-rw-r--r--src/filter/VolumeFilterPlugin.cxx63
-rw-r--r--src/pcm/Volume.cxx87
-rw-r--r--src/pcm/Volume.hxx79
4 files changed, 156 insertions, 132 deletions
diff --git a/src/filter/ReplayGainFilterPlugin.cxx b/src/filter/ReplayGainFilterPlugin.cxx
index c6c3cc2aa..998fda6f7 100644
--- a/src/filter/ReplayGainFilterPlugin.cxx
+++ b/src/filter/ReplayGainFilterPlugin.cxx
@@ -28,6 +28,7 @@
#include "MixerControl.hxx"
#include "pcm/Volume.hxx"
#include "pcm/PcmBuffer.hxx"
+#include "util/ConstBuffer.hxx"
#include "util/Error.hxx"
#include "util/Domain.hxx"
#include "Log.hxx"
@@ -55,8 +56,8 @@ class ReplayGainFilter final : public Filter {
ReplayGainInfo info;
/**
- * The current volume, between 0 and a value that may or may not exceed
- * #PCM_VOLUME_1.
+ * About the current volume: it is between 0 and a value that
+ * may or may not exceed #PCM_VOLUME_1.
*
* If the default value of true is used for replaygain_limit, the
* application of the volume to the signal will never cause clipping.
@@ -66,16 +67,11 @@ class ReplayGainFilter final : public Filter {
* maintain a consistent audio level. Whether clipping will actually
* occur depends on what value the user is using for replaygain_preamp.
*/
- unsigned volume;
-
- AudioFormat format;
-
- PcmBuffer buffer;
+ PcmVolume pv;
public:
ReplayGainFilter()
- :mixer(nullptr), mode(REPLAY_GAIN_OFF),
- volume(PCM_VOLUME_1) {
+ :mixer(nullptr), mode(REPLAY_GAIN_OFF) {
info.Clear();
}
@@ -125,6 +121,7 @@ public:
void
ReplayGainFilter::Update()
{
+ unsigned volume = PCM_VOLUME_1;
if (mode != REPLAY_GAIN_OFF) {
const auto &tuple = info.tuples[mode];
float scale = tuple.CalculateScale(replay_gain_preamp,
@@ -134,8 +131,9 @@ ReplayGainFilter::Update()
"scale=%f\n", (double)scale);
volume = pcm_float_to_volume(scale);
- } else
- volume = PCM_VOLUME_1;
+ }
+
+ pv.SetVolume(volume);
if (mixer != nullptr) {
/* update the hardware mixer volume */
@@ -160,48 +158,25 @@ replay_gain_filter_init(gcc_unused const config_param &param,
AudioFormat
ReplayGainFilter::Open(AudioFormat &af, gcc_unused Error &error)
{
- format = af;
+ if (!pv.Open(af.format, error))
+ return AudioFormat::Undefined();
- return format;
+ return af;
}
void
ReplayGainFilter::Close()
{
- buffer.Clear();
+ pv.Close();
}
const void *
ReplayGainFilter::FilterPCM(const void *src, size_t src_size,
- size_t *dest_size_r, Error &error)
+ size_t *dest_size_r, gcc_unused Error &error)
{
-
- *dest_size_r = src_size;
-
- if (volume == PCM_VOLUME_1)
- /* optimized special case: 100% volume = no-op */
- return src;
-
- void *dest = buffer.Get(src_size);
- if (volume <= 0) {
- /* optimized special case: 0% volume = memset(0) */
- /* XXX is this valid for all sample formats? What
- about floating point? */
- memset(dest, 0, src_size);
- return dest;
- }
-
- memcpy(dest, src, src_size);
-
- bool success = pcm_volume(dest, src_size,
- format.format,
- volume);
- if (!success) {
- error.Set(replay_gain_domain, "pcm_volume() has failed");
- return nullptr;
- }
-
- return dest;
+ const auto dest = pv.Apply({src, src_size});
+ *dest_size_r = dest.size;
+ return dest.data;
}
const struct filter_plugin replay_gain_filter_plugin = {
diff --git a/src/filter/VolumeFilterPlugin.cxx b/src/filter/VolumeFilterPlugin.cxx
index 2438e0336..8b9c6f8e9 100644
--- a/src/filter/VolumeFilterPlugin.cxx
+++ b/src/filter/VolumeFilterPlugin.cxx
@@ -23,8 +23,8 @@
#include "FilterInternal.hxx"
#include "FilterRegistry.hxx"
#include "pcm/Volume.hxx"
-#include "pcm/PcmBuffer.hxx"
#include "AudioFormat.hxx"
+#include "util/ConstBuffer.hxx"
#include "util/Error.hxx"
#include "util/Domain.hxx"
@@ -32,29 +32,15 @@
#include <string.h>
class VolumeFilter final : public Filter {
- /**
- * The current volume, from 0 to #PCM_VOLUME_1.
- */
- unsigned volume;
-
- AudioFormat format;
-
- PcmBuffer buffer;
+ PcmVolume pv;
public:
- VolumeFilter()
- :volume(PCM_VOLUME_1) {}
-
unsigned GetVolume() const {
- assert(volume <= PCM_VOLUME_1);
-
- return volume;
+ return pv.GetVolume();
}
void SetVolume(unsigned _volume) {
- assert(_volume <= PCM_VOLUME_1);
-
- volume = _volume;
+ pv.SetVolume(_volume);
}
virtual AudioFormat Open(AudioFormat &af, Error &error) override;
@@ -73,50 +59,27 @@ volume_filter_init(gcc_unused const config_param &param,
}
AudioFormat
-VolumeFilter::Open(AudioFormat &audio_format, gcc_unused Error &error)
+VolumeFilter::Open(AudioFormat &audio_format, Error &error)
{
- format = audio_format;
+ if (!pv.Open(audio_format.format, error))
+ return AudioFormat::Undefined();
- return format;
+ return audio_format;
}
void
VolumeFilter::Close()
{
- buffer.Clear();
+ pv.Close();
}
const void *
VolumeFilter::FilterPCM(const void *src, size_t src_size,
- size_t *dest_size_r, Error &error)
+ size_t *dest_size_r, gcc_unused Error &error)
{
- *dest_size_r = src_size;
-
- if (volume >= PCM_VOLUME_1)
- /* optimized special case: 100% volume = no-op */
- return src;
-
- void *dest = buffer.Get(src_size);
-
- if (volume <= 0) {
- /* optimized special case: 0% volume = memset(0) */
- /* XXX is this valid for all sample formats? What
- about floating point? */
- memset(dest, 0, src_size);
- return dest;
- }
-
- memcpy(dest, src, src_size);
-
- bool success = pcm_volume(dest, src_size,
- format.format,
- volume);
- if (!success) {
- error.Set(volume_domain, "pcm_volume() has failed");
- return NULL;
- }
-
- return dest;
+ const auto dest = pv.Apply({src, src_size});
+ *dest_size_r = dest.size;
+ return dest.data;
}
const struct filter_plugin volume_filter_plugin = {
diff --git a/src/pcm/Volume.cxx b/src/pcm/Volume.cxx
index 410df7695..539ef1238 100644
--- a/src/pcm/Volume.cxx
+++ b/src/pcm/Volume.cxx
@@ -19,9 +19,11 @@
#include "config.h"
#include "Volume.hxx"
+#include "Domain.hxx"
#include "PcmUtils.hxx"
#include "Traits.hxx"
-#include "AudioFormat.hxx"
+#include "util/ConstBuffer.hxx"
+#include "util/Error.hxx"
#include <stdint.h>
#include <string.h>
@@ -143,61 +145,88 @@ pcm_volume_change_float(float *dest, const float *src, const float *end,
}
bool
-pcm_volume(void *buffer, size_t length,
- SampleFormat format,
- int volume)
+PcmVolume::Open(SampleFormat _format, Error &error)
{
- if (volume == PCM_VOLUME_1S)
- return true;
+ assert(format == SampleFormat::UNDEFINED);
- if (volume <= 0) {
- memset(buffer, 0, length);
- return true;
+ switch (_format) {
+ case SampleFormat::UNDEFINED:
+ case SampleFormat::DSD:
+ error.Format(pcm_domain,
+ "Software volume for %s is not implemented",
+ sample_format_to_string(_format));
+ return false;
+
+ case SampleFormat::S8:
+ case SampleFormat::S16:
+ case SampleFormat::S24_P32:
+ case SampleFormat::S32:
+ case SampleFormat::FLOAT:
+ break;
}
- const void *end = pcm_end_pointer(buffer, length);
+ format = _format;
+ return true;
+}
+
+ConstBuffer<void>
+PcmVolume::Apply(ConstBuffer<void> src)
+{
+ if (volume == PCM_VOLUME_1)
+ return src;
+
+ void *data = buffer.Get(src.size);
+
+ if (volume == 0) {
+ /* optimized special case: 0% volume = memset(0) */
+ /* TODO: is this valid for all sample formats? What
+ about floating point? */
+ memset(data, 0, src.size);
+ return { data, src.size };
+ }
+
+ const void *end = pcm_end_pointer(src.data, src.size);
switch (format) {
case SampleFormat::UNDEFINED:
case SampleFormat::DSD:
- /* not implemented */
- return false;
+ assert(false);
+ gcc_unreachable();
case SampleFormat::S8:
- pcm_volume_change_8((int8_t *)buffer,
- (const int8_t *)buffer,
+ pcm_volume_change_8((int8_t *)data,
+ (const int8_t *)src.data,
(const int8_t *)end,
volume);
- return true;
+ break;
case SampleFormat::S16:
- pcm_volume_change_16((int16_t *)buffer,
- (const int16_t *)buffer,
+ pcm_volume_change_16((int16_t *)data,
+ (const int16_t *)src.data,
(const int16_t *)end,
volume);
- return true;
+ break;
case SampleFormat::S24_P32:
- pcm_volume_change_24((int32_t *)buffer,
- (const int32_t *)buffer,
+ pcm_volume_change_24((int32_t *)data,
+ (const int32_t *)src.data,
(const int32_t *)end,
volume);
- return true;
+ break;
case SampleFormat::S32:
- pcm_volume_change_32((int32_t *)buffer,
- (const int32_t *)buffer,
+ pcm_volume_change_32((int32_t *)data,
+ (const int32_t *)src.data,
(const int32_t *)end,
volume);
- return true;
+ break;
case SampleFormat::FLOAT:
- pcm_volume_change_float((float *)buffer,
- (const float *)buffer,
+ pcm_volume_change_float((float *)data,
+ (const float *)src.data,
(const float *)end,
pcm_volume_to_float(volume));
- return true;
+ break;
}
- assert(false);
- gcc_unreachable();
+ return { data, src.size };
}
diff --git a/src/pcm/Volume.hxx b/src/pcm/Volume.hxx
index 52102a294..c31aafb6e 100644
--- a/src/pcm/Volume.hxx
+++ b/src/pcm/Volume.hxx
@@ -22,10 +22,18 @@
#include "PcmPrng.hxx"
#include "AudioFormat.hxx"
+#include "PcmBuffer.hxx"
#include <stdint.h>
#include <stddef.h>
+#ifndef NDEBUG
+#include <assert.h>
+#endif
+
+class Error;
+template<typename T> struct ConstBuffer;
+
/**
* Number of fractional bits for a fixed-point volume value.
*/
@@ -71,17 +79,66 @@ pcm_volume_dither(void)
}
/**
- * Adjust the volume of the specified PCM buffer.
- *
- * @param buffer the PCM buffer
- * @param length the length of the PCM buffer
- * @param format the sample format of the PCM buffer
- * @param volume the volume between 0 and #PCM_VOLUME_1
- * @return true on success, false if the audio format is not supported
+ * A class that converts samples from one format to another.
*/
-bool
-pcm_volume(void *buffer, size_t length,
- SampleFormat format,
- int volume);
+class PcmVolume {
+ SampleFormat format;
+
+ unsigned volume;
+
+ PcmBuffer buffer;
+
+public:
+ PcmVolume()
+ :volume(PCM_VOLUME_1) {
+#ifndef NDEBUG
+ format = SampleFormat::UNDEFINED;
+#endif
+ }
+
+#ifndef NDEBUG
+ ~PcmVolume() {
+ assert(format == SampleFormat::UNDEFINED);
+ }
+#endif
+
+ unsigned GetVolume() const {
+ return volume;
+ }
+
+ /**
+ * @param _volume the volume level in the range
+ * [0..#PCM_VOLUME_1]; may be bigger than #PCM_VOLUME_1, but
+ * then it will most likely clip a lot
+ */
+ void SetVolume(unsigned _volume) {
+ volume = _volume;
+ }
+
+ /**
+ * Opens the object, prepare for Apply().
+ *
+ * @param format the sample format
+ * @param error location to store the error
+ * @return true on success
+ */
+ bool Open(SampleFormat format, Error &error);
+
+ /**
+ * Closes the object. After that, you may call Open() again.
+ */
+ void Close() {
+#ifndef NDEBUG
+ assert(format != SampleFormat::UNDEFINED);
+ format = SampleFormat::UNDEFINED;
+#endif
+ }
+
+ /**
+ * Apply the volume level.
+ */
+ gcc_pure
+ ConstBuffer<void> Apply(ConstBuffer<void> src);
+};
#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-05 03:17:46 +0000