cWaveDevice.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cWaveDevice_H
#define _INC_cWaveDevice_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../AV/cWaveFormat.h"
 
#ifdef _WIN32
#include "../WinAPI/cWinResource.h"
#include "GrayCore/include/cWinHeap2.h"
#include "GrayCore/include/cTypes.h"
#include "GrayCore/include/cHeap.h"
#include "GrayCore/include/cRefPtr.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cHandlePtr.h"
 
namespace Gray
{
        template <> inline void cHandlePtr<HWAVEIN>::CloseHandle(HWAVEIN h) // static
        {
                ::waveInClose(h);
        }
        template <> inline void cHandlePtr<HWAVEOUT>::CloseHandle(HWAVEOUT h) // static
        {
                ::waveOutClose(h);
        }
}
 
namespace GrayLib
{
        typedef UINT WAVE_DEVICEID_t;   
        typedef UINT WAVE_DEVPID_t;             
        class cWaveDevice;
 
        class GRAYLIB_LINK cWaveHeaderBase
        {
 
        public:
                cRefPtr<cWaveDevice> m_pDevice; 
 
        private:
                CWinGlobalT<WAVEHDR> m_wh;              
                bool m_bManageDataBuffer;               
 
        public:
                cWaveHeaderBase(void* pDataBuffer = nullptr, size_t dwBufferLength = 0);
                ~cWaveHeaderBase();
 
                void UnprepareDevice();  // release from device. (NOT WHILE WHDR_INQUEUE !)
                HRESULT PrepareDevice(cWaveDevice* pDevice);
 
                void DetachData();
                bool AttachData(void* pDataBuffer, size_t dwBufferLength);
 
                WAVEHDR* get_wh() const noexcept
                {
                        return m_wh.get_Data();
                }
                bool isValid() const noexcept
                {
                        WAVEHDR* pwh = get_wh();
                        if (pwh == nullptr)
                                return false;
                        if (pwh->lpData == nullptr)
                                return false;
                        ASSERT(pwh->dwUser == (DWORD_PTR)this);
                        return true;
                }
                bool isValidCheck() const noexcept
                {
                        return isValid();
                }
                bool isInQueue() const noexcept
                {
                        if (!isValid())
                                return false;
                        if (get_wh()->dwFlags & WHDR_INQUEUE)
                                return true;
                        return false;
                }
        };
 
        class GRAYLIB_LINK cWaveDevice : public cRefBase, public cSoundBase
        {
 
                friend class cWaveHeaderBase;
 
        protected:
                WAVE_DEVICEID_t m_uDeviceID;    
                HWAVE   m_hDevice;                      
                bool    m_bActive;                      
                int             m_iHeadersInQueue;      
 
        private:
                virtual HRESULT PrepareHeader(WAVEHDR* pwh) = 0;
                virtual HRESULT UnprepareHeader(WAVEHDR* pwh) = 0;
 
        public:
                static const WAVE_DEVICEID_t k_NO_ID = ((WAVE_DEVICEID_t)(WAVE_MAPPER - 1)); // no device at all.
 
                cWaveDevice(WAVE_DEVICEID_t uDeviceID = WAVE_MAPPER);
                virtual ~cWaveDevice();
 
                static WAVE_DEVICEID_t GRAYCALL FindDeviceByPersistID(bool bInput, WAVE_DEVPID_t nPersistId);
                static inline WAVE_DEVPID_t MakePersistID(WORD wPid, WORD wMid)
                {
                        return (WAVE_DEVPID_t)MAKEDWORD(wPid, wMid); // get full product id = product + manufacturer
                }
                operator HWAVE() const noexcept
                {
                        return m_hDevice;
                }
                bool isOpen() const noexcept
                {
                        return m_hDevice != HANDLE_NULL;
                }
                HWAVE get_Handle() const noexcept
                {
                        return m_hDevice;
                }
                void DetachHandle() noexcept
                {
                        m_hDevice = HANDLE_NULL;
                }
 
                WAVE_DEVICEID_t get_DeviceID() const noexcept
                {
                        return m_uDeviceID;
                }
 
                virtual HRESULT put_DeviceID(WAVE_DEVICEID_t uDeviceID) = 0;
                virtual WAVE_DEVICEID_t QueryDeviceID() const = 0; // if WAVE_MAPPER, what device are we mapped to ?
 
                bool isActive() const noexcept
                {
                        return m_bActive;
                }
                int get_HeadersInQueue() const noexcept
                {
                        return m_iHeadersInQueue;
                }
                int& ref_HeadersInQueue() noexcept
                {
                        return m_iHeadersInQueue;
                }
 
                virtual HRESULT OpenWave(const cWaveFormat& format, DWORD_PTR dwCallback, DWORD_PTR dwInstanceData, DWORD dwOpenFlags) = 0;
                virtual void CloseWave() = 0;
 
