mp3_utils Namespace Reference

Data Structures
struct	TMPEGFrameInfo

Typedefs
typedef t_uint8	byte

Enumerations
enum	{ MPG_MD_STEREO =0, MPG_MD_JOINT_STEREO =1, MPG_MD_DUAL_CHANNEL =2, MPG_MD_MONO =3 }
enum	{ MPEG_1, MPEG_2, MPEG_25 }

Functions
t_uint16	CalculateFrameCRC (const t_uint8 *frameData, t_size frameSize, TMPEGFrameInfo const &frameInfo)
t_uint16	ExtractFrameCRC (const t_uint8 *frameData, t_size frameSize, TMPEGFrameInfo const &frameInfo)
bool	IsSameStream (TMPEGFrameInfo const &p_frame1, TMPEGFrameInfo const &p_frame2)
bool	ParseMPEGFrameHeader (TMPEGFrameInfo &p_info, const t_uint8 p_header[4])
unsigned	QueryMPEGFrameSize (const t_uint8 p_header[4])
void	RecalculateFrameCRC (t_uint8 *frameData, t_size frameSize, TMPEGFrameInfo const &frameInfo)
bool	ValidateFrameCRC (const t_uint8 *frameData, t_size frameSize)
bool	ValidateFrameCRC (const t_uint8 *frameData, t_size frameSize, TMPEGFrameInfo const &frameInfo)

---

Data Structure Documentation

struct mp3_utils::TMPEGFrameInfo

Definition at line 15 of file mp3_utils.h.

Data Fields
unsigned	m_bytes
unsigned	m_channel_mode
unsigned	m_channels
bool	m_crc
unsigned	m_duration
unsigned	m_layer
unsigned	m_mpegversion
unsigned	m_sample_rate

Typedef Documentation

typedef t_uint8 mp3_utils::byte

Definition at line 11 of file mp3_utils.h.

Enumeration Type Documentation

anonymous enum

Enumerator
MPG_MD_STEREO
MPG_MD_JOINT_STEREO
MPG_MD_DUAL_CHANNEL
MPG_MD_MONO

Definition at line 4 of file mp3_utils.h.

         {
        MPG_MD_STEREO=0,
        MPG_MD_JOINT_STEREO=1,
        MPG_MD_DUAL_CHANNEL=2,
        MPG_MD_MONO=3,
    };

anonymous enum

Enumerator
MPEG_1
MPEG_2
MPEG_25

Definition at line 13 of file mp3_utils.h.

{MPEG_1, MPEG_2, MPEG_25};

Function Documentation

t_uint16 mp3_utils::CalculateFrameCRC	(	const t_uint8 *	frameData,
		t_size	frameSize,
		TMPEGFrameInfo const &	frameInfo
	)

Assumes valid frame with CRC (frameInfo.m_crc set, frameInfo.m_bytes <= frameSize).

Definition at line 238 of file mp3_utils.cpp.

                                                                                                              {
    PFC_ASSERT( frameSize >= info.m_bytes && info.m_crc );

    t_size sideInfoLen = 0;
    if (info.m_mpegversion == MPEG_1)
        sideInfoLen = (info.m_channels == 1) ? 4 + 17 : 4 + 32;
    else
        sideInfoLen = (info.m_channels == 1) ? 4 + 9 : 4 + 17;

    //CRC
    sideInfoLen += 2;

    PFC_ASSERT( sideInfoLen  <= frameSize );

    return grabFrameCRC(frameData, sideInfoLen);
}

t_uint16 mp3_utils::ExtractFrameCRC	(	const t_uint8 *	frameData,
		t_size	frameSize,
		TMPEGFrameInfo const &	frameInfo
	)

Assumes valid frame with CRC (frameInfo.m_crc set, frameInfo.m_bytes <= frameSize).

Definition at line 232 of file mp3_utils.cpp.

                                                                                                            {
    PFC_ASSERT( frameSize >= info.m_bytes && info.m_crc );

    return ((t_uint16)frameData[4] << 8) | (t_uint16)frameData[5];

}

bool mp3_utils::IsSameStream	(	TMPEGFrameInfo const &	p_frame1,
		TMPEGFrameInfo const &	p_frame2
	)

Definition at line 183 of file mp3_utils.cpp.

                                                                                            {
    return 
        p_frame1.m_channel_mode == p_frame2.m_channel_mode && 
        p_frame1.m_sample_rate == p_frame2.m_sample_rate &&
        p_frame1.m_layer == p_frame2.m_layer &&
        p_frame1.m_mpegversion == p_frame2.m_mpegversion;
}

bool mp3_utils::ParseMPEGFrameHeader	(	TMPEGFrameInfo &	p_info,
		const t_uint8	p_header[4]
	)

Definition at line 48 of file mp3_utils.cpp.

