bitpack.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:4k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file bitpack.h
  3.  * @brief Convert data to packed bit stream
  4.  *
  5.  * $LicenseInfo:firstyear=2000&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2000-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #ifndef LL_BITPACK_H
  33. #define LL_BITPACK_H
  34. #include "llerror.h"
  35. const U32 MAX_DATA_BITS = 8;
  36. class LLBitPack
  37. {
  38. public:
  39. LLBitPack(U8 *buffer, U32 max_size) : mBuffer(buffer), mBufferSize(0), mLoad(0), mLoadSize(0), mTotalBits(0), mMaxSize(max_size)
  40. {
  41. }
  42. ~LLBitPack()
  43. {
  44. }
  45. void resetBitPacking()
  46. {
  47. mLoad = 0;
  48. mLoadSize = 0;
  49. mTotalBits = 0;
  50. mBufferSize = 0;
  51. }
  52. U32 bitPack(U8 *total_data, U32 total_dsize)
  53. {
  54. U32 dsize;
  55. U8 data;
  56. while (total_dsize > 0)
  57. {
  58. if (total_dsize > MAX_DATA_BITS)
  59. {
  60. dsize = MAX_DATA_BITS;
  61. total_dsize -= MAX_DATA_BITS;
  62. }
  63. else
  64. {
  65. dsize = total_dsize;
  66. total_dsize = 0;
  67. }
  68. data = *total_data++;
  69. data <<= (MAX_DATA_BITS - dsize);
  70. while (dsize > 0) 
  71. {
  72. if (mLoadSize == MAX_DATA_BITS) 
  73. {
  74. *(mBuffer + mBufferSize++) = mLoad;
  75. if (mBufferSize > mMaxSize)
  76. {
  77. llerror("mBufferSize exceeding mMaxSize!", 0);
  78. }
  79. mLoadSize = 0;
  80. mLoad = 0x00;
  81. }
  82. mLoad <<= 1;
  83. mLoad |= (data >> (MAX_DATA_BITS - 1));
  84. data <<= 1;
  85. mLoadSize++;
  86. mTotalBits++;
  87. dsize--;
  88. }
  89. }
  90. return mBufferSize;
  91. }
  92. U32 bitCopy(U8 *total_data, U32 total_dsize)
  93. {
  94. U32 dsize;
  95. U8  data;
  96. while (total_dsize > 0)
  97. {
  98. if (total_dsize > MAX_DATA_BITS)
  99. {
  100. dsize = MAX_DATA_BITS;
  101. total_dsize -= MAX_DATA_BITS;
  102. }
  103. else
  104. {
  105. dsize = total_dsize;
  106. total_dsize = 0;
  107. }
  108. data = *total_data++;
  109. while (dsize > 0) 
  110. {
  111. if (mLoadSize == MAX_DATA_BITS) 
  112. {
  113. *(mBuffer + mBufferSize++) = mLoad;
  114. if (mBufferSize > mMaxSize)
  115. {
  116. llerror("mBufferSize exceeding mMaxSize!", 0);
  117. }
  118. mLoadSize = 0;
  119. mLoad = 0x00;
  120. }
  121. mLoad <<= 1;
  122. mLoad |= (data >> (MAX_DATA_BITS - 1));
  123. data <<= 1;
  124. mLoadSize++;
  125. mTotalBits++;
  126. dsize--;
  127. }
  128. }
  129. return mBufferSize;
  130. }
  131. U32 bitUnpack(U8 *total_retval, U32 total_dsize)
  132. {
  133. U32 dsize;
  134. U8 *retval;
  135. while (total_dsize > 0)
  136. {
  137. if (total_dsize > MAX_DATA_BITS)
  138. {
  139. dsize = MAX_DATA_BITS;
  140. total_dsize -= MAX_DATA_BITS;
  141. }
  142. else
  143. {
  144. dsize = total_dsize;
  145. total_dsize = 0;
  146. }
  147. retval = total_retval++;
  148. *retval = 0x00;
  149. while (dsize > 0) 
  150. {
  151. if (mLoadSize == 0) 
  152. {
  153. #ifdef _DEBUG
  154. if (mBufferSize > mMaxSize)
  155. {
  156. llerrs << "mBufferSize exceeding mMaxSize" << llendl;
  157. llerrs << mBufferSize << " > " << mMaxSize << llendl;
  158. }
  159. #endif
  160. mLoad = *(mBuffer + mBufferSize++);
  161. mLoadSize = MAX_DATA_BITS;
  162. }
  163. *retval <<= 1;
  164. *retval |= (mLoad >> (MAX_DATA_BITS - 1));
  165. mLoadSize--;
  166. mLoad <<= 1;
  167. dsize--;
  168. }
  169. }
  170. return mBufferSize;
  171. }
  172. U32 flushBitPack()
  173. {
  174. if (mLoadSize) 
  175. {
  176. mLoad <<= (MAX_DATA_BITS - mLoadSize);
  177. *(mBuffer + mBufferSize++) = mLoad;
  178. if (mBufferSize > mMaxSize)
  179. {
  180. llerror("mBufferSize exceeding mMaxSize!", 0);
  181. }
  182. mLoadSize = 0;
  183. }
  184. return mBufferSize;
  185. }
  186. U8 *mBuffer;
  187. U32 mBufferSize;
  188. U8 mLoad;
  189. U32 mLoadSize;
  190. U32 mTotalBits;
  191. U32 mMaxSize;
  192. };
  193. #endif