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