Buffer.h

Go to the documentation of this file.

//Luke Lenhart, 2008
//See /docs/License.txt for details on how this code may be used.

#pragma once

#include "../base/Setup.h"

#ifdef MPMA_COMPILE_AUDIO

#include <list>
#include <vector>
#include "Source.h"
#include "../base/ReferenceCount.h"
#include "../base/Locks.h"
#include "AL_Include.h"

namespace AUDIO_INTERNAL { class BackgroundProcessing; }

namespace AUDIO
{
    enum BufferBehavior
    {
        STATIC_DATA=0x100,
        STREAM_DATA
    };

    //internal data common to all buffer objects
    struct InternalSharedBufferData
    {
        inline InternalSharedBufferData(): isReal(true), isStatic(true), streamingSource(0), staticBuffer(0)
            {}

        bool isReal;
        bool isStatic;
        MPMA::RWSleepLock bufferLock;

        //these are used only for a streaming buffer
        std::list<Source*> readySources; //sources available to play
        Source *streamingSource; //original copy of the streaming source, from which we'll make any duplicates we need (also stored in readySources)
        float streamSeconds; //how big the total streaming buffers are

        struct PlayerBuffers
        {
            ALuint playerResource; //the player (openal source)
            ALuint *buffers; //buffers used by the player for streaming
            nuint buffersFinished; //how many buffers are done playing and not queued
            Source *source; //source used for this player
            class Player *player; //player that is playing this
            bool beingFreed; //whether this entry is in the process of being freed
            bool freeRequestAboutToOccur; //whether we were just asked to free it... in which case the bg thread should not touch it

            //temporary buffer used to hold data during streaming
            uint8 *streamingBufferData;
            nuint streamingBufferSize;
        };
        std::list<PlayerBuffers> players; //list of players currently using this buffer

        //used for static buffer only
        ALuint staticBuffer;
    };

    class Buffer: public MPMA::ReferenceCountedData<InternalSharedBufferData>
    {
    public:
        Buffer(Source &source, BufferBehavior bufferBehavior, float streamSizeInSeconds=0.2f);

        virtual ~Buffer();

        inline Buffer()
            { Data().isReal=false; }

        inline bool IsReal() const
            { return Data().isReal; }

    protected:
        //returns whether this buffer has static data
        inline bool IsStatic() const
            { return Data().isStatic; }

        //sets up the initial buffer or buffers needed to start playing and associates them with a player(what openal calls a source).
        bool SetupInitialPlayBuffers(ALuint playerResource, class Player *player);

        //the player has either stopped or destructed, so stop processing it
        void FreePlayer(ALuint playerResource, class Player *player);

    private:
        //attempts construction using a hardware static buffer.
        bool ConstructInHardwareBuffer(Source *source);

        //attempts construction using a system static buffer.
        bool ConstructInSystemBuffer(Source *source);

        //attempts construction using a hardware static buffer.
        bool ConstructInStreamingBuffer(Source *source, float streamSizeInSeconds);

        //called if we failed construction, so initialize us into an error state.
        void ConstructAsError(const char *msg);

        //reads all data from a static finite source.
        void ReadAllStaticSourceData(Source *source, std::vector<uint8> &data);

        //catches the streaming data up to date on a player/buffer set
        void UpdateStreamingPlayerBuffer(InternalSharedBufferData::PlayerBuffers &pb, bool isInitialRead=false);

        //frees the resources associated with a playerbuffer and removes it from the list
        void FreePlayerBuffer(InternalSharedBufferData::PlayerBuffers *pb);

        friend class Player;
        friend class AUDIO_INTERNAL::BackgroundProcessing;
    };

}

#endif //#ifdef MPMA_COMPILE_AUDIO