Merge pull request #7 from zyebytevt/zyedev

Add streaming audio, optimize Particles2D, fix few issues

Author: zyebytevt

TODO.md

@@ -43,10 +43,10 @@ A lot of stuff has already been done before this file has been started.
 [X] Work on (G)UI
 [ ] Add more GUI widgets (TextInputBox, CheckBox, RadioButton, Slider)
 [X] Change cursor shape
-[ ] Explain building steps
-[ ] Markup for creating GUI
-[ ] Get audio working
-[ ] Add streaming audio
+[X] Explain building steps
+[X] Markup for creating GUI
+[X] Get audio working
+[X] Add streaming audio
 [ ] Fix profiler omg
 [ ] Add unittests
 [ ] MMAP shenanigans for ZPK files

platform/openal/buffer.d

@@ -10,6 +10,37 @@ import bindbc.openal;
 import zyeware.common;
 import zyeware.audio;
 
+// TODO: Check memory constness someday.
+@asset(Yes.cache)
+class AudioStream
+{
+protected:
+    const(ubyte)[] mEncodedMemory;
+
+public:
+    this(const(ubyte)[] encodedMemory)
+    {
+        mEncodedMemory = encodedMemory;
+    }
+
+    const(ubyte)[] encodedMemory() pure nothrow
+    {
+        return mEncodedMemory;
+    }
+
+    static AudioStream load(string path)
+    {
+        VFSFile source = VFS.getFile(path);
+        ubyte[] bestCommunityData = source.readAll!(ubyte[])();
+        source.close();
+
+        Logger.core.log(LogLevel.debug_, "Loaded file '%s' as audio.", path);
+
+        return new AudioStream(bestCommunityData);
+    }
+}
+
+/*
 @asset(Yes.cache)
 class Sound
 {
@@ -56,4 +87,4 @@ class StreamingSound
 {
 public:
     static StreamingSound load(string path);
-}
+}*/

platform/openal/source.d

@@ -11,7 +11,161 @@ import bindbc.openal;
 
 import zyeware.common;
 import zyeware.audio;
+import zyeware.audio.thread;
 
