upgraded to xpdf-3.01pl1
[swftools.git] / pdf2swf / xpdf / JArithmeticDecoder.cc
1 //========================================================================
2 //
3 // JArithmeticDecoder.cc
4 //
5 // Copyright 2002-2004 Glyph & Cog, LLC
6 //
7 //========================================================================
8
9 #include <aconf.h>
10
11 #ifdef USE_GCC_PRAGMAS
12 #pragma implementation
13 #endif
14
15 #include "Object.h"
16 #include "Stream.h"
17 #include "JArithmeticDecoder.h"
18
19 //------------------------------------------------------------------------
20 // JArithmeticDecoderStates
21 //------------------------------------------------------------------------
22
23 JArithmeticDecoderStats::JArithmeticDecoderStats(int contextSizeA) {
24   contextSize = contextSizeA;
25   cxTab = (Guchar *)gmallocn(contextSize, sizeof(Guchar));
26   reset();
27 }
28
29 JArithmeticDecoderStats::~JArithmeticDecoderStats() {
30   gfree(cxTab);
31 }
32
33 JArithmeticDecoderStats *JArithmeticDecoderStats::copy() {
34   JArithmeticDecoderStats *stats;
35
36   stats = new JArithmeticDecoderStats(contextSize);
37   memcpy(stats->cxTab, cxTab, contextSize);
38   return stats;
39 }
40
41 void JArithmeticDecoderStats::reset() {
42   memset(cxTab, 0, contextSize);
43 }
44
45 void JArithmeticDecoderStats::copyFrom(JArithmeticDecoderStats *stats) {
46   memcpy(cxTab, stats->cxTab, contextSize);
47 }
48
49 void JArithmeticDecoderStats::setEntry(Guint cx, int i, int mps) {
50   cxTab[cx] = (i << 1) + mps;
51 }
52
53 //------------------------------------------------------------------------
54 // JArithmeticDecoder
55 //------------------------------------------------------------------------
56
57 Guint JArithmeticDecoder::qeTab[47] = {
58   0x56010000, 0x34010000, 0x18010000, 0x0AC10000,
59   0x05210000, 0x02210000, 0x56010000, 0x54010000,
60   0x48010000, 0x38010000, 0x30010000, 0x24010000,
61   0x1C010000, 0x16010000, 0x56010000, 0x54010000,
62   0x51010000, 0x48010000, 0x38010000, 0x34010000,
63   0x30010000, 0x28010000, 0x24010000, 0x22010000,
64   0x1C010000, 0x18010000, 0x16010000, 0x14010000,
65   0x12010000, 0x11010000, 0x0AC10000, 0x09C10000,
66   0x08A10000, 0x05210000, 0x04410000, 0x02A10000,
67   0x02210000, 0x01410000, 0x01110000, 0x00850000,
68   0x00490000, 0x00250000, 0x00150000, 0x00090000,
69   0x00050000, 0x00010000, 0x56010000
70 };
71
72 int JArithmeticDecoder::nmpsTab[47] = {
73    1,  2,  3,  4,  5, 38,  7,  8,  9, 10, 11, 12, 13, 29, 15, 16,
74   17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
75   33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 45, 46
76 };
77
78 int JArithmeticDecoder::nlpsTab[47] = {
79    1,  6,  9, 12, 29, 33,  6, 14, 14, 14, 17, 18, 20, 21, 14, 14,
80   15, 16, 17, 18, 19, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
81   30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 46
82 };
83
84 int JArithmeticDecoder::switchTab[47] = {
85   1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0,
86   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
87   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
88 };
89
90 JArithmeticDecoder::JArithmeticDecoder() {
91   str = NULL;
92   dataLen = 0;
93   limitStream = gFalse;
94 }
95
96 inline Guint JArithmeticDecoder::readByte() {
97   if (limitStream) {
98     --dataLen;
99     if (dataLen < 0) {
100       return 0xff;
101     }
102   }
103   return (Guint)str->getChar() & 0xff;
104 }
105
106 JArithmeticDecoder::~JArithmeticDecoder() {
107   cleanup();
108 }
109
110 void JArithmeticDecoder::start() {
111   buf0 = readByte();
112   buf1 = readByte();
113
114   // INITDEC
115   c = (buf0 ^ 0xff) << 16;
116   byteIn();
117   c <<= 7;
118   ct -= 7;
119   a = 0x80000000;
120 }
121
122 void JArithmeticDecoder::restart(int dataLenA) {
123   int oldDataLen;
124
125   oldDataLen = dataLen;
126   dataLen = dataLenA;
127   if (oldDataLen == -1) {
128     buf1 = readByte();
129   } else if (oldDataLen <= -2) {
130     buf0 = readByte();
131     buf1 = readByte();
132   }
133 }
134
135 void JArithmeticDecoder::cleanup() {
136   if (limitStream) {
137     while (dataLen > 0) {
138       buf0 = buf1;
139       buf1 = readByte();
140     }
141   }
142 }
143
144 int JArithmeticDecoder::decodeBit(Guint context,
145                                   JArithmeticDecoderStats *stats) {
146   int bit;
147   Guint qe;
148   int iCX, mpsCX;
149
150   iCX = stats->cxTab[context] >> 1;
151   mpsCX = stats->cxTab[context] & 1;
152   qe = qeTab[iCX];
153   a -= qe;
154   if (c < a) {
155     if (a & 0x80000000) {
156       bit = mpsCX;
157     } else {
158       // MPS_EXCHANGE
159       if (a < qe) {
160         bit = 1 - mpsCX;
161         if (switchTab[iCX]) {
162           stats->cxTab[context] = (nlpsTab[iCX] << 1) | (1 - mpsCX);
163         } else {
164           stats->cxTab[context] = (nlpsTab[iCX] << 1) | mpsCX;
165         }
166       } else {
167         bit = mpsCX;
168         stats->cxTab[context] = (nmpsTab[iCX] << 1) | mpsCX;
169       }
170       // RENORMD
171       do {
172         if (ct == 0) {
173           byteIn();
174         }
175         a <<= 1;
176         c <<= 1;
177         --ct;
178       } while (!(a & 0x80000000));
179     }
180   } else {
181     c -= a;
182     // LPS_EXCHANGE
183     if (a < qe) {
184       bit = mpsCX;
185       stats->cxTab[context] = (nmpsTab[iCX] << 1) | mpsCX;
186     } else {
187       bit = 1 - mpsCX;
188       if (switchTab[iCX]) {
189         stats->cxTab[context] = (nlpsTab[iCX] << 1) | (1 - mpsCX);
190       } else {
191         stats->cxTab[context] = (nlpsTab[iCX] << 1) | mpsCX;
192       }
193     }
194     a = qe;
195     // RENORMD
196     do {
197       if (ct == 0) {
198         byteIn();
199       }
200       a <<= 1;
201       c <<= 1;
202       --ct;
203     } while (!(a & 0x80000000));
204   }
205   return bit;
206 }
207
208 int JArithmeticDecoder::decodeByte(Guint context,
209                                    JArithmeticDecoderStats *stats) {
210   int byte;
211   int i;
212
213   byte = 0;
214   for (i = 0; i < 8; ++i) {
215     byte = (byte << 1) | decodeBit(context, stats);
216   }
217   return byte;
218 }
219
220 GBool JArithmeticDecoder::decodeInt(int *x, JArithmeticDecoderStats *stats) {
221   int s;
222   Guint v;
223   int i;
224
225   prev = 1;
226   s = decodeIntBit(stats);
227   if (decodeIntBit(stats)) {
228     if (decodeIntBit(stats)) {
229       if (decodeIntBit(stats)) {
230         if (decodeIntBit(stats)) {
231           if (decodeIntBit(stats)) {
232             v = 0;
233             for (i = 0; i < 32; ++i) {
234               v = (v << 1) | decodeIntBit(stats);
235             }
236             v += 4436;
237           } else {
238             v = 0;
239             for (i = 0; i < 12; ++i) {
240               v = (v << 1) | decodeIntBit(stats);
241             }
242             v += 340;
243           }
244         } else {
245           v = 0;
246           for (i = 0; i < 8; ++i) {
247             v = (v << 1) | decodeIntBit(stats);
248           }
249           v += 84;
250         }
251       } else {
252         v = 0;
253         for (i = 0; i < 6; ++i) {
254           v = (v << 1) | decodeIntBit(stats);
255         }
256         v += 20;
257       }
258     } else {
259       v = decodeIntBit(stats);
260       v = (v << 1) | decodeIntBit(stats);
261       v = (v << 1) | decodeIntBit(stats);
262       v = (v << 1) | decodeIntBit(stats);
263       v += 4;
264     }
265   } else {
266     v = decodeIntBit(stats);
267     v = (v << 1) | decodeIntBit(stats);
268   }
269
270   if (s) {
271     if (v == 0) {
272       return gFalse;
273     }
274     *x = -(int)v;
275   } else {
276     *x = (int)v;
277   }
278   return gTrue;
279 }
280
281 int JArithmeticDecoder::decodeIntBit(JArithmeticDecoderStats *stats) {
282   int bit;
283
284   bit = decodeBit(prev, stats);
285   if (prev < 0x100) {
286     prev = (prev << 1) | bit;
287   } else {
288     prev = (((prev << 1) | bit) & 0x1ff) | 0x100;
289   }
290   return bit;
291 }
292
293 Guint JArithmeticDecoder::decodeIAID(Guint codeLen,
294                                      JArithmeticDecoderStats *stats) {
295   Guint i;
296   int bit;
297
298   prev = 1;
299   for (i = 0; i < codeLen; ++i) {
300     bit = decodeBit(prev, stats);
301     prev = (prev << 1) | bit;
302   }
303   return prev - (1 << codeLen);
304 }
305
306 void JArithmeticDecoder::byteIn() {
307   if (buf0 == 0xff) {
308     if (buf1 > 0x8f) {
309       ct = 8;
310     } else {
311       buf0 = buf1;
312       buf1 = readByte();
313       c = c + 0xfe00 - (buf0 << 9);
314       ct = 7;
315     }
316   } else {
317     buf0 = buf1;
318     buf1 = readByte();
319     c = c + 0xff00 - (buf0 << 8);
320     ct = 8;
321   }
322 }