SoundStream Abstractions

Author: BrentDaMage

platforms/sound/openal/SoundStreamAL.cpp

@@ -3,49 +3,19 @@
 #include "common/Logger.hpp"
 
 SoundStreamAL::SoundStreamAL()
+    : SoundStream()
 {
-    _decoder = nullptr;
-    _info = stb_vorbis_info();
     _createSource();
     _createBuffers();
-    _tempPcmBufferSize = 4096 * 8;
-    _tempPcmBuffer = new int16_t[_tempPcmBufferSize];
     _alFormat = AL_NONE;
-    _totalSamplesLeft = 0;
-    _isStreaming = false;
-    _isPaused = false;
-    _shouldLoop = false;
 
-    setVolume(1.0f);
+    _setVolume(getVolume());
 }
 
 SoundStreamAL::~SoundStreamAL()
 {
     _deleteSource();
     _deleteBuffers();
-    _deleteDecoder();
-    delete[] _tempPcmBuffer;
-}
-
-bool SoundStreamAL::_stream(uint32_t buffer)
-{
-    int size = 0;
-    int result = 0;
-
-    while (size < _tempPcmBufferSize)
-    {
-        result = stb_vorbis_get_samples_short_interleaved(_decoder, _info.channels, _tempPcmBuffer + size, _tempPcmBufferSize - size);
-        if (result > 0) size += result * _info.channels;
-        else break;
-    }
-
-    if (size == 0) return false;
-
-    alBufferData(buffer, _alFormat, _tempPcmBuffer, size * sizeof(int16_t), _info.sample_rate);
-    AL_ERROR_CHECK();
-    _totalSamplesLeft -= size;
-
-    return true;
 }
 
 void SoundStreamAL::_deleteSource()
@@ -72,13 +42,25 @@ void SoundStreamAL::_resetSource()
 
 void SoundStreamAL::_deleteBuffers()
 {
-    alDeleteBuffers(2, _buffers);
+    alDeleteBuffers(_buffers.size(), _buffers.data());
     AL_ERROR_CHECK();
+
+    _buffers.clear();
+    _bufferIdMap.clear();
 }
 
 void SoundStreamAL::_createBuffers()
 {
-    alGenBuffers(2, _buffers);
+    // Should not be called while buffers are already present
+    assert(_buffers.size() == 0);
+
+    ALuint buffers[2];
+    alGenBuffers(2, buffers);
+    for (int i = 0; i < sizeof(buffers) / sizeof(ALuint); i++)
+    {
+        _buffers.push_back(buffers[i]);
+        _bufferIdMap.emplace(buffers[i], i);
+    }
 }
 
 void SoundStreamAL::_resetBuffers()
@@ -87,77 +69,73 @@ void SoundStreamAL::_resetBuffers()
     _createBuffers();
 }
 
-void SoundStreamAL::_deleteDecoder()
+void SoundStreamAL::_setVolume(float vol)
 {
-    if (_decoder != nullptr)
-        stb_vorbis_close(_decoder);
-    _decoder = nullptr;
+    alSourcef(_source, AL_GAIN, vol);
+    AL_ERROR_CHECK();
 }
 
-bool SoundStreamAL::open(const std::string& fileName)
+void SoundStreamAL::_play()
 {
-    if (isStreaming())
-    {
-        close();
-    }
+    alSourcePlay(_source);
+    AL_ERROR_CHECK();
+}
 
-    _isPaused = false;
+void SoundStreamAL::_pause()
+{
+    alSourcePause(_source);
+    AL_ERROR_CHECK();
+}
 
-    _decoder = stb_vorbis_open_filename(fileName.c_str(), NULL, NULL);
-    if (!_decoder) return false;
-    // Get file info
-    _info = stb_vorbis_get_info(_decoder);
-    if (_info.channels == 2) _alFormat = AL_FORMAT_STEREO16;
+bool SoundStreamAL::_open(const std::string& fileName)
+{
+    if (m_info.channels == 2) _alFormat = AL_FORMAT_STEREO16;
     else _alFormat = AL_FORMAT_MONO16;
 
-    if (!_stream(_buffers[0])) return false;
-    if (!_stream(_buffers[1])) return false;
-    alSourceQueueBuffers(_source, 2, _buffers);
-    AL_ERROR_CHECK();
-    alSourcePlay(_source);
+    size_t size = _buffers.size();
+    for (int i = 0; i < size; i++)
+    {
+        if (!_stream(i)) return false;
+    }
+    alSourceQueueBuffers(_source, size, _buffers.data());
     AL_ERROR_CHECK();
-
-    _totalSamplesLeft = stb_vorbis_stream_length_in_samples(_decoder) * _info.channels;
-    _isStreaming = true;
+    _play();
 
     return true;
 }
 
