| OLD | NEW |
| 1 // Copyright 2014 PDFium Authors. All rights reserved. | 1 // Copyright 2014 PDFium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
| 4 | 4 |
| 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com | 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
| 6 | 6 |
| 7 #ifndef _JBIG2_BIT_STREAM_H_ | 7 #ifndef _JBIG2_BIT_STREAM_H_ |
| 8 #define _JBIG2_BIT_STREAM_H_ | 8 #define _JBIG2_BIT_STREAM_H_ |
| 9 #include "JBig2_Define.h" | 9 #include "JBig2_Define.h" |
| 10 class CJBig2_BitStream : public CJBig2_Object | 10 class CJBig2_BitStream : public CJBig2_Object { |
| 11 { | 11 public: |
| 12 public: | 12 CJBig2_BitStream(uint8_t* pBuffer, FX_DWORD dwLength); |
| 13 | 13 |
| 14 CJBig2_BitStream(uint8_t *pBuffer, FX_DWORD dwLength); | 14 CJBig2_BitStream(CJBig2_BitStream& bs); |
| 15 | 15 |
| 16 CJBig2_BitStream(CJBig2_BitStream &bs); | 16 ~CJBig2_BitStream(); |
| 17 | 17 |
| 18 ~CJBig2_BitStream(); | 18 int32_t readNBits(FX_DWORD nBits, FX_DWORD* dwResult); |
| 19 | 19 |
| 20 int32_t readNBits(FX_DWORD nBits, FX_DWORD *dwResult); | 20 int32_t readNBits(FX_DWORD nBits, int32_t* nResult); |
| 21 | 21 |
| 22 int32_t readNBits(FX_DWORD nBits, int32_t *nResult); | 22 int32_t read1Bit(FX_DWORD* dwResult); |
| 23 | 23 |
| 24 int32_t read1Bit(FX_DWORD *dwResult); | 24 int32_t read1Bit(FX_BOOL* bResult); |
| 25 | 25 |
| 26 int32_t read1Bit(FX_BOOL *bResult); | 26 int32_t read1Byte(uint8_t* cResult); |
| 27 | 27 |
| 28 int32_t read1Byte(uint8_t *cResult); | 28 int32_t readInteger(FX_DWORD* dwResult); |
| 29 | 29 |
| 30 int32_t readInteger(FX_DWORD *dwResult); | 30 int32_t readShortInteger(FX_WORD* wResult); |
| 31 | 31 |
| 32 int32_t readShortInteger(FX_WORD *wResult); | 32 void alignByte(); |
| 33 | 33 |
| 34 void alignByte(); | 34 void align4Byte(); |
| 35 | 35 |
| 36 void align4Byte(); | 36 uint8_t getAt(FX_DWORD dwOffset); |
| 37 | 37 |
| 38 uint8_t getAt(FX_DWORD dwOffset); | 38 uint8_t getCurByte(); |
| 39 | 39 |
| 40 uint8_t getCurByte(); | 40 uint8_t getNextByte(); |
| 41 | 41 |
| 42 uint8_t getNextByte(); | 42 int32_t incByteIdx(); |
| 43 | 43 |
| 44 int32_t incByteIdx(); | 44 uint8_t getCurByte_arith(); |
| 45 | 45 |
| 46 uint8_t getCurByte_arith(); | 46 uint8_t getNextByte_arith(); |
| 47 | 47 |
| 48 uint8_t getNextByte_arith(); | 48 FX_DWORD getOffset(); |
| 49 | 49 |
| 50 FX_DWORD getOffset(); | 50 void setOffset(FX_DWORD dwOffset); |
| 51 | 51 |
| 52 void setOffset(FX_DWORD dwOffset); | 52 FX_DWORD getBitPos(); |
| 53 | 53 |
| 54 FX_DWORD getBitPos(); | 54 void setBitPos(FX_DWORD dwBitPos); |
| 55 | 55 |
| 56 void setBitPos(FX_DWORD dwBitPos); | 56 uint8_t* getBuf(); |
| 57 | 57 |
| 58 uint8_t *getBuf(); | 58 FX_DWORD getLength() { return m_dwLength; } |
| 59 | 59 |
| 60 FX_DWORD getLength() | 60 uint8_t* getPointer(); |
| 61 { | 61 |
| 62 return m_dwLength; | 62 void offset(FX_DWORD dwOffset); |
| 63 } | 63 |
| 64 | 64 FX_DWORD getByteLeft(); |
| 65 uint8_t *getPointer(); | 65 |
| 66 | 66 private: |
| 67 void offset(FX_DWORD dwOffset); | 67 uint8_t* m_pBuf; |
| 68 | 68 |
| 69 FX_DWORD getByteLeft(); | 69 FX_DWORD m_dwLength; |
| 70 private: | 70 |
| 71 | 71 FX_DWORD m_dwByteIdx; |
| 72 uint8_t *m_pBuf; | 72 |
| 73 | 73 FX_DWORD m_dwBitIdx; |
| 74 FX_DWORD m_dwLength; | |
| 75 | |
| 76 FX_DWORD m_dwByteIdx; | |
| 77 | |
| 78 FX_DWORD m_dwBitIdx; | |
| 79 }; | 74 }; |
| 80 inline CJBig2_BitStream::CJBig2_BitStream(uint8_t *pBuffer, FX_DWORD dwLength) | 75 inline CJBig2_BitStream::CJBig2_BitStream(uint8_t* pBuffer, FX_DWORD dwLength) { |
| 81 { | 76 m_pBuf = pBuffer; |
| 82 m_pBuf = pBuffer; | 77 m_dwLength = dwLength; |
| 83 m_dwLength = dwLength; | 78 m_dwByteIdx = 0; |
| 84 m_dwByteIdx = 0; | 79 m_dwBitIdx = 0; |
| 85 m_dwBitIdx = 0; | 80 if (m_dwLength > 256 * 1024 * 1024) { |
| 86 if (m_dwLength > 256 * 1024 * 1024) { | 81 m_dwLength = 0; |
| 87 m_dwLength = 0; | 82 m_pBuf = NULL; |
| 88 m_pBuf = NULL; | 83 } |
| 89 } | 84 } |
| 90 } | 85 inline CJBig2_BitStream::CJBig2_BitStream(CJBig2_BitStream& bs) { |
| 91 inline CJBig2_BitStream::CJBig2_BitStream(CJBig2_BitStream &bs) | 86 m_pBuf = bs.m_pBuf; |
| 92 { | 87 m_dwLength = bs.m_dwLength; |
| 93 m_pBuf = bs.m_pBuf; | 88 m_dwByteIdx = bs.m_dwByteIdx; |
| 94 m_dwLength = bs.m_dwLength; | 89 m_dwBitIdx = bs.m_dwBitIdx; |
| 95 m_dwByteIdx = bs.m_dwByteIdx; | 90 } |
| 96 m_dwBitIdx = bs.m_dwBitIdx; | 91 inline CJBig2_BitStream::~CJBig2_BitStream() {} |
| 97 } | 92 inline int32_t CJBig2_BitStream::readNBits(FX_DWORD dwBits, |
| 98 inline CJBig2_BitStream::~CJBig2_BitStream() | 93 FX_DWORD* dwResult) { |
| 99 { | 94 FX_DWORD dwTemp = (m_dwByteIdx << 3) + m_dwBitIdx; |
| 100 } | 95 if (dwTemp <= (m_dwLength << 3)) { |
| 101 inline int32_t CJBig2_BitStream::readNBits(FX_DWORD dwBits, FX_DWORD *dwResult) | 96 *dwResult = 0; |
| 102 { | 97 if (dwTemp + dwBits <= (m_dwLength << 3)) { |
| 103 FX_DWORD dwTemp = (m_dwByteIdx << 3) + m_dwBitIdx; | 98 dwTemp = dwBits; |
| 104 if(dwTemp <= (m_dwLength << 3)) { | 99 } else { |
| 105 *dwResult = 0; | 100 dwTemp = (m_dwLength << 3) - dwTemp; |
| 106 if(dwTemp + dwBits <= (m_dwLength << 3)) { | 101 } |
| 107 dwTemp = dwBits; | 102 while (dwTemp > 0) { |
| 108 } else { | 103 *dwResult = |
| 109 dwTemp = (m_dwLength << 3) - dwTemp; | 104 (*dwResult << 1) | ((m_pBuf[m_dwByteIdx] >> (7 - m_dwBitIdx)) & 0x01); |
| 110 } | 105 if (m_dwBitIdx == 7) { |
| 111 while(dwTemp > 0) { | 106 m_dwByteIdx++; |
| 112 *dwResult = (*dwResult << 1) | ((m_pBuf[m_dwByteIdx] >> (7 - m_dwBit
Idx)) & 0x01); | |
| 113 if(m_dwBitIdx == 7) { | |
| 114 m_dwByteIdx ++; | |
| 115 m_dwBitIdx = 0; | |
| 116 } else { | |
| 117 m_dwBitIdx ++; | |
| 118 } | |
| 119 dwTemp --; | |
| 120 } | |
| 121 return 0; | |
| 122 } else { | |
| 123 return -1; | |
| 124 } | |
| 125 } | |
| 126 inline int32_t CJBig2_BitStream::readNBits(FX_DWORD dwBits, int32_t *nResult) | |
| 127 { | |
| 128 FX_DWORD dwTemp = (m_dwByteIdx << 3) + m_dwBitIdx; | |
| 129 if(dwTemp <= (m_dwLength << 3)) { | |
| 130 *nResult = 0; | |
| 131 if(dwTemp + dwBits <= (m_dwLength << 3)) { | |
| 132 dwTemp = dwBits; | |
| 133 } else { | |
| 134 dwTemp = (m_dwLength << 3) - dwTemp; | |
| 135 } | |
| 136 while(dwTemp > 0) { | |
| 137 *nResult = (*nResult << 1) | ((m_pBuf[m_dwByteIdx] >> (7 - m_dwBitId
x)) & 0x01); | |
| 138 if(m_dwBitIdx == 7) { | |
| 139 m_dwByteIdx ++; | |
| 140 m_dwBitIdx = 0; | |
| 141 } else { | |
| 142 m_dwBitIdx ++; | |
| 143 } | |
| 144 dwTemp --; | |
| 145 } | |
| 146 return 0; | |
| 147 } else { | |
| 148 return -1; | |
| 149 } | |
| 150 } | |
| 151 | |
| 152 inline int32_t CJBig2_BitStream::read1Bit(FX_DWORD *dwResult) | |
| 153 { | |
| 154 if(m_dwByteIdx < m_dwLength) { | |
| 155 *dwResult = (m_pBuf[m_dwByteIdx] >> (7 - m_dwBitIdx)) & 0x01; | |
| 156 if(m_dwBitIdx == 7) { | |
| 157 m_dwByteIdx ++; | |
| 158 m_dwBitIdx = 0; | |
| 159 } else { | |
| 160 m_dwBitIdx ++; | |
| 161 } | |
| 162 return 0; | |
| 163 } else { | |
| 164 return -1; | |
| 165 } | |
| 166 } | |
| 167 | |
| 168 inline int32_t CJBig2_BitStream::read1Bit(FX_BOOL *bResult) | |
| 169 { | |
| 170 if(m_dwByteIdx < m_dwLength) { | |
| 171 *bResult = (m_pBuf[m_dwByteIdx] >> (7 - m_dwBitIdx)) & 0x01; | |
| 172 if(m_dwBitIdx == 7) { | |
| 173 m_dwByteIdx ++; | |
| 174 m_dwBitIdx = 0; | |
| 175 } else { | |
| 176 m_dwBitIdx ++; | |
| 177 } | |
| 178 return 0; | |
| 179 } else { | |
| 180 return -1; | |
| 181 } | |
| 182 } | |
| 183 inline int32_t CJBig2_BitStream::read1Byte(uint8_t *cResult) | |
| 184 { | |
| 185 if(m_dwByteIdx < m_dwLength) { | |
| 186 *cResult = m_pBuf[m_dwByteIdx]; | |
| 187 m_dwByteIdx ++; | |
| 188 return 0; | |
| 189 } else { | |
| 190 return -1; | |
| 191 } | |
| 192 } | |
| 193 | |
| 194 inline int32_t CJBig2_BitStream::readInteger(FX_DWORD *dwResult) | |
| 195 { | |
| 196 if(m_dwByteIdx + 3 < m_dwLength) { | |
| 197 *dwResult = (m_pBuf[m_dwByteIdx] << 24) | (m_pBuf[m_dwByteIdx + 1] << 16
) | |
| 198 | (m_pBuf[m_dwByteIdx + 2] << 8) | m_pBuf[m_dwByteIdx + 3]; | |
| 199 m_dwByteIdx += 4; | |
| 200 return 0; | |
| 201 } else { | |
| 202 return -1; | |
| 203 } | |
| 204 } | |
| 205 | |
| 206 inline int32_t CJBig2_BitStream::readShortInteger(FX_WORD *dwResult) | |
| 207 { | |
| 208 if(m_dwByteIdx + 1 < m_dwLength) { | |
| 209 *dwResult = (m_pBuf[m_dwByteIdx] << 8) | m_pBuf[m_dwByteIdx + 1]; | |
| 210 m_dwByteIdx += 2; | |
| 211 return 0; | |
| 212 } else { | |
| 213 return -1; | |
| 214 } | |
| 215 } | |
| 216 inline void CJBig2_BitStream::alignByte() | |
| 217 { | |
| 218 if(m_dwBitIdx != 0) { | |
| 219 m_dwByteIdx ++; | |
| 220 m_dwBitIdx = 0; | 107 m_dwBitIdx = 0; |
| 221 } | 108 } else { |
| 222 } | 109 m_dwBitIdx++; |
| 223 inline void CJBig2_BitStream::align4Byte() | 110 } |
| 224 { | 111 dwTemp--; |
| 225 if(m_dwBitIdx != 0) { | 112 } |
| 226 m_dwByteIdx ++; | 113 return 0; |
| 114 } else { |
| 115 return -1; |
| 116 } |
| 117 } |
| 118 inline int32_t CJBig2_BitStream::readNBits(FX_DWORD dwBits, int32_t* nResult) { |
| 119 FX_DWORD dwTemp = (m_dwByteIdx << 3) + m_dwBitIdx; |
| 120 if (dwTemp <= (m_dwLength << 3)) { |
| 121 *nResult = 0; |
| 122 if (dwTemp + dwBits <= (m_dwLength << 3)) { |
| 123 dwTemp = dwBits; |
| 124 } else { |
| 125 dwTemp = (m_dwLength << 3) - dwTemp; |
| 126 } |
| 127 while (dwTemp > 0) { |
| 128 *nResult = |
| 129 (*nResult << 1) | ((m_pBuf[m_dwByteIdx] >> (7 - m_dwBitIdx)) & 0x01); |
| 130 if (m_dwBitIdx == 7) { |
| 131 m_dwByteIdx++; |
| 227 m_dwBitIdx = 0; | 132 m_dwBitIdx = 0; |
| 228 } | 133 } else { |
| 229 m_dwByteIdx = (m_dwByteIdx + 3) & -4; | 134 m_dwBitIdx++; |
| 230 } | 135 } |
| 231 inline uint8_t CJBig2_BitStream::getAt(FX_DWORD dwOffset) | 136 dwTemp--; |
| 232 { | 137 } |
| 233 if(dwOffset < m_dwLength) { | 138 return 0; |
| 234 return m_pBuf[dwOffset]; | 139 } else { |
| 235 } else { | 140 return -1; |
| 236 return 0; | 141 } |
| 237 } | 142 } |
| 238 } | 143 |
| 239 inline uint8_t CJBig2_BitStream::getCurByte() | 144 inline int32_t CJBig2_BitStream::read1Bit(FX_DWORD* dwResult) { |
| 240 { | 145 if (m_dwByteIdx < m_dwLength) { |
| 241 if(m_dwByteIdx < m_dwLength) { | 146 *dwResult = (m_pBuf[m_dwByteIdx] >> (7 - m_dwBitIdx)) & 0x01; |
| 242 return m_pBuf[m_dwByteIdx]; | 147 if (m_dwBitIdx == 7) { |
| 243 } else { | 148 m_dwByteIdx++; |
| 244 return 0; | 149 m_dwBitIdx = 0; |
| 245 } | 150 } else { |
| 246 } | 151 m_dwBitIdx++; |
| 247 inline uint8_t CJBig2_BitStream::getNextByte() | 152 } |
| 248 { | 153 return 0; |
| 249 if(m_dwByteIdx + 1 < m_dwLength) { | 154 } else { |
| 250 return m_pBuf[m_dwByteIdx + 1]; | 155 return -1; |
| 251 } else { | 156 } |
| 252 return 0; | 157 } |
| 253 } | 158 |
| 254 } | 159 inline int32_t CJBig2_BitStream::read1Bit(FX_BOOL* bResult) { |
| 255 inline int32_t CJBig2_BitStream::incByteIdx() | 160 if (m_dwByteIdx < m_dwLength) { |
| 256 { | 161 *bResult = (m_pBuf[m_dwByteIdx] >> (7 - m_dwBitIdx)) & 0x01; |
| 257 if(m_dwByteIdx < m_dwLength) { | 162 if (m_dwBitIdx == 7) { |
| 258 m_dwByteIdx ++; | 163 m_dwByteIdx++; |
| 259 return 0; | 164 m_dwBitIdx = 0; |
| 260 } else { | 165 } else { |
| 261 return -1; | 166 m_dwBitIdx++; |
| 262 } | 167 } |
| 263 } | 168 return 0; |
| 264 inline uint8_t CJBig2_BitStream::getCurByte_arith() | 169 } else { |
| 265 { | 170 return -1; |
| 266 if(m_dwByteIdx < m_dwLength) { | 171 } |
| 267 return m_pBuf[m_dwByteIdx]; | 172 } |
| 268 } else { | 173 inline int32_t CJBig2_BitStream::read1Byte(uint8_t* cResult) { |
| 269 return 0xff; | 174 if (m_dwByteIdx < m_dwLength) { |
| 270 } | 175 *cResult = m_pBuf[m_dwByteIdx]; |
| 271 } | 176 m_dwByteIdx++; |
| 272 inline uint8_t CJBig2_BitStream::getNextByte_arith() | 177 return 0; |
| 273 { | 178 } else { |
| 274 if(m_dwByteIdx + 1 < m_dwLength) { | 179 return -1; |
| 275 return m_pBuf[m_dwByteIdx + 1]; | 180 } |
| 276 } else { | 181 } |
| 277 return 0xff; | 182 |
| 278 } | 183 inline int32_t CJBig2_BitStream::readInteger(FX_DWORD* dwResult) { |
| 279 } | 184 if (m_dwByteIdx + 3 < m_dwLength) { |
| 280 inline FX_DWORD CJBig2_BitStream::getOffset() | 185 *dwResult = (m_pBuf[m_dwByteIdx] << 24) | (m_pBuf[m_dwByteIdx + 1] << 16) | |
| 281 { | 186 (m_pBuf[m_dwByteIdx + 2] << 8) | m_pBuf[m_dwByteIdx + 3]; |
| 282 return m_dwByteIdx; | 187 m_dwByteIdx += 4; |
| 283 } | 188 return 0; |
| 284 inline void CJBig2_BitStream::setOffset(FX_DWORD dwOffset) | 189 } else { |
| 285 { | 190 return -1; |
| 286 if (dwOffset > m_dwLength) { | 191 } |
| 287 dwOffset = m_dwLength; | 192 } |
| 288 } | 193 |
| 289 m_dwByteIdx = dwOffset; | 194 inline int32_t CJBig2_BitStream::readShortInteger(FX_WORD* dwResult) { |
| 290 } | 195 if (m_dwByteIdx + 1 < m_dwLength) { |
| 291 inline FX_DWORD CJBig2_BitStream::getBitPos() | 196 *dwResult = (m_pBuf[m_dwByteIdx] << 8) | m_pBuf[m_dwByteIdx + 1]; |
| 292 { | 197 m_dwByteIdx += 2; |
| 293 return (m_dwByteIdx << 3) + m_dwBitIdx; | 198 return 0; |
| 294 } | 199 } else { |
| 295 inline void CJBig2_BitStream::setBitPos(FX_DWORD dwBitPos) | 200 return -1; |
| 296 { | 201 } |
| 297 m_dwByteIdx = dwBitPos >> 3; | 202 } |
| 298 m_dwBitIdx = dwBitPos & 7; | 203 inline void CJBig2_BitStream::alignByte() { |
| 299 } | 204 if (m_dwBitIdx != 0) { |
| 300 inline uint8_t *CJBig2_BitStream::getBuf() | 205 m_dwByteIdx++; |
| 301 { | 206 m_dwBitIdx = 0; |
| 302 return m_pBuf; | 207 } |
| 303 } | 208 } |
| 304 inline uint8_t *CJBig2_BitStream::getPointer() | 209 inline void CJBig2_BitStream::align4Byte() { |
| 305 { | 210 if (m_dwBitIdx != 0) { |
| 306 return m_pBuf + m_dwByteIdx; | 211 m_dwByteIdx++; |
| 307 } | 212 m_dwBitIdx = 0; |
| 308 inline void CJBig2_BitStream::offset(FX_DWORD dwOffset) | 213 } |
| 309 { | 214 m_dwByteIdx = (m_dwByteIdx + 3) & -4; |
| 310 m_dwByteIdx += dwOffset; | 215 } |
| 311 } | 216 inline uint8_t CJBig2_BitStream::getAt(FX_DWORD dwOffset) { |
| 312 inline FX_DWORD CJBig2_BitStream::getByteLeft() | 217 if (dwOffset < m_dwLength) { |
| 313 { | 218 return m_pBuf[dwOffset]; |
| 314 return m_dwLength - m_dwByteIdx; | 219 } else { |
| 220 return 0; |
| 221 } |
| 222 } |
| 223 inline uint8_t CJBig2_BitStream::getCurByte() { |
| 224 if (m_dwByteIdx < m_dwLength) { |
| 225 return m_pBuf[m_dwByteIdx]; |
| 226 } else { |
| 227 return 0; |
| 228 } |
| 229 } |
| 230 inline uint8_t CJBig2_BitStream::getNextByte() { |
| 231 if (m_dwByteIdx + 1 < m_dwLength) { |
| 232 return m_pBuf[m_dwByteIdx + 1]; |
| 233 } else { |
| 234 return 0; |
| 235 } |
| 236 } |
| 237 inline int32_t CJBig2_BitStream::incByteIdx() { |
| 238 if (m_dwByteIdx < m_dwLength) { |
| 239 m_dwByteIdx++; |
| 240 return 0; |
| 241 } else { |
| 242 return -1; |
| 243 } |
| 244 } |
| 245 inline uint8_t CJBig2_BitStream::getCurByte_arith() { |
| 246 if (m_dwByteIdx < m_dwLength) { |
| 247 return m_pBuf[m_dwByteIdx]; |
| 248 } else { |
| 249 return 0xff; |
| 250 } |
| 251 } |
| 252 inline uint8_t CJBig2_BitStream::getNextByte_arith() { |
| 253 if (m_dwByteIdx + 1 < m_dwLength) { |
| 254 return m_pBuf[m_dwByteIdx + 1]; |
| 255 } else { |
| 256 return 0xff; |
| 257 } |
| 258 } |
| 259 inline FX_DWORD CJBig2_BitStream::getOffset() { |
| 260 return m_dwByteIdx; |
| 261 } |
| 262 inline void CJBig2_BitStream::setOffset(FX_DWORD dwOffset) { |
| 263 if (dwOffset > m_dwLength) { |
| 264 dwOffset = m_dwLength; |
| 265 } |
| 266 m_dwByteIdx = dwOffset; |
| 267 } |
| 268 inline FX_DWORD CJBig2_BitStream::getBitPos() { |
| 269 return (m_dwByteIdx << 3) + m_dwBitIdx; |
| 270 } |
| 271 inline void CJBig2_BitStream::setBitPos(FX_DWORD dwBitPos) { |
| 272 m_dwByteIdx = dwBitPos >> 3; |
| 273 m_dwBitIdx = dwBitPos & 7; |
| 274 } |
| 275 inline uint8_t* CJBig2_BitStream::getBuf() { |
| 276 return m_pBuf; |
| 277 } |
| 278 inline uint8_t* CJBig2_BitStream::getPointer() { |
| 279 return m_pBuf + m_dwByteIdx; |
| 280 } |
| 281 inline void CJBig2_BitStream::offset(FX_DWORD dwOffset) { |
| 282 m_dwByteIdx += dwOffset; |
| 283 } |
| 284 inline FX_DWORD CJBig2_BitStream::getByteLeft() { |
| 285 return m_dwLength - m_dwByteIdx; |
| 315 } | 286 } |
| 316 #endif | 287 #endif |
| OLD | NEW |