cMP3File.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cMP3File_H
#define _INC_cMP3File_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../AV/cAVSink.h"
#include "GrayCore/include/cStream.h"
 
namespace GrayLib
{
        class cWaveFormat;
 
        class GRAYLIB_LINK cMP3Header
        {
 
        public:
                enum MASK_TYPE
                {
                        // Assume big endian (network order) read order from file.
                        // Chop up the 32 bits into sections.
                        MASK_CHANNEL = 0x000000C0,
                        MASK_PADDING = 0x00000200,
                        MASK_SAMPLERATE = 0x00000C00,
                        MASK_BITRATE = 0x0000f000,
                        MASK_PROTECTION = 0x00010000,   // has NO 16 bit CRC to follow. (if set)
                        MASK_LAYER = 0x00060000,
                        MASK_VERSION = 0x00180000,
                        MASK_FRAME_SYNC = 0xFFE00000,   // Must have all bits set.
                };
                enum CHANNEL_TYPE
                {
                        // MASK_CHANNEL
                        CHANNEL_STEREO = 0x00000000,
                        CHANNEL_JOINT = 0x00000040,
                        CHANNEL_DUAL = 0x00000080,
                        CHANNEL_MONO = 0x000000C0,
                };
                enum SAMPLERATE_IDX_TYPE
                {
                        // MASK_SAMPLERATE
                        SAMPLERATE_IDX_QTY = 3,
                        SAMPLERATE_MASK = 0x03,
                };
                enum BITRATE_IDX_TYPE
                {
                        // MASK_BITRATE
                        BITRATE_IDX_UNK0 = 0,   // unused.
                        BITRATE_IDX_UNK15 = 15, // unused.
                        BITRATE_MASK = 0x0f,
                        BITRATE_IDX_QTY = 16,
                };
                enum LAYER_TYPE
                {
                        // MASK_LAYER = Layer description
                        LAYER_UNK = 0,
                        LAYER_3 = 1,
                        LAYER_2 = 2,
                        LAYER_1 = 3,
                        LAYER_MASK = 0x03,
                };
                enum VERSION_TYPE
                {
                        // MASK_VERSION
                        VERSION_25 = 0, // Nonstandard proprietary MPEG-2.5 Audio Layer III
                        VERSION_INVALID = 1,
                        VERSION_2 = 2,          // MPEG-2 Audio Layer III
                        VERSION_1 = 3,          // MPEG-1 Audio Layer III
                        VERSION_MASK = 0x03,
                };
 
                enum SHIFT_TYPE
                {
                        SHIFT_CHANNEL = 0,
                        SHIFT_SAMPLERATE = 10,  // 32, 44.1, 48 kHz
                        SHIFT_BITRATE = 12,     // 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256 and 320 kbit/s
                        SHIFT_LAYER = 17,
                        SHIFT_VERSION = 19,
                };
 
        private:
                enum SAMPLERATE_VER_TYPE
                {
                        SAMPLERATE_VER_1,       // for VERSION_1
                        SAMPLERATE_VER_2,       // for VERSION_2
                        SAMPLERATE_VER_25,      // for VERSION_25
                        SAMPLERATE_VER_QTY
                };
                enum BITRATE_VER_TYPE
                {
                        BITRATE_VER_1,          // for VERSION_1
                        BITRATE_VER_2,          // for VERSION_25 and VERSION_2
                        BITRATE_VER_QTY
                };
                static const WORD k_SampleRate[SAMPLERATE_IDX_QTY][SAMPLERATE_VER_QTY]; 
                static const WORD k_BitRate[BITRATE_IDX_QTY][BITRATE_VER_QTY];                          
                UINT32 m_uCode;         
 
        public:
                cMP3Header(UINT uCode) noexcept
                        : m_uCode(uCode)
                {
                }
 
                static bool GRAYCALL IsValidAudioCode(UINT32 uCode);
 
