SndWrapLinux.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 __SNDWRAPLINUX_H__
#define __SNDWRAPLINUX_H__
 
#include "WaveLoader.h"
#include "SndWrap.h"
#include "eC_File.h"
#include "GUIThread.h"
 
 
class CSndWrapLinux: 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:
    CSndWrapLinux();
 
    virtual ~CSndWrapLinux();
 
    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* pubData,
            const eC_UInt& uiDataSize,
            const eC_Bool& bAllocated)
        {
            if (pubData)
            {
                if (m_pubData)
                    ReleaseData();
 
                if (bAllocated)
                    m_pubData = pubData;
                else
                {
                    m_pubData = new eC_UByte[uiDataSize];
                    memcpy(m_pubData, pubData, uiDataSize);
                }
                m_uiDataSize = uiDataSize;
                m_bAllocated = bAllocated;
            }
        }
 
        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 && m_bAllocated)
                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; 
        eC_Bool m_bAllocated; 
        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__