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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
rmfftype.h
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：49k
源码类别：

Symbian

开发平台：

C/C++

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