TnbWaveFile.h

[詳解]

#pragma once
#include <TnbMap.h>
#include <TnbConstFileMapping.h>
#include <TnbDummyCollection.h>
#include <TnbCollectionAdapter.h>
#include <mmsystem.h>
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CWaveFormat : public WAVEFORMATEX
{
public:
 
    CWaveFormat(DWORD samplesPerSec = 44100, WORD bitsPerSample = 16, WORD channels = 2)
    {
        wFormatTag = WAVE_FORMAT_PCM;
        cbSize = sizeof(WAVEFORMATEX);
        Set(samplesPerSec, bitsPerSample, channels);
    }
 
    CWaveFormat(const WAVEFORMATEX& f)
    {
        WAVEFORMATEX* P = this;
        *P = f;
    }
 
    void Set(DWORD samplesPerSec, WORD bitsPerSample, WORD channels)
    {
        nSamplesPerSec  = samplesPerSec;
        wBitsPerSample  = bitsPerSample;
        nChannels       = channels;
        nBlockAlign     = static_cast<WORD>(nChannels * wBitsPerSample / 8);
        nAvgBytesPerSec = nSamplesPerSec * nBlockAlign;
    }
 
    DWORD CalcTime(size_t samples) const
    {
        ULONGLONG r = samples;
        r *= 1000;
        return static_cast<DWORD>((r + nSamplesPerSec - 1) / nSamplesPerSec);
    }
 
    size_t CalcSamples(DWORD time) const
    {
        ULONGLONG r = time;
        r *= nSamplesPerSec;
        return static_cast<size_t>(r / 1000);
    }
};
 
 
 
class CWaveFile : CCopyImpossible
{
public:
 
    struct TChunkHeader
    {
        FOURCC type;    
        LONG length;    
    };
 
    class CListInfoChunk
    {
    public:
 
        void Empty(void)
        {
            m_map.RemoveAll();
        }
 
        CVectorT<FOURCC> EnumType(void) const
        {
            CVectorT<FOURCC> v;
            v.Copy(m_map.GetKeysAdapter());
            return v;
        }
 
        bool Has(FOURCC cc) const
        {
            return m_map.HasKey(cc);
        }
 
        bool Get(CAscii& _str, FOURCC cc) const
        {
            if ( m_map.HasKey(cc) )
            {
                _str = m_map[cc];
                return true;
            }
            return false;
        }
 
        void Set(FOURCC cc, LPCTSTR lpsz)
        {
            m_map[cc] = lpsz;
        }
 
        CByteVector Make(void) const
        {
            CByteVector vb;
            vb.AddElements(4, reinterpret_cast<const BYTE*>("INFO"));
            loop ( i, m_map.GetSize() )
            {
                FOURCC cc = m_map.At(i).first;
                const CAscii& s = m_map.At(i).second;
                DWORD len = s.GetLength() + 1;
                vb.AddElements(4, reinterpret_cast<const BYTE*>(&cc));
                vb.AddElements(4, reinterpret_cast<const BYTE*>(&len));
                vb.AddElements(len, reinterpret_cast<const BYTE*>(s.operator LPCSTR()));
                if ( (len & 1) != 0 )
                {
                    vb.Add(0);
                }
            }
            return vb;
        }
 
        bool Analyze(const IConstCollectionT<BYTE>& c)
        {
            m_map.RemoveAll();
            size_t sz = 0;
            DWORD pos = 0;
            FOURCC type;
            sz = c.GetElements(sizeof(FOURCC), reinterpret_cast<BYTE*>(&type), pos);
            if ( sz != sizeof(FOURCC) )
            {
                return false;
            }
            pos += sz;
            if ( type != MAKEFOURCC('I', 'N', 'F', 'O') )
            {
                return false;
            }
            TChunkHeader chunk;
            while ( pos < c.GetSize() )
            {
                sz = c.GetElements(sizeof(chunk), reinterpret_cast<BYTE*>(&chunk), pos);
                if ( sz != sizeof(chunk) )
                {
                    return false;
                }
                pos += sz;
                size_t len = chunk.length;
                if ( (len & 1) != 0 )
                {
                    len ++; //偶数にする
                }
                CAscii& a = m_map[chunk.type];
                sz = c.GetElements(len, reinterpret_cast<BYTE*>(a.GetBuffer(len + 1)), pos);
                if ( sz != len )
                {
                    return false;
                }
                pos += sz;
                a.ReleaseBuffer();
            }
            return true;
        }
 
