rmfftype.h

linux下的一款播放器

    RMPackUINT16(AudioSpecificRevision, off);
    RMPackUINT32(raID, off);
    RMPackUINT32(RaChunkSize, off);
    RMPackUINT16(version, off);
    RMPackUINT16(revision, off);
    RMPackUINT16(headerBytesTotal, off);
    RMPackUINT16(compressionType, off);
    RMPackUINT32(granularity, off);
    RMPackUINT32(bytesTotal, off);
    RMPackUINT32(bytesPerMinute, off);
    RMPackUINT32(bytesPerMinute2, off);
    RMPackUINT16(interleaveFactor, off);
    RMPackUINT16(interleaveBlockSize, off);
    RMPackUINT32(userData, off);
    RMPackUINT32(sampleRate, off);
    RMPackUINT16(sampleSize, off);
    RMPackUINT16(numChannels, off);
    {memcpy(off, InterleaveCode, 5); off += 5; }
    {memcpy(off, CompressionCode, 5); off += 5; }
    *off++ = isInterleaved;
    *off++ = copyByte;
    *off++ = streamType;
    RMPackByteString(title, title_len, off);
    RMPackByteString(author, author_len, off);
    RMPackByteString(copyright, copyright_len, off);
    RMPackByteString(app, app_len, off);
    len = off-buf;
    return off;
}

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

    theID                 = RMUnpackUINT32(off);
    AudioSpecificVersion  = RMUnpackUINT16(off);
    AudioSpecificRevision = RMUnpackUINT16(off);
    raID                  = RMUnpackUINT32(off);
    RaChunkSize           = RMUnpackUINT32(off);
    version               = RMUnpackUINT16(off);
    revision              = RMUnpackUINT16(off);
    headerBytesTotal      = RMUnpackUINT16(off);
    compressionType       = RMUnpackUINT16(off);
    granularity           = RMUnpackUINT32(off);
    bytesTotal            = RMUnpackUINT32(off);
    bytesPerMinute        = RMUnpackUINT32(off);
    bytesPerMinute2       = RMUnpackUINT32(off);
    interleaveFactor      = RMUnpackUINT16(off);
    interleaveBlockSize   = RMUnpackUINT16(off);
    userData              = RMUnpackUINT32(off);
    sampleRate            = RMUnpackUINT32(off);
    sampleSize            = RMUnpackUINT16(off);
    numChannels           = RMUnpackUINT16(off);
    if (off-buf+5 > (int)len)
	return 0;
    {memcpy(InterleaveCode, off, 5); off += 5; }
    if (off-buf+5 > (int)len)
	return 0;
    {memcpy(CompressionCode, off, 5); off += 5; }
    isInterleaved = *off++;
    copyByte      = *off++;
    streamType    = *off++;
    if (!RMUnpackByteString(title, title_len, off, buf, len)) return 0;
    if (!RMUnpackByteString(author, author_len, off, buf, len)) return 0;
    if (!RMUnpackByteString(copyright, copyright_len, off, buf, len)) return 0;
    if (!RMUnpackByteString(app, app_len, off, buf, len)) return 0;
    return off;
}

HX_INLINE VideoTypeSpecificData::VideoTypeSpecificData() :
    cbLength(0),
    moftag(0),
    submoftag(0),
    uiWidth(0),
    uiHeight(0),
    uiBitCount(0),
    uiPadWidth(0),
    uiPadHeight(0),
    framesPerSecond(0),
    ulSPOExtra(0),
    ulStreamVersion(0)
{
}

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

    RMPackUINT32(cbLength, off);
    RMPackUINT32(moftag, off);
    RMPackUINT32(submoftag, off);
    RMPackUINT16(uiWidth, off);
    RMPackUINT16(uiHeight, off);
    RMPackUINT16(uiBitCount, off);
    RMPackUINT16(uiPadWidth, off);
    RMPackUINT16(uiPadHeight, off);
    RMPackUINT32(framesPerSecond, off);
    UINT32 ulBytesPacked = off - buf;
    UINT32 ulBytesLeft   = (len >= ulBytesPacked ? len - ulBytesPacked : 0);
    if (ulBytesLeft >= 8)
    {
        RMPackUINT32(ulSPOExtra, off);
        RMPackUINT32(ulStreamVersion, off);
    }
    len = off-buf;
    return off;
}

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

    cbLength        = RMUnpackUINT32(off);
    moftag          = RMUnpackUINT32(off);
    submoftag       = RMUnpackUINT32(off);
    uiWidth         = RMUnpackUINT16(off);
    uiHeight        = RMUnpackUINT16(off);
    uiBitCount      = RMUnpackUINT16(off);
    uiPadWidth      = RMUnpackUINT16(off);
    uiPadHeight     = RMUnpackUINT16(off);
    framesPerSecond = RMUnpackUINT32(off);
    UINT32 ulBytesParsed = off - buf;
    UINT32 ulBytesLeft   = (len >= ulBytesParsed ? len - ulBytesParsed : 0);
    if (ulBytesLeft >= 8)
    {
        ulSPOExtra      = RMUnpackUINT32(off);
        ulStreamVersion = RMUnpackUINT32(off);
    }
    return off;
}

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

    RMPackUINT32(object_id, off);
    RMPackUINT16(num_rules, off);
    for (int i = 0;  i < num_rules; i++)
        RMPackUINT16(rule_to_header_map[i], off);
    RMPackUINT16(num_headers, off);
    len = off-buf;
    return off;
}

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

    object_id = RMUnpackUINT32(off);
    num_rules = RMUnpackUINT16(off);
    rule_to_header_map = new UINT16[num_rules];
    if (!rule_to_header_map) return 0;
    for (int i = 0;  i < num_rules; i++)
        rule_to_header_map[i] = RMUnpackUINT16(off);
    num_headers = RMUnpackUINT16(off);
    return off;
}