-void SoundStreamAL::close()
+void SoundStreamAL::_close()
 {
     _resetSource();
     //_resetBuffers();
-    _deleteDecoder();
     _alFormat = AL_NONE;
-    _totalSamplesLeft = 0;
-    _isStreaming = false;
 }
 
-void SoundStreamAL::update()
+void SoundStreamAL::_update()
 {
-    if (!isPlaying()) return;
-
-    int32_t processed = 0;
+    ALint processed = 0;
 
     alGetSourcei(_source, AL_BUFFERS_PROCESSED, &processed);
     AL_ERROR_CHECK();
 
     while (processed--)
     {
-        uint32_t buffer = 0;
+        ALuint buffer = 0;
 
         alSourceUnqueueBuffers(_source, 1, &buffer);
         AL_ERROR_CHECK();
 
-        if (!_stream(buffer))
+        int bufferId = _bufferIdMap[buffer];
+
+        if (!_stream(bufferId))
         {
             bool shouldExit = true;
 
-            if (_shouldLoop)
+            if (shouldLoop())
             {
-                stb_vorbis_seek_start(_decoder);
-                _totalSamplesLeft = stb_vorbis_stream_length_in_samples(_decoder) * _info.channels;
-                shouldExit = !_stream(buffer);
+                stb_vorbis_seek_start(m_decoder);
+                m_totalSamplesLeft = stb_vorbis_stream_length_in_samples(m_decoder) * m_info.channels;
+                shouldExit = !_stream(bufferId);
             }
 
             if (shouldExit)
@@ -171,8 +149,8 @@ void SoundStreamAL::update()
     }
 }
 
-void SoundStreamAL::setVolume(float vol)
+void SoundStreamAL::_publishBuffer(unsigned int destBufferId, const SoundBuffer& sourceBuffer)
 {
-    alSourcef(_source, AL_GAIN, vol);
+    alBufferData(_buffers[destBufferId], _alFormat, sourceBuffer.m_pData, sourceBuffer.m_dataSize * sizeof(int16_t), m_info.sample_rate);
     AL_ERROR_CHECK();
-}
+}

platforms/sound/openal/SoundStreamAL.hpp

@@ -1,38 +1,31 @@
 #pragma once
 
 #include <stdint.h>
+#include <vector>
+#include <map>
 
-#define STB_VORBIS_HEADER_ONLY
-#include "thirdparty/stb_image/include/stb_vorbis.c"
 #include "thirdparty/OpenAL.h"
 
 #include "client/sound/SoundStream.hpp"
 
 class SoundStreamAL : public SoundStream
 {
 private:
-    stb_vorbis* _decoder;
-    stb_vorbis_info _info;
+    typedef std::map<ALuint, unsigned int> BufferIdMap;
 
-    uint32_t _buffers[2];
-    uint32_t _source;
+private:
+    std::vector<ALuint> _buffers;
+    BufferIdMap _bufferIdMap;
 
-    size_t _tempPcmBufferSize;
-    int16_t* _tempPcmBuffer;
+    ALuint _source;
 
     ALenum _alFormat;
-    size_t _totalSamplesLeft;
-    bool _isStreaming;
-    bool _isPaused;
-    bool _shouldLoop;
 
 public:
     SoundStreamAL();
     ~SoundStreamAL();
 
 private:
-    bool _stream(uint32_t buffer);
-
     void _deleteSource();
     void _createSource();
     void _resetSource();
@@ -41,16 +34,12 @@ class SoundStreamAL : public SoundStream
     void _createBuffers();
     void _resetBuffers();
 
-    void _deleteDecoder();
-
-public:
-    bool isStreaming() const override { return _isStreaming; }
-    bool isPaused() const override { return _isPaused; }
-
-    bool open(const std::string& flieName) override;
-    void close() override;
-    void update() override;
-
-    void setPausedState(bool state) override { _isPaused = state; };
-    void setVolume(float vol) override;
+protected:
+    void _setVolume(float vol) override;
+    void _play() override;
+    void _pause() override;
+    bool _open(const std::string& fileName) override;
+    void _close() override;
+    void _update() override;
+    void _publishBuffer(unsigned int destBufferId, const SoundBuffer& sourceBuffer);
 };