        bool Analyze(size_t size, const BYTE* P)
        {
            return Analyze(CConstAdapterT<BYTE>(size, P));
        }
 
    private:
        CMapT<FOURCC, CAscii>   m_map;  
    };
 
 
    //--------------
 
 
    CWaveFile(void) : m_dataSize(0), m_dataOffset(0), m_adapter(NULL, 0)
    {
    }
 
    ~CWaveFile(void)
    {
        Close();
    }
 
    bool IsOpened(void) const
    {
        return m_file.IsOpened();
    }
 
    void Close(void)
    {
        m_file.Close();
        m_file16.Close();
        m_chunkMap.RemoveAll();
        m_refData.RemoveAll();
        m_dataOffset = 0;
        m_dataSize = 0;
    }
 
    bool Open(LPCTSTR fileName, const WAVEFORMATEX& format)
    {
        Close();
        m_format = format;
        if ( ! m_file.Open(fileName) )
        {
            return false;
        }
        if ( ! m_file16.Open(fileName) )
        {
            return false;
        }
        m_dataOffset = 0;
        m_dataSize = m_file.GetSize();
        return true;
    }
 
    bool Open(LPCTSTR fileName)
    {
        Close();
        if ( ! m_file.Open(fileName) )
        {
            return false;
        }
        INDEX pos = 0;
        TChunkHeader fileChunk;
        pos += m_file.GetElements(sizeof(fileChunk), reinterpret_cast<BYTE*>(&fileChunk), pos);
        FOURCC riffType;
        pos += m_file.GetElements(sizeof(riffType), reinterpret_cast<BYTE*>(&riffType), pos);
        if ( fileChunk.type == FC_RIFF && fileChunk.length <= ToInt(m_file.GetSize()) && riffType == FC_WAVE )
        {
            while( pos < m_file.GetSize() )
            {
                TChunkHeader chunk;
                pos += m_file.GetElements(sizeof(chunk), reinterpret_cast<BYTE*>(&chunk), pos);
                if ( chunk.type == FC_FMT )
                {
                    m_file.GetElements(sizeof(m_format), reinterpret_cast<BYTE*>(&m_format), pos);
                    WORD bps = m_format.wBitsPerSample;
                    if ( bps != 8 && bps != 16 )
                    {
                        break;
                    }
                    if ( m_format.wFormatTag != WAVE_FORMAT_PCM )
                    {
                        break;
                    }
                    if ( m_format.nChannels != 1 && m_format.nChannels != 2 )
                    {
                        break;
                    }
                    m_format.cbSize = 0;
                }
                else if ( chunk.type == FC_DATA )
                {
                    m_dataOffset = pos;
                    m_dataSize = chunk.length;
                }
                else
                {
                    TChunkMap cm;
                    cm.offset = pos;
                    cm.size = chunk.length;
                    m_chunkMap[chunk.type] = cm;
                }
                if ( chunk.length == 0 )
                {
                    break;
                }
                pos += chunk.length;
            }
            if ( pos >= m_file.GetSize() )
            {
                if ( m_file16.Open(fileName, m_dataOffset, m_dataSize / sizeof(short)) )
                {
                    return true;
                }
            }
        }
        Close();
        return false;
    }
 
    const CWaveFormat& RefFormat(void) const
    {
        return m_format;    
    }
 
    size_t GetSamples(void) const
    {
        if ( m_format.nBlockAlign == 0 )
        {
            return 0;
        }
        return m_dataSize / m_format.nBlockAlign;
    }
 
