cWaveFormat.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cWaveFormat_H
#define _INC_cWaveFormat_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cSoundBase.h"
#include "GrayCore/include/cString.h"
#ifdef _WIN32
#include <mmreg.h>              // WAVE_FORMAT_ADPCM
#endif
 
#ifdef __GNUC__
enum WAVE_FORMAT_TYPE_
{
#ifdef __linux__
        WAVE_FORMAT_PCM = 1,    // WORD wFormatTag
        WAVE_FORMAT_ADPCM = 2,
        WAVE_FORMAT_ALAW = 6,   // telephone
        WAVE_FORMAT_MULAW = 7,
        WAVE_FORMAT_DIGIADPCM = 0x0036, // big endian PCM.
        WAVE_FORMAT_MPEG = 0x0050,
        WAVE_FORMAT_MPEGLAYER3 = 0x0055,        // ISO/MPEG Layer3 Format Tag
#endif
};
#endif
 
#ifndef _WIN32
typedef struct waveformat_tag
{
        // Old fashioned define for WAVEFORMAT.
        WORD    wFormatTag;        // format type
        WORD    nChannels;         // number of channels (i.e. mono, stereo, etc.)
        DWORD   nSamplesPerSec;    // sample rate
        DWORD   nAvgBytesPerSec;   // for buffer estimation
        WORD    nBlockAlign;       // block size of data
} WAVEFORMAT;
typedef struct pcmwaveformat_tag
{
        WAVEFORMAT  wf;
        WORD        wBitsPerSample;
} PCMWAVEFORMAT;
#endif
 
#if ! defined(_WAVEFORMATEX_) && ( ! defined(_WIN32) || (WINVER < 0x0400))
#define _WAVEFORMATEX_
typedef struct tWAVEFORMATEX
{
        WORD    wFormatTag;        
        WORD    nChannels;         
        UINT32  nSamplesPerSec;    
        UINT32  nAvgBytesPerSec;   
        WORD    nBlockAlign;       
        WORD    wBitsPerSample;    
        WORD    cbSize;            
        // extra information (after cbSize)
} WAVEFORMATEX;
#endif // _WAVEFORMATEX_
 
namespace GrayLib
{
        class cRIFFReader;
        typedef UINT WAVE_BLOCKS_t;     
 
        //***********************************************************************
 
        class GRAYLIB_LINK cWaveFormatEx : public WAVEFORMATEX
        {
 
        public:
                void Init() noexcept
                {
                        cMem::Zero(this, sizeof(WAVEFORMATEX));
                }
                void Init(WORD wFormatTag2, WORD nChannels2 = 1, UINT nSamplesPerSec2 = 8000, WORD wBitsPerSample2 = 8, WORD wSizeEx2 = 0) noexcept
                {
                        this->wFormatTag = wFormatTag2;
                        this->nChannels = nChannels2;                           // number of channels (i.e. mono, stereo...)
                        this->nSamplesPerSec = nSamplesPerSec2;         // sample rate
                        this->wBitsPerSample = wBitsPerSample2;         // Number of bits per sample of mono data
                        this->nAvgBytesPerSec = 0;    // for buffer estimation. set/calculated later.
                        this->nBlockAlign = 0;        // block size of data. set/calculated later.
                        this->cbSize = wSizeEx2;             // the count in bytes of the size of extra stuff
                        // ASSUME ReCalc is called.
                }
                bool isPCM() const noexcept
                {
                        return(this->wFormatTag == WAVE_FORMAT_PCM);
                }
                WORD get_Channels() const noexcept
                {
                        return(this->nChannels);
                }
                size_t get_BlockSize() const noexcept
                {
                        return(this->nBlockAlign);
                }
                UINT get_SamplesPerSec() const noexcept
                {
                        return(this->nSamplesPerSec);
                }
                size_t get_BytesPerSec() const noexcept
                {
                        return(this->nAvgBytesPerSec);
                }
                size_t get_SampleSize() const  // valid for PCM only.
                {
                        ASSERT(isPCM());
                        return((this->wBitsPerSample == 8) ? 1 : 2);    // sizeof(WORD)
                }
                UINT get_SampleRangeHalf(void) const    // valid for PCM only.
                {
                        ASSERT(isPCM());
                        ASSERT(this->wBitsPerSample);
                        return((1 << (this->wBitsPerSample - 1)) - 1);
                }
                size_t GetStructSize(bool bMin) const noexcept
                {
                        switch (this->wFormatTag)
                        {
                        case 0:
                                return 0;
                        case WAVE_FORMAT_PCM:
                                // Last part (cbSize) is optional. because we know it is 0
                                if (bMin)
                                        return sizeof(PCMWAVEFORMAT);   // old implementations used this much.
                                return sizeof(WAVEFORMATEX); // must really allocate this much.
                        }
                        return(sizeof(WAVEFORMATEX) + this->cbSize);
                }
 
