path: root/src/libjin/audio/sdl/source.cpp

#include <exception>
#include <fstream>

#include "../../math/math.h"
#include "../../utils/macros.h"
#include "source.h"
#include "3rdparty/wav/wav.h"
#define STB_VORBIS_HEADER_ONLY
#include "3rdparty/stb/stb_vorbis.c"

namespace jin
{
namespace audio
{

    typedef struct SDLSourceCommand
    {
        typedef enum Action
        {
            Nothing = 0, //
            Play,        // ��ͷ��ʼ
            Stop,        // ֹͣ
            Pause,       //
            Resume,      //
            Rewind,      //
            SetVolume,   //
            SetLoop,     //
            SetRate,     //
        };

        Action action;
        union {
            int _integer;
            float _float;
            bool _boolean;
            const char* _string;
        } parameter;

        SDLSource* source;
    };

    typedef MASK enum STATUS
    {
        PLAYING = 1,
        PAUSED  = 2,
        STOPPED = 4
    };

#define Command SDLSourceCommand
#define Action Command::Action
#define Manager SDLSourceManager

    shared std::queue<Command*> Manager::commands;
    shared std::stack<Command*> Manager::commandsPool;
    shared std::vector<SDLSource*> Manager::sources;
    shared Manager* Manager::manager = nullptr;

    SDLSource* SDLSource::createSource(SourceType format, const char* file)
    {
        std::ifstream fs(file, std::ios::binary);
        fs.seekg(0,std::ios::end);
        int size = fs.tellg(); 
        fs.seekg(0, std::ios::beg); 
        char* buffer = (char*)malloc(size);
        memset(buffer, 0, size);
        fs.read(buffer, size); 
        SDLSource* source = createSource(format, buffer, size);
        free(buffer);
        return source;
    }

    SDLSource* SDLSource::createSource(SourceType format, void* mem, size_t size)
    {
        if (mem == nullptr)
            return nullptr; 
        SDLSource* source = new SDLSource();
        memset(&source->status, 0, sizeof(status));
        memset(&source->raw, 0, sizeof(raw));
        try
        {
            switch (format)
            {
            case  WAV:
                source->loadWAV(mem, size);
                break;
            case OGG:
                source->loadOGG(mem, size);
                break;
            }
        }
        catch (SourceException& exp)
        {
            delete source;
            return nullptr;
        };
        return source; 
    }

    SDLSource::SDLSource()
    {
    }

    SDLSource::~SDLSource()
    {
        delete raw.data; 
        raw.end = 0;
        raw.data = 0;
    }

    void SDLSource::loadWAV(void* mem, int size)
    {
        wav_t wav; 
        if (wav_read(&wav, mem, size) == 0)
        {
            raw.data     = wav.data;
            raw.size     = wav.length * wav.bitdepth / 8;
            raw.end      = (char*)raw.data + raw.size;
            raw.rate     = wav.samplerate;
            raw.bitdepth = wav.bitdepth;
            raw.samples  = raw.size / (wav.bitdepth / 8.f);
            raw.channel  = wav.channels;
            raw.silence  = 0;
        }
        else
            throw SourceException();
    }

    void SDLSource::loadOGG(void* mem, int size)
    {
        raw.samples  = stb_vorbis_decode_memory((unsigned char*)mem, size, (int*)&raw.channel, &raw.rate, (short**)&raw.data) << 1;
        raw.size     = raw.samples << 1; // 2 bytes each sample
        raw.bitdepth = 16; 
        raw.end      = (char*)raw.data + raw.size; 
        raw.silence  = 0;

        if (raw.samples < 0)
        {
            throw SourceException();
        }
    }

#define ActionNone(T)\
do{\
Command* cmd = Manager::get()->getCommand();\
cmd->action = Action::T;                    \
cmd->source = this;                         \
Manager::get()->pushCommand(cmd);           \
} while (0)

#define ActionArg(T, ARGT, ARG)\
do{\
Command* cmd = Manager::get()->getCommand();\
cmd->action = Action::T;                    \
cmd->parameter.ARGT = ARG;                  \
cmd->source = this;                         \
Manager::get()->pushCommand(cmd);           \
}while(0)

#define ActionInt(T, INT)    ActionArg(T, _integer, INT)
#define ActionFloat(T, FLT)  ActionArg(T, _float, FLT)
#define ActionString(T, STR) ActionArg(T, _string, STR)
#define ActionBool(T, BOL)   ActionArg(T, _boolean, BOL)

    void SDLSource::play()
    {
        ActionNone(Play);
    }