platforms/sound/openal/SoundSystemAL.cpp

@@ -156,20 +156,20 @@ void SoundSystemAL::_cleanSources()
 ALuint SoundSystemAL::_getBuffer(const SoundDesc& sound)
 {
 	// Fetch pre-existing buffer
-	if (_buffers.count(sound.m_pData) > 0)
+	if (_buffers.count(sound.m_buffer.m_pData) > 0)
 	{
-		return _buffers[sound.m_pData];
+		return _buffers[sound.m_buffer.m_pData];
 	}
 
 	// Create Buffer
 	ALuint buffer;
 	alGenBuffers(1, &buffer);
 	AL_ERROR_CHECK();
-	alBufferData(buffer, _getSoundFormat(sound.m_header), sound.m_pData, sound.m_dataSize, sound.m_header.m_sample_rate);
+	alBufferData(buffer, _getSoundFormat(sound.m_header), sound.m_buffer.m_pData, sound.m_buffer.m_dataSize, sound.m_header.m_sample_rate);
 	AL_ERROR_CHECK();
 
 	// Store
-	_buffers[sound.m_pData] = buffer;
+	_buffers[sound.m_buffer.m_pData] = buffer;
 	return buffer;
 }
 

source/client/sound/SoundData.cpp

@@ -45,8 +45,8 @@ bool SoundDesc::_loadPcm(const AppPlatform* platform, const char *name)
         m_codecType = AudioCodec::PCM;
         m_fileData = m_file.data;
         m_header = *(PCMSoundHeader *) m_fileData;
-        m_pData = (uint16_t *) (m_fileData + sizeof(PCMSoundHeader));
-        m_dataSize = m_header.m_channels * m_header.m_length * m_header.m_bytes_per_sample;
+        m_buffer.m_pData = (void *) (m_fileData + sizeof(PCMSoundHeader));
+        m_buffer.m_dataSize = m_header.m_channels * m_header.m_length * m_header.m_bytes_per_sample;
 
         // Success!
         return true;
@@ -66,13 +66,13 @@ bool SoundDesc::_loadOgg(const AppPlatform* platform, const char* category, cons
         m_header.m_bytes_per_sample = 2; // Always 2 (16-bit)
         // Casting to a short** here might cause problems. Let's find out...
         // Seems like it doesn't. Cool.
-        m_header.m_length = stb_vorbis_decode_memory(m_file.data, (int) m_file.size, &m_header.m_channels, &m_header.m_sample_rate, (short **) &m_pData);
+        m_header.m_length = stb_vorbis_decode_memory(m_file.data, (int) m_file.size, &m_header.m_channels, &m_header.m_sample_rate, (short **) &m_buffer.m_pData);
         if (m_header.m_length == -1)
         {
             LOG_E("An error occurred while trying to decode a sound!");
             return false;
         }
-        m_dataSize = m_header.m_channels * m_header.m_length * m_header.m_bytes_per_sample;
+        m_buffer.m_dataSize = m_header.m_channels * m_header.m_length * m_header.m_bytes_per_sample;
 
         // Success!
         return true;
@@ -90,7 +90,7 @@ void SoundDesc::_unload()
     }
     // Free OGG Data
     if (m_codecType == AudioCodec::OGG) {
-        free(m_pData);
+        free(m_buffer.m_pData);
     }
     // Free File Data
     delete m_file.data;

source/client/sound/SoundData.hpp

@@ -33,6 +33,12 @@ struct PCMSoundHeader
 	int m_length;
 };
 
+struct SoundBuffer
+{
+	void* m_pData;
+	int m_dataSize;
+};
+
 struct AudioDescriptor
 {
     bool m_isLoaded;
@@ -43,8 +49,7 @@ struct AudioDescriptor
 struct SoundDesc : AudioDescriptor
 {
 	AssetFile m_file;
-	uint16_t* m_pData;
-	int m_dataSize;
+	SoundBuffer m_buffer;
 	unsigned char* m_fileData;
 
 	bool _load(const AppPlatform* platform, const char* category, const char *name);