rmfftype.h

linux下的一款播放器

class PacketHeader
{
public:
    UINT8*	pack(UINT8* buf, UINT32 &len);
    UINT8*	unpack(UINT8* buf, UINT32 len);
    const UINT32	static_size() {return 12;}

    UINT16	object_version;
    UINT16	length;
    UINT16	stream_number;
    UINT32	timestamp;
    UINT16	flags;
};

typedef PacketHeader * PacketHeaderPtr;
class PacketHeader1
{
public:
    UINT8*	pack(UINT8* buf, UINT32 &len);
    UINT8*	unpack(UINT8* buf, UINT32 len);
    const UINT32	static_size() {return 13;}

    UINT16	object_version;
    UINT16	length;
    UINT16	stream_number;
    UINT32	timestamp;
    UINT16	asm_rule;
    UINT8	asm_flags;
};

class Profile
{
public:
    UINT8*	pack(UINT8* buf, UINT32 &len);
    UINT8*	unpack(UINT8* buf, UINT32 len);
    const UINT32	static_size() {return 18;}

    UINT32	object_id;
    UINT32	size;
    UINT16	object_version;
    UINT32	Bandwidth;
    UINT32	CpuPower;
};

typedef Profile * ProfilePtr;

//
// RMEventPacketData is placed directly after the packet header
// for an event stream inside of an RM file.
// event_type_and_string_len should be set to the length of the
// string plus 2 bytes for the event type.
// Also note that start_time and stop_time in here are in
// deciseconds NOT milliseconds.
//
class RMEventPacketData
{
public:
    UINT8*	pack(UINT8* buf, UINT32 &len);
    UINT8*	unpack(UINT8* buf, UINT32 len);
    const UINT32	static_size() {return 14;}

    UINT16	sequence_number;
    UINT32	start_time_deciseconds;
    UINT32	stop_time_deciseconds;
    UINT16	event_type_and_string_len;
    UINT16	event_type_id;
    UINT8	*event_string;
};

//
// An array of RMImageMapRegionData structures
// is included as part of the raw data for each
// image map packet. The interpretation of num_values
// and values is determined by shape.
//
class RMImageMapRegionData
{
public:
    UINT8*	pack(UINT8* buf, UINT32 &len);
    UINT8*	unpack(UINT8* buf, UINT32 len);
    const UINT32	static_size() {return 22;}

    UINT32	start_time;
    UINT32	end_time;
    UINT16	shape;
    UINT16	num_values;
    UINT16	*values;
    UINT16	action;
    UINT32	seek_time;
    UINT16	url_len;
    UINT8	*url;
    UINT16	status_len;
    UINT8	*status;
};

//
// RMImageMapPacketData, like RMEventPacketData, is placed
// directly after the packet header for an image map stream
// inside of an RM file.
//
class RMImageMapPacketData
{
public:
    UINT8*	pack(UINT8* buf, UINT32 &len);
    UINT8*	unpack(UINT8* buf, UINT32 len);
    const UINT32	static_size() {return 20;}

    UINT16	sequence_number;
    UINT16	num_regions;
    UINT32	start_time;
    UINT32	end_time;
    UINT16	left;
    UINT16	top;
    UINT16	right;
    UINT16	bottom;
    RMImageMapRegionData	*regions;
};

//
// RMBaseImageMapPacketData extracts the basic
// image map data (start, stop, dimensions) without
// actually creating all of the regions on the heap.
//
class RMBaseImageMapPacketData
{
public:
    UINT8*	pack(UINT8* buf, UINT32 &len);
    UINT8*	unpack(UINT8* buf, UINT32 len);
    const UINT32	static_size() {return 20;}

    UINT16	sequence_number;
    UINT16	num_regions;
    UINT32	start_time;
    UINT32	end_time;
    UINT16	left;
    UINT16	top;
    UINT16	right;
    UINT16	bottom;
};

class StreamPair
{
public:
    UINT8*	pack(UINT8* buf, UINT32 &len);
    UINT8*	unpack(UINT8* buf, UINT32 len);
    const UINT32	static_size() {return 4;}