                virtual HRESULT Start() = 0;
                virtual HRESULT Stop() = 0;
                virtual HRESULT Reset() = 0;
 
                virtual HRESULT GetPosition(MMTIME& Info) const = 0;
                virtual HRESULT WriteHeader(cWaveHeaderBase* pHdr) = 0;
 
                // Driver returns headers when it is done with it.
                static cWaveHeaderBase* GRAYCALL OnHeaderReturn(WAVEHDR* pHdr);
 
                UNITTEST_FRIEND(cWaveDevice);
        };
 
        class GRAYLIB_LINK cWaveRecorder : public cWaveDevice
        {
        public:
                _GTNSND(WAVEINCAPS) m_Caps;       
        private:
                virtual HRESULT PrepareHeader(WAVEHDR* pwh) override;
                virtual HRESULT UnprepareHeader(WAVEHDR* pwh) override;
        public:
                cWaveRecorder(WAVE_DEVICEID_t uDeviceID = WAVE_MAPPER);
                virtual ~cWaveRecorder();
 
                operator HWAVEIN() const
                {
                        return((HWAVEIN)m_hDevice);
                }
                HWAVEIN get_Handle() const
                {
                        return((HWAVEIN)m_hDevice);
                }
                WAVE_DEVPID_t get_PersistID() const
                {
                        return MakePersistID(m_Caps.wPid, m_Caps.wMid);
                }
 
                virtual HRESULT put_DeviceID(WAVE_DEVICEID_t uDeviceID) override;
                virtual WAVE_DEVICEID_t QueryDeviceID() const override;
 
                static UINT GRAYCALL GetNumDevs();
                static HRESULT GRAYCALL QueryCaps(WAVE_DEVICEID_t uDeviceID, OUT _GTNSND(WAVEINCAPS)* pCaps);
                HRESULT QueryCaps();
 
                virtual HRESULT OpenWave(const cWaveFormat& format, DWORD_PTR dwCallback, DWORD_PTR dwInstanceData, DWORD fdwOpenFlags) override;
                virtual void CloseWave() override;
 
                HRESULT SetLowPri();    // background recorder.
                virtual HRESULT Start() override;
                virtual HRESULT Stop() override;
                virtual HRESULT Reset() override;
 
                virtual HRESULT GetPosition(MMTIME& Info) const override;
                virtual HRESULT WriteHeader(cWaveHeaderBase* pHdr) override;
        };
 
        class GRAYLIB_LINK cWavePlayer : public cWaveDevice
        {
        public:
                _GTNSND(WAVEOUTCAPS) m_Caps;      
        private:
                virtual HRESULT PrepareHeader(WAVEHDR* pwh) override;
                virtual HRESULT UnprepareHeader(WAVEHDR* pwh) override;
        public:
                cWavePlayer(WAVE_DEVICEID_t uDeviceID = WAVE_MAPPER);
                virtual ~cWavePlayer();
 
                operator HWAVEOUT() const
                {
                        return((HWAVEOUT)m_hDevice);
                }
                HWAVEOUT get_Handle() const
                {
                        return((HWAVEOUT)m_hDevice);
                }
                WAVE_DEVPID_t get_PersistID() const
                {
                        return MakePersistID(m_Caps.wPid, m_Caps.wMid);
                }
                virtual HRESULT put_DeviceID(WAVE_DEVICEID_t uDeviceID) override;
                virtual WAVE_DEVICEID_t QueryDeviceID() const override;
 
                static UINT GRAYCALL GetNumDevs();
                static HRESULT GRAYCALL QueryCaps(WAVE_DEVICEID_t uDeviceID, OUT _GTNSND(WAVEOUTCAPS)* pCaps);
 
                HRESULT QueryCaps();
 
                virtual HRESULT OpenWave(const cWaveFormat& format, DWORD_PTR dwCallback, DWORD_PTR dwInstanceData, DWORD fdwOpenFlags) override;
                virtual void CloseWave() override;
 
                virtual HRESULT GetPosition(MMTIME& Info) const override;
                virtual HRESULT Start() override;
                virtual HRESULT Stop() override;
                virtual HRESULT Reset() override;
                virtual HRESULT WriteHeader(cWaveHeaderBase* pHdr) override;
 
                // 0 to 0xffff per stereo channel volume
                HRESULT get_Volume(SOUND_VOL2_t& dwVolume);
                HRESULT put_Volume(SOUND_VOL2_t dwVolume);
                HRESULT put_VolumeStereo(SOUND_VOL_t wVolumeLeft, SOUND_VOL_t wVolumeRight);
 
                // Very rarely supported feature.
                HRESULT get_PlaybackRate(DWORD& dwRate);
                HRESULT put_PlaybackRate(DWORD dwRate);
        };
};
#endif // _WIN32
#endif //_INC_cWaveDevice_H