openMSX
SoundDevice.cc
Go to the documentation of this file.
1#include "SoundDevice.hh"
2
3#include "MSXMixer.hh"
4#include "DeviceConfig.hh"
5#include "Mixer.hh"
6#include "XMLElement.hh"
7#include "Filename.hh"
8#include "StringOp.hh"
9#include "MSXException.hh"
10
11#include "narrow.hh"
12#include "ranges.hh"
13#include "one_of.hh"
14#include "vla.hh"
15#include "xrange.hh"
16
17#include <array>
18#include <bit>
19#include <cassert>
20
21namespace openmsx {
22
23[[nodiscard]] static std::string makeUnique(const MSXMixer& mixer, std::string_view name)
24{
25 std::string result(name);
26 if (mixer.findDevice(result)) {
27 unsigned n = 0;
28 do {
29 result = strCat(name, " (", ++n, ')');
30 } while (mixer.findDevice(result));
31 }
32 return result;
33}
34
35void SoundDevice::addFill(float*& buf, float val, unsigned num)
36{
37 // Note: in the past we tried to optimize this by always producing
38 // a multiple of 4 output values. In the general case a SoundDevice is
39 // allowed to do this, but only at the end of the sound buffer. This
40 // method can also be called in the middle of a buffer (so multiple
41 // times per buffer), in such case it does go wrong.
42 assert(num > 0);
43 do {
44 *buf++ += val;
45 } while (--num);
46}
47
48SoundDevice::SoundDevice(MSXMixer& mixer_, std::string_view name_, static_string_view description_,
49 unsigned numChannels_, unsigned inputRate, bool stereo_)
50 : mixer(mixer_)
51 , name(makeUnique(mixer, name_))
52 , description(description_)
53 , numChannels(numChannels_)
54 , stereo(stereo_ ? 2 : 1)
55{
56 assert(numChannels <= MAX_CHANNELS);
57 assert(stereo == one_of(1u, 2u));
58
59 setInputRate(inputRate);
60
61 // initially no channels are muted
62 ranges::fill(channelMuted, false);
63 ranges::fill(channelBalance, 0);
64}
65
67
69{
70 return 1.0f / 32768.0f;
71}
72
74{
75 const auto& soundConfig = config.getChild("sound");
76 float volume = narrow<float>(soundConfig.getChildDataAsInt("volume", 0)) * (1.0f / 32767.0f);
77 int devBalance = 0;
78 std::string_view mode = soundConfig.getChildData("mode", "mono");
79 if (mode == "mono") {
80 devBalance = 0;
81 } else if (mode == "left") {
82 devBalance = -100;
83 } else if (mode == "right") {
84 devBalance = 100;
85 } else {
86 throw MSXException("balance \"", mode, "\" illegal");
87 }
88
89 for (const auto* b : soundConfig.getChildren("balance")) {
90 auto balance = StringOp::stringTo<int>(b->getData());
91 if (!balance) {
92 throw MSXException("balance ", b->getData(), " illegal");
93 }
94
95 const auto* channel = b->findAttribute("channel");
96 if (!channel) {
97 devBalance = *balance;
98 continue;
99 }
100
101 // TODO Support other balances
102 if (*balance != one_of(0, -100, 100)) {
103 throw MSXException("balance ", *balance, " illegal");
104 }
105 if (*balance != 0) {
106 balanceCenter = false;
107 }
108
109 auto channels = StringOp::parseRange(channel->getValue(), 1, numChannels);
110 channels.foreachSetBit([&](size_t c) {
111 channelBalance[c - 1] = *balance;
112 });
113 }
114
115 mixer.registerSound(*this, volume, devBalance, numChannels);
116}
117
119{
120 mixer.unregisterSound(*this);
121}
122
123void SoundDevice::updateStream(EmuTime::param time)
124{
125 mixer.updateStream(time);
126}
127
128void SoundDevice::setSoftwareVolume(float volume, EmuTime::param time)
129{
130 setSoftwareVolume(volume, volume, time);
131}
132
133void SoundDevice::setSoftwareVolume(float left, float right, EmuTime::param time)
134{
135 updateStream(time);
136 softwareVolumeLeft = left;
137 softwareVolumeRight = right;
138 mixer.updateSoftwareVolume(*this);
139}
140
141void SoundDevice::recordChannel(unsigned channel, const Filename& filename)
142{
143 assert(channel < numChannels);
144 bool wasRecording = writer[channel].has_value();
145 if (!filename.empty()) {
146 writer[channel].emplace(
147 filename, stereo, inputSampleRate);
148 } else {
149 writer[channel].reset();
150 }
151 bool recording = writer[channel].has_value();
152 if (recording != wasRecording) {
153 if (recording) {
154 if (numRecordChannels == 0) {
155 mixer.setSynchronousMode(true);
156 }
157 ++numRecordChannels;
158 assert(numRecordChannels <= numChannels);
159 } else {
160 assert(numRecordChannels > 0);
161 --numRecordChannels;
162 if (numRecordChannels == 0) {
163 mixer.setSynchronousMode(false);
164 }
165 }
166 }
167}
168
169void SoundDevice::muteChannel(unsigned channel, bool muted)
170{
171 assert(channel < numChannels);
172 channelMuted[channel] = muted;
173}
174
175std::span<const float> SoundDevice::getLastBuffer(unsigned channel)
176{
177 assert(channel < numChannels);
178 auto& buf = channelBuffers[channel];
179
180 buf.requestCounter = inputSampleRate; // active for ~1 second
181
182 unsigned requestedSize = getLastBufferSize();
183 if (buf.stopIdx < requestedSize) return {}; // not enough samples (yet)
184 return {&buf.buffer[buf.stopIdx - requestedSize], requestedSize};
185}
186
187bool SoundDevice::mixChannels(float* dataOut, size_t samples)
188{
189#ifdef __SSE2__
190 assert((uintptr_t(dataOut) & 15) == 0); // must be 16-byte aligned
191#endif
192 if (samples == 0) return true;
193 size_t outputStereo = isStereo() ? 2 : 1;
194
195 std::array<float*, MAX_CHANNELS> bufs_;
196 auto bufs = subspan(bufs_, 0, numChannels);
197
198 // TODO optimization: All channels with the same balance (according to
199 // channelBalance[]) could use the same buffer when balanceCenter is
200 // false
201 auto needSeparateBuffer = [&](unsigned channel) {
202 return channelBuffers[channel].requestCounter != 0
203 || channelMuted[channel]
204 || writer[channel]
205 || !balanceCenter;
206 };
207 bool anySeparateChannel = false;
208 unsigned size = samples * stereo;
209 unsigned padded = (size + 3) & ~3; // round up to multiple of 4
210 for (auto i : xrange(numChannels)) {
211 auto& cb = channelBuffers[i];
212 if (!needSeparateBuffer(i)) {
213 // no need to keep this channel separate
214 bufs[i] = dataOut;
215 cb.stopIdx = 0; // no valid last data
216 } else {
217 anySeparateChannel = true;
218 cb.requestCounter = std::max<int>(0, cb.requestCounter - samples);
219
220 unsigned remainingSize = cb.buffer.size() - cb.stopIdx;
221 if (remainingSize < padded) {
222 // not enough space at the tail of the buffer
223 unsigned lastBufferSize = getLastBufferSize();
224 auto allocateSize = 2 * std::max(lastBufferSize, padded);
225 if (cb.buffer.size() < allocateSize) [[unlikely]] {
226 // increase buffer size
227 cb.buffer.resize(allocateSize);
228 }
229 unsigned reuse = lastBufferSize >= size ? lastBufferSize - size : 0;
230 if (cb.stopIdx > reuse) {
231 // move existing data to front
232 memmove(&cb.buffer[0], &cb.buffer[cb.stopIdx - reuse], reuse * sizeof(float));
233 }
234 cb.stopIdx = reuse;
235 }
236 auto* ptr = &cb.buffer[cb.stopIdx];
237 bufs[i] = ptr;
238 ranges::fill(std::span{ptr, size}, 0.0f);
239 cb.stopIdx += size;
240 }
241 }
242
243 static_assert(sizeof(float) == sizeof(uint32_t));
244 if ((numChannels != 1) || anySeparateChannel) {
245 // The generateChannels() method of SoundDevices with more than
246 // one channel will _add_ the generated channel data in the
247 // provided buffers. Those with only one channel will directly
248 // replace the content of the buffer. For the former we must
249 // start from a buffer containing all zeros.
250 ranges::fill(std::span{dataOut, outputStereo * samples}, 0.0f);
251 }
252
253 generateChannels(bufs, narrow<unsigned>(samples));
254
255 if (!anySeparateChannel) {
256 return ranges::any_of(xrange(numChannels),
257 [&](auto i) { return bufs[i]; });
258 }
259
260 // record channels
261 for (auto i : xrange(numChannels)) {
262 if (writer[i]) {
263 assert(bufs[i] != dataOut);
264 if (bufs[i]) {
265 auto amp = getAmplificationFactor();
266 if (stereo == 1) {
267 writer[i]->write(
268 std::span{bufs[i], samples},
269 amp.left);
270 } else {
271 writer[i]->write(
272 std::span{std::bit_cast<const StereoFloat*>(bufs[i]), samples},
273 amp.left, amp.right);
274 }
275 } else {
276 writer[i]->writeSilence(narrow<unsigned>(stereo * samples));
277 }
278 }
279 }
280
281 // remove muted channels (explicitly by user or by device itself)
282 bool anyUnmuted = false;
283 unsigned numMix = 0;
284 VLA(int, mixBalance, numChannels);
285 for (auto i : xrange(numChannels)) {
286 if (bufs[i] && !channelMuted[i]) {
287 anyUnmuted = true;
288 if (bufs[i] != dataOut) {
289 bufs[numMix] = bufs[i];
290 mixBalance[numMix] = channelBalance[i];
291 ++numMix;
292 }
293 }
294 }
295
296 if (numMix == 0) {
297 // all extra channels muted
298 return anyUnmuted;
299 }
300
301 // actually mix channels
302 if (!balanceCenter) {
303 size_t i = 0;
304 do {
305 float left0 = 0.0f;
306 float right0 = 0.0f;
307 float left1 = 0.0f;
308 float right1 = 0.0f;
309 unsigned j = 0;
310 do {
311 if (mixBalance[j] <= 0) {
312 left0 += bufs[j][i + 0];
313 left1 += bufs[j][i + 1];
314 }
315 if (mixBalance[j] >= 0) {
316 right0 += bufs[j][i + 0];
317 right1 += bufs[j][i + 1];
318 }
319 j++;
320 } while (j < numMix);
321 dataOut[i * 2 + 0] = left0;
322 dataOut[i * 2 + 1] = right0;
323 dataOut[i * 2 + 2] = left1;
324 dataOut[i * 2 + 3] = right1;
325 i += 2;
326 } while (i < samples);
327
328 return true;
329 }
330
331 // In the past we had ARM and x86-SSE2 optimized assembly routines for
332 // the stuff below. Currently this code is only rarely used anymore
333 // (only when recording or muting individual sound chip channels), so
334 // it's not worth the extra complexity anymore.
335 size_t num = samples * stereo;
336 size_t i = 0;
337 do {
338 auto out0 = dataOut[i + 0];
339 auto out1 = dataOut[i + 1];
340 auto out2 = dataOut[i + 2];
341 auto out3 = dataOut[i + 3];
342 unsigned j = 0;
343 do {
344 out0 += bufs[j][i + 0];
345 out1 += bufs[j][i + 1];
346 out2 += bufs[j][i + 2];
347 out3 += bufs[j][i + 3];
348 ++j;
349 } while (j < numMix);
350 dataOut[i + 0] = out0;
351 dataOut[i + 1] = out1;
352 dataOut[i + 2] = out2;
353 dataOut[i + 3] = out3;
354 i += 4;
355 } while (i < num);
356
357 return true;
358}
359
361{
362 return mixer.getHostSampleClock();
363}
365{
366 return mixer.getEffectiveSpeed();
367}
368
369} // namespace openmsx
const XMLElement & getChild(std::string_view name) const
Represents a clock with a variable frequency.
This class represents a filename.
Definition Filename.hh:20
bool empty() const
Convenience method to test for empty filename.
Definition Filename.cc:21
double getEffectiveSpeed() const
void recordChannel(unsigned channel, const Filename &filename)
void updateStream(EmuTime::param time)
unsigned getLastBufferSize() const
getLastBuffer() with return buffers containing this many samples.
AmplificationFactors getAmplificationFactor() const
static void addFill(float *&buffer, float value, unsigned num)
Adds a number of samples that all have the same value.
const DynamicClock & getHostSampleClock() const
See MSXMixer::getHostSampleClock().
void setInputRate(unsigned sampleRate)
void setSoftwareVolume(float volume, EmuTime::param time)
Change the 'software volume' of this sound device.
bool mixChannels(float *dataOut, size_t samples)
Calls generateChannels() and combines the output to a single channel.
static constexpr unsigned MAX_CHANNELS
void unregisterSound()
Unregisters this sound device with the Mixer.
SoundDevice(const SoundDevice &)=delete
bool isStereo() const
Is the full output of this device stereo?
virtual void generateChannels(std::span< float * > buffers, unsigned num)=0
Abstract method to generate the actual sound data.
void registerSound(const DeviceConfig &config)
Registers this sound device with the Mixer.
std::span< const float > getLastBuffer(unsigned channel)
Query the last generated audio signal for a specific channel.
void muteChannel(unsigned channel, bool muted)
virtual float getAmplificationFactorImpl() const
Get amplification/attenuation factor for this device.
std::string_view getChildData(std::string_view childName) const
Definition XMLElement.cc:64
static_string_view
IterableBitSet< 64 > parseRange(string_view str, unsigned min, unsigned max)
Definition StringOp.cc:181
This file implemented 3 utility functions:
Definition Autofire.cc:11
constexpr void fill(ForwardRange &&range, const T &value)
Definition ranges.hh:315
constexpr bool any_of(InputRange &&range, UnaryPredicate pred)
Definition ranges.hh:200
constexpr auto subspan(Range &&range, size_t offset, size_t count=std::dynamic_extent)
Definition ranges.hh:481
std::string strCat()
Definition strCat.hh:703
#define VLA(TYPE, NAME, LENGTH)
Definition vla.hh:12
constexpr auto xrange(T e)
Definition xrange.hh:132