rmfftype.h

linux下的一款播放器

{
    UINT8* off = buf;

    RMPackUINT16(object_version, off);
    if (object_version == 0)
    {
        RMPackUINT32(timestamp, off);
        RMPackUINT32(offset, off);
        RMPackUINT32(num_interleave_packets, off);
    }
    len = off-buf;
    return off;
}

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

    object_version = RMUnpackUINT16(off);
    if (object_version == 0)
    {
        timestamp              = RMUnpackUINT32(off);
        offset                 = RMUnpackUINT32(off);
        num_interleave_packets = RMUnpackUINT32(off);
    }
    return off;
}

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

    RMPackUINT16(object_version, off);
    RMPackUINT16(length, off);
    len = off-buf;
    return off;
}

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

    object_version = RMUnpackUINT16(off);
    length         = RMUnpackUINT16(off);
    return off;
}

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

    RMPackUINT16(object_version, off);
    if (object_version == 0)
    {
        RMPackUINT16(length, off);
        RMPackUINT16(stream_number, off);
        RMPackUINT32(timestamp, off);
        RMPackUINT16(flags, off);
    }
    len = off-buf;
    return off;
}

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

    object_version = RMUnpackUINT16(off);
    if (object_version == 0)
    {
        length        = RMUnpackUINT16(off);
        stream_number = RMUnpackUINT16(off);
        timestamp     = RMUnpackUINT32(off);
        flags         = RMUnpackUINT16(off);
    }
    return off;
}

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

    RMPackUINT16(object_version, off);
    if (object_version == 1)
    {
        RMPackUINT16(length, off);
        RMPackUINT16(stream_number, off);
        RMPackUINT32(timestamp, off);
        RMPackUINT16(asm_rule, off);
        *off++ = asm_flags;
    }
    len = off-buf;
    return off;
}

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

    object_version = RMUnpackUINT16(off);
    if (object_version == 1)
    {
        length        = RMUnpackUINT16(off);
        stream_number = RMUnpackUINT16(off);
        timestamp     = RMUnpackUINT32(off);
        asm_rule      = RMUnpackUINT16(off);
        asm_flags     = *off++;
    }
    return off;
}

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

    RMPackUINT32(object_id, off);
    RMPackUINT32(size, off);
    RMPackUINT16(object_version, off);
    if (object_version == 0)
    {
        RMPackUINT32(Bandwidth, off);
        RMPackUINT32(CpuPower, off);
    }
    len = off-buf;
    return off;
}