    UINT16	stream1_num;
    UINT16	stream2_num;
};

class StreamPairsHeader
{
public:
    UINT8*	pack(UINT8* buf, UINT32 &len);
    UINT8*	unpack(UINT8* buf, UINT32 len);
    const UINT32	static_size() {return 10;}

    UINT32	size;
    UINT16	object_version;
    UINT16	num_stream_pairs;
    StreamPair	*stream_pairs;
    UINT8	stream1_property_name_len;
    UINT8	*stream1_property_name;
    UINT8	stream2_property_name_len;
    UINT8	*stream2_property_name;
};

class PhysicalStreamInfo
{
public:
    UINT8*	pack(UINT8* buf, UINT32 &len);
    UINT8*	unpack(UINT8* buf, UINT32 len);
    const UINT32	static_size() {return 23;}

    UINT32	size;
    UINT16	object_version;
    UINT16	unPhysicalStreamNumber;
    UINT16	unLogicalStreamNumber;
    UINT32	ulDataOffset;
    UINT32	ulBandwidth;
    UINT8	bInterleavedBackwardsCompatible;
    UINT8	bTaggedBackwardsCompatible;
    UINT8	bIncludeAsMultirate;
    UINT8	bOwnsDataSection;
    UINT8	bIgnoreOnWrite;
};

class PhysicalStreamInfoHeader
{
public:
    UINT8*	pack(UINT8* buf, UINT32 &len);
    UINT8*	unpack(UINT8* buf, UINT32 len);
    const UINT32	static_size() {return 8;}

    UINT32	size;
    UINT16	object_version;
    UINT16	num_physical_streams;
    PhysicalStreamInfo	*physical_streams;
};

void   RMPackUINT32(UINT32 ulValue, UINT8*& rpBuf);
UINT32 RMUnpackUINT32(UINT8*& rpBuf);
void   RMPackUINT16(UINT16 usValue, UINT8*& rpBuf);
UINT16 RMUnpackUINT16(UINT8*& rpBuf);
void   RMPackByteString(UINT8* pStr, UINT8 ucStrSize, UINT8*& rpBuf);
BOOL   RMUnpackByteString(UINT8*& rpStr, UINT8& rucStrSize, UINT8*& rpBuf, UINT8* pBuf, UINT32 ulLen);
void   RMPackUINT16String(UINT8* pStr, UINT16 usStrSize, UINT8*& rpBuf);
BOOL   RMUnpackUINT16String(UINT8*& rpStr, UINT16& rusStrSize, UINT8*& rpBuf, UINT8* pBuf, UINT32 ulLen);
void   RMPackUINT32Buffer(UINT8* pBuffer, UINT32 ulSize, UINT8*& rpBuf);
BOOL   RMUnpackUINT32Buffer(UINT8*& rpBuffer, UINT32& rulSize, UINT8*& rpBuf, UINT8* pBuf, UINT32 ulLen);

#if defined (_DEFINE_INLINE)

HX_INLINE void RMPackUINT32(UINT32 ulValue, UINT8*& rpBuf)
{
    rpBuf[0] = (UINT8) ((ulValue >> 24) & 0x000000FF);
    rpBuf[1] = (UINT8) ((ulValue >> 16) & 0x000000FF);
    rpBuf[2] = (UINT8) ((ulValue >>  8) & 0x000000FF);
    rpBuf[3] = (UINT8) ( ulValue        & 0x000000FF);
    rpBuf   += 4;
}

HX_INLINE UINT32 RMUnpackUINT32(UINT8*& rpBuf)
{
    UINT32 ulRet = (rpBuf[0] << 24) | (rpBuf[1] << 16) | (rpBuf[2] << 8) | rpBuf[3];
    rpBuf       += 4;
    return ulRet;
}

HX_INLINE void RMPackUINT16(UINT16 usValue, UINT8*& rpBuf)
{
    rpBuf[0] = (UINT8) ((usValue >> 8) & 0x00FF);
    rpBuf[1] = (UINT8) ( usValue       & 0x00FF);
    rpBuf   += 2;
}

