cWaveData.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cWaveData_H
#define _INC_cWaveData_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cWaveFormat.h"
 
#ifdef _WIN32
#include "../WinAPI/cWinResource.h"
#include "../Math/cValueRange.h"
#include "GrayCore/include/cWinHeap2.h"
#include "GrayCore/include/cListNodeRef.h"
 
namespace GrayLib
{
        typedef BYTE FAR* P_WAV_DATA_t;          
        typedef const BYTE FAR* P_WAV_CDATA_t;   
        class cWaveData;
 
        class GRAYLIB_LINK cWaveRange : public cValueRange<WAVE_BLOCKS_t>
        {
 
                typedef cValueRange<WAVE_BLOCKS_t> SUPER_t;
 
        public:
                cWaveRange(WAVE_BLOCKS_t tLo = 0, WAVE_BLOCKS_t tHi = 0)
                        : cValueRange<WAVE_BLOCKS_t>(tLo, tHi)
                {
                }
                ~cWaveRange()
                {
                }
                WAVE_BLOCKS_t get_Start(void) const
                {
                        return m_Lo;
                }
                WAVE_BLOCKS_t get_End(void) const
                {
                        return m_Hi;
                }
                WAVE_BLOCKS_t get_Size(void) const
                {
                        return(m_Hi - m_Lo);
                }
        };
 
        //************************************************************
 
        class GRAYLIB_LINK cWaveBuffer
                : public cListNodeRef<cWaveBuffer>
        {
 
                friend class cWaveData;
                typedef cListNodeRef<cWaveBuffer> SUPER_t;
 
        public:
                CWinGlobalV             m_Data;                 
                WAVE_BLOCKS_t  m_sizeBlocks;  
                WAVE_BLOCKS_t  m_index;         
                STREAM_POS_t m_nFileOffset; 
 
        public:
                cWaveBuffer(WAVE_BLOCKS_t size, HGLOBAL hData);
                virtual ~cWaveBuffer();
 
                CHEAPOBJECT_IMPL;
 
                void Discard(void);
                void LoadOnDemand();
                virtual void onFinalRelease() override;
 
                P_WAV_DATA_t get_Data()
                {
                        if (m_Data.get_Data() == nullptr)
                        {
                                LoadOnDemand();
                        }
                        return (P_WAV_DATA_t)m_Data.get_Data();
                }
                cWaveData* get_Parent() const;
        };
 
        typedef cRefPtr<cWaveBuffer> cWaveBufferPtr;
 
        class GRAYLIB_LINK cWaveSampleRef
        {
        public:
                cWaveBufferPtr m_Buffer;                
                P_WAV_DATA_t m_pBufferData;             
                WAVE_BLOCKS_t m_dwBufferSize;   
        public:
                cWaveSampleRef()
                        : m_pBufferData(nullptr)
                        , m_dwBufferSize(0)
                {
                }
        };
 
        //***********************************************************************
 
        class GRAYLIB_LINK cWaveData : public cListT<cWaveBuffer>
        {
 
                typedef cListT<cWaveBuffer> SUPER_t;
 
        public:
                cWaveFormatN m_Form;            
        private:
                WAVE_BLOCKS_t m_size;           
 
        protected:
                virtual void RemoveListNode(cListNodeBase* pObRec);
                void BufferAdjustIndexes(cWaveBuffer* pBuffer);
 
        public:
                cWaveData();
                virtual ~cWaveData();
 
                virtual void OnSizeChange(WAVE_BLOCKS_t sizeold, WAVE_BLOCKS_t sizenew) = 0;
 
                WAVE_BLOCKS_t get_DataSize() const
                {
                        return m_size;
                }
                cWaveFormat& ref_WaveFormat()
                {
                        return m_Form;
                }
 
                cWaveBufferPtr BufferLink(WAVE_BLOCKS_t size, HGLOBAL hData, cWaveBuffer* pPrv);
                HRESULT BufferChangeSize(cWaveBuffer* pBuffer, WAVE_BLOCKS_t size);
                bool BufferSplit(cWaveBuffer* pBuf, WAVE_BLOCKS_t size);
                cWaveBufferPtr BufferFind(WAVE_BLOCKS_t index);
        };
 
        inline cWaveData* cWaveBuffer::get_Parent() const
        {
                return(CHECKPTR_CAST(cWaveData, cListNodeBase::get_Parent()));
        }
}
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
namespace Gray
{
        template class GRAYLIB_LINK cListT<GrayLib::cWaveBuffer>;
}
#endif
 
#endif  // _WIN32
#endif // _INC_cWaveData_H