+class AudioSource
+{
+private:
+    static const(ubyte)[] sEmptyData = new ubyte[0];
+
+protected:
+    enum State
+    {
+        stopped,
+        paused,
+        playing
+    }
+
+    // TODO: Add engine-wide buffer size settings
+    enum bufferSize = 4096 * 4;
+    enum bufferCount = 4;
+
+    float[] mProcBuffer;
+
+    AudioStream mAudioStream;
+    AudioDecoder mDecoder;
+    uint mSourceId;
+    uint[] mBufferIDs;
+    int mProcessed;
+
+    State mState;
+    bool mLooping; // TODO: Maybe add loop point?
+    AudioBus mBus;
+
+package(zyeware):
+    void updateBuffers()
+    {
+        if (mState == State.stopped)
+            return;
+
+        long lastReadLength;
+        int processed;
+        uint pBuf;
+        alGetSourcei(mSourceId, AL_BUFFERS_PROCESSED, &processed);
+
+        while (processed--)
+        {
+            alSourceUnqueueBuffers(mSourceId, 1, &pBuf);
+
+            lastReadLength = mDecoder.read(mProcBuffer);
+
+            if (lastReadLength <= 0)
+            {
+                if (mLooping)
+                {
+                    mDecoder.seekTo(0); // TODO: Replace with a loop point
+                    lastReadLength = mDecoder.read(mProcBuffer);
+                }
+                else
+                    break;
+            }
+
+            alBufferData(pBuf, mDecoder.channels == 1 ? AL_FORMAT_MONO_FLOAT32 : AL_FORMAT_STEREO_FLOAT32,
+                &mProcBuffer[0], cast(int) (lastReadLength * float.sizeof), cast(int) mDecoder.sampleRate);
+
+            alSourceQueueBuffers(mSourceId, 1, &pBuf);
+        }
+
+        int buffersQueued;
+        alGetSourcei(mSourceId, AL_BUFFERS_QUEUED, &buffersQueued);
+        if (buffersQueued == 0)
+            stop();
+    }
+
+public:
+    this(AudioBus bus = null)
+    {
+        mBus = bus ? bus : AudioAPI.getBus("master");
+
+        mProcBuffer = new float[bufferSize];
+        mBufferIDs = new uint[bufferCount];
+
+        alGenSources(1, &mSourceId);
+        alGenBuffers(cast(int) mBufferIDs.length, &mBufferIDs[0]);
+
+        AudioThread.register(this);
+    }
+
+    ~this()
+    {
+        AudioThread.unregister(this);
+
+        destroy!false(mDecoder);
+
+        alDeleteBuffers(cast(int) mBufferIDs.length, &mBufferIDs[0]);
+        alDeleteSources(1, &mSourceId);
+    }
+
+    void play()
+    {
+        if (mState == State.playing)
+            stop();
+
+        if (mState == State.stopped)
+        {
+            long lastReadLength;
+            for (size_t i; i < bufferCount; ++i)
+            {
+                lastReadLength = mDecoder.read(mProcBuffer);
+                alBufferData(mBufferIDs[i], mDecoder.channels == 1 ? AL_FORMAT_MONO_FLOAT32 : AL_FORMAT_STEREO_FLOAT32,
+                    &mProcBuffer[0], cast(int) (lastReadLength * float.sizeof), cast(int) mDecoder.sampleRate);
+                alSourceQueueBuffers(mSourceId, 1, &mBufferIDs[i]);
+            }
+        }
+
+        mState = State.playing;
+        alSourcePlay(mSourceId);
+    }
+
+    void pause()
+    {
+        mState = State.paused;
+        alSourcePause(mSourceId);
+    }
+
+    void stop()
+    {
+        mState = State.stopped;
+        alSourceStop(mSourceId);
+
+        mDecoder.seekTo(0);
+
+        int bufferCount;
+        alGetSourcei(mSourceId, AL_BUFFERS_QUEUED, &bufferCount);
+        
+        for (size_t i; i < bufferCount; ++i)
+        {
+            uint removedBuffer;
+            alSourceUnqueueBuffers(mSourceId, 1, &removedBuffer);
+        }
+    }
+
+    inout(AudioStream) stream() inout nothrow
+    {
+        return mAudioStream;
+    }
+
+    void stream(AudioStream value)
+    {
+        if (mState != State.stopped)
+            stop();
+
+        mAudioStream = value;
+        mDecoder.setData(mAudioStream.encodedMemory);
+    }
+}
+
+/*
 class AudioSource
 {
 protected:
@@ -113,4 +267,4 @@ public:
     {
         alSourcei(mId, AL_LOOPING, value);
     }
-}
+}*/

platform/opengl/shader.d

@@ -78,9 +78,9 @@ protected:
 
         mTextureCount = samplerID;
 
-        foreach (string name, int binding; sUniformBlockBindings)
+        foreach (string uniformName, int binding; sUniformBlockBindings)
         {
-            int blockIndex = glGetUniformBlockIndex(mProgramID, name.toStringz);
+            int blockIndex = glGetUniformBlockIndex(mProgramID, uniformName.toStringz);
             if (blockIndex != -1)
                 glUniformBlockBinding(mProgramID, blockIndex, binding);
         }

source/zyeware/audio/buffer.di

@@ -8,6 +8,23 @@ module zyeware.audio.buffer;
 import zyeware.common;
 import zyeware.audio;
 
+alias NoiseBitties = AudioStream;
+alias AirVibrationData = AudioStream;
+alias EarMassager = AudioStream;
+alias SonicStream = AudioStream;
+
+@asset(Yes.cache)
+class AudioStream
+{
+public:
+    this(const(ubyte)[] encodedMemory);
+
+    const(ubyte)[] encodedMemory() pure nothrow;
+
+    static AudioStream load(string path);
+}
+
+/*
 @asset(Yes.cache)
 class Sound
 {
@@ -22,4 +39,5 @@ class StreamedSound
 {
 public:
     static StreamedSound load(string path);
-}
+}
+*/