    void SDLSource::stop() 
    {
        ActionNone(Stop);
    }

    void SDLSource::pause() 
    {
        ActionNone(Pause);
    }

    void SDLSource::resume() 
    {
        ActionNone(Resume);
    }
    
    void SDLSource::rewind() 
    {
        ActionNone(Rewind);
    }

    inline bool SDLSource::isStopped() const
    {
        return is(STOPPED);
    }

    bool SDLSource::isPaused() const
    {
        return is(PAUSED);
    }

    void SDLSource::setPitch(float pitch) 
    {
    }

    void SDLSource::setVolume(float volume) 
    {
        ActionFloat(SetVolume, volume);
    }

    bool SDLSource::setLoop(bool loop) 
    {
        ActionBool(SetLoop, loop);
        return false; 
    }

    void SDLSource::setRate(float rate) 
    {
        ActionFloat(SetRate, rate);
    }

    Manager* Manager::get()
    {
        return (manager == nullptr ? manager = new Manager() : manager);
    }

    shared void Manager::processCommands()
    {
        Command* cmd = nullptr;
        SDLSource* source = nullptr;
        while (!commands.empty())
        {
            cmd = commands.front();
            source = cmd->source;
            if (source != nullptr && cmd != nullptr)
            {
                switch (cmd->action)
                {
                case Command::Action::Play:
                    removeSource(source);
                    pushSource(source);
                    source->status.state = PLAYING;
                    source->status.pos = 0;  // rewind
                    break;
                case Command::Action::Stop:
                    manager->removeSource(source);
                    source->status.state = STOPPED;
                    source->status.pos = 0; // rewind
                    break;
                case Command::Action::Pause:
                    manager->removeSource(source);
                    source->status.state = PAUSED;
                    break;
                case Command::Action::Resume:
                    manager->removeSource(source);
                    manager->pushSource(source);
                    source->status.state = PLAYING;
                    break;
                case Command::Action::Rewind:
                    source->status.state = PLAYING;
                    source->status.pos = 0;
                    break;
                case Command::Action::SetVolume:
                    //float cmd->parameter._float;
                    break;
                case Command::Action::SetLoop:
                    source->status.loop = cmd->parameter._boolean;
                    break;
                    /*case Command::Action::SetRate:
                    */
                }
            }
            commands.pop();
        }
    }

    shared void Manager::processSources(Uint8* buffer, int len)
    {
        memset(buffer, 0, len);
        int16_t* buf16 = (int16_t*)buffer;
        int samples = len >> 1;
        std::vector<SDLSource*>::iterator it = sources.begin();
        SDLSource* source = nullptr;
        for (; it != sources.end();)
        {
            source = *it;
            int16_t* data16 = (int16_t*)source->raw.data;
            if (source->is(STOPPED))
                removeSource(source);
            else if (source->is(PAUSED))
                continue;
            else if (source->is(PLAYING))
            {
                int16_t* src16 = (int16_t*)((char*)source->raw.data + source->status.pos);
                int remainsample = (source->raw.size - source->status.pos) >> 1;
                int bound = min(samples, remainsample);
                for (int i = 0; i < bound; ++i)
                {
                    buf16[i] += src16[i]; // mix sources
                }
                source->status.pos += (bound << 1);
                if (remainsample < samples)
                {
                    if (source->status.loop)
                    {
                        int j = 0;
                        for (int i = bound; i < samples; ++i)
                        {
                            int val = data16[j];
                            buf16[i] += val;
                            ++j;
                        }
                        source->status.pos = (j << 1);
                        break;
                    }
                    else
                    {
                        it = sources.erase(it);
                        continue;
                    }
                }
            }
            ++it;
        }
    }
    
    shared void Manager::removeSource(SDLSource* source)
    {
        std::vector<SDLSource*>::iterator it = sources.begin(); 
        for (it = sources.begin(); it != sources.end(); )
        {
            if (*it == source)
            {
                it = sources.erase(it); 
                return;
            }
            ++it;
        }
    }

    shared void Manager::pushSource(SDLSource* source)
    {
        if(source != nullptr)
            sources.push_back(source);
    }

    shared void Manager::pushCommand(SDLSourceCommand* cmd)
    {
        commands.push(cmd);
    }

    shared Command* Manager::getCommand()
    {
        if (!commandsPool.empty())
        {
            Command* cmd = commandsPool.top();
            commandsPool.pop();
        }
        return new Command();
    }

    shared void Manager::collectCommand(Command* cmd)
    {
        if (cmd != nullptr)
        {
            commandsPool.push(cmd);
        }
    }

}
}