    DWORD GetTotalTime(void) const
    {
        if ( m_format.nBlockAlign == 0 || m_format.nSamplesPerSec == 0 )
        {
            return 0;
        }
        ULONGLONG r = (m_dataSize / m_format.nBlockAlign);
        r *= 1000;
        return static_cast<DWORD>((r + m_format.nSamplesPerSec - 1) / m_format.nSamplesPerSec);
    }
 
    size_t GetDataSize(void) const
    {
        return m_dataSize;
    }
 
    const BYTE* RefData(INDEX i = 0) const
    {
        if ( m_refData.IsEmpty() )
        {
            m_refData.Copy(GetByteData());
        }
        return m_refData.ReferBuffer() + i;
    }
 
    const IConstCollectionT<BYTE>& GetByteData(void) const
    {
        m_adapter = CConstOffsetAdapterT<BYTE>(&m_file, m_dataOffset, m_dataSize);
        return m_adapter;
    }
 
    const IConstCollectionT<short>& GetShortData(void) const
    {
        return m_file16;
    }
 
    const IConstCollectionT<BYTE>& GetChunk(FOURCC cc) const
    {
        if ( m_chunkMap.HasKey(cc) )
        {
            m_adapter = CConstOffsetAdapterT<BYTE>(&m_file, m_chunkMap[cc].offset, m_chunkMap[cc].size);
            return m_adapter;
        }
        return m_nullCollection;
    }
 
    bool GetListInfoChunk(CListInfoChunk& _lic) const
    {
        const IConstCollectionT<BYTE>& c = GetChunk(MAKEFOURCC('L','I','S','T'));
        if ( c.GetSize() > 0 )
        {
            return _lic.Analyze(c);
        }
        return false;
    }
 
    static size_t MakeWaveHeader(CWorkMem& _head, int channels, long rate, WORD bit, size_t dataSize, size_t extendSize = 0)
    {
        _head.Resize(sizeof(TWaveFileHeader));
        TWaveFileHeader* P = reinterpret_cast<TWaveFileHeader*>(_head.Ref());
        P->fileChunk.type               = FC_RIFF;
        P->fileChunk.length             = dataSize + extendSize + sizeof(TWaveFileHeader) - 8;
        P->fileType                     = FC_WAVE;
        P->format.wf.wFormatTag         = WAVE_FORMAT_PCM;
        P->format.wf.nChannels          = static_cast<WORD>(channels);
        P->format.wf.nSamplesPerSec     = rate;
        P->format.wBitsPerSample        = bit;
        P->format.wf.nBlockAlign        = static_cast<WORD>(channels * bit / 8);
        P->format.wf.nAvgBytesPerSec    = channels * bit / 8 * rate;
        P->formatChunk.type             = FC_FMT;
        P->formatChunk.length           = sizeof(PCMWAVEFORMAT);
        P->dataChunk.type               = FC_DATA;
        P->dataChunk.length             = dataSize;
        return sizeof(TWaveFileHeader);
    }
 
private:
    enum
    {
        FC_RIFF     = MAKEFOURCC('R', 'I', 'F', 'F'),   
        FC_WAVE     = MAKEFOURCC('W', 'A', 'V', 'E'),   
        FC_FMT      = MAKEFOURCC('f', 'm', 't', ' '),   
        FC_DATA     = MAKEFOURCC('d', 'a', 't', 'a'),   
    };
    struct TWaveFileHeader 
    {
        TChunkHeader    fileChunk;      
        FOURCC          fileType;       
        TChunkHeader    formatChunk;    
        PCMWAVEFORMAT   format;         
        TChunkHeader    dataChunk;      
    };
    struct TChunkMap
    {
        size_t      size;   
        INDEX       offset; 
    };
 
    CWaveFormat                         m_format;           
    CConstFileMapping                   m_file;             
    CConstFileMappingT<short>           m_file16;           
    size_t                              m_dataSize;         
    INDEX                               m_dataOffset;       
    CMapT<FOURCC, TChunkMap>            m_chunkMap;         
    mutable CByteVector                 m_refData;          
    mutable CConstOffsetAdapterT<BYTE>  m_adapter;          
    CDummyCollectionT<BYTE>             m_nullCollection;   
};
 
 
 
}; // TNB