SndWrapWAVBase.h

/*
* Copyright (C) TES Electronic Solutions GmbH,
* All Rights Reserved.
* Contact: info@guiliani.de
*
* This file is part of the Guiliani HMI framework
* for the development of graphical user interfaces on embedded systems.
*/
 
#ifndef __SNDWRAPWAVBASE_H__
#define __SNDWRAPWAVBASE_H__
 
#include "WaveLoader.h"
#include "SndWrap.h"
#include "eC_File.h"
#include "GUIThread.h"
 
 
class CSndWrapWAVBase: public CSndWrap
{
public:
    virtual void LoadSnd(const eC_String &pkPath, const SoundResource_t &eID, eC_UInt uiDeviceID = 0);
    virtual void UnloadSnd(const SoundResource_t &eID);
    virtual eC_Bool SetVolume(eC_UByte ubVolume = 0xff) = 0;
    virtual eC_UByte GetVolume() = 0;
    virtual eC_Bool PauseSnd(const SoundResource_t &eID);
    virtual eC_Bool PlaySnd(const SoundResource_t &eID, eC_UInt Flags = PLAY_ASYNC);
    virtual eC_Bool ResumeSnd (const SoundResource_t &eID);
    virtual eC_Bool StopSnd(const SoundResource_t &eID);
 
    virtual eC_Bool IsSoundPlaying(const SoundResource_t &eID);
 
protected:
    CSndWrapWAVBase();
 
    virtual ~CSndWrapWAVBase();
 
    class CSound
    {
    public:
        CSound() : m_pubData(NULL), m_uiDataSize(0), m_eSoundID(SND_START_TAG) { memset(&m_kWaveformat, 0, sizeof(m_kWaveformat)); }
 
        inline void SetWaveFormat(const FileLoader::WaveLoader::FormatChunk_t& kWaveFormat) { m_kWaveformat = kWaveFormat; }
 
        inline const FileLoader::WaveLoader::FormatChunk_t& GetWaveFormat() const { return m_kWaveformat; }
 
        inline void SetData(eC_UByte *data, eC_UInt datasize)
        {
            if (data)
            {
                if (m_pubData)
                    ReleaseData();
                m_pubData = new eC_UByte[datasize];
                memcpy(m_pubData, data, datasize);
                m_uiDataSize = datasize;
            }
        }
 
        inline eC_UByte* GetData() const { return m_pubData; }
 
        inline eC_UInt GetDataSize() const
        {
            if (m_pubData)
                return m_uiDataSize;
            else
                return 0;
        }
 
        inline void ReleaseData() { if (m_pubData) delete[] m_pubData; m_pubData = 0; }
 
        inline void SetSoundID(const SoundResource_t eSoundID) {m_eSoundID = eSoundID;}
 
        inline SoundResource_t GetSoundID() const {return m_eSoundID;}
 
    private:
        eC_UByte *m_pubData;                                    
        eC_UInt m_uiDataSize;                                   
        SoundResource_t m_eSoundID;                             
        FileLoader::WaveLoader::FormatChunk_t m_kWaveformat;    
    };
 
 
    class CPlayThreadBase: public CGUIThread
    {
    public:
        CPlayThreadBase(const eC_UInt uiStackSize, const ThreadPriority_t kThreadPriority) :
            CGUIThread(uiStackSize),
            m_kThreadPriority(kThreadPriority)
        {}
 
        virtual ~CPlayThreadBase() {}
 
        virtual void Play(const CSound& kSound) = 0;
 
        virtual void Pause() = 0;
 
        virtual void Resume() = 0;
 
        virtual void Stop() = 0;
 
        inline const CSound& GetSound() const {return m_kSound;}
 
        inline const void SetSound(const CSound& kSound) {m_kSound = kSound;}
 
        inline ThreadPriority_t GetThreadPriority() const {return m_kThreadPriority;}
 
    private:
        void Setup() {}
 
        virtual void Execute(void *pArg) = 0;
 
        void Cleanup() {}
 
        eC_Int Start(void *pArg);
 
        CSound m_kSound;                        
        ThreadPriority_t m_kThreadPriority;     
    };
 
    CPlayThreadBase* m_pPlayThread;       
    eC_TArray<CSound> m_aSoundFiles;      
 
private:
    eC_Bool DeInit();
 
    eC_Bool Init();
 
    eC_Bool SetNOFSounds(eC_UInt uiNOFSounds);
};
#endif //#ifndef __SNDWRAPWAVBASE_H__