                void put_Code(UINT32 uCode)
                {
                        m_uCode = uCode;
                }
                UINT32 get_Code() const
                {
                        return m_uCode;
                }
                bool isValidAudioCode() const
                {
                        return IsValidAudioCode(m_uCode);
                }
                bool isAudioTag3v1() const
                {
                        // Audio Tag ID3v1
                        // m_uCode = TAG* followed by 12 more bytes.
                        if (((BYTE)(m_uCode >> 24)) != 'T')
                                return false;
                        if (((BYTE)(m_uCode >> 16)) != 'A')
                                return false;
                        if (((BYTE)(m_uCode >> 8)) != 'G')
                                return false;
                        return true;
                }
 
                CHANNEL_TYPE get_Channel() const
                {
                        return (CHANNEL_TYPE)(m_uCode & MASK_CHANNEL);
                }
                WORD get_ChannelQty() const
                {
                        return (get_Channel() == CHANNEL_MONO) ? 1 : 2;
                }
                void put_Channel(CHANNEL_TYPE eChan)
                {
                        m_uCode &= ~MASK_CHANNEL;
                        m_uCode |= (eChan & MASK_CHANNEL);
                }
                BITRATE_IDX_TYPE get_BitRateIdx() const
                {
                        return (BITRATE_IDX_TYPE)((m_uCode & MASK_BITRATE) >> SHIFT_BITRATE);
                }
                void put_BitRateIdx(BITRATE_IDX_TYPE idx)
                {
                        m_uCode &= ~MASK_BITRATE;
                        m_uCode |= ((idx << SHIFT_BITRATE) & MASK_BITRATE);
                }
                SAMPLERATE_IDX_TYPE get_SampleRateIdx() const
                {
                        return (SAMPLERATE_IDX_TYPE)((m_uCode & MASK_SAMPLERATE) >> SHIFT_SAMPLERATE);
                }
                void put_SampleRateIdx(SAMPLERATE_IDX_TYPE idx)
                {
                        m_uCode &= ~MASK_SAMPLERATE;
                        m_uCode |= ((idx << SHIFT_SAMPLERATE) & MASK_SAMPLERATE);
                }
                VERSION_TYPE get_Version() const
                {
                        return (VERSION_TYPE)((m_uCode & MASK_VERSION) >> SHIFT_VERSION);
                }
                void put_Version(VERSION_TYPE eVer)
                {
                        m_uCode &= ~MASK_VERSION;
                        m_uCode |= (eVer << SHIFT_VERSION) & MASK_VERSION;
                }
                bool hasProtectionCRC() const
                {
                        return !(m_uCode & MASK_PROTECTION);
                }
 
                // Derived params.
                UINT get_BitRate() const;
                HRESULT put_BitRate(UINT uBitRate);
                UINT get_SampleRate() const;
                HRESULT put_SampleRate(UINT uSampleRate);
 
                UINT get_Samples() const
                {
                        return (get_SampleRate() > 32000) ? 1152 : 576;
                }
                size_t get_SizeBlock() const;
 
                HRESULT GetWaveFormat(cWaveFormat& form) const;
        };
 
        class GRAYLIB_LINK cMP3FileReader : public cAVReader
        {
 
        public:
                cMP3FileReader(cStreamInput& stmIn, cAVSink* pAVSink);
                virtual ~cMP3FileReader();
 
                virtual HRESULT ReadStream() override;
                UNITTEST_FRIEND(cMP3File);
        };
 
        class GRAYLIB_LINK cMP3FileWriter : public cAVSink
        {
        public:
                cStreamOutput* m_pStreamOut;    
 
        public:
                cMP3FileWriter(cStreamOutput* pStreamOut)
                : m_pStreamOut(pStreamOut)
                {
                }
                virtual ~cMP3FileWriter()
                {
                }
 
                virtual HRESULT OnHeaderStream(const cAVHeaderStream& head, const void* pForm, size_t nSizeForm) override;
                virtual HRESULT OnFrame(const cAVHeaderFrame& head, const void* pData, size_t nSizeData) override;
        };
}
#endif