HX_INLINE UINT8*
Profile::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)
    {
        Bandwidth = RMUnpackUINT32(off);
        CpuPower  = RMUnpackUINT32(off);
    }
    return off;
}

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

    RMPackUINT16(sequence_number, off);
    RMPackUINT32(start_time_deciseconds, off);
    RMPackUINT32(stop_time_deciseconds, off);
    RMPackUINT16(event_type_and_string_len, off);
    RMPackUINT16(event_type_id, off);
    memcpy(off, event_string, event_type_and_string_len - 2);
    off += event_type_and_string_len - 2;
    len = off-buf;
    return off;
}

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

    sequence_number           = RMUnpackUINT16(off);
    start_time_deciseconds    = RMUnpackUINT32(off);
    stop_time_deciseconds     = RMUnpackUINT32(off);
    event_type_and_string_len = RMUnpackUINT16(off);
    event_type_id             = RMUnpackUINT16(off);
    if (off-buf+(event_type_and_string_len - 2) > (int)len)
	return 0;
    event_string = (UINT8*) off;
    off += event_type_and_string_len - 2;
    return off;
}

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

    RMPackUINT32(start_time, off);
    RMPackUINT32(end_time, off);
    RMPackUINT16(shape, off);
    RMPackUINT16(num_values, off);
    for (int i = 0;  i < num_values; i++)
        RMPackUINT16(values[i], off);
    RMPackUINT16(action, off);
    RMPackUINT32(seek_time, off);
    RMPackUINT16String(url, url_len, off);
    RMPackUINT16String(status, status_len, off);
    len = off-buf;
    return off;
}

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

    start_time = RMUnpackUINT32(off);
    end_time   = RMUnpackUINT32(off);
    shape      = RMUnpackUINT16(off);
    num_values = RMUnpackUINT16(off);
    values     = new UINT16[num_values];
    if (!values) return 0;
    for (int i = 0;  i < num_values; i++)
        values[i] = RMUnpackUINT16(off);
    action    = RMUnpackUINT16(off);
    seek_time = RMUnpackUINT32(off);
    if (!RMUnpackUINT16String(url, url_len, off, buf, len)) return 0;
    if (!RMUnpackUINT16String(status, status_len, off, buf, len)) return 0;
    return off;
}

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

    RMPackUINT16(sequence_number, off);
    RMPackUINT16(num_regions, off);
    RMPackUINT32(start_time, off);
    RMPackUINT32(end_time, off);
    RMPackUINT16(left, off);
    RMPackUINT16(top, off);
    RMPackUINT16(right, off);
    RMPackUINT16(bottom, off);
    for (int i = 0;  i < num_regions; i++)
        off = regions[i].pack(off, len);
    len = off-buf;
    return off;
}

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

    sequence_number = RMUnpackUINT16(off);
    num_regions     = RMUnpackUINT16(off);
    start_time      = RMUnpackUINT32(off);
    end_time        = RMUnpackUINT32(off);
    left            = RMUnpackUINT16(off);
    top             = RMUnpackUINT16(off);
    right           = RMUnpackUINT16(off);
    bottom          = RMUnpackUINT16(off);
    regions = new RMImageMapRegionData[num_regions];
    if (!regions) return 0;
    for (int i = 0;  i < num_regions; i++)
        off = regions[i].unpack(off, len);
    return off;
}

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

    RMPackUINT16(sequence_number, off);
    RMPackUINT16(num_regions, off);
    RMPackUINT32(start_time, off);
    RMPackUINT32(end_time, off);
    RMPackUINT16(left, off);
    RMPackUINT16(top, off);
    RMPackUINT16(right, off);
    RMPackUINT16(bottom, off);
    len = off-buf;
    return off;
}

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

    sequence_number = RMUnpackUINT16(off);
    num_regions     = RMUnpackUINT16(off);
    start_time      = RMUnpackUINT32(off);
    end_time        = RMUnpackUINT32(off);
    left            = RMUnpackUINT16(off);
    top             = RMUnpackUINT16(off);
    right           = RMUnpackUINT16(off);
    bottom          = RMUnpackUINT16(off);
    return off;
}

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

    RMPackUINT16(stream1_num, off);
    RMPackUINT16(stream2_num, off);
    len = off-buf;
    return off;
}

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

    stream1_num = RMUnpackUINT16(off);
    stream2_num = RMUnpackUINT16(off);
    return off;
}

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

    RMPackUINT32(size, off);
    RMPackUINT16(object_version, off);
    RMPackUINT16(num_stream_pairs, off);
    for (int i = 0;  i < num_stream_pairs; i++)
        off = stream_pairs[i].pack(off, len);
    RMPackByteString(stream1_property_name, stream1_property_name_len, off);
    RMPackByteString(stream2_property_name, stream2_property_name_len, off);
    len = off-buf;
    return off;
}

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

    size             = RMUnpackUINT32(off);
    object_version   = RMUnpackUINT16(off);
    num_stream_pairs = RMUnpackUINT16(off);
    stream_pairs = new StreamPair[num_stream_pairs];
    if (!stream_pairs) return 0;
    for (int i = 0;  i < num_stream_pairs; i++)
        off = stream_pairs[i].unpack(off, len);
    if (!RMUnpackByteString(stream1_property_name, stream1_property_name_len, off, buf, len)) return 0;
    if (!RMUnpackByteString(stream2_property_name, stream2_property_name_len, off, buf, len)) return 0;
    return off;
}

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

    RMPackUINT32(size, off);
    RMPackUINT16(object_version, off);
    RMPackUINT16(unPhysicalStreamNumber, off);
    RMPackUINT16(unLogicalStreamNumber, off);
    RMPackUINT32(ulDataOffset, off);
    RMPackUINT32(ulBandwidth, off);
    *off++ = bInterleavedBackwardsCompatible;
    *off++ = bTaggedBackwardsCompatible;
    *off++ = bIncludeAsMultirate;
    *off++ = bOwnsDataSection;
    *off++ = bIgnoreOnWrite;
    len = off-buf;
    return off;
}

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

    size                   = RMUnpackUINT32(off);
    object_version         = RMUnpackUINT16(off);
    unPhysicalStreamNumber = RMUnpackUINT16(off);
    unLogicalStreamNumber  = RMUnpackUINT16(off);
    ulDataOffset           = RMUnpackUINT32(off);
    ulBandwidth            = RMUnpackUINT32(off);
    bInterleavedBackwardsCompatible = *off++;
    bTaggedBackwardsCompatible      = *off++;
    bIncludeAsMultirate             = *off++;
    bOwnsDataSection                = *off++;
    bIgnoreOnWrite                  = *off++;
    return off;
}

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

    RMPackUINT32(size, off);
    RMPackUINT16(object_version, off);
    RMPackUINT16(num_physical_streams, off);
    for (int i = 0;  i < num_physical_streams; i++)
        off = physical_streams[i].pack(off, len);
    len = off-buf;
    return off;
}

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

    size                 = RMUnpackUINT32(off);
    object_version       = RMUnpackUINT16(off);
    num_physical_streams = RMUnpackUINT16(off);
    physical_streams = new PhysicalStreamInfo[num_physical_streams];
    if (!physical_streams) return 0;
    for (int i = 0;  i < num_physical_streams; i++)
        off = physical_streams[i].unpack(off, len);
    return off;
}


HX_INLINE u_int32
get_rm_object_id(Byte* buffer, int buffer_len)
{
    RMGenericHeader	gen_header;
    if (gen_header.unpack(buffer, buffer_len) == 0)
    {
	return 0;
    }
    return gen_header.object_id;
}
#endif //_DEFINE_INLINE


#if (defined( _WIN32 ) || defined( _WINDOWS )) && defined(_M_IX86)
#pragma pack()

//	Restore warnings
#pragma warning( default : 4200 )
#endif
#ifdef _MACINTOSH
#pragma options align=reset
#endif

#endif