Merge to XFA: Use stdint.h types throughout PDFium.
[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 #include "JBig2_Define.h"
10 class CJBig2_BitStream : public CJBig2_Object
11 {
12 public:
13
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()
61     {
62         return m_dwLength;
63     }
64
65     uint8_t *getPointer();
66
67     void offset(FX_DWORD dwOffset);
68
69     FX_DWORD getByteLeft();
70 private:
71
72     uint8_t *m_pBuf;
73
74     FX_DWORD m_dwLength;
75
76     FX_DWORD m_dwByteIdx;
77
78     FX_DWORD m_dwBitIdx;
79 };
80 inline CJBig2_BitStream::CJBig2_BitStream(uint8_t *pBuffer, FX_DWORD dwLength)
81 {
82     m_pBuf = pBuffer;
83     m_dwLength = dwLength;
84     m_dwByteIdx = 0;
85     m_dwBitIdx  = 0;
86     if (m_dwLength > 256 * 1024 * 1024) {
87         m_dwLength = 0;
88         m_pBuf = NULL;
89     }
90 }
91 inline CJBig2_BitStream::CJBig2_BitStream(CJBig2_BitStream &bs)
92 {
93     m_pBuf = bs.m_pBuf;
94     m_dwLength = bs.m_dwLength;
95     m_dwByteIdx = bs.m_dwByteIdx;
96     m_dwBitIdx = bs.m_dwBitIdx;
97 }
98 inline CJBig2_BitStream::~CJBig2_BitStream()
99 {
100 }
101 inline int32_t CJBig2_BitStream::readNBits(FX_DWORD dwBits, FX_DWORD *dwResult)
102 {
103     FX_DWORD dwTemp = (m_dwByteIdx << 3) + m_dwBitIdx;
104     if(dwTemp <= (m_dwLength << 3)) {
105         *dwResult = 0;
106         if(dwTemp + dwBits <= (m_dwLength << 3)) {
107             dwTemp = dwBits;
108         } else {
109             dwTemp = (m_dwLength << 3) - dwTemp;
110         }
111         while(dwTemp > 0) {
112             *dwResult = (*dwResult << 1) | ((m_pBuf[m_dwByteIdx] >> (7 - m_dwBitIdx)) & 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_dwBitIdx)) & 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;
221     }
222 }
223 inline void CJBig2_BitStream::align4Byte()
224 {
225     if(m_dwBitIdx != 0) {
226         m_dwByteIdx ++;
227         m_dwBitIdx = 0;
228     }
229     m_dwByteIdx = (m_dwByteIdx + 3) & -4;
230 }
231 inline uint8_t CJBig2_BitStream::getAt(FX_DWORD dwOffset)
232 {
233     if(dwOffset < m_dwLength) {
234         return m_pBuf[dwOffset];
235     } else {
236         return 0;
237     }
238 }
239 inline uint8_t CJBig2_BitStream::getCurByte()
240 {
241     if(m_dwByteIdx < m_dwLength) {
242         return m_pBuf[m_dwByteIdx];
243     } else {
244         return 0;
245     }
246 }
247 inline uint8_t CJBig2_BitStream::getNextByte()
248 {
249     if(m_dwByteIdx + 1 < m_dwLength) {
250         return m_pBuf[m_dwByteIdx + 1];
251     } else {
252         return 0;
253     }
254 }
255 inline int32_t CJBig2_BitStream::incByteIdx()
256 {
257     if(m_dwByteIdx < m_dwLength) {
258         m_dwByteIdx ++;
259         return 0;
260     } else {
261         return -1;
262     }
263 }
264 inline uint8_t CJBig2_BitStream::getCurByte_arith()
265 {
266     if(m_dwByteIdx < m_dwLength) {
267         return m_pBuf[m_dwByteIdx];
268     } else {
269         return 0xff;
270     }
271 }
272 inline uint8_t CJBig2_BitStream::getNextByte_arith()
273 {
274     if(m_dwByteIdx + 1 < m_dwLength) {
275         return m_pBuf[m_dwByteIdx + 1];
276     } else {
277         return 0xff;
278     }
279 }
280 inline FX_DWORD CJBig2_BitStream::getOffset()
281 {
282     return m_dwByteIdx;
283 }
284 inline void CJBig2_BitStream::setOffset(FX_DWORD dwOffset)
285 {
286     if (dwOffset > m_dwLength) {
287         dwOffset = m_dwLength;
288     }
289     m_dwByteIdx = dwOffset;
290 }
291 inline FX_DWORD CJBig2_BitStream::getBitPos()
292 {
293     return (m_dwByteIdx << 3) + m_dwBitIdx;
294 }
295 inline void CJBig2_BitStream::setBitPos(FX_DWORD dwBitPos)
296 {
297     m_dwByteIdx = dwBitPos >> 3;
298     m_dwBitIdx = dwBitPos & 7;
299 }
300 inline uint8_t *CJBig2_BitStream::getBuf()
301 {
302     return m_pBuf;
303 }
304 inline uint8_t *CJBig2_BitStream::getPointer()
305 {
306     return m_pBuf + m_dwByteIdx;
307 }
308 inline void CJBig2_BitStream::offset(FX_DWORD dwOffset)
309 {
310     m_dwByteIdx += dwOffset;
311 }
312 inline FX_DWORD CJBig2_BitStream::getByteLeft()
313 {
314     return m_dwLength - m_dwByteIdx;
315 }
316 #endif