AL streaming test

src/audio/AL/ALAudio.cpp

@@ -45,9 +45,28 @@ std::shared_ptr<PCMStream> ALStream::getSource() const {
     }
 }
 
-Speaker* ALStream::createSpeaker() {
+bool ALStream::preloadBuffer(uint buffer, bool loop) {
+    size_t read = source->read(this->buffer, BUFFER_SIZE, loop);
+    if (!read)
+        return false;
+    ALenum format = AL::to_al_format(source->getChannels(), source->getBitsPerSample());
+    AL_CHECK(alBufferData(buffer, format, this->buffer, read, source->getSampleRate()));
+    return true;
+}
+
+Speaker* ALStream::createSpeaker(bool loop) {
+    this->loop = loop;
     uint source = al->getFreeSource();
-    // TODO: prepare source and enqueue buffers
+    if (source == 0) {
+        return nullptr;
+    }
+    for (uint i = 0; i < ALStream::STREAM_BUFFERS; i++) {
+        uint buffer = al->getFreeBuffer();
+        if (!preloadBuffer(buffer, loop)) {
+            break;
+        }
+        AL_CHECK(alSourceQueueBuffers(source, 1, &buffer));
+    }
     return new ALSpeaker(al, source, PRIORITY_HIGH);
 }
 
@@ -65,14 +84,40 @@ speakerid_t ALStream::getSpeaker() const {
 }
 
 void ALStream::update(double delta) {
-    // TODO: implement
+    if (this->speaker == 0) {
+        return;
+    }
+    Speaker* speaker = audio::get(this->speaker);
+    if (speaker == nullptr) {
+        speaker = 0;
+        return;
+    }
+    ALSpeaker* alspeaker = dynamic_cast<ALSpeaker*>(speaker);
+    uint source = alspeaker->source;
+    uint processed = AL::getSourcei(source, AL_BUFFERS_PROCESSED);
+
+    while (processed--) {
+        uint buffer;
+        AL_CHECK(alSourceUnqueueBuffers(source, 1, &buffer));
+        unusedBuffers.push(buffer);
+        std::cout << "unqueue " << buffer << std::endl;
+    }
+
+    if (!unusedBuffers.empty()) {
+        uint buffer = unusedBuffers.front();
+        if (preloadBuffer(buffer, loop)) {
+            unusedBuffers.pop();
+            std::cout << "queue " << buffer << std::endl;
+            AL_CHECK(alSourceQueueBuffers(source, 1, &buffer));
+        }
+    }
 }
 
 void ALStream::setTime(duration_t time) {
     // TODO: implement
 }
 
-ALSpeaker::ALSpeaker(ALAudio* al, uint source, int priority) : al(al), source(source), priority(priority) {
+ALSpeaker::ALSpeaker(ALAudio* al, uint source, int priority) : al(al), priority(priority), source(source) {
 }
 
 ALSpeaker::~ALSpeaker() {

src/audio/AL/ALAudio.h

@@ -1,6 +1,7 @@
 #ifndef SRC_AUDIO_AUDIO_H_
 #define SRC_AUDIO_AUDIO_H_
 
+#include <queue>
 #include <vector>
 #include <string>
 #include <glm/glm.hpp>
@@ -43,28 +44,38 @@ namespace audio {
     };
 
     class ALStream : public Stream {
+        static inline constexpr size_t BUFFER_SIZE = 44100;
+        
         ALAudio* al;
         std::shared_ptr<PCMStream> source;
+        std::queue<uint> unusedBuffers;
         speakerid_t speaker = 0;
         bool keepSource;
+        char buffer[BUFFER_SIZE];
+        bool loop = false;
+
+        bool preloadBuffer(uint buffer, bool loop);
     public:
         ALStream(ALAudio* al, std::shared_ptr<PCMStream> source, bool keepSource);
         ~ALStream();
 
         std::shared_ptr<PCMStream> getSource() const override;
         void bindSpeaker(speakerid_t speaker) override;
-        Speaker* createSpeaker() override;
+        Speaker* createSpeaker(bool loop) override;
         speakerid_t getSpeaker() const override;
         void update(double delta) override;
-        void setTime(duration_t time) override;        
+        void setTime(duration_t time) override;       
+
+        static inline constexpr uint STREAM_BUFFERS = 3; 
     };
 
     /// @brief AL source adapter
     class ALSpeaker : public Speaker {
         ALAudio* al;
-        uint source;
         int priority;
     public:
+        uint source;
+
         ALSpeaker(ALAudio* al, uint source, int priority);
         ~ALSpeaker();