source/zyeware/audio/decoder.d

@@ -12,23 +12,26 @@ import zyeware.common;
 struct AudioDecoder
 {
 protected:
-    VFSFile mFile;
-    AudioStream stream;
+    const(ubyte)[] mEncodedMemory;
+    AudioStream mStream;
 
 public:
-    @disable this();
+    //@disable this();
     @disable this(this);
 
-    /// Params:
-    ///     file = The file used for audio decoding.
-    /// Throws: `AudioException` if the file could not be opened for decoding.
-    this(VFSFile file)
+    ~this()
+    {
+        if (mStream.isOpenForReading())
+            destroy!false(mStream);
+    }
+
+    void setData(const(ubyte)[] encodedMemory)
     {
-        mFile = file;
+        mEncodedMemory = encodedMemory;
 
         try 
         {
-            stream.openFromMemory(mFile.readAll!(ubyte[])());
+            mStream.openFromMemory(mEncodedMemory);
         }
         catch (AudioFormatsException ex)
         {
@@ -38,30 +41,24 @@ public:
             size_t errLine = ex.line;
             destroyAudioFormatException(ex);
 
-            throw new Exception(errMsg, null, errFile, errLine);
+            throw new AudioException(errMsg, errFile, errLine, null);
         }
     }
 
-    ~this()
-    {
-        if (stream.isOpenForReading())
-            destroy!false(stream);
-    }
-
     /// Tries to read samples into the supplied buffer.
     ///
     /// Params:
     ///     buffer = The buffer to read into. It's length should be a multiple of the channel count.
     /// Returns: The amount of samples actually read.
     size_t read(T)(ref T[] buffer)
-        in (buffer.length % stream.getNumChannels() == 0, "Buffer length is not a multiple of channel count.")
+        in (buffer.length % mStream.getNumChannels() == 0, "Buffer length is not a multiple of channel count.")
     {
         static if (is(T == float))
-            return stream.readSamplesFloat(buffer.ptr, cast(int)(buffer.length/stream.getNumChannels()))
-                * stream.getNumChannels();
+            return mStream.readSamplesFloat(buffer.ptr, cast(int)(buffer.length/mStream.getNumChannels()))
+                * mStream.getNumChannels();
         else static if (is(T == double))
-            return stream.readSamplesDouble(buffer.ptr, cast(int)(buffer.length/stream.getNumChannels()))
-                * stream.getNumChannels();
+            return mStream.readSamplesDouble(buffer.ptr, cast(int)(buffer.length/mStream.getNumChannels()))
+                * mStream.getNumChannels();
         else
             static assert(false, "'read' cannot process type " ~ T.stringof);
     }
@@ -76,27 +73,32 @@ public:
     {
         auto buffer = new T[samples * mAudioInfo.channels];
         static if (is(T == float))
-            return stream.readSamplesFloat(buffer.ptr, buffer.length/stream.getNumChannels());
+            return mStream.readSamplesFloat(buffer.ptr, buffer.length/mStream.getNumChannels());
         else static if (is(T == double))
-            return stream.readSamplesDouble(buffer.ptr, buffer.length/stream.getNumChannels());
+            return mStream.readSamplesDouble(buffer.ptr, buffer.length/mStream.getNumChannels());
         else
             static assert(false, "'read' cannot process type " ~ T.stringof);
 
         return buffer[0 .. sampleCount];
     }*/
 
+    void seekTo(size_t frame)
+    {
+        mStream.seekPosition(cast(int) frame); // ?????
+    }
+
     size_t sampleCount() 
     {
-        return stream.getLengthInFrames();
+        return mStream.getLengthInFrames();
     }
 
     size_t sampleRate() 
     {
-        return cast(size_t) stream.getSamplerate();
+        return cast(size_t) mStream.getSamplerate();
     }
 
     size_t channels() 
     {
-        return stream.getNumChannels();
+        return mStream.getNumChannels();
     }
 }