                void ReCalc(void);
                bool isValidFormat() const;
        };
 
        class GRAYLIB_LINK cWaveFormat : public cHeapBlock
        {
                typedef cHeapBlock SUPER_t;
 
        protected:
                size_t GetStructSize(bool bMin) const;
 
        public:
                cWaveFormat();
                virtual ~cWaveFormat();
 
                void SetFormatNull();
                HRESULT SetFormat(const cWaveFormatEx* pForm);
                HRESULT SetFormatBytes(const void* pFormData, size_t iSize);
                HRESULT SetFormatEx(WORD wFormatTag, WORD nChannels = 1, UINT nSamplesPerSec = 8000, WORD wBitsPerSample = 8, WORD wSizeEx = 0);
                HRESULT SetFormatPCM(WORD nChannels = 1, UINT32 nSamplesPerSec = 11025, WORD wBitsPerSample = 8);
 
                bool isValidFormat() const;
                virtual void ReCalc(void);
 
                bool IsSameAs(const cWaveFormatEx* pForm) const;
 
                WAVE_BLOCKS_t CvtSrcToDstSize(WAVE_BLOCKS_t SrcSize, const cWaveFormatEx* pDstForm) const;
                UINT GetRateDiff(const cWaveFormatEx* pDstForm) const
                {
                        return((get_SamplesPerSec() << 16) / pDstForm->nSamplesPerSec);
                }
 
                const cWaveFormatEx* get_WF() const
                {
                        return (const cWaveFormatEx*)get_Data();
                }
                cWaveFormatEx* ref_WF()
                {
                        return (cWaveFormatEx*)get_Data();
                }
                operator const cWaveFormatEx* () const
                {
                        return (const cWaveFormatEx*)get_Data();
                }
                bool isPCM() const
                {
                        if (get_WF() == nullptr)
                                return false;
                        return get_WF()->isPCM();
                }
                size_t get_BlockSize() const
                {
                        if (get_WF() == nullptr)
                                return 0;
                        return(get_WF()->get_BlockSize());
                }
                UINT get_SamplesPerSec() const
                {
                        if (get_WF() == nullptr)
                                return 0;
                        return(get_WF()->get_SamplesPerSec());
                }
                size_t get_BytesPerSec() const
                {
                        if (get_WF() == nullptr)
                                return 0;
                        return(get_WF()->get_BytesPerSec());
                }
                WORD get_Channels() const
                {
                        if (get_WF() == nullptr)
                                return 0;
                        return(get_WF()->get_Channels());
                }
                size_t get_SampleSize() const  // valid for PCM only.
                {
                        if (get_WF() == nullptr)
                                return 0;
                        return(get_WF()->get_SampleSize());
                }
                UINT get_SampleRangeHalf(void) const    // valid for PCM only.
                {
                        if (get_WF() == nullptr)
                                return 0;
                        return(get_WF()->get_SampleRangeHalf());
                }
 
 
                size_t CvtBlocksToBytes(WAVE_BLOCKS_t index) const
                {
                        return(index * get_BlockSize());
                }
                WAVE_BLOCKS_t CvtBytesToBlocks(size_t sizebytes) const
                {
                        return((WAVE_BLOCKS_t)(sizebytes / get_BlockSize()));
                }
 
                UINT CvtBlocksToSamples(WAVE_BLOCKS_t index) const;
                WAVE_BLOCKS_t CvtSamplesToBlocks(UINT dwSamples) const;
 
                TIMESYSD_t CvtBlocksTomSec(WAVE_BLOCKS_t index) const;
                WAVE_BLOCKS_t CvtmSecToBlocks(TIMESYSD_t mSec) const;
 
                // static size_t GRAYCALL FormatCalcSize( const cWaveFormatEx* pForm );
                bool ReAllocFormatSize(size_t iSize);
 
                HRESULT WriteStream(cStreamOutput* pFile) const;
                HRESULT ReadStream(cStreamInput& strIn, size_t iSizeMax);
 
                UNITTEST_FRIEND(cWaveFormat);
        };
 
        class GRAYLIB_LINK cWaveFormatN : public cWaveFormat // cRefBase
        {
                typedef cWaveFormat SUPER_t;
 
        protected:
                cString m_sFormName;    
 
        public:
                virtual ~cWaveFormatN()
                {
                }
 
                cString get_FormName() const
                {
                        return m_sFormName;
                }
 
                HRESULT SetFormatCheck(const cWaveFormatEx* pForm);
                virtual void ReCalc(void);
        };
};
#endif // _INC_cWaveFormat_H