HX_INLINE UINT16 RMUnpackUINT16(UINT8*& rpBuf)
{
    UINT16 usRet = (rpBuf[0] << 8) | rpBuf[1];
    rpBuf       += 2;
    return usRet;
}

HX_INLINE void RMPackByteString(UINT8* pStr, UINT8 ucStrSize, UINT8*& rpBuf)
{
    *rpBuf++ = ucStrSize;
    memcpy(rpBuf, pStr, ucStrSize);
    rpBuf += ucStrSize;
}

HX_INLINE BOOL RMUnpackByteString(UINT8*& rpStr, UINT8& rucStrSize, UINT8*& rpBuf, UINT8* pBuf, UINT32 ulLen)
{
    rucStrSize = *rpBuf++;
    if (rpBuf-pBuf+rucStrSize > (int)ulLen) return FALSE;
    rpStr =  rpBuf;
    rpBuf += rucStrSize;
    return TRUE;
}

HX_INLINE void RMPackUINT16String(UINT8* pStr, UINT16 usStrSize, UINT8*& rpBuf)
{
    RMPackUINT16(usStrSize, rpBuf);
    memcpy(rpBuf, pStr, usStrSize);
    rpBuf += usStrSize;
}

HX_INLINE BOOL RMUnpackUINT16String(UINT8*& rpStr, UINT16& rusStrSize, UINT8*& rpBuf, UINT8* pBuf, UINT32 ulLen)
{
    rusStrSize = RMUnpackUINT16(rpBuf);
    if (rpBuf-pBuf+rusStrSize > (int)ulLen) return FALSE;
    rpStr =  rpBuf;
    rpBuf += rusStrSize;
    return TRUE;
}

HX_INLINE void RMPackUINT32Buffer(UINT8* pBuffer, UINT32 ulSize, UINT8*& rpBuf)
{
    RMPackUINT32(ulSize, rpBuf);
    memcpy(rpBuf, pBuffer, ulSize);
    rpBuf += ulSize;
}

HX_INLINE BOOL RMUnpackUINT32Buffer(UINT8*& rpBuffer, UINT32& rulSize, UINT8*& rpBuf, UINT8* pBuf, UINT32 ulLen)
{
    rulSize = RMUnpackUINT32(rpBuf);
    if (rpBuf-pBuf+rulSize > (int)ulLen) return FALSE;
    rpBuffer = rpBuf;
    rpBuf   += rulSize;
    return TRUE;
}

HX_INLINE UINT8*
RMGenericHeader::pack(UINT8* buf, UINT32 &len)
{
    UINT8* off = buf;

    RMPackUINT32(object_id, off);
    RMPackUINT32(size, off);
    RMPackUINT16(object_version, off);

    len = off-buf;
    return off;
}

HX_INLINE UINT8*
RMGenericHeader::unpack(UINT8* buf, UINT32 len)
{
    if (!buf || !len)
	return 0;
    UINT8* off = buf;

    object_id      = RMUnpackUINT32(off);
    size           = RMUnpackUINT32(off);
    object_version = RMUnpackUINT16(off);

    return off;
}

HX_INLINE UINT8*
RMFileHeader::pack(UINT8* buf, UINT32 &len)
{
    UINT8* off = buf;

    RMPackUINT32(object_id, off);
    RMPackUINT32(size, off);
    RMPackUINT16(object_version, off);
    if ((object_version == 0) || (object_version == 1))
    {
        RMPackUINT32(file_version, off);
        RMPackUINT32(num_headers, off);
    }
    len = off-buf;
    return off;
}

HX_INLINE UINT8*
RMFileHeader::unpack(UINT8* buf, UINT32 len)
{
    if (!buf || !len)
	return 0;
    UINT8* off = buf;

    object_id      = RMUnpackUINT32(off);
    size           = RMUnpackUINT32(off);
    object_version = RMUnpackUINT16(off);
    if ((object_version == 0) || (object_version == 1))
    {
        file_version = RMUnpackUINT32(off);
        num_headers  = RMUnpackUINT32(off);
    }
    return off;
}


