bitstuff.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:6k
源码类别:

Symbian

开发平台:

C/C++

  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 ***** */ 
  35. typedef struct TAG_LD {
  36.   /* bit input */
  37.   unsigned char *rdbfr;
  38.   unsigned char *rdptr;
  39.   int incnt;
  40.   int bitcnt;
  41. } LD;
  42. #if defined _AIX || defined _OSF1 || (defined _SOLARIS && !defined __GNUC__)
  43. #define INLINE static inline
  44. #else
  45. #define INLINE static __inline
  46. #endif
  47. /*
  48.  * Initializes bit-buffer.
  49.  * Use:
  50.  *  void initbuffer (char *buffer, void *bufinfo);
  51.  * Input:
  52.  * buffer - pointer to the input buffer to use
  53.  * bufinfo - pointer to the buffer information
  54.  * Returns:
  55.  *  none
  56.  */
  57. INLINE void initbuffer (unsigned char *buffer, void *bufinfo)
  58. {
  59. LD * ld = (LD*)bufinfo;
  60. ld->rdptr = buffer;
  61. ld->rdbfr = buffer;
  62. ld->incnt = 0;
  63. ld->bitcnt = 0;
  64. }
  65. /*
  66.  * Fills pre-load buffer.
  67.  * Use:
  68.  *  void fillbfr (void *inst);
  69.  * Input:
  70.  * inst - decoder instance
  71.  * Returns:
  72.  *  none
  73.  */
  74. INLINE void fillbfr (void *inst) {/* obsolete */}
  75. /*
  76.  * Returns next n bits (right adjusted) without advancing.
  77.  * Use:
  78.  *  unsigned int showbits(int n, void *inst);
  79.  * Input:
  80.  * n - the number of bits to retrieve
  81.  * inst - decoder instance
  82.  * Note:
  83.  *  len must be less than 24
  84.  * Returns:
  85.  * the bit vector
  86.  */
  87. #ifdef _M_IX86
  88. #pragma warning(disable:4035)
  89. INLINE unsigned int showbits (int n, void *inst)
  90. {
  91. __asm mov eax,inst
  92. __asm mov edx,/* LD */ [eax].rdptr
  93. __asm mov ecx,/* LD */ [eax].incnt
  94. __asm mov eax,dword ptr [edx]
  95. __asm mov edx,32
  96. __asm bswap eax
  97. __asm sub edx,n
  98. __asm shl eax,cl
  99. __asm mov ecx,edx
  100. __asm shr eax,cl
  101. }
  102. #else
  103. /* I guess it should be portable: */
  104. INLINE unsigned int showbits (int n, void *inst)
  105. {
  106. LD * ld = (LD*)inst;
  107. unsigned char *p = ld->rdptr;
  108. unsigned int a, c = ld->incnt;
  109. /* load in big-Endian order: */
  110. a = (unsigned int)(p[0]<<24) + (p[1]<<16) + (p[2]<<8) + (p[3]);
  111. return (a << c) >> (32-n);
  112. }
  113. #endif
  114. /*
  115.  * Advance by n bits.
  116.  * Use:
  117.  * void flushbits(int n, void *inst);
  118.  * Input:
  119.  * n - the number of bits to throw away
  120.  * inst - decoder instance
  121.  * Returns:
  122.  * none
  123.  */
  124. INLINE void flushbits (int n, void *inst)
  125. {
  126. LD * ld = (LD*)inst;
  127.   ld->incnt += n;
  128. ld->bitcnt+= n;
  129. ld->rdptr += ld->incnt >> 3;
  130. ld->incnt &= 0x07;
  131. }
  132. /*
  133.  * Returns next n bits (right adjusted)
  134.  * Use:
  135.  *  unsigned int getbits(int n, void *inst);
  136.  * Input:
  137.  * n - the number of bits to retrieve
  138.  * inst - decoder instance
  139.  * Note:
  140.  *  len must be less than 24
  141.  * Returns:
  142.  * the bit vector
  143.  */
  144. INLINE unsigned int getbits(int n, void *inst)
  145. {
  146. unsigned int l = showbits(n, inst);
  147.     flushbits(n, inst);
  148. return l;
  149. }
  150. /*
  151.  * Returns next bit from the bitstream.
  152.  * Use:
  153.  * unsigned int getbits1 (void * inst);
  154.  * Input:
  155.  * inst - decoder instance
  156.  * Returns:
  157.  * bit value
  158.  */
  159. #if 1
  160. INLINE unsigned int getbits1 (void * inst)
  161. {
  162. LD * ld = (LD*)inst;
  163. unsigned int a = ld->rdptr[0];
  164. unsigned int c = ld->incnt + 1;
  165. ld->bitcnt ++;
  166. ld->incnt = c & 7;
  167. ld->rdptr += c >> 3;
  168. return (a >> (8 - c)) & 1;
  169. }
  170. #else
  171. /* 'lazy' version */
  172. INLINE unsigned int getbits1 (void * inst)
  173. {
  174. return getbits(1, inst);
  175. }
  176. #endif
  177. /*
  178.  * Returns current byte number.
  179.  * Use:
  180.  * unsigned int getbytes (void *bufinfo);
  181.  * bufinfo - pointer to the buffer information
  182.  * Returns:
  183.  * none
  184.  */
  185. INLINE unsigned int getbytes (void *bufinfo)
  186. {
  187. LD * ld = (LD*)ld;
  188.   return ld->bitcnt >> 3;
  189. }
  190. /*
  191.  * Seek to a certain position in the bitstream:
  192.  * Use:
  193.  * unsigned char *gotoByte (int byteInPacket, void *bufinfo);
  194.  * Input:
  195.  * byteInPacket - target byte position
  196.  * bufinfo - pointer to the buffer information
  197.  * Returns
  198.  *  pointer to the requested position in the bistream
  199.  */
  200. INLINE unsigned char *gotoByte (int byteInPacket, void *bufinfo)
  201. {
  202. LD * ld = (LD*)bufinfo;
  203. unsigned char * newPtrLocation = ld->rdbfr + byteInPacket;
  204. ld->rdptr = newPtrLocation;
  205. ld->bitcnt = byteInPacket << 3;
  206. ld->incnt= 0;
  207. return newPtrLocation;
  208. }