HX_INLINE NameValueProperty::NameValueProperty()
{
    size           = 0;
    object_version = 0;
    name_length    = 0;
    name           = NULL;
    value_length   = 0;
    value_data     = NULL;
}

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

    RMPackUINT32(size, off);
    RMPackUINT16(object_version, off);
    if ((object_version == 0))
    {
        RMPackByteString(name, name_length, off);
        RMPackUINT32(type, off);
        RMPackUINT16String(value_data, value_length, off);
    }
    len = off-buf;
    return off;
}

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

    size = RMUnpackUINT32(off);
    object_version = RMUnpackUINT16(off);
    if ((object_version == 0))
    {
        if (!RMUnpackByteString(name, name_length, off, buf, len)) return 0;
        type = RMUnpackUINT32(off);
        if (!RMUnpackUINT16String(value_data, value_length, off, buf, len)) return 0;
    }
    return off;
}

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

    RMPackUINT32(value, off);
    len = off-buf;
    return off;
}

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

    value = RMUnpackUINT32(off);
    return off;
}

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

    RMPackUINT32(size, off);
    RMPackUINT16(object_version, off);
    if ((object_version == 0))
    {
        RMPackUINT16(num_physical_streams, off);
        int i = 0;
        for (i = 0;  i < num_physical_streams; i++)
            RMPackUINT16(physical_stream_numbers[i], off);
        for (i = 0;  i < num_physical_streams; i++)
            RMPackUINT32(data_offsets[i], off);
        RMPackUINT16(num_rules, off);
        for (i = 0;  i < num_rules; i++)
            RMPackUINT16(rule_to_physical_stream_number_map[i], off);
        RMPackUINT16(num_properties, off);
        for (i = 0;  i < num_properties; i++)
            off = properties[i].pack(off, len);
    }
    len = off-buf;
    return off;
}

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

    size = RMUnpackUINT32(off);
    object_version = RMUnpackUINT16(off);
    if ((object_version == 0))
    {
        num_physical_streams = RMUnpackUINT16(off);
        physical_stream_numbers = new UINT16[num_physical_streams];
        if (!physical_stream_numbers) return 0;
        int i = 0;
        for (i = 0;  i < num_physical_streams; i++)
            physical_stream_numbers[i] = RMUnpackUINT16(off);
        data_offsets = new UINT32[num_physical_streams];
        if (!data_offsets) return 0;
        for (i = 0;  i < num_physical_streams; i++)
            data_offsets[i] = RMUnpackUINT32(off);
        num_rules = RMUnpackUINT16(off);
        rule_to_physical_stream_number_map = new UINT16[num_rules];
        if (!rule_to_physical_stream_number_map) return 0;
        for (i = 0;  i < num_rules; i++)
            rule_to_physical_stream_number_map[i] = RMUnpackUINT16(off);
        num_properties = RMUnpackUINT16(off);
        properties = new NameValueProperty[num_properties];
        if (!properties) return 0;
        for (i = 0;  i < num_properties && off; i++)
            off = properties[i].unpack(off, len);
    }
    return off;
}

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

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

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

    size           = RMUnpackUINT32(off);
    object_version = RMUnpackUINT16(off);
    if (object_version == 0)
    {
        num_properties = RMUnpackUINT16(off);
        properties = new NameValueProperty[num_properties];
        if (!properties) return 0;
        for (int i = 0;  i < num_properties; i++)
            off = properties[i].unpack(off, len);
    }
    return off;
}

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

    RMPackUINT32(object_id, off);
    RMPackUINT32(size, off);
    RMPackUINT16(object_version, off);
    if (object_version == 0)
    {
        RMPackUINT16String(title, title_len, off);
        RMPackUINT16String(author, author_len, off);
        RMPackUINT16String(copyright, copyright_len, off);
        RMPackUINT16String(comment, comment_len, off);
    }
    len = off-buf;
    return off;
}

HX_INLINE UINT8*
Content::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)
    {
        if (!RMUnpackUINT16String(title, title_len, off, buf, len)) return 0;
        if (!RMUnpackUINT16String(author, author_len, off, buf, len)) return 0;
        if (!RMUnpackUINT16String(copyright, copyright_len, off, buf, len)) return 0;
        if (!RMUnpackUINT16String(comment, comment_len, off, buf, len)) return 0;
    }
    return off;
}


//
// BUGBUG
// XXX
// PMC can't generate a declaration for this constructor.
// So, the generated .h file will not build until the
// declaration is added by hand.
//
HX_INLINE
Content::Content()
{
	object_id = 0;
	size = 0;
	object_version = 0;
	title_len = 0;
	title = NULL;
	author_len = 0;
	author = NULL;
	copyright_len = 0;
	copyright = NULL;
	comment_len = 0;
	comment = NULL;
}

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

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

HX_INLINE UINT8*
DataHeader::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)
    {
        num_interleave_packets = RMUnpackUINT32(off);
        next_data_header       = RMUnpackUINT32(off);
    }
    return off;
}

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

    RMPackUINT32(object_id, off);
    RMPackUINT32(size, off);
    RMPackUINT16(object_version, off);
    if (object_version == 0)
    {
        RMPackUINT32(num_indices, off);
        RMPackUINT16(stream_number, off);
        RMPackUINT32(next_index_header, off);
    }
    len = off-buf;
    return off;
}

HX_INLINE UINT8*
IndexHeader::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)
    {
        num_indices       = RMUnpackUINT32(off);
        stream_number     = RMUnpackUINT16(off);
        next_index_header = RMUnpackUINT32(off);
    }
    return off;
}

HX_INLINE UINT8*
IndexRecord::pack(UINT8* buf, UINT32 &len)