KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > lowagie > text > pdf > codec > CCITTG4Encoder


1 /*
2  * Copyright 2005 by Paulo Soares.
3  *
4  * The contents of this file are subject to the Mozilla Public License Version 1.1
5  * (the "License"); you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at http://www.mozilla.org/MPL/
7  *
8  * Software distributed under the License is distributed on an "AS IS" basis,
9  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
10  * for the specific language governing rights and limitations under the License.
11  *
12  * The Original Code is 'iText, a free JAVA-PDF library'.
13  *
14  * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
15  * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
16  * All Rights Reserved.
17  * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
18  * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
19  *
20  * Contributor(s): all the names of the contributors are added in the source code
21  * where applicable.
22  *
23  * Alternatively, the contents of this file may be used under the terms of the
24  * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
25  * provisions of LGPL are applicable instead of those above. If you wish to
26  * allow use of your version of this file only under the terms of the LGPL
27  * License and not to allow others to use your version of this file under
28  * the MPL, indicate your decision by deleting the provisions above and
29  * replace them with the notice and other provisions required by the LGPL.
30  * If you do not delete the provisions above, a recipient may use your version
31  * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
32  *
33  * This library is free software; you can redistribute it and/or modify it
34  * under the terms of the MPL as stated above or under the terms of the GNU
35  * Library General Public License as published by the Free Software Foundation;
36  * either version 2 of the License, or any later version.
37  *
38  * This library is distributed in the hope that it will be useful, but WITHOUT
39  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
40  * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
41  * details.
42  *
43  * If you didn't download this code from the following link, you should check if
44  * you aren't using an obsolete version:
45  * http://www.lowagie.com/iText/
46  *
47  * This code is base in the libtiff encoder
48  */
49 package com.lowagie.text.pdf.codec;
50
51 import com.lowagie.text.pdf.ByteBuffer;
52
53 /**
54  * Encodes data in the CCITT G4 FAX format.
55  */
56 public class CCITTG4Encoder {
57     private int rowbytes;
58     private int rowpixels;
59     private int bit = 8;
60     private int data;
61     private byte[] refline;
62     private ByteBuffer outBuf = new ByteBuffer(1024);
63     private byte[] dataBp;
64     private int offsetData;
65     private int sizeData;
66     
67     /**
68      * Creates a new encoder.
69      * @param width the line width
70      */
71     public CCITTG4Encoder(int width) {
72         rowpixels = width;
73         rowbytes = (rowpixels + 7) / 8;
74         refline = new byte[rowbytes];
75     }
76     
77     /**
78      * Encodes a number of lines.
79      * @param data the data to be encoded
80      * @param offset the offset into the data
81      * @param size the size of the data to be encoded
82      */
83     public void fax4Encode(byte[] data, int offset, int size) {
84         dataBp = data;
85         offsetData = offset;
86         sizeData = size;
87         while (sizeData > 0) {
88             Fax3Encode2DRow();
89             System.arraycopy(dataBp, offsetData, refline, 0, rowbytes);
90             offsetData += rowbytes;
91             sizeData -= rowbytes;
92         }
93     }
94     
95
96     /**
97      * Encodes a full image.
98      * @param data the data to encode
99      * @param width the image width
100      * @param height the image height
101      * @return the encoded image
102      */
103     public static byte[] compress(byte[] data, int width, int height) {
104         CCITTG4Encoder g4 = new CCITTG4Encoder(width);
105         g4.fax4Encode(data, 0, g4.rowbytes * height);
106         return g4.close();
107     }
108     
109     /**
110      * Encodes a number of lines.
111      * @param data the data to be encoded
112      * @param height the number of lines to encode
113      */
114     public void fax4Encode(byte[] data, int height) {
115         fax4Encode(data, 0, rowbytes * height);
116     }
117
118     private void putcode(int[] table) {
119         putBits(table[CODE], table[LENGTH]);
120     }
121     
122     private void putspan(int span, int[][] tab) {
123         int code, length;
124         
125         while (span >= 2624) {
126             int[] te = tab[63 + (2560>>6)];
127             code = te[CODE];
128             length = te[LENGTH];
129             putBits(code, length);
130             span -= te[RUNLEN];
131         }
132         if (span >= 64) {
133             int[] te = tab[63 + (span>>6)];
134             code = te[CODE];
135             length = te[LENGTH];
136             putBits(code, length);
137             span -= te[RUNLEN];
138         }
139         code = tab[span][CODE];
140         length = tab[span][LENGTH];
141         putBits(code, length);
142     }
143     
144     private void putBits(int bits, int length) {
145         while (length > bit) {
146             data |= bits >> (length - bit);
147             length -= bit;
148             outBuf.append((byte)data);
149             data = 0;
150             bit = 8;
151         }
152         data |= (bits & msbmask[length]) << (bit - length);
153         bit -= length;
154         if (bit == 0) {
155             outBuf.append((byte)data);
156             data = 0;
157             bit = 8;
158         }
159     }
160     
161     private void Fax3Encode2DRow() {
162         int a0 = 0;
163         int a1 = (pixel(dataBp, offsetData, 0) != 0 ? 0 : finddiff(dataBp, offsetData, 0, rowpixels, 0));
164         int b1 = (pixel(refline, 0, 0) != 0 ? 0 : finddiff(refline, 0, 0, rowpixels, 0));
165         int a2, b2;
166         
167         for (;;) {
168             b2 = finddiff2(refline, 0, b1, rowpixels, pixel(refline, 0,b1));
169             if (b2 >= a1) {
170                 int d = b1 - a1;
171                 if (!(-3 <= d && d <= 3)) { /* horizontal mode */
172                     a2 = finddiff2(dataBp, offsetData, a1, rowpixels, pixel(dataBp, offsetData,a1));
173                     putcode(horizcode);
174                     if (a0+a1 == 0 || pixel(dataBp, offsetData, a0) == 0) {
175                         putspan(a1-a0, TIFFFaxWhiteCodes);
176                         putspan(a2-a1, TIFFFaxBlackCodes);
177                     } else {
178                         putspan(a1-a0, TIFFFaxBlackCodes);
179                         putspan(a2-a1, TIFFFaxWhiteCodes);
180                     }
181                     a0 = a2;
182                 } else { /* vertical mode */
183                     putcode(vcodes[d+3]);
184                     a0 = a1;
185                 }
186             } else { /* pass mode */
187                 putcode(passcode);
188                 a0 = b2;
189             }
190             if (a0 >= rowpixels)
191                 break;
192             a1 = finddiff(dataBp, offsetData, a0, rowpixels, pixel(dataBp, offsetData,a0));
193             b1 = finddiff(refline, 0, a0, rowpixels, pixel(dataBp, offsetData,a0) ^ 1);
194             b1 = finddiff(refline, 0, b1, rowpixels, pixel(dataBp, offsetData,a0));
195         }
196     }
197     
198     private void Fax4PostEncode() {
199         putBits(EOL, 12);
200         putBits(EOL, 12);
201         if (bit != 8) {
202             outBuf.append((byte)data);
203             data = 0;
204             bit = 8;
205         }
206     }
207     
208     /**
209      * Closes the encoder and returns the encoded data.
210      * @return the encoded data
211      */
212     public byte[] close() {
213         Fax4PostEncode();
214         return outBuf.toByteArray();
215     }
216     
217     private int pixel(byte[] data, int offset, int bit) {
218         if (bit >= rowpixels)
219             return 0;
220         return ((data[offset + (bit >> 3)] & 0xff) >> (7-((bit)&7))) & 1;
221     }
222     
223     private static int find1span(byte[] bp, int offset, int bs, int be) {
224         int bits = be - bs;
225         int n, span;
226         
227         int pos = offset + (bs >> 3);
228         /*
229          * Check partial byte on lhs.
230          */
231         if (bits > 0 && (n = (bs & 7)) != 0) {
232             span = oneruns[((int)bp[pos] << n) & 0xff];
233             if (span > 8-n) /* table value too generous */
234                 span = 8-n;
235             if (span > bits) /* constrain span to bit range */
236                 span = bits;
237             if (n+span < 8) /* doesn't extend to edge of byte */
238                 return span;
239             bits -= span;
240             pos++;
241         } else
242             span = 0;
243         /*
244          * Scan full bytes for all 1's.
245          */
246         while (bits >= 8) {
247             if (bp[pos] != -1) /* end of run */
248                 return (span + oneruns[bp[pos] & 0xff]);
249             span += 8;
250             bits -= 8;
251             pos++;
252         }
253         /*
254          * Check partial byte on rhs.
255          */
256         if (bits > 0) {
257             n = oneruns[bp[pos] & 0xff];
258             span += (n > bits ? bits : n);
259         }
260         return span;
261     }
262     
263     private static int find0span(byte[] bp, int offset, int bs, int be) {
264         int bits = be - bs;
265         int n, span;
266         
267         int pos = offset + (bs >> 3);
268         /*
269          * Check partial byte on lhs.
270          */
271         if (bits > 0 && (n = (bs & 7)) != 0) {
272             span = zeroruns[((int)bp[pos] << n) & 0xff];
273             if (span > 8-n) /* table value too generous */
274                 span = 8-n;
275             if (span > bits) /* constrain span to bit range */
276                 span = bits;
277             if (n+span < 8) /* doesn't extend to edge of byte */
278                 return span;
279             bits -= span;
280             pos++;
281         } else
282             span = 0;
283         /*
284          * Scan full bytes for all 1's.
285          */
286         while (bits >= 8) {
287             if (bp[pos] != 0) /* end of run */
288                 return (span + zeroruns[bp[pos] & 0xff]);
289             span += 8;
290             bits -= 8;
291             pos++;
292         }
293         /*
294          * Check partial byte on rhs.
295          */
296         if (bits > 0) {
297             n = zeroruns[bp[pos] & 0xff];
298             span += (n > bits ? bits : n);
299         }
300         return span;
301     }
302     
303     private static int finddiff(byte[] bp, int offset, int bs, int be, int color) {
304         return bs + (color != 0 ? find1span(bp, offset, bs, be) : find0span(bp, offset, bs, be));
305     }
306     
307     private static int finddiff2(byte[] bp, int offset, int bs, int be, int color) {
308         return bs < be ? finddiff(bp, offset, bs, be, color) : be;
309     }
310     
311     private static byte zeroruns[] = {
312         8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, /* 0x00 - 0x0f */
313         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0x10 - 0x1f */
314         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0x20 - 0x2f */
315         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0x30 - 0x3f */
316         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x40 - 0x4f */
317         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x50 - 0x5f */
318         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x60 - 0x6f */
319         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x70 - 0x7f */
320         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x80 - 0x8f */
321         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x90 - 0x9f */
322         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xa0 - 0xaf */
323         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xb0 - 0xbf */
324         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xc0 - 0xcf */
325         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xd0 - 0xdf */
326         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xe0 - 0xef */
327         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 0xf0 - 0xff */
328     };
329     
330     private static byte oneruns[] = {
331         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 - 0x0f */
332         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 - 0x1f */
333         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 - 0x2f */
334         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x30 - 0x3f */
335         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 - 0x4f */
336         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 - 0x5f */
337         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 - 0x6f */
338         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x70 - 0x7f */
339         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x80 - 0x8f */
340         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x90 - 0x9f */
341         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xa0 - 0xaf */
342         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xb0 - 0xbf */
343         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0xc0 - 0xcf */
344         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* 0xd0 - 0xdf */
345         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, /* 0xe0 - 0xef */
346         4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 7, 8 /* 0xf0 - 0xff */
347     };
348
349     private static final int LENGTH = 0; /* bit length of g3 code */
350     private static final int CODE = 1; /* g3 code */
351     private static final int RUNLEN = 2; /* run length in bits */
352
353     private static final int EOL = 0x001; /* EOL code value - 0000 0000 0000 1 */
354
355     /* status values returned instead of a run length */
356     private static final int G3CODE_EOL = -1; /* NB: ACT_EOL - ACT_WRUNT */
357     private static final int G3CODE_INVALID = -2; /* NB: ACT_INVALID - ACT_WRUNT */
358     private static final int G3CODE_EOF = -3; /* end of input data */
359     private static final int G3CODE_INCOMP = -4; /* incomplete run code */
360
361     private int[][] TIFFFaxWhiteCodes = {
362         { 8, 0x35, 0 }, /* 0011 0101 */
363         { 6, 0x7, 1 }, /* 0001 11 */
364         { 4, 0x7, 2 }, /* 0111 */
365         { 4, 0x8, 3 }, /* 1000 */
366         { 4, 0xB, 4 }, /* 1011 */
367         { 4, 0xC, 5 }, /* 1100 */
368         { 4, 0xE, 6 }, /* 1110 */
369         { 4, 0xF, 7 }, /* 1111 */
370         { 5, 0x13, 8 }, /* 1001 1 */
371         { 5, 0x14, 9 }, /* 1010 0 */
372         { 5, 0x7, 10 }, /* 0011 1 */
373         { 5, 0x8, 11 }, /* 0100 0 */
374         { 6, 0x8, 12 }, /* 0010 00 */
375         { 6, 0x3, 13 }, /* 0000 11 */
376         { 6, 0x34, 14 }, /* 1101 00 */
377         { 6, 0x35, 15 }, /* 1101 01 */
378         { 6, 0x2A, 16 }, /* 1010 10 */
379         { 6, 0x2B, 17 }, /* 1010 11 */
380         { 7, 0x27, 18 }, /* 0100 111 */
381         { 7, 0xC, 19 }, /* 0001 100 */
382         { 7, 0x8, 20 }, /* 0001 000 */
383         { 7, 0x17, 21 }, /* 0010 111 */
384         { 7, 0x3, 22 }, /* 0000 011 */
385         { 7, 0x4, 23 }, /* 0000 100 */
386         { 7, 0x28, 24 }, /* 0101 000 */
387         { 7, 0x2B, 25 }, /* 0101 011 */
388         { 7, 0x13, 26 }, /* 0010 011 */
389         { 7, 0x24, 27 }, /* 0100 100 */
390         { 7, 0x18, 28 }, /* 0011 000 */
391         { 8, 0x2, 29 }, /* 0000 0010 */
392         { 8, 0x3, 30 }, /* 0000 0011 */
393         { 8, 0x1A, 31 }, /* 0001 1010 */
394         { 8, 0x1B, 32 }, /* 0001 1011 */
395         { 8, 0x12, 33 }, /* 0001 0010 */
396         { 8, 0x13, 34 }, /* 0001 0011 */
397         { 8, 0x14, 35 }, /* 0001 0100 */
398         { 8, 0x15, 36 }, /* 0001 0101 */
399         { 8, 0x16, 37 }, /* 0001 0110 */
400         { 8, 0x17, 38 }, /* 0001 0111 */
401         { 8, 0x28, 39 }, /* 0010 1000 */
402         { 8, 0x29, 40 }, /* 0010 1001 */
403         { 8, 0x2A, 41 }, /* 0010 1010 */
404         { 8, 0x2B, 42 }, /* 0010 1011 */
405         { 8, 0x2C, 43 }, /* 0010 1100 */
406         { 8, 0x2D, 44 }, /* 0010 1101 */
407         { 8, 0x4, 45 }, /* 0000 0100 */
408         { 8, 0x5, 46 }, /* 0000 0101 */
409         { 8, 0xA, 47 }, /* 0000 1010 */
410         { 8, 0xB, 48 }, /* 0000 1011 */
411         { 8, 0x52, 49 }, /* 0101 0010 */
412         { 8, 0x53, 50 }, /* 0101 0011 */
413         { 8, 0x54, 51 }, /* 0101 0100 */
414         { 8, 0x55, 52 }, /* 0101 0101 */
415         { 8, 0x24, 53 }, /* 0010 0100 */
416         { 8, 0x25, 54 }, /* 0010 0101 */
417         { 8, 0x58, 55 }, /* 0101 1000 */
418         { 8, 0x59, 56 }, /* 0101 1001 */
419         { 8, 0x5A, 57 }, /* 0101 1010 */
420         { 8, 0x5B, 58 }, /* 0101 1011 */
421         { 8, 0x4A, 59 }, /* 0100 1010 */
422         { 8, 0x4B, 60 }, /* 0100 1011 */
423         { 8, 0x32, 61 }, /* 0011 0010 */
424         { 8, 0x33, 62 }, /* 0011 0011 */
425         { 8, 0x34, 63 }, /* 0011 0100 */
426         { 5, 0x1B, 64 }, /* 1101 1 */
427         { 5, 0x12, 128 }, /* 1001 0 */
428         { 6, 0x17, 192 }, /* 0101 11 */
429         { 7, 0x37, 256 }, /* 0110 111 */
430         { 8, 0x36, 320 }, /* 0011 0110 */
431         { 8, 0x37, 384 }, /* 0011 0111 */
432         { 8, 0x64, 448 }, /* 0110 0100 */
433         { 8, 0x65, 512 }, /* 0110 0101 */
434         { 8, 0x68, 576 }, /* 0110 1000 */
435         { 8, 0x67, 640 }, /* 0110 0111 */
436         { 9, 0xCC, 704 }, /* 0110 0110 0 */
437         { 9, 0xCD, 768 }, /* 0110 0110 1 */
438         { 9, 0xD2, 832 }, /* 0110 1001 0 */
439         { 9, 0xD3, 896 }, /* 0110 1001 1 */
440         { 9, 0xD4, 960 }, /* 0110 1010 0 */
441         { 9, 0xD5, 1024 }, /* 0110 1010 1 */
442         { 9, 0xD6, 1088 }, /* 0110 1011 0 */
443         { 9, 0xD7, 1152 }, /* 0110 1011 1 */
444         { 9, 0xD8, 1216 }, /* 0110 1100 0 */
445         { 9, 0xD9, 1280 }, /* 0110 1100 1 */
446         { 9, 0xDA, 1344 }, /* 0110 1101 0 */
447         { 9, 0xDB, 1408 }, /* 0110 1101 1 */
448         { 9, 0x98, 1472 }, /* 0100 1100 0 */
449         { 9, 0x99, 1536 }, /* 0100 1100 1 */
450         { 9, 0x9A, 1600 }, /* 0100 1101 0 */
451         { 6, 0x18, 1664 }, /* 0110 00 */
452         { 9, 0x9B, 1728 }, /* 0100 1101 1 */
453         { 11, 0x8, 1792 }, /* 0000 0001 000 */
454         { 11, 0xC, 1856 }, /* 0000 0001 100 */
455         { 11, 0xD, 1920 }, /* 0000 0001 101 */
456         { 12, 0x12, 1984 }, /* 0000 0001 0010 */
457         { 12, 0x13, 2048 }, /* 0000 0001 0011 */
458         { 12, 0x14, 2112 }, /* 0000 0001 0100 */
459         { 12, 0x15, 2176 }, /* 0000 0001 0101 */
460         { 12, 0x16, 2240 }, /* 0000 0001 0110 */
461         { 12, 0x17, 2304 }, /* 0000 0001 0111 */
462         { 12, 0x1C, 2368 }, /* 0000 0001 1100 */
463         { 12, 0x1D, 2432 }, /* 0000 0001 1101 */
464         { 12, 0x1E, 2496 }, /* 0000 0001 1110 */
465         { 12, 0x1F, 2560 }, /* 0000 0001 1111 */
466         { 12, 0x1, G3CODE_EOL }, /* 0000 0000 0001 */
467         { 9, 0x1, G3CODE_INVALID }, /* 0000 0000 1 */
468         { 10, 0x1, G3CODE_INVALID }, /* 0000 0000 01 */
469         { 11, 0x1, G3CODE_INVALID }, /* 0000 0000 001 */
470         { 12, 0x0, G3CODE_INVALID } /* 0000 0000 0000 */
471     };
472
473     private int[][] TIFFFaxBlackCodes = {
474         { 10, 0x37, 0 }, /* 0000 1101 11 */
475         { 3, 0x2, 1 }, /* 010 */
476         { 2, 0x3, 2 }, /* 11 */
477         { 2, 0x2, 3 }, /* 10 */
478         { 3, 0x3, 4 }, /* 011 */
479         { 4, 0x3, 5 }, /* 0011 */
480         { 4, 0x2, 6 }, /* 0010 */
481         { 5, 0x3, 7 }, /* 0001 1 */
482         { 6, 0x5, 8 }, /* 0001 01 */
483         { 6, 0x4, 9 }, /* 0001 00 */
484         { 7, 0x4, 10 }, /* 0000 100 */
485         { 7, 0x5, 11 }, /* 0000 101 */
486         { 7, 0x7, 12 }, /* 0000 111 */
487         { 8, 0x4, 13 }, /* 0000 0100 */
488         { 8, 0x7, 14 }, /* 0000 0111 */
489         { 9, 0x18, 15 }, /* 0000 1100 0 */
490         { 10, 0x17, 16 }, /* 0000 0101 11 */
491         { 10, 0x18, 17 }, /* 0000 0110 00 */
492         { 10, 0x8, 18 }, /* 0000 0010 00 */
493         { 11, 0x67, 19 }, /* 0000 1100 111 */
494         { 11, 0x68, 20 }, /* 0000 1101 000 */
495         { 11, 0x6C, 21 }, /* 0000 1101 100 */
496         { 11, 0x37, 22 }, /* 0000 0110 111 */
497         { 11, 0x28, 23 }, /* 0000 0101 000 */
498         { 11, 0x17, 24 }, /* 0000 0010 111 */
499         { 11, 0x18, 25 }, /* 0000 0011 000 */
500         { 12, 0xCA, 26 }, /* 0000 1100 1010 */
501         { 12, 0xCB, 27 }, /* 0000 1100 1011 */
502         { 12, 0xCC, 28 }, /* 0000 1100 1100 */
503         { 12, 0xCD, 29 }, /* 0000 1100 1101 */
504         { 12, 0x68, 30 }, /* 0000 0110 1000 */
505         { 12, 0x69, 31 }, /* 0000 0110 1001 */
506         { 12, 0x6A, 32 }, /* 0000 0110 1010 */
507         { 12, 0x6B, 33 }, /* 0000 0110 1011 */
508         { 12, 0xD2, 34 }, /* 0000 1101 0010 */
509         { 12, 0xD3, 35 }, /* 0000 1101 0011 */
510         { 12, 0xD4, 36 }, /* 0000 1101 0100 */
511         { 12, 0xD5, 37 }, /* 0000 1101 0101 */
512         { 12, 0xD6, 38 }, /* 0000 1101 0110 */
513         { 12, 0xD7, 39 }, /* 0000 1101 0111 */
514         { 12, 0x6C, 40 }, /* 0000 0110 1100 */
515         { 12, 0x6D, 41 }, /* 0000 0110 1101 */
516         { 12, 0xDA, 42 }, /* 0000 1101 1010 */
517         { 12, 0xDB, 43 }, /* 0000 1101 1011 */
518         { 12, 0x54, 44 }, /* 0000 0101 0100 */
519         { 12, 0x55, 45 }, /* 0000 0101 0101 */
520         { 12, 0x56, 46 }, /* 0000 0101 0110 */
521         { 12, 0x57, 47 }, /* 0000 0101 0111 */
522         { 12, 0x64, 48 }, /* 0000 0110 0100 */
523         { 12, 0x65, 49 }, /* 0000 0110 0101 */
524         { 12, 0x52, 50 }, /* 0000 0101 0010 */
525         { 12, 0x53, 51 }, /* 0000 0101 0011 */
526         { 12, 0x24, 52 }, /* 0000 0010 0100 */
527         { 12, 0x37, 53 }, /* 0000 0011 0111 */
528         { 12, 0x38, 54 }, /* 0000 0011 1000 */
529         { 12, 0x27, 55 }, /* 0000 0010 0111 */
530         { 12, 0x28, 56 }, /* 0000 0010 1000 */
531         { 12, 0x58, 57 }, /* 0000 0101 1000 */
532         { 12, 0x59, 58 }, /* 0000 0101 1001 */
533         { 12, 0x2B, 59 }, /* 0000 0010 1011 */
534         { 12, 0x2C, 60 }, /* 0000 0010 1100 */
535         { 12, 0x5A, 61 }, /* 0000 0101 1010 */
536         { 12, 0x66, 62 }, /* 0000 0110 0110 */
537         { 12, 0x67, 63 }, /* 0000 0110 0111 */
538         { 10, 0xF, 64 }, /* 0000 0011 11 */
539         { 12, 0xC8, 128 }, /* 0000 1100 1000 */
540         { 12, 0xC9, 192 }, /* 0000 1100 1001 */
541         { 12, 0x5B, 256 }, /* 0000 0101 1011 */
542         { 12, 0x33, 320 }, /* 0000 0011 0011 */
543         { 12, 0x34, 384 }, /* 0000 0011 0100 */
544         { 12, 0x35, 448 }, /* 0000 0011 0101 */
545         { 13, 0x6C, 512 }, /* 0000 0011 0110 0 */
546         { 13, 0x6D, 576 }, /* 0000 0011 0110 1 */
547         { 13, 0x4A, 640 }, /* 0000 0010 0101 0 */
548         { 13, 0x4B, 704 }, /* 0000 0010 0101 1 */
549         { 13, 0x4C, 768 }, /* 0000 0010 0110 0 */
550         { 13, 0x4D, 832 }, /* 0000 0010 0110 1 */
551         { 13, 0x72, 896 }, /* 0000 0011 1001 0 */
552         { 13, 0x73, 960 }, /* 0000 0011 1001 1 */
553         { 13, 0x74, 1024 }, /* 0000 0011 1010 0 */
554         { 13, 0x75, 1088 }, /* 0000 0011 1010 1 */
555         { 13, 0x76, 1152 }, /* 0000 0011 1011 0 */
556         { 13, 0x77, 1216 }, /* 0000 0011 1011 1 */
557         { 13, 0x52, 1280 }, /* 0000 0010 1001 0 */
558         { 13, 0x53, 1344 }, /* 0000 0010 1001 1 */
559         { 13, 0x54, 1408 }, /* 0000 0010 1010 0 */
560         { 13, 0x55, 1472 }, /* 0000 0010 1010 1 */
561         { 13, 0x5A, 1536 }, /* 0000 0010 1101 0 */
562         { 13, 0x5B, 1600 }, /* 0000 0010 1101 1 */
563         { 13, 0x64, 1664 }, /* 0000 0011 0010 0 */
564         { 13, 0x65, 1728 }, /* 0000 0011 0010 1 */
565         { 11, 0x8, 1792 }, /* 0000 0001 000 */
566         { 11, 0xC, 1856 }, /* 0000 0001 100 */
567         { 11, 0xD, 1920 }, /* 0000 0001 101 */
568         { 12, 0x12, 1984 }, /* 0000 0001 0010 */
569         { 12, 0x13, 2048 }, /* 0000 0001 0011 */
570         { 12, 0x14, 2112 }, /* 0000 0001 0100 */
571         { 12, 0x15, 2176 }, /* 0000 0001 0101 */
572         { 12, 0x16, 2240 }, /* 0000 0001 0110 */
573         { 12, 0x17, 2304 }, /* 0000 0001 0111 */
574         { 12, 0x1C, 2368 }, /* 0000 0001 1100 */
575         { 12, 0x1D, 2432 }, /* 0000 0001 1101 */
576         { 12, 0x1E, 2496 }, /* 0000 0001 1110 */
577         { 12, 0x1F, 2560 }, /* 0000 0001 1111 */
578         { 12, 0x1, G3CODE_EOL }, /* 0000 0000 0001 */
579         { 9, 0x1, G3CODE_INVALID }, /* 0000 0000 1 */
580         { 10, 0x1, G3CODE_INVALID }, /* 0000 0000 01 */
581         { 11, 0x1, G3CODE_INVALID }, /* 0000 0000 001 */
582         { 12, 0x0, G3CODE_INVALID } /* 0000 0000 0000 */
583     };
584     
585     private int[] horizcode =
586         { 3, 0x1, 0 }; /* 001 */
587     private int[] passcode =
588         { 4, 0x1, 0 }; /* 0001 */
589     private int[][] vcodes = {
590         { 7, 0x03, 0 }, /* 0000 011 */
591         { 6, 0x03, 0 }, /* 0000 11 */
592         { 3, 0x03, 0 }, /* 011 */
593         { 1, 0x1, 0 }, /* 1 */
594         { 3, 0x2, 0 }, /* 010 */
595         { 6, 0x02, 0 }, /* 0000 10 */
596         { 7, 0x02, 0 } /* 0000 010 */
597     };
598     private int[] msbmask =
599     { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
600 }
601
Popular Tags