HX_INLINE UINT8*
Properties::pack(UINT8* buf, UINT32 &len)
{
    UINT8* off = buf;

    RMPackUINT32(object_id, off);
    RMPackUINT32(size, off);
    RMPackUINT16(object_version, off);
    if ((object_version == 0))
    {
        RMPackUINT32(max_bit_rate, off);
        RMPackUINT32(avg_bit_rate, off);
        RMPackUINT32(max_packet_size, off);
        RMPackUINT32(avg_packet_size, off);
        RMPackUINT32(num_interleave_packets, off);
        RMPackUINT32(duration, off);
        RMPackUINT32(preroll, off);
        RMPackUINT32(index_offset, off);
        RMPackUINT32(data_offset, off);
        RMPackUINT16(num_streams, off);
        RMPackUINT16(flags, off);
    }
    len = off-buf;
    return off;
}

HX_INLINE UINT8*
Properties::unpack(UINT8* buf, UINT32 len)
{
    if (!buf || !len)
	return 0;
    UINT8* off = buf;

    object_id      = RMUnpackUINT32(off);
    size           = RMUnpackUINT32(off);
    object_version = RMUnpackUINT16(off);
    if ((object_version == 0))
    {
        max_bit_rate           = RMUnpackUINT32(off);
        avg_bit_rate           = RMUnpackUINT32(off);
        max_packet_size        = RMUnpackUINT32(off);
        avg_packet_size        = RMUnpackUINT32(off);
        num_interleave_packets = RMUnpackUINT32(off);
        duration               = RMUnpackUINT32(off);
        preroll                = RMUnpackUINT32(off);
        index_offset           = RMUnpackUINT32(off);
        data_offset            = RMUnpackUINT32(off);
        num_streams            = RMUnpackUINT16(off);
        flags                  = RMUnpackUINT16(off);
    }
    return off;
}


HX_INLINE UINT8*
MediaProperties::pack(UINT8* buf, UINT32 &len)
{
    UINT8* off = buf;

    RMPackUINT32(object_id, off);
    RMPackUINT32(size, off);
    RMPackUINT16(object_version, off);
    if ((object_version == 0))
    {
        RMPackUINT16(stream_number, off);
        RMPackUINT32(max_bit_rate, off);
        RMPackUINT32(avg_bit_rate, off);
        RMPackUINT32(max_packet_size, off);
        RMPackUINT32(avg_packet_size, off);
        RMPackUINT32(start_time, off);
        RMPackUINT32(preroll, off);
        RMPackUINT32(duration, off);
        RMPackByteString(stream_name, stream_name_size, off);
        RMPackByteString(mime_type, mime_type_size, off);
        RMPackUINT32Buffer(type_specific_data, type_specific_len, off);
    }
    len = off-buf;
    return off;
}

HX_INLINE UINT8*
MediaProperties::unpack(UINT8* buf, UINT32 len)
{
    if (!buf || !len)
	return 0;
    UINT8* off = buf;

    object_id      = RMUnpackUINT32(off);
    size           = RMUnpackUINT32(off);
    object_version = RMUnpackUINT16(off);
    if ((object_version == 0))
    {
        stream_number   = RMUnpackUINT16(off);
        max_bit_rate    = RMUnpackUINT32(off);
        avg_bit_rate    = RMUnpackUINT32(off);
        max_packet_size = RMUnpackUINT32(off);
        avg_packet_size = RMUnpackUINT32(off);
        start_time      = RMUnpackUINT32(off);
        preroll         = RMUnpackUINT32(off);
        duration        = RMUnpackUINT32(off);
        if (!RMUnpackByteString(stream_name, stream_name_size, off, buf, len)) return 0;
        if (!RMUnpackByteString(mime_type, mime_type_size, off, buf, len)) return 0;
        if (!RMUnpackUINT32Buffer(type_specific_data, type_specific_len, off, buf, len)) return 0;
    }
    return off;
}

HX_INLINE UINT8*
AudioTypeSpecificData::pack(UINT8* buf, UINT32 &len)
{
    UINT8* off = buf;

    RMPackUINT32(theID, off);
    RMPackUINT16(AudioSpecificVersion, off);