{
    enum {MPEG_LAYER_1 = 3, MPEG_LAYER_2 = 2, MPEG_LAYER_3 = 1};
    enum {_MPEG_1 = 3, _MPEG_2 = 2, _MPEG_25 = 0};

    header_parser parser(p_header);
    if (parser.read(11) != 0x7FF) return false;
    unsigned mpeg_version = parser.read(2);
    unsigned layer = parser.read(2);
    unsigned protection = parser.read(1);
    unsigned bitrate_index = parser.read(4);
    unsigned sample_rate_index = parser.read(2);
    if (sample_rate_index == 3) return false;//reserved
    unsigned paddingbit = parser.read(1);
    int paddingdelta = 0;
    parser.read(1);//private
    unsigned channel_mode = parser.read(2);
    parser.read(2);//channel_mode_extension
    parser.read(1);//copyright
    parser.read(1);//original
    parser.read(2);//emphasis

    unsigned bitrate = 0,sample_rate = 0;

    switch(layer)
    {
    default:
        return false;
    case MPEG_LAYER_3:
        paddingdelta = paddingbit ? 1 : 0;
        
        p_info.m_layer = 3;
        switch(mpeg_version)
        {
        case _MPEG_1:
            p_info.m_duration = 1152;
            bitrate = bitrate_table_l3v1[bitrate_index];
            break;
        case _MPEG_2:
        case _MPEG_25:
            p_info.m_duration = 576;
            bitrate = bitrate_table_l23v2[bitrate_index];
            break;
        default:
            return false;
        }
    
        break;
    case MPEG_LAYER_2:
        paddingdelta = paddingbit ? 1 : 0;
        p_info.m_duration = 1152;
        p_info.m_layer = 2;
        switch(mpeg_version)
        {
        case _MPEG_1:
            bitrate = bitrate_table_l2v1[bitrate_index];
            break;
        case _MPEG_2:
        case _MPEG_25:
            bitrate = bitrate_table_l23v2[bitrate_index];
            break;
        default:
            return false;
        }
        break;
    case MPEG_LAYER_1:
        paddingdelta = paddingbit ? 4 : 0;
        p_info.m_duration = 384;
        p_info.m_layer = 1;
        switch(mpeg_version)
        {
        case _MPEG_1:
            bitrate = bitrate_table_l1v1[bitrate_index];
            break;
        case _MPEG_2:
        case _MPEG_25:
            bitrate = bitrate_table_l1v2[bitrate_index];
            break;      
        default:
            return false;
        }
        break;
    }
    if (bitrate == 0) return false;

    sample_rate = sample_rate_table[sample_rate_index];
    if (sample_rate == 0) return false;
    switch(mpeg_version)
    {
    case _MPEG_1:
        sample_rate *= 4;
        p_info.m_mpegversion = MPEG_1;
        break;
    case _MPEG_2:
        sample_rate *= 2;
        p_info.m_mpegversion = MPEG_2;
        break;
    case _MPEG_25:
        p_info.m_mpegversion = MPEG_25;
        break;
    }

    switch(channel_mode)
    {
    case 0:
    case 1:
    case 2:
        p_info.m_channels = 2;
        break;
    case 3:
        p_info.m_channels = 1;
        break;
    }

    p_info.m_channel_mode = channel_mode;

    p_info.m_sample_rate = sample_rate;


    p_info.m_bytes = ( bitrate /*kbps*/ * (1000/8) /* kbps-to-bytes*/ * p_info.m_duration /*samples-per-frame*/ ) / sample_rate + paddingdelta;

    if (p_info.m_layer == 1) p_info.m_bytes &= ~3;

    p_info.m_crc = protection == 0;

    return true;
}

unsigned mp3_utils::QueryMPEGFrameSize

(

const t_uint8

p_header[4]

)

Definition at line 41 of file mp3_utils.cpp.

{
    TMPEGFrameInfo info;
    if (!ParseMPEGFrameHeader(info,p_header)) return 0;
    return info.m_bytes;
}

void mp3_utils::RecalculateFrameCRC	(	t_uint8 *	frameData,
		t_size	frameSize,
		TMPEGFrameInfo const &	frameInfo
	)

Assumes valid frame with CRC (frameInfo.m_crc set, frameInfo.m_bytes <= frameSize).

Definition at line 213 of file mp3_utils.cpp.

                                                                                                      {
    PFC_ASSERT( frameSize >= info.m_bytes && info.m_crc );

    const t_uint16 crc = CalculateFrameCRC(frameData, frameSize, info);
    frameData[4] = (t_uint8)(crc >> 8);
    frameData[5] = (t_uint8)(crc & 0xFF);
}

bool mp3_utils::ValidateFrameCRC	(	const t_uint8 *	frameData,
		t_size	frameSize
	)

Definition at line 256 of file mp3_utils.cpp.

                                                                            {
    if (frameSize < 4) return false; //FAIL, not a valid frame
    TMPEGFrameInfo info;
    if (!ParseMPEGFrameHeader(info, frameData)) return false; //FAIL, not a valid frame
    return ValidateFrameCRC(frameData, frameSize, info);
}

bool mp3_utils::ValidateFrameCRC	(	const t_uint8 *	frameData,
		t_size	frameSize,
		TMPEGFrameInfo const &	frameInfo
	)

Definition at line 193 of file mp3_utils.cpp.

                                                                                                         {
    if (frameSize < info.m_bytes) return false; //FAIL, incomplete data
    if (!info.m_crc) return true; //nothing to check, frame appears valid
    return ExtractFrameCRC(frameData, frameSize, info) == CalculateFrameCRC(frameData, frameSize, info);
}