开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
rmfftype.h
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：49k
源码类别：

Symbian

开发平台：

Visual C++

rmfftype.h：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: rmfftype.h,v 1.5.8.4 2004/07/09 01:45:13 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #ifndef PMC_PREDEFINED_TYPES
  51. #define PMC_PREDEFINED_TYPES
  53. typedef char* pmc_string;
  55. struct buffer {
  56.  UINT32 len;
  57.  INT8* data;
  58. };
  59. #endif/*PMC_PREDEFINED_TYPES*/
  61. // realvideo cooment...
  62. // one more RV comment.....
  63. #ifndef _RMFFTYPES_
  64. #define _RMFFTYPES_
  66. #if !(defined REAL_MEDIA_FILE_SERVER_PORT)
  67. #include "hxtypes.h"
  68. #else
  69. #include "machdep.h"
  70. #include "types.h"
  71. #endif /* !(defined REAL_MEDIA_FILE_SERVER_PORT) */
  72. #include <string.h> // for memcpy's
  74. #include "rule2flg.h" // /For class RuleToFlagMap
  76. #if (!defined(_BEOS))
  77. #define int8 char
  78. #define int16 INT16
  79. #define int32 LONG32
  80. #endif
  81. #define u_int8 UCHAR
  82. #define u_int16 UINT16
  83. #define u_int32 ULONG32
  86. // Event stuff
  87. #define RAE_FILE_VERSION 2
  88. #define RAE_FILE_MAGIC_SIZE 5
  89. #define RAE_FILE_VERSION_SIZE 2     
  90. #define RAE_FILE_HEADER_SIZE (RAE_FILE_MAGIC_SIZE + RAE_FILE_VERSION_SIZE)
  91. #define RAE_EVENT_HEADER_SIZE (sizeof(ULONG32) + sizeof(ULONG32) + sizeof(UINT16))
  93. #define RA_MEDIA_DATA 0x4D444941 // 'MDIA'
  94. #define RA_EVENT_DATA 0x45564E54 //  'EVNT'
  97. #define RM_HEADER_OBJECT 0x2E524D46 // '.RMF' 
  98. #define RMS_HEADER_OBJECT 0x2E524D53 // '.RMS' 
  99. #define RM_PROPERTIES_OBJECT 0x50524F50 // 'PROP' 
  100. #define RM_MEDIA_PROPERTIES_OBJECT 0x4D445052 // 'MDPR' 
  101. #define RM_CONTENT_OBJECT 0x434F4E54 // 'CONT' 
  102. #define RM_DATA_OBJECT 0x44415441 // 'DATA' 
  103. #define RM_INDEX_OBJECT 0x494E4458 // 'INDX'  // 'DATA' 
  104. #define RM_MULTIHEADER_OBJECT 0x4D4C5449 // 'MLTI'
  106. #define RM_FILE_OBJECT_VERSION 0
  107. #define RM_PROPERTIES_OBJECT_VERSION 0
  108. #define RM_MEDIAPROPERTIES_OBJECT_VERSION 0
  109. #define RM_CONTENT_OBJECT_VERSION 0
  110. #define RM_DATA_OBJECT_VERSION 0
  111. #define RM_INDEX_OBJECT_VERSION 0
  112. #define RM_PACKET_OBJECT_VERSION 0
  113. #define RM_INDEXRECORD_OBJECT_VERSION 0
  116. #define HX_SAVE_ENABLED 0x0001
  117. #define HX_PERFECT_PLAY_ENABLED 0x0002
  118. #define HX_LIVE_BROADCAST 0x0004
  119. #define HX_MOBILE_PLAY_ENABLED 0x0008
  121. #if (defined( _WIN32 ) || defined( _WINDOWS )) && defined(_M_IX86)
  122. #pragma pack(1)
  123. // disable warning on: zero-sized array in struct/union
  124. #pragma warning( disable : 4200 )
  125. #endif
  127. #ifdef _MACINTOSH
  128. // modify packing of VideoTypeSpecificData to match 
  129. // hxcodec.h's packing of HX_FORMAT_VIDEO
  130. // cr grobbinsky cf rlovejoy
  131. #pragma options align=mac68k
  132. #endif
  134. #include "hxinline.h"
  136. class RMGenericHeader
  137. {
  138. public:
  139.     UINT8* pack(UINT8* buf, UINT32 &len);
  140.     UINT8* unpack(UINT8* buf, UINT32 len);
  141.     const UINT32 static_size() {return 10;}
  143.     UINT32 object_id;
  144.     UINT32 size;
  145.     UINT16 object_version;
  146. };
  148. typedef RMGenericHeader * RMGenericHeaderPtr;
  149. class RMFileHeader
  150. {
  151. public:
  152.     UINT8* pack(UINT8* buf, UINT32 &len);
  153.     UINT8* unpack(UINT8* buf, UINT32 len);
  154.     const UINT32 static_size() {return 18;}
  156.     UINT32 object_id;
  157.     UINT32 size;
  158.     UINT16 object_version;
  159.     UINT32 file_version;
  160.     UINT32 num_headers;
  161. };
  163. typedef RMFileHeader * RMFileHeaderPtr;
  164. class Properties
  165. {
  166. public:
  167.     UINT8* pack(UINT8* buf, UINT32 &len);
  168.     UINT8* unpack(UINT8* buf, UINT32 len);
  169.     const UINT32 static_size() {return 50;}
  171.     UINT32 object_id;
  172.     UINT32 size;
  173.     UINT16 object_version;
  174.     UINT32 max_bit_rate;
  175.     UINT32 avg_bit_rate;
  176.     UINT32 max_packet_size;
  177.     UINT32 avg_packet_size;
  178.     UINT32 num_interleave_packets;
  179.     UINT32 duration;
  180.     UINT32 preroll;
  181.     UINT32 index_offset;
  182.     UINT32 data_offset;
  183.     UINT16 num_streams;
  184.     UINT16 flags;
  185. };
  187. typedef Properties * PropertiesPtr;
  188. class MediaProperties
  189. {
  190. public:
  191.     UINT8* pack(UINT8* buf, UINT32 &len);
  192.     UINT8* unpack(UINT8* buf, UINT32 len);
  193.     const UINT32 static_size() {return 46;}
  195.     UINT32 object_id;
  196.     UINT32 size;
  197.     UINT16 object_version;
  198.     UINT16 stream_number;
  199.     UINT32 max_bit_rate;
  200.     UINT32 avg_bit_rate;
  201.     UINT32 max_packet_size;
  202.     UINT32 avg_packet_size;
  203.     UINT32 start_time;
  204.     UINT32 preroll;
  205.     UINT32 duration;
  206.     UINT8 stream_name_size;
  207.     UINT8 *stream_name;
  208.     UINT8 mime_type_size;
  209.     UINT8 *mime_type;
  210.     UINT32 type_specific_len;
  211.     UINT8 *type_specific_data;
  212. };
  214. typedef MediaProperties * MediaPropertiesPtr;
  216. //
  217. // Can be used to crack open ra4 type specific
  218. // data. Might also work on a portion of ra5
  219. // data as well, but I would not count on it.
  220. // Should be using classes defined over in
  221. // raform4.pm instead.
  222. //
  223. class AudioTypeSpecificData
  224. {
  225. public:
  226.     UINT8* pack(UINT8* buf, UINT32 &len);
  227.     UINT8* unpack(UINT8* buf, UINT32 len);
  228.     const UINT32 static_size() {return 73;}
  230.     UINT32 theID;
  231.     UINT16 AudioSpecificVersion;
  232.     UINT16 AudioSpecificRevision;
  233.     UINT32 raID;
  234.     UINT32 RaChunkSize;
  235.     UINT16 version;
  236.     UINT16 revision;
  237.     UINT16 headerBytesTotal;
  238.     UINT16 compressionType;
  239.     UINT32 granularity;
  240.     UINT32 bytesTotal;
  241.     UINT32 bytesPerMinute;
  242.     UINT32 bytesPerMinute2;
  243.     UINT16 interleaveFactor;
  244.     UINT16 interleaveBlockSize;
  245.     UINT32 userData;
  246.     UINT32 sampleRate;
  247.     UINT16 sampleSize;
  248.     UINT16 numChannels;
  249.     UINT8 InterleaveCode[5];
  250.     UINT8 CompressionCode[5];
  251.     UINT8 isInterleaved;
  252.     UINT8 copyByte;
  253.     UINT8 streamType;
  254.     UINT8 title_len;
  255.     UINT8 *title;
  256.     UINT8 author_len;
  257.     UINT8 *author;
  258.     UINT8 copyright_len;
  259.     UINT8 *copyright;
  260.     UINT8 app_len;
  261.     UINT8 *app;
  262. };
  264. class VideoTypeSpecificData
  265. {
  266. public:
  267.     VideoTypeSpecificData();
  269.     UINT8* pack(UINT8* buf, UINT32 &len);
  270.     UINT8* unpack(UINT8* buf, UINT32 len);
  271.     const UINT32 static_size() {return 26;}
  273.     UINT32 cbLength;
  274.     UINT32 moftag;
  275.     UINT32 submoftag;
  276.     UINT16 uiWidth;
  277.     UINT16 uiHeight;
  278.     UINT16 uiBitCount;
  279.     UINT16 uiPadWidth;
  280.     UINT16 uiPadHeight;
  281.     UINT32 framesPerSecond;
  282.     UINT32      ulSPOExtra;
  283.     UINT32      ulStreamVersion;
  284. };
  286. class MultiStreamHeader
  287. {
  288. public:
  289.     UINT8* pack(UINT8* buf, UINT32 &len);
  290.     UINT8* unpack(UINT8* buf, UINT32 len);
  291.     const UINT32 static_size() {return 8;}
  293.     UINT32 object_id;
  294.     UINT16 num_rules;
  295.     UINT16 *rule_to_header_map;
  296.     UINT16 num_headers;
  297. };
  299. class NameValueProperty
  300. {
  301. public:
  302.     NameValueProperty();
  303.     UINT8* pack(UINT8* buf, UINT32 &len);
  304.     UINT8* unpack(UINT8* buf, UINT32 len);
  305.     const UINT32 static_size() {return 13;}
  307.     UINT32 size;
  308.     UINT16 object_version;
  309.     UINT8 name_length;
  310.     UINT8 *name;
  311.     UINT32 type;
  312.     UINT16 value_length;
  313.     UINT8 *value_data;
  314. };
  316. //
  317. // Use this for packing/unpacking
  318. // a single 32 bit integer.
  319. //
  321. class Unsigned32BitInteger
  322. {
  323. public:
  324.     UINT8* pack(UINT8* buf, UINT32 &len);
  325.     UINT8* unpack(UINT8* buf, UINT32 len);
  326.     const UINT32 static_size() {return 4;}
  328.     UINT32 value;
  329. };
  331. //
  332. // enum defining valid values for "type" in
  333. // NameValueProperty structure
  334. //
  336. enum
  337. {
  338. PROP_INTEGER,
  339. PROP_BUFFER,
  340. PROP_STRING
  341. };
  343. class LogicalStream
  344. {
  345. public:
  346.     UINT8* pack(UINT8* buf, UINT32 &len);
  347.     UINT8* unpack(UINT8* buf, UINT32 len);
  348.     const UINT32 static_size() {return 12;}
  350.     UINT32 size;
  351.     UINT16 object_version;
  352.     UINT16 num_physical_streams;
  353.     UINT16 *physical_stream_numbers;
  354.     UINT32 *data_offsets;
  355.     UINT16 num_rules;
  356.     UINT16 *rule_to_physical_stream_number_map;
  357.     UINT16 num_properties;
  358.     NameValueProperty *properties;
  359. };
  361. class MetaInformation
  362. {
  363. public:
  364.     UINT8* pack(UINT8* buf, UINT32 &len);
  365.     UINT8* unpack(UINT8* buf, UINT32 len);
  366.     const UINT32 static_size() {return 8;}
  368.     UINT32 size;
  369.     UINT16 object_version;
  370.     UINT16 num_properties;
  371.     NameValueProperty *properties;
  372. };
  374. //
  375. // BUGBUG
  376. // XXX
  377. // PMC can't generate a declaration for this constructor.
  378. // So, the generated .h file will not build until the
  379. // declaration is added by hand.
  380. //
  381. class Content
  382. {
  383. public:
  384.     Content();
  385.     UINT8* pack(UINT8* buf, UINT32 &len);
  386.     UINT8* unpack(UINT8* buf, UINT32 len);
  387.     const UINT32 static_size() {return 18;}
  389.     UINT32 object_id;
  390.     UINT32 size;
  391.     UINT16 object_version;
  392.     UINT16 title_len;
  393.     UINT8 *title;
  394.     UINT16 author_len;
  395.     UINT8 *author;
  396.     UINT16 copyright_len;
  397.     UINT8 *copyright;
  398.     UINT16 comment_len;
  399.     UINT8 *comment;
  400. };
  402. typedef  Content * ContentPtr;
  403. class DataHeader
  404. {
  405. public:
  406.     UINT8* pack(UINT8* buf, UINT32 &len);
  407.     UINT8* unpack(UINT8* buf, UINT32 len);
  408.     const UINT32 static_size() {return 18;}
  410.     UINT32 object_id;
  411.     UINT32 size;
  412.     UINT16 object_version;
  413.     UINT32 num_interleave_packets;
  414.     UINT32 next_data_header;
  415. };
  417. typedef DataHeader * DataHeaderPtr;
  418. class IndexHeader
  419. {
  420. public:
  421.     UINT8* pack(UINT8* buf, UINT32 &len);
  422.     UINT8* unpack(UINT8* buf, UINT32 len);
  423.     const UINT32 static_size() {return 20;}
  425.     UINT32 object_id;
  426.     UINT32 size;
  427.     UINT16 object_version;
  428.     UINT32 num_indices;
  429.     UINT16 stream_number;
  430.     UINT32 next_index_header;
  431. };
  433. typedef IndexHeader * IndexHeaderPtr;
  434. class IndexRecord
  435. {
  436. public:
  437.     UINT8* pack(UINT8* buf, UINT32 &len);
  438.     UINT8* unpack(UINT8* buf, UINT32 len);
  439.     const UINT32 static_size() {return 14;}
  441.     UINT16 object_version;
  442.     UINT32 timestamp;
  443.     UINT32 offset;
  444.     UINT32 num_interleave_packets;
  445. };
  447. typedef IndexRecord * IndexRecordPtr;
  449. //
  450. // The PacketHeader has changed with version 1.
  451. // So, there are a couple of new structures.
  452. // Use PacketHeaderBase to figure out what
  453. // packet version/size you've got, and then
  454. // create the appropriate PacketHeader version
  455. // struct to really unpack the buffer. We could
  456. // also have done this by embedding if (object_version == xx)
  457. // into the PacketHeader struct, but this lets us
  458. // use the static_size() function to get the
  459. // actual packed size of the struct in question.
  460. //
  461. class PacketHeaderBase
  462. {
  463. public:
  464.     UINT8* pack(UINT8* buf, UINT32 &len);
  465.     UINT8* unpack(UINT8* buf, UINT32 len);
  466.     const UINT32 static_size() {return 4;}
  468.     UINT16 object_version;
  469.     UINT16 length;
  470. };
  472. class PacketHeader
  473. {
  474. public:
  475.     UINT8* pack(UINT8* buf, UINT32 &len);
  476.     UINT8* unpack(UINT8* buf, UINT32 len);
  477.     const UINT32 static_size() {return 12;}
  479.     UINT16 object_version;
  480.     UINT16 length;
  481.     UINT16 stream_number;
  482.     UINT32 timestamp;
  483.     UINT16 flags;
  484. };
  486. typedef PacketHeader * PacketHeaderPtr;
  487. class PacketHeader1
  488. {
  489. public:
  490.     UINT8* pack(UINT8* buf, UINT32 &len);
  491.     UINT8* unpack(UINT8* buf, UINT32 len);
  492.     const UINT32 static_size() {return 13;}
  494.     UINT16 object_version;
  495.     UINT16 length;
  496.     UINT16 stream_number;
  497.     UINT32 timestamp;
  498.     UINT16 asm_rule;
  499.     UINT8 asm_flags;
  500. };
  502. class Profile
  503. {
  504. public:
  505.     UINT8* pack(UINT8* buf, UINT32 &len);
  506.     UINT8* unpack(UINT8* buf, UINT32 len);
  507.     const UINT32 static_size() {return 18;}
  509.     UINT32 object_id;
  510.     UINT32 size;
  511.     UINT16 object_version;
  512.     UINT32 Bandwidth;
  513.     UINT32 CpuPower;
  514. };
  516. typedef Profile * ProfilePtr;
  518. //
  519. // RMEventPacketData is placed directly after the packet header
  520. // for an event stream inside of an RM file.
  521. // event_type_and_string_len should be set to the length of the
  522. // string plus 2 bytes for the event type.
  523. // Also note that start_time and stop_time in here are in
  524. // deciseconds NOT milliseconds.
  525. //
  526. class RMEventPacketData
  527. {
  528. public:
  529.     UINT8* pack(UINT8* buf, UINT32 &len);
  530.     UINT8* unpack(UINT8* buf, UINT32 len);
  531.     const UINT32 static_size() {return 14;}
  533.     UINT16 sequence_number;
  534.     UINT32 start_time_deciseconds;
  535.     UINT32 stop_time_deciseconds;
  536.     UINT16 event_type_and_string_len;
  537.     UINT16 event_type_id;
  538.     UINT8 *event_string;
  539. };
  541. //
  542. // An array of RMImageMapRegionData structures
  543. // is included as part of the raw data for each
  544. // image map packet. The interpretation of num_values
  545. // and values is determined by shape.
  546. //
  547. class RMImageMapRegionData
  548. {
  549. public:
  550.     UINT8* pack(UINT8* buf, UINT32 &len);
  551.     UINT8* unpack(UINT8* buf, UINT32 len);
  552.     const UINT32 static_size() {return 22;}
  554.     UINT32 start_time;
  555.     UINT32 end_time;
  556.     UINT16 shape;
  557.     UINT16 num_values;
  558.     UINT16 *values;
  559.     UINT16 action;
  560.     UINT32 seek_time;
  561.     UINT16 url_len;
  562.     UINT8 *url;
  563.     UINT16 status_len;
  564.     UINT8 *status;
  565. };
  567. //
  568. // RMImageMapPacketData, like RMEventPacketData, is placed
  569. // directly after the packet header for an image map stream
  570. // inside of an RM file.
  571. //
  572. class RMImageMapPacketData
  573. {
  574. public:
  575.     UINT8* pack(UINT8* buf, UINT32 &len);
  576.     UINT8* unpack(UINT8* buf, UINT32 len);
  577.     const UINT32 static_size() {return 20;}
  579.     UINT16 sequence_number;
  580.     UINT16 num_regions;
  581.     UINT32 start_time;
  582.     UINT32 end_time;
  583.     UINT16 left;
  584.     UINT16 top;
  585.     UINT16 right;
  586.     UINT16 bottom;
  587.     RMImageMapRegionData *regions;
  588. };
  590. //
  591. // RMBaseImageMapPacketData extracts the basic
  592. // image map data (start, stop, dimensions) without
  593. // actually creating all of the regions on the heap.
  594. //
  595. class RMBaseImageMapPacketData
  596. {
  597. public:
  598.     UINT8* pack(UINT8* buf, UINT32 &len);
  599.     UINT8* unpack(UINT8* buf, UINT32 len);
  600.     const UINT32 static_size() {return 20;}
  602.     UINT16 sequence_number;
  603.     UINT16 num_regions;
  604.     UINT32 start_time;
  605.     UINT32 end_time;
  606.     UINT16 left;
  607.     UINT16 top;
  608.     UINT16 right;
  609.     UINT16 bottom;
  610. };
  612. class StreamPair
  613. {
  614. public:
  615.     UINT8* pack(UINT8* buf, UINT32 &len);
  616.     UINT8* unpack(UINT8* buf, UINT32 len);
  617.     const UINT32 static_size() {return 4;}
  619.     UINT16 stream1_num;
  620.     UINT16 stream2_num;
  621. };
  623. class StreamPairsHeader
  624. {
  625. public:
  626.     UINT8* pack(UINT8* buf, UINT32 &len);
  627.     UINT8* unpack(UINT8* buf, UINT32 len);
  628.     const UINT32 static_size() {return 10;}
  630.     UINT32 size;
  631.     UINT16 object_version;
  632.     UINT16 num_stream_pairs;
  633.     StreamPair *stream_pairs;
  634.     UINT8 stream1_property_name_len;
  635.     UINT8 *stream1_property_name;
  636.     UINT8 stream2_property_name_len;
  637.     UINT8 *stream2_property_name;
  638. };
  640. class PhysicalStreamInfo
  641. {
  642. public:
  643.     UINT8* pack(UINT8* buf, UINT32 &len);
  644.     UINT8* unpack(UINT8* buf, UINT32 len);
  645.     const UINT32 static_size() {return 23;}
  647.     UINT32 size;
  648.     UINT16 object_version;
  649.     UINT16 unPhysicalStreamNumber;
  650.     UINT16 unLogicalStreamNumber;
  651.     UINT32 ulDataOffset;
  652.     UINT32 ulBandwidth;
  653.     UINT8 bInterleavedBackwardsCompatible;
  654.     UINT8 bTaggedBackwardsCompatible;
  655.     UINT8 bIncludeAsMultirate;
  656.     UINT8 bOwnsDataSection;
  657.     UINT8 bIgnoreOnWrite;
  658. };
  660. class PhysicalStreamInfoHeader
  661. {
  662. public:
  663.     UINT8* pack(UINT8* buf, UINT32 &len);
  664.     UINT8* unpack(UINT8* buf, UINT32 len);
  665.     const UINT32 static_size() {return 8;}
  667.     UINT32 size;
  668.     UINT16 object_version;
  669.     UINT16 num_physical_streams;
  670.     PhysicalStreamInfo *physical_streams;
  671. };
  673. void   RMPackUINT32(UINT32 ulValue, UINT8*& rpBuf);
  674. UINT32 RMUnpackUINT32(UINT8*& rpBuf);
  675. void   RMPackUINT16(UINT16 usValue, UINT8*& rpBuf);
  676. UINT16 RMUnpackUINT16(UINT8*& rpBuf);
  677. void   RMPackByteString(UINT8* pStr, UINT8 ucStrSize, UINT8*& rpBuf);
  678. BOOL   RMUnpackByteString(UINT8*& rpStr, UINT8& rucStrSize, UINT8*& rpBuf, UINT8* pBuf, UINT32 ulLen);
  679. void   RMPackUINT16String(UINT8* pStr, UINT16 usStrSize, UINT8*& rpBuf);
  680. BOOL   RMUnpackUINT16String(UINT8*& rpStr, UINT16& rusStrSize, UINT8*& rpBuf, UINT8* pBuf, UINT32 ulLen);
  681. void   RMPackUINT32Buffer(UINT8* pBuffer, UINT32 ulSize, UINT8*& rpBuf);
  682. BOOL   RMUnpackUINT32Buffer(UINT8*& rpBuffer, UINT32& rulSize, UINT8*& rpBuf, UINT8* pBuf, UINT32 ulLen);
  684. #if defined (_DEFINE_INLINE)
  686. HX_INLINE void RMPackUINT32(UINT32 ulValue, UINT8*& rpBuf)
  687. {
  688.     rpBuf[0] = (UINT8) ((ulValue >> 24) & 0x000000FF);
  689.     rpBuf[1] = (UINT8) ((ulValue >> 16) & 0x000000FF);
  690.     rpBuf[2] = (UINT8) ((ulValue >>  8) & 0x000000FF);
  691.     rpBuf[3] = (UINT8) ( ulValue        & 0x000000FF);
  692.     rpBuf   += 4;
  693. }
  695. HX_INLINE UINT32 RMUnpackUINT32(UINT8*& rpBuf)
  696. {
  697.     UINT32 ulRet = (rpBuf[0] << 24) | (rpBuf[1] << 16) | (rpBuf[2] << 8) | rpBuf[3];
  698.     rpBuf       += 4;
  699.     return ulRet;
  700. }
  702. HX_INLINE void RMPackUINT16(UINT16 usValue, UINT8*& rpBuf)
  703. {
  704.     rpBuf[0] = (UINT8) ((usValue >> 8) & 0x00FF);
  705.     rpBuf[1] = (UINT8) ( usValue       & 0x00FF);
  706.     rpBuf   += 2;
  707. }
  709. HX_INLINE UINT16 RMUnpackUINT16(UINT8*& rpBuf)
  710. {
  711.     UINT16 usRet = (rpBuf[0] << 8) | rpBuf[1];
  712.     rpBuf       += 2;
  713.     return usRet;
  714. }
  716. HX_INLINE void RMPackByteString(UINT8* pStr, UINT8 ucStrSize, UINT8*& rpBuf)
  717. {
  718.     *rpBuf++ = ucStrSize;
  719.     memcpy(rpBuf, pStr, ucStrSize);
  720.     rpBuf += ucStrSize;
  721. }
  723. HX_INLINE BOOL RMUnpackByteString(UINT8*& rpStr, UINT8& rucStrSize, UINT8*& rpBuf, UINT8* pBuf, UINT32 ulLen)
  724. {
  725.     rucStrSize = *rpBuf++;
  726.     if (rpBuf-pBuf+rucStrSize > (int)ulLen) return FALSE;
  727.     rpStr =  rpBuf;
  728.     rpBuf += rucStrSize;
  729.     return TRUE;
  730. }
  732. HX_INLINE void RMPackUINT16String(UINT8* pStr, UINT16 usStrSize, UINT8*& rpBuf)
  733. {
  734.     RMPackUINT16(usStrSize, rpBuf);
  735.     memcpy(rpBuf, pStr, usStrSize);
  736.     rpBuf += usStrSize;
  737. }
  739. HX_INLINE BOOL RMUnpackUINT16String(UINT8*& rpStr, UINT16& rusStrSize, UINT8*& rpBuf, UINT8* pBuf, UINT32 ulLen)
  740. {
  741.     rusStrSize = RMUnpackUINT16(rpBuf);
  742.     if (rpBuf-pBuf+rusStrSize > (int)ulLen) return FALSE;
  743.     rpStr =  rpBuf;
  744.     rpBuf += rusStrSize;
  745.     return TRUE;
  746. }
  748. HX_INLINE void RMPackUINT32Buffer(UINT8* pBuffer, UINT32 ulSize, UINT8*& rpBuf)
  749. {
  750.     RMPackUINT32(ulSize, rpBuf);
  751.     memcpy(rpBuf, pBuffer, ulSize);
  752.     rpBuf += ulSize;
  753. }
  755. HX_INLINE BOOL RMUnpackUINT32Buffer(UINT8*& rpBuffer, UINT32& rulSize, UINT8*& rpBuf, UINT8* pBuf, UINT32 ulLen)
  756. {
  757.     rulSize = RMUnpackUINT32(rpBuf);
  758.     if (rpBuf-pBuf+rulSize > (int)ulLen) return FALSE;
  759.     rpBuffer = rpBuf;
  760.     rpBuf   += rulSize;
  761.     return TRUE;
  762. }
  764. HX_INLINE UINT8*
  765. RMGenericHeader::pack(UINT8* buf, UINT32 &len)
  766. {
  767.     UINT8* off = buf;
  769.     RMPackUINT32(object_id, off);
  770.     RMPackUINT32(size, off);
  771.     RMPackUINT16(object_version, off);
  773.     len = off-buf;
  774.     return off;
  775. }
  777. HX_INLINE UINT8*
  778. RMGenericHeader::unpack(UINT8* buf, UINT32 len)
  779. {
  780.     if (!buf || !len)
  781. return 0;
  782.     UINT8* off = buf;
  784.     object_id      = RMUnpackUINT32(off);
  785.     size           = RMUnpackUINT32(off);
  786.     object_version = RMUnpackUINT16(off);
  788.     return off;
  789. }
  791. HX_INLINE UINT8*
  792. RMFileHeader::pack(UINT8* buf, UINT32 &len)
  793. {
  794.     UINT8* off = buf;
  796.     RMPackUINT32(object_id, off);
  797.     RMPackUINT32(size, off);
  798.     RMPackUINT16(object_version, off);
  799.     if ((object_version == 0) || (object_version == 1))
  800.     {
  801.         RMPackUINT32(file_version, off);
  802.         RMPackUINT32(num_headers, off);
  803.     }
  804.     len = off-buf;
  805.     return off;
  806. }
  808. HX_INLINE UINT8*
  809. RMFileHeader::unpack(UINT8* buf, UINT32 len)
  810. {
  811.     if (!buf || !len)
  812. return 0;
  813.     UINT8* off = buf;
  815.     object_id      = RMUnpackUINT32(off);
  816.     size           = RMUnpackUINT32(off);
  817.     object_version = RMUnpackUINT16(off);
  818.     if ((object_version == 0) || (object_version == 1))
  819.     {
  820.         file_version = RMUnpackUINT32(off);
  821.         num_headers  = RMUnpackUINT32(off);
  822.     }
  823.     return off;
  824. }
  827. HX_INLINE UINT8*
  828. Properties::pack(UINT8* buf, UINT32 &len)
  829. {
  830.     UINT8* off = buf;
  832.     RMPackUINT32(object_id, off);
  833.     RMPackUINT32(size, off);
  834.     RMPackUINT16(object_version, off);
  835.     if ((object_version == 0))
  836.     {
  837.         RMPackUINT32(max_bit_rate, off);
  838.         RMPackUINT32(avg_bit_rate, off);
  839.         RMPackUINT32(max_packet_size, off);
  840.         RMPackUINT32(avg_packet_size, off);
  841.         RMPackUINT32(num_interleave_packets, off);
  842.         RMPackUINT32(duration, off);
  843.         RMPackUINT32(preroll, off);
  844.         RMPackUINT32(index_offset, off);
  845.         RMPackUINT32(data_offset, off);
  846.         RMPackUINT16(num_streams, off);
  847.         RMPackUINT16(flags, off);
  848.     }
  849.     len = off-buf;
  850.     return off;
  851. }
  853. HX_INLINE UINT8*
  854. Properties::unpack(UINT8* buf, UINT32 len)
  855. {
  856.     if (!buf || !len)
  857. return 0;
  858.     UINT8* off = buf;
  860.     object_id      = RMUnpackUINT32(off);
  861.     size           = RMUnpackUINT32(off);
  862.     object_version = RMUnpackUINT16(off);
  863.     if ((object_version == 0))
  864.     {
  865.         max_bit_rate           = RMUnpackUINT32(off);
  866.         avg_bit_rate           = RMUnpackUINT32(off);
  867.         max_packet_size        = RMUnpackUINT32(off);
  868.         avg_packet_size        = RMUnpackUINT32(off);
  869.         num_interleave_packets = RMUnpackUINT32(off);
  870.         duration               = RMUnpackUINT32(off);
  871.         preroll                = RMUnpackUINT32(off);
  872.         index_offset           = RMUnpackUINT32(off);
  873.         data_offset            = RMUnpackUINT32(off);
  874.         num_streams            = RMUnpackUINT16(off);
  875.         flags                  = RMUnpackUINT16(off);
  876.     }
  877.     return off;
  878. }
  881. HX_INLINE UINT8*
  882. MediaProperties::pack(UINT8* buf, UINT32 &len)
  883. {
  884.     UINT8* off = buf;
  886.     RMPackUINT32(object_id, off);
  887.     RMPackUINT32(size, off);
  888.     RMPackUINT16(object_version, off);
  889.     if ((object_version == 0))
  890.     {
  891.         RMPackUINT16(stream_number, off);
  892.         RMPackUINT32(max_bit_rate, off);
  893.         RMPackUINT32(avg_bit_rate, off);
  894.         RMPackUINT32(max_packet_size, off);
  895.         RMPackUINT32(avg_packet_size, off);
  896.         RMPackUINT32(start_time, off);
  897.         RMPackUINT32(preroll, off);
  898.         RMPackUINT32(duration, off);
  899.         RMPackByteString(stream_name, stream_name_size, off);
  900.         RMPackByteString(mime_type, mime_type_size, off);
  901.         RMPackUINT32Buffer(type_specific_data, type_specific_len, off);
  902.     }
  903.     len = off-buf;
  904.     return off;
  905. }
  907. HX_INLINE UINT8*
  908. MediaProperties::unpack(UINT8* buf, UINT32 len)
  909. {
  910.     if (!buf || !len)
  911. return 0;
  912.     UINT8* off = buf;
  914.     object_id      = RMUnpackUINT32(off);
  915.     size           = RMUnpackUINT32(off);
  916.     object_version = RMUnpackUINT16(off);
  917.     if ((object_version == 0))
  918.     {
  919.         stream_number   = RMUnpackUINT16(off);
  920.         max_bit_rate    = RMUnpackUINT32(off);
  921.         avg_bit_rate    = RMUnpackUINT32(off);
  922.         max_packet_size = RMUnpackUINT32(off);
  923.         avg_packet_size = RMUnpackUINT32(off);
  924.         start_time      = RMUnpackUINT32(off);
  925.         preroll         = RMUnpackUINT32(off);
  926.         duration        = RMUnpackUINT32(off);
  927.         if (!RMUnpackByteString(stream_name, stream_name_size, off, buf, len)) return 0;
  928.         if (!RMUnpackByteString(mime_type, mime_type_size, off, buf, len)) return 0;
  929.         if (!RMUnpackUINT32Buffer(type_specific_data, type_specific_len, off, buf, len)) return 0;
  930.     }
  931.     return off;
  932. }
  934. HX_INLINE UINT8*
  935. AudioTypeSpecificData::pack(UINT8* buf, UINT32 &len)
  936. {
  937.     UINT8* off = buf;
  939.     RMPackUINT32(theID, off);
  940.     RMPackUINT16(AudioSpecificVersion, off);
  941.     RMPackUINT16(AudioSpecificRevision, off);
  942.     RMPackUINT32(raID, off);
  943.     RMPackUINT32(RaChunkSize, off);
  944.     RMPackUINT16(version, off);
  945.     RMPackUINT16(revision, off);
  946.     RMPackUINT16(headerBytesTotal, off);
  947.     RMPackUINT16(compressionType, off);
  948.     RMPackUINT32(granularity, off);
  949.     RMPackUINT32(bytesTotal, off);
  950.     RMPackUINT32(bytesPerMinute, off);
  951.     RMPackUINT32(bytesPerMinute2, off);
  952.     RMPackUINT16(interleaveFactor, off);
  953.     RMPackUINT16(interleaveBlockSize, off);
  954.     RMPackUINT32(userData, off);
  955.     RMPackUINT32(sampleRate, off);
  956.     RMPackUINT16(sampleSize, off);
  957.     RMPackUINT16(numChannels, off);
  958.     {memcpy(off, InterleaveCode, 5); off += 5; }
  959.     {memcpy(off, CompressionCode, 5); off += 5; }
  960.     *off++ = isInterleaved;
  961.     *off++ = copyByte;
  962.     *off++ = streamType;
  963.     RMPackByteString(title, title_len, off);
  964.     RMPackByteString(author, author_len, off);
  965.     RMPackByteString(copyright, copyright_len, off);
  966.     RMPackByteString(app, app_len, off);
  967.     len = off-buf;
  968.     return off;
  969. }
  971. HX_INLINE UINT8*
  972. AudioTypeSpecificData::unpack(UINT8* buf, UINT32 len)
  973. {
  974.     if (!buf || !len)
  975. return 0;
  976.     UINT8* off = buf;
  978.     theID                 = RMUnpackUINT32(off);
  979.     AudioSpecificVersion  = RMUnpackUINT16(off);
  980.     AudioSpecificRevision = RMUnpackUINT16(off);
  981.     raID                  = RMUnpackUINT32(off);
  982.     RaChunkSize           = RMUnpackUINT32(off);
  983.     version               = RMUnpackUINT16(off);
  984.     revision              = RMUnpackUINT16(off);
  985.     headerBytesTotal      = RMUnpackUINT16(off);
  986.     compressionType       = RMUnpackUINT16(off);
  987.     granularity           = RMUnpackUINT32(off);
  988.     bytesTotal            = RMUnpackUINT32(off);
  989.     bytesPerMinute        = RMUnpackUINT32(off);
  990.     bytesPerMinute2       = RMUnpackUINT32(off);
  991.     interleaveFactor      = RMUnpackUINT16(off);
  992.     interleaveBlockSize   = RMUnpackUINT16(off);
  993.     userData              = RMUnpackUINT32(off);
  994.     sampleRate            = RMUnpackUINT32(off);
  995.     sampleSize            = RMUnpackUINT16(off);
  996.     numChannels           = RMUnpackUINT16(off);
  997.     if (off-buf+5 > (int)len)
  998. return 0;
  999.     {memcpy(InterleaveCode, off, 5); off += 5; }
  1000.     if (off-buf+5 > (int)len)
  1001. return 0;
  1002.     {memcpy(CompressionCode, off, 5); off += 5; }
  1003.     isInterleaved = *off++;
  1004.     copyByte      = *off++;
  1005.     streamType    = *off++;
  1006.     if (!RMUnpackByteString(title, title_len, off, buf, len)) return 0;
  1007.     if (!RMUnpackByteString(author, author_len, off, buf, len)) return 0;
  1008.     if (!RMUnpackByteString(copyright, copyright_len, off, buf, len)) return 0;
  1009.     if (!RMUnpackByteString(app, app_len, off, buf, len)) return 0;
  1010.     return off;
  1011. }
  1013. HX_INLINE VideoTypeSpecificData::VideoTypeSpecificData() :
  1014.     cbLength(0),
  1015.     moftag(0),
  1016.     submoftag(0),
  1017.     uiWidth(0),
  1018.     uiHeight(0),
  1019.     uiBitCount(0),
  1020.     uiPadWidth(0),
  1021.     uiPadHeight(0),
  1022.     framesPerSecond(0),
  1023.     ulSPOExtra(0),
  1024.     ulStreamVersion(0)
  1025. {
  1026. }
  1028. HX_INLINE UINT8*
  1029. VideoTypeSpecificData::pack(UINT8* buf, UINT32 &len)
  1030. {
  1031.     UINT8* off = buf;
  1033.     RMPackUINT32(cbLength, off);
  1034.     RMPackUINT32(moftag, off);
  1035.     RMPackUINT32(submoftag, off);
  1036.     RMPackUINT16(uiWidth, off);
  1037.     RMPackUINT16(uiHeight, off);
  1038.     RMPackUINT16(uiBitCount, off);
  1039.     RMPackUINT16(uiPadWidth, off);
  1040.     RMPackUINT16(uiPadHeight, off);
  1041.     RMPackUINT32(framesPerSecond, off);
  1042.     UINT32 ulBytesPacked = off - buf;
  1043.     UINT32 ulBytesLeft   = (len >= ulBytesPacked ? len - ulBytesPacked : 0);
  1044.     if (ulBytesLeft >= 8)
  1045.     {
  1046.         RMPackUINT32(ulSPOExtra, off);
  1047.         RMPackUINT32(ulStreamVersion, off);
  1048.     }
  1049.     len = off-buf;
  1050.     return off;
  1051. }
  1053. HX_INLINE UINT8*
  1054. VideoTypeSpecificData::unpack(UINT8* buf, UINT32 len)
  1055. {
  1056.     if (!buf || !len)
  1057. return 0;
  1058.     UINT8* off = buf;
  1060.     cbLength        = RMUnpackUINT32(off);
  1061.     moftag          = RMUnpackUINT32(off);
  1062.     submoftag       = RMUnpackUINT32(off);
  1063.     uiWidth         = RMUnpackUINT16(off);
  1064.     uiHeight        = RMUnpackUINT16(off);
  1065.     uiBitCount      = RMUnpackUINT16(off);
  1066.     uiPadWidth      = RMUnpackUINT16(off);
  1067.     uiPadHeight     = RMUnpackUINT16(off);
  1068.     framesPerSecond = RMUnpackUINT32(off);
  1069.     UINT32 ulBytesParsed = off - buf;
  1070.     UINT32 ulBytesLeft   = (len >= ulBytesParsed ? len - ulBytesParsed : 0);
  1071.     if (ulBytesLeft >= 8)
  1072.     {
  1073.         ulSPOExtra      = RMUnpackUINT32(off);
  1074.         ulStreamVersion = RMUnpackUINT32(off);
  1075.     }
  1076.     return off;
  1077. }
  1079. HX_INLINE UINT8*
  1080. MultiStreamHeader::pack(UINT8* buf, UINT32 &len)
  1081. {
  1082.     UINT8* off = buf;
  1084.     RMPackUINT32(object_id, off);
  1085.     RMPackUINT16(num_rules, off);
  1086.     for (int i = 0;  i < num_rules; i++)
  1087.         RMPackUINT16(rule_to_header_map[i], off);
  1088.     RMPackUINT16(num_headers, off);
  1089.     len = off-buf;
  1090.     return off;
  1091. }
  1093. HX_INLINE UINT8*
  1094. MultiStreamHeader::unpack(UINT8* buf, UINT32 len)
  1095. {
  1096.     if (!buf || !len)
  1097. return 0;
  1098.     UINT8* off = buf;
  1100.     object_id = RMUnpackUINT32(off);
  1101.     num_rules = RMUnpackUINT16(off);
  1102.     rule_to_header_map = new UINT16[num_rules];
  1103.     if (!rule_to_header_map) return 0;
  1104.     for (int i = 0;  i < num_rules; i++)
  1105.         rule_to_header_map[i] = RMUnpackUINT16(off);
  1106.     num_headers = RMUnpackUINT16(off);
  1107.     return off;
  1108. }
  1110. HX_INLINE NameValueProperty::NameValueProperty()
  1111. {
  1112.     size           = 0;
  1113.     object_version = 0;
  1114.     name_length    = 0;
  1115.     name           = NULL;
  1116.     value_length   = 0;
  1117.     value_data     = NULL;
  1118. }
  1120. HX_INLINE UINT8*
  1121. NameValueProperty::pack(UINT8* buf, UINT32 &len)
  1122. {
  1123.     UINT8* off = buf;
  1125.     RMPackUINT32(size, off);
  1126.     RMPackUINT16(object_version, off);
  1127.     if ((object_version == 0))
  1128.     {
  1129.         RMPackByteString(name, name_length, off);
  1130.         RMPackUINT32(type, off);
  1131.         RMPackUINT16String(value_data, value_length, off);
  1132.     }
  1133.     len = off-buf;
  1134.     return off;
  1135. }
  1137. HX_INLINE UINT8*
  1138. NameValueProperty::unpack(UINT8* buf, UINT32 len)
  1139. {
  1140.     if (!buf || !len)
  1141. return 0;
  1142.     UINT8* off = buf;
  1144.     size = RMUnpackUINT32(off);
  1145.     object_version = RMUnpackUINT16(off);
  1146.     if ((object_version == 0))
  1147.     {
  1148.         if (!RMUnpackByteString(name, name_length, off, buf, len)) return 0;
  1149.         type = RMUnpackUINT32(off);
  1150.         if (!RMUnpackUINT16String(value_data, value_length, off, buf, len)) return 0;
  1151.     }
  1152.     return off;
  1153. }
  1155. HX_INLINE UINT8*
  1156. Unsigned32BitInteger::pack(UINT8* buf, UINT32 &len)
  1157. {
  1158.     UINT8* off = buf;
  1160.     RMPackUINT32(value, off);
  1161.     len = off-buf;
  1162.     return off;
  1163. }
  1165. HX_INLINE UINT8*
  1166. Unsigned32BitInteger::unpack(UINT8* buf, UINT32 len)
  1167. {
  1168.     if (!buf || !len)
  1169. return 0;
  1170.     UINT8* off = buf;
  1172.     value = RMUnpackUINT32(off);
  1173.     return off;
  1174. }
  1176. HX_INLINE UINT8*
  1177. LogicalStream::pack(UINT8* buf, UINT32 &len)
  1178. {
  1179.     UINT8* off = buf;
  1181.     RMPackUINT32(size, off);
  1182.     RMPackUINT16(object_version, off);
  1183.     if ((object_version == 0))
  1184.     {
  1185.         RMPackUINT16(num_physical_streams, off);
  1186.         int i = 0;
  1187.         for (i = 0;  i < num_physical_streams; i++)
  1188.             RMPackUINT16(physical_stream_numbers[i], off);
  1189.         for (i = 0;  i < num_physical_streams; i++)
  1190.             RMPackUINT32(data_offsets[i], off);
  1191.         RMPackUINT16(num_rules, off);
  1192.         for (i = 0;  i < num_rules; i++)
  1193.             RMPackUINT16(rule_to_physical_stream_number_map[i], off);
  1194.         RMPackUINT16(num_properties, off);
  1195.         for (i = 0;  i < num_properties; i++)
  1196.             off = properties[i].pack(off, len);
  1197.     }
  1198.     len = off-buf;
  1199.     return off;
  1200. }
  1202. HX_INLINE UINT8*
  1203. LogicalStream::unpack(UINT8* buf, UINT32 len)
  1204. {
  1205.     if (!buf || !len)
  1206.         return 0;
  1207.     UINT8* off = buf;
  1209.     size = RMUnpackUINT32(off);
  1210.     object_version = RMUnpackUINT16(off);
  1211.     if ((object_version == 0))
  1212.     {
  1213.         num_physical_streams = RMUnpackUINT16(off);
  1214.         physical_stream_numbers = new UINT16[num_physical_streams];
  1215.         if (!physical_stream_numbers) return 0;
  1216.         int i = 0;
  1217.         for (i = 0;  i < num_physical_streams; i++)
  1218.             physical_stream_numbers[i] = RMUnpackUINT16(off);
  1219.         data_offsets = new UINT32[num_physical_streams];
  1220.         if (!data_offsets) return 0;
  1221.         for (i = 0;  i < num_physical_streams; i++)
  1222.             data_offsets[i] = RMUnpackUINT32(off);
  1223.         num_rules = RMUnpackUINT16(off);
  1224.         rule_to_physical_stream_number_map = new UINT16[num_rules];
  1225.         if (!rule_to_physical_stream_number_map) return 0;
  1226.         for (i = 0;  i < num_rules; i++)
  1227.             rule_to_physical_stream_number_map[i] = RMUnpackUINT16(off);
  1228.         num_properties = RMUnpackUINT16(off);
  1229.         properties = new NameValueProperty[num_properties];
  1230.         if (!properties) return 0;
  1231.         for (i = 0;  i < num_properties && off; i++)
  1232.             off = properties[i].unpack(off, len);
  1233.     }
  1234.     return off;
  1235. }
  1237. HX_INLINE UINT8*
  1238. MetaInformation::pack(UINT8* buf, UINT32 &len)
  1239. {
  1240.     UINT8* off = buf;
  1242.     RMPackUINT32(size, off);
  1243.     RMPackUINT16(object_version, off);
  1244.     if ((object_version == 0))
  1245.     {
  1246.         RMPackUINT16(num_properties, off);
  1247.         for (int i = 0;  i < num_properties; i++)
  1248.             off = properties[i].pack(off, len);
  1249.     }
  1250.     len = off-buf;
  1251.     return off;
  1252. }
  1254. HX_INLINE UINT8*
  1255. MetaInformation::unpack(UINT8* buf, UINT32 len)
  1256. {
  1257.     if (!buf || !len)
  1258. return 0;
  1259.     UINT8* off = buf;
  1261.     size           = RMUnpackUINT32(off);
  1262.     object_version = RMUnpackUINT16(off);
  1263.     if (object_version == 0)
  1264.     {
  1265.         num_properties = RMUnpackUINT16(off);
  1266.         properties = new NameValueProperty[num_properties];
  1267.         if (!properties) return 0;
  1268.         for (int i = 0;  i < num_properties; i++)
  1269.             off = properties[i].unpack(off, len);
  1270.     }
  1271.     return off;
  1272. }
  1274. HX_INLINE UINT8*
  1275. Content::pack(UINT8* buf, UINT32 &len)
  1276. {
  1277.     UINT8* off = buf;
  1279.     RMPackUINT32(object_id, off);
  1280.     RMPackUINT32(size, off);
  1281.     RMPackUINT16(object_version, off);
  1282.     if (object_version == 0)
  1283.     {
  1284.         RMPackUINT16String(title, title_len, off);
  1285.         RMPackUINT16String(author, author_len, off);
  1286.         RMPackUINT16String(copyright, copyright_len, off);
  1287.         RMPackUINT16String(comment, comment_len, off);
  1288.     }
  1289.     len = off-buf;
  1290.     return off;
  1291. }
  1293. HX_INLINE UINT8*
  1294. Content::unpack(UINT8* buf, UINT32 len)
  1295. {
  1296.     if (!buf || !len)
  1297. return 0;
  1298.     UINT8* off = buf;
  1300.     object_id      = RMUnpackUINT32(off);
  1301.     size           = RMUnpackUINT32(off);
  1302.     object_version = RMUnpackUINT16(off);
  1303.     if (object_version == 0)
  1304.     {
  1305.         if (!RMUnpackUINT16String(title, title_len, off, buf, len)) return 0;
  1306.         if (!RMUnpackUINT16String(author, author_len, off, buf, len)) return 0;
  1307.         if (!RMUnpackUINT16String(copyright, copyright_len, off, buf, len)) return 0;
  1308.         if (!RMUnpackUINT16String(comment, comment_len, off, buf, len)) return 0;
  1309.     }
  1310.     return off;
  1311. }
  1314. //
  1315. // BUGBUG
  1316. // XXX
  1317. // PMC can't generate a declaration for this constructor.
  1318. // So, the generated .h file will not build until the
  1319. // declaration is added by hand.
  1320. //
  1321. HX_INLINE
  1322. Content::Content()
  1323. {
  1324. object_id = 0;
  1325. size = 0;
  1326. object_version = 0;
  1327. title_len = 0;
  1328. title = NULL;
  1329. author_len = 0;
  1330. author = NULL;
  1331. copyright_len = 0;
  1332. copyright = NULL;
  1333. comment_len = 0;
  1334. comment = NULL;
  1335. }
  1337. HX_INLINE UINT8*
  1338. DataHeader::pack(UINT8* buf, UINT32 &len)
  1339. {
  1340.     UINT8* off = buf;
  1342.     RMPackUINT32(object_id, off);
  1343.     RMPackUINT32(size, off);
  1344.     RMPackUINT16(object_version, off);
  1345.     if (object_version == 0)
  1346.     {
  1347.         RMPackUINT32(num_interleave_packets, off);
  1348.         RMPackUINT32(next_data_header, off);
  1349.     }
  1350.     len = off-buf;
  1351.     return off;
  1352. }
  1354. HX_INLINE UINT8*
  1355. DataHeader::unpack(UINT8* buf, UINT32 len)
  1356. {
  1357.     if (!buf || !len)
  1358. return 0;
  1359.     UINT8* off = buf;
  1361.     object_id      = RMUnpackUINT32(off);
  1362.     size           = RMUnpackUINT32(off);
  1363.     object_version = RMUnpackUINT16(off);
  1364.     if (object_version == 0)
  1365.     {
  1366.         num_interleave_packets = RMUnpackUINT32(off);
  1367.         next_data_header       = RMUnpackUINT32(off);
  1368.     }
  1369.     return off;
  1370. }
  1372. HX_INLINE UINT8*
  1373. IndexHeader::pack(UINT8* buf, UINT32 &len)
  1374. {
  1375.     UINT8* off = buf;
  1377.     RMPackUINT32(object_id, off);
  1378.     RMPackUINT32(size, off);
  1379.     RMPackUINT16(object_version, off);
  1380.     if (object_version == 0)
  1381.     {
  1382.         RMPackUINT32(num_indices, off);
  1383.         RMPackUINT16(stream_number, off);
  1384.         RMPackUINT32(next_index_header, off);
  1385.     }
  1386.     len = off-buf;
  1387.     return off;
  1388. }
  1390. HX_INLINE UINT8*
  1391. IndexHeader::unpack(UINT8* buf, UINT32 len)
  1392. {
  1393.     if (!buf || !len)
  1394. return 0;
  1395.     UINT8* off = buf;
  1397.     object_id      = RMUnpackUINT32(off);
  1398.     size           = RMUnpackUINT32(off);
  1399.     object_version = RMUnpackUINT16(off);
  1400.     if (object_version == 0)
  1401.     {
  1402.         num_indices       = RMUnpackUINT32(off);
  1403.         stream_number     = RMUnpackUINT16(off);
  1404.         next_index_header = RMUnpackUINT32(off);
  1405.     }
  1406.     return off;
  1407. }
  1409. HX_INLINE UINT8*
  1410. IndexRecord::pack(UINT8* buf, UINT32 &len)
  1411. {
  1412.     UINT8* off = buf;
  1414.     RMPackUINT16(object_version, off);
  1415.     if (object_version == 0)
  1416.     {
  1417.         RMPackUINT32(timestamp, off);
  1418.         RMPackUINT32(offset, off);
  1419.         RMPackUINT32(num_interleave_packets, off);
  1420.     }
  1421.     len = off-buf;
  1422.     return off;
  1423. }
  1425. HX_INLINE UINT8*
  1426. IndexRecord::unpack(UINT8* buf, UINT32 len)
  1427. {
  1428.     if (!buf || !len)
  1429. return 0;
  1430.     UINT8* off = buf;
  1432.     object_version = RMUnpackUINT16(off);
  1433.     if (object_version == 0)
  1434.     {
  1435.         timestamp              = RMUnpackUINT32(off);
  1436.         offset                 = RMUnpackUINT32(off);
  1437.         num_interleave_packets = RMUnpackUINT32(off);
  1438.     }
  1439.     return off;
  1440. }
  1442. HX_INLINE UINT8*
  1443. PacketHeaderBase::pack(UINT8* buf, UINT32 &len)
  1444. {
  1445.     UINT8* off = buf;
  1447.     RMPackUINT16(object_version, off);
  1448.     RMPackUINT16(length, off);
  1449.     len = off-buf;
  1450.     return off;
  1451. }
  1453. HX_INLINE UINT8*
  1454. PacketHeaderBase::unpack(UINT8* buf, UINT32 len)
  1455. {
  1456.     if (!buf || !len)
  1457. return 0;
  1458.     UINT8* off = buf;
  1460.     object_version = RMUnpackUINT16(off);
  1461.     length         = RMUnpackUINT16(off);
  1462.     return off;
  1463. }
  1465. HX_INLINE UINT8*
  1466. PacketHeader::pack(UINT8* buf, UINT32 &len)
  1467. {
  1468.     UINT8* off = buf;
  1470.     RMPackUINT16(object_version, off);
  1471.     if (object_version == 0)
  1472.     {
  1473.         RMPackUINT16(length, off);
  1474.         RMPackUINT16(stream_number, off);
  1475.         RMPackUINT32(timestamp, off);
  1476.         RMPackUINT16(flags, off);
  1477.     }
  1478.     len = off-buf;
  1479.     return off;
  1480. }
  1482. HX_INLINE UINT8*
  1483. PacketHeader::unpack(UINT8* buf, UINT32 len)
  1484. {
  1485.     if (!buf || !len)
  1486. return 0;
  1487.     UINT8* off = buf;
  1489.     object_version = RMUnpackUINT16(off);
  1490.     if (object_version == 0)
  1491.     {
  1492.         length        = RMUnpackUINT16(off);
  1493.         stream_number = RMUnpackUINT16(off);
  1494.         timestamp     = RMUnpackUINT32(off);
  1495.         flags         = RMUnpackUINT16(off);
  1496.     }
  1497.     return off;
  1498. }
  1500. HX_INLINE UINT8*
  1501. PacketHeader1::pack(UINT8* buf, UINT32 &len)
  1502. {
  1503.     UINT8* off = buf;
  1505.     RMPackUINT16(object_version, off);
  1506.     if (object_version == 1)
  1507.     {
  1508.         RMPackUINT16(length, off);
  1509.         RMPackUINT16(stream_number, off);
  1510.         RMPackUINT32(timestamp, off);
  1511.         RMPackUINT16(asm_rule, off);
  1512.         *off++ = asm_flags;
  1513.     }
  1514.     len = off-buf;
  1515.     return off;
  1516. }
  1518. HX_INLINE UINT8*
  1519. PacketHeader1::unpack(UINT8* buf, UINT32 len)
  1520. {
  1521.     if (!buf || !len)
  1522. return 0;
  1523.     UINT8* off = buf;
  1525.     object_version = RMUnpackUINT16(off);
  1526.     if (object_version == 1)
  1527.     {
  1528.         length        = RMUnpackUINT16(off);
  1529.         stream_number = RMUnpackUINT16(off);
  1530.         timestamp     = RMUnpackUINT32(off);
  1531.         asm_rule      = RMUnpackUINT16(off);
  1532.         asm_flags     = *off++;
  1533.     }
  1534.     return off;
  1535. }
  1537. HX_INLINE UINT8*
  1538. Profile::pack(UINT8* buf, UINT32 &len)
  1539. {
  1540.     UINT8* off = buf;
  1542.     RMPackUINT32(object_id, off);
  1543.     RMPackUINT32(size, off);
  1544.     RMPackUINT16(object_version, off);
  1545.     if (object_version == 0)
  1546.     {
  1547.         RMPackUINT32(Bandwidth, off);
  1548.         RMPackUINT32(CpuPower, off);
  1549.     }
  1550.     len = off-buf;
  1551.     return off;
  1552. }
  1554. HX_INLINE UINT8*
  1555. Profile::unpack(UINT8* buf, UINT32 len)
  1556. {
  1557.     if (!buf || !len)
  1558. return 0;
  1559.     UINT8* off = buf;
  1561.     object_id      = RMUnpackUINT32(off);
  1562.     size           = RMUnpackUINT32(off);
  1563.     object_version = RMUnpackUINT16(off);
  1564.     if (object_version == 0)
  1565.     {
  1566.         Bandwidth = RMUnpackUINT32(off);
  1567.         CpuPower  = RMUnpackUINT32(off);
  1568.     }
  1569.     return off;
  1570. }
  1572. HX_INLINE UINT8*
  1573. RMEventPacketData::pack(UINT8* buf, UINT32 &len)
  1574. {
  1575.     UINT8* off = buf;
  1577.     RMPackUINT16(sequence_number, off);
  1578.     RMPackUINT32(start_time_deciseconds, off);
  1579.     RMPackUINT32(stop_time_deciseconds, off);
  1580.     RMPackUINT16(event_type_and_string_len, off);
  1581.     RMPackUINT16(event_type_id, off);
  1582.     memcpy(off, event_string, event_type_and_string_len - 2);
  1583.     off += event_type_and_string_len - 2;
  1584.     len = off-buf;
  1585.     return off;
  1586. }
  1588. HX_INLINE UINT8*
  1589. RMEventPacketData::unpack(UINT8* buf, UINT32 len)
  1590. {
  1591.     if (!buf || !len)
  1592. return 0;
  1593.     UINT8* off = buf;
  1595.     sequence_number           = RMUnpackUINT16(off);
  1596.     start_time_deciseconds    = RMUnpackUINT32(off);
  1597.     stop_time_deciseconds     = RMUnpackUINT32(off);
  1598.     event_type_and_string_len = RMUnpackUINT16(off);
  1599.     event_type_id             = RMUnpackUINT16(off);
  1600.     if (off-buf+(event_type_and_string_len - 2) > (int)len)
  1601. return 0;
  1602.     event_string = (UINT8*) off;
  1603.     off += event_type_and_string_len - 2;
  1604.     return off;
  1605. }
  1607. HX_INLINE UINT8*
  1608. RMImageMapRegionData::pack(UINT8* buf, UINT32 &len)
  1609. {
  1610.     UINT8* off = buf;
  1612.     RMPackUINT32(start_time, off);
  1613.     RMPackUINT32(end_time, off);
  1614.     RMPackUINT16(shape, off);
  1615.     RMPackUINT16(num_values, off);
  1616.     for (int i = 0;  i < num_values; i++)
  1617.         RMPackUINT16(values[i], off);
  1618.     RMPackUINT16(action, off);
  1619.     RMPackUINT32(seek_time, off);
  1620.     RMPackUINT16String(url, url_len, off);
  1621.     RMPackUINT16String(status, status_len, off);
  1622.     len = off-buf;
  1623.     return off;
  1624. }
  1626. HX_INLINE UINT8*
  1627. RMImageMapRegionData::unpack(UINT8* buf, UINT32 len)
  1628. {
  1629.     if (!buf || !len)
  1630. return 0;
  1631.     UINT8* off = buf;
  1633.     start_time = RMUnpackUINT32(off);
  1634.     end_time   = RMUnpackUINT32(off);
  1635.     shape      = RMUnpackUINT16(off);
  1636.     num_values = RMUnpackUINT16(off);
  1637.     values     = new UINT16[num_values];
  1638.     if (!values) return 0;
  1639.     for (int i = 0;  i < num_values; i++)
  1640.         values[i] = RMUnpackUINT16(off);
  1641.     action    = RMUnpackUINT16(off);
  1642.     seek_time = RMUnpackUINT32(off);
  1643.     if (!RMUnpackUINT16String(url, url_len, off, buf, len)) return 0;
  1644.     if (!RMUnpackUINT16String(status, status_len, off, buf, len)) return 0;
  1645.     return off;
  1646. }
  1648. HX_INLINE UINT8*
  1649. RMImageMapPacketData::pack(UINT8* buf, UINT32 &len)
  1650. {
  1651.     UINT8* off = buf;
  1653.     RMPackUINT16(sequence_number, off);
  1654.     RMPackUINT16(num_regions, off);
  1655.     RMPackUINT32(start_time, off);
  1656.     RMPackUINT32(end_time, off);
  1657.     RMPackUINT16(left, off);
  1658.     RMPackUINT16(top, off);
  1659.     RMPackUINT16(right, off);
  1660.     RMPackUINT16(bottom, off);
  1661.     for (int i = 0;  i < num_regions; i++)
  1662.         off = regions[i].pack(off, len);
  1663.     len = off-buf;
  1664.     return off;
  1665. }
  1667. HX_INLINE UINT8*
  1668. RMImageMapPacketData::unpack(UINT8* buf, UINT32 len)
  1669. {
  1670.     if (!buf || !len)
  1671. return 0;
  1672.     UINT8* off = buf;
  1674.     sequence_number = RMUnpackUINT16(off);
  1675.     num_regions     = RMUnpackUINT16(off);
  1676.     start_time      = RMUnpackUINT32(off);
  1677.     end_time        = RMUnpackUINT32(off);
  1678.     left            = RMUnpackUINT16(off);
  1679.     top             = RMUnpackUINT16(off);
  1680.     right           = RMUnpackUINT16(off);
  1681.     bottom          = RMUnpackUINT16(off);
  1682.     regions = new RMImageMapRegionData[num_regions];
  1683.     if (!regions) return 0;
  1684.     for (int i = 0;  i < num_regions; i++)
  1685.         off = regions[i].unpack(off, len);
  1686.     return off;
  1687. }
  1689. HX_INLINE UINT8*
  1690. RMBaseImageMapPacketData::pack(UINT8* buf, UINT32 &len)
  1691. {
  1692.     UINT8* off = buf;
  1694.     RMPackUINT16(sequence_number, off);
  1695.     RMPackUINT16(num_regions, off);
  1696.     RMPackUINT32(start_time, off);
  1697.     RMPackUINT32(end_time, off);
  1698.     RMPackUINT16(left, off);
  1699.     RMPackUINT16(top, off);
  1700.     RMPackUINT16(right, off);
  1701.     RMPackUINT16(bottom, off);
  1702.     len = off-buf;
  1703.     return off;
  1704. }
  1706. HX_INLINE UINT8*
  1707. RMBaseImageMapPacketData::unpack(UINT8* buf, UINT32 len)
  1708. {
  1709.     if (!buf || !len)
  1710. return 0;
  1711.     UINT8* off = buf;
  1713.     sequence_number = RMUnpackUINT16(off);
  1714.     num_regions     = RMUnpackUINT16(off);
  1715.     start_time      = RMUnpackUINT32(off);
  1716.     end_time        = RMUnpackUINT32(off);
  1717.     left            = RMUnpackUINT16(off);
  1718.     top             = RMUnpackUINT16(off);
  1719.     right           = RMUnpackUINT16(off);
  1720.     bottom          = RMUnpackUINT16(off);
  1721.     return off;
  1722. }
  1724. HX_INLINE UINT8*
  1725. StreamPair::pack(UINT8* buf, UINT32 &len)
  1726. {
  1727.     UINT8* off = buf;
  1729.     RMPackUINT16(stream1_num, off);
  1730.     RMPackUINT16(stream2_num, off);
  1731.     len = off-buf;
  1732.     return off;
  1733. }
  1735. HX_INLINE UINT8*
  1736. StreamPair::unpack(UINT8* buf, UINT32 len)
  1737. {
  1738.     if (!buf || !len)
  1739. return 0;
  1740.     UINT8* off = buf;
  1742.     stream1_num = RMUnpackUINT16(off);
  1743.     stream2_num = RMUnpackUINT16(off);
  1744.     return off;
  1745. }
  1747. HX_INLINE UINT8*
  1748. StreamPairsHeader::pack(UINT8* buf, UINT32 &len)
  1749. {
  1750.     UINT8* off = buf;
  1752.     RMPackUINT32(size, off);
  1753.     RMPackUINT16(object_version, off);
  1754.     RMPackUINT16(num_stream_pairs, off);
  1755.     for (int i = 0;  i < num_stream_pairs; i++)
  1756.         off = stream_pairs[i].pack(off, len);
  1757.     RMPackByteString(stream1_property_name, stream1_property_name_len, off);
  1758.     RMPackByteString(stream2_property_name, stream2_property_name_len, off);
  1759.     len = off-buf;
  1760.     return off;
  1761. }
  1763. HX_INLINE UINT8*
  1764. StreamPairsHeader::unpack(UINT8* buf, UINT32 len)
  1765. {
  1766.     if (!buf || !len)
  1767. return 0;
  1768.     UINT8* off = buf;
  1770.     size             = RMUnpackUINT32(off);
  1771.     object_version   = RMUnpackUINT16(off);
  1772.     num_stream_pairs = RMUnpackUINT16(off);
  1773.     stream_pairs = new StreamPair[num_stream_pairs];
  1774.     if (!stream_pairs) return 0;
  1775.     for (int i = 0;  i < num_stream_pairs; i++)
  1776.         off = stream_pairs[i].unpack(off, len);
  1777.     if (!RMUnpackByteString(stream1_property_name, stream1_property_name_len, off, buf, len)) return 0;
  1778.     if (!RMUnpackByteString(stream2_property_name, stream2_property_name_len, off, buf, len)) return 0;
  1779.     return off;
  1780. }
  1782. HX_INLINE UINT8*
  1783. PhysicalStreamInfo::pack(UINT8* buf, UINT32 &len)
  1784. {
  1785.     UINT8* off = buf;
  1787.     RMPackUINT32(size, off);
  1788.     RMPackUINT16(object_version, off);
  1789.     RMPackUINT16(unPhysicalStreamNumber, off);
  1790.     RMPackUINT16(unLogicalStreamNumber, off);
  1791.     RMPackUINT32(ulDataOffset, off);
  1792.     RMPackUINT32(ulBandwidth, off);
  1793.     *off++ = bInterleavedBackwardsCompatible;
  1794.     *off++ = bTaggedBackwardsCompatible;
  1795.     *off++ = bIncludeAsMultirate;
  1796.     *off++ = bOwnsDataSection;
  1797.     *off++ = bIgnoreOnWrite;
  1798.     len = off-buf;
  1799.     return off;
  1800. }
  1802. HX_INLINE UINT8*
  1803. PhysicalStreamInfo::unpack(UINT8* buf, UINT32 len)
  1804. {
  1805.     if (!buf || !len)
  1806. return 0;
  1807.     UINT8* off = buf;
  1809.     size                   = RMUnpackUINT32(off);
  1810.     object_version         = RMUnpackUINT16(off);
  1811.     unPhysicalStreamNumber = RMUnpackUINT16(off);
  1812.     unLogicalStreamNumber  = RMUnpackUINT16(off);
  1813.     ulDataOffset           = RMUnpackUINT32(off);
  1814.     ulBandwidth            = RMUnpackUINT32(off);
  1815.     bInterleavedBackwardsCompatible = *off++;
  1816.     bTaggedBackwardsCompatible      = *off++;
  1817.     bIncludeAsMultirate             = *off++;
  1818.     bOwnsDataSection                = *off++;
  1819.     bIgnoreOnWrite                  = *off++;
  1820.     return off;
  1821. }
  1823. HX_INLINE UINT8*
  1824. PhysicalStreamInfoHeader::pack(UINT8* buf, UINT32 &len)
  1825. {
  1826.     UINT8* off = buf;
  1828.     RMPackUINT32(size, off);
  1829.     RMPackUINT16(object_version, off);
  1830.     RMPackUINT16(num_physical_streams, off);
  1831.     for (int i = 0;  i < num_physical_streams; i++)
  1832.         off = physical_streams[i].pack(off, len);
  1833.     len = off-buf;
  1834.     return off;
  1835. }
  1837. HX_INLINE UINT8*
  1838. PhysicalStreamInfoHeader::unpack(UINT8* buf, UINT32 len)
  1839. {
  1840.     if (!buf || !len)
  1841. return 0;
  1842.     UINT8* off = buf;
  1844.     size                 = RMUnpackUINT32(off);
  1845.     object_version       = RMUnpackUINT16(off);
  1846.     num_physical_streams = RMUnpackUINT16(off);
  1847.     physical_streams = new PhysicalStreamInfo[num_physical_streams];
  1848.     if (!physical_streams) return 0;
  1849.     for (int i = 0;  i < num_physical_streams; i++)
  1850.         off = physical_streams[i].unpack(off, len);
  1851.     return off;
  1852. }
  1855. HX_INLINE u_int32
  1856. get_rm_object_id(Byte* buffer, int buffer_len)
  1857. {
  1858.     RMGenericHeader gen_header;
  1859.     if (gen_header.unpack(buffer, buffer_len) == 0)
  1860.     {
  1861. return 0;
  1862.     }
  1863.     return gen_header.object_id;
  1864. }
  1865. #endif //_DEFINE_INLINE
  1868. #if (defined( _WIN32 ) || defined( _WINDOWS )) && defined(_M_IX86)
  1869. #pragma pack()
  1871. // Restore warnings
  1872. #pragma warning( default : 4200 )
  1873. #endif
  1874. #ifdef _MACINTOSH
  1875. #pragma options align=reset
  1876. #endif
  1878. #endif