/*
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package ch.randelshofer.quaqua.ext.batik.ext.awt.image.codec.tiff;
/**
*
* @version $Id: TIFFFaxDecoder.java 498740 2007-01-22 18:35:57Z dvholten $
*/
class TIFFFaxDecoder {
private int bitPointer, bytePointer;
private byte[] data;
private int w, h;
private int fillOrder;
// Data structures needed to store changing elements for the previous
// and the current scanline
private int changingElemSize = 0;
private int[] prevChangingElems;
private int[] currChangingElems;
// Element at which to start search in getNextChangingElement
private int lastChangingElement = 0;
private int compression = 2;
// Variables set by T4Options
private int uncompressedMode = 0;
private int fillBits = 0;
private int oneD;
static int[] table1 = {
0x00, // 0 bits are left in first byte - SHOULD NOT HAPPEN
0x01, // 1 bits are left in first byte
0x03, // 2 bits are left in first byte
0x07, // 3 bits are left in first byte
0x0f, // 4 bits are left in first byte
0x1f, // 5 bits are left in first byte
0x3f, // 6 bits are left in first byte
0x7f, // 7 bits are left in first byte
0xff // 8 bits are left in first byte
};
static int[] table2 = {
0x00, // 0
0x80, // 1
0xc0, // 2
0xe0, // 3
0xf0, // 4
0xf8, // 5
0xfc, // 6
0xfe, // 7
0xff // 8
};
// Table to be used when fillOrder = 2, for flipping bytes.
static byte[] flipTable = {
0, -128, 64, -64, 32, -96, 96, -32,
16, -112, 80, -48, 48, -80, 112, -16,
8, -120, 72, -56, 40, -88, 104, -24,
24, -104, 88, -40, 56, -72, 120, -8,
4, -124, 68, -60, 36, -92, 100, -28,
20, -108, 84, -44, 52, -76, 116, -12,
12, -116, 76, -52, 44, -84, 108, -20,
28, -100, 92, -36, 60, -68, 124, -4,
2, -126, 66, -62, 34, -94, 98, -30,
18, -110, 82, -46, 50, -78, 114, -14,
10, -118, 74, -54, 42, -86, 106, -22,
26, -102, 90, -38, 58, -70, 122, -6,
6, -122, 70, -58, 38, -90, 102, -26,
22, -106, 86, -42, 54, -74, 118, -10,
14, -114, 78, -50, 46, -82, 110, -18,
30, -98, 94, -34, 62, -66, 126, -2,
1, -127, 65, -63, 33, -95, 97, -31,
17, -111, 81, -47, 49, -79, 113, -15,
9, -119, 73, -55, 41, -87, 105, -23,
25, -103, 89, -39, 57, -71, 121, -7,
5, -123, 69, -59, 37, -91, 101, -27,
21, -107, 85, -43, 53, -75, 117, -11,
13, -115, 77, -51, 45, -83, 109, -19,
29, -99, 93, -35, 61, -67, 125, -3,
3, -125, 67, -61, 35, -93, 99, -29,
19, -109, 83, -45, 51, -77, 115, -13,
11, -117, 75, -53, 43, -85, 107, -21,
27, -101, 91, -37, 59, -69, 123, -5,
7, -121, 71, -57, 39, -89, 103, -25,
23, -105, 87, -41, 55, -73, 119, -9,
15, -113, 79, -49, 47, -81, 111, -17,
31, -97, 95, -33, 63, -65, 127, -1,
};
// The main 10 bit white runs lookup table
static short[] white = {
// 0 - 7
6430, 6400, 6400, 6400, 3225, 3225, 3225, 3225,
// 8 - 15
944, 944, 944, 944, 976, 976, 976, 976,
// 16 - 23
1456, 1456, 1456, 1456, 1488, 1488, 1488, 1488,
// 24 - 31
718, 718, 718, 718, 718, 718, 718, 718,
// 32 - 39
750, 750, 750, 750, 750, 750, 750, 750,
// 40 - 47
1520, 1520, 1520, 1520, 1552, 1552, 1552, 1552,
// 48 - 55
428, 428, 428, 428, 428, 428, 428, 428,
// 56 - 63
428, 428, 428, 428, 428, 428, 428, 428,
// 64 - 71
654, 654, 654, 654, 654, 654, 654, 654,
// 72 - 79
1072, 1072, 1072, 1072, 1104, 1104, 1104, 1104,
// 80 - 87
1136, 1136, 1136, 1136, 1168, 1168, 1168, 1168,
// 88 - 95
1200, 1200, 1200, 1200, 1232, 1232, 1232, 1232,
// 96 - 103
622, 622, 622, 622, 622, 622, 622, 622,
// 104 - 111
1008, 1008, 1008, 1008, 1040, 1040, 1040, 1040,
// 112 - 119
44, 44, 44, 44, 44, 44, 44, 44,
// 120 - 127
44, 44, 44, 44, 44, 44, 44, 44,
// 128 - 135
396, 396, 396, 396, 396, 396, 396, 396,
// 136 - 143
396, 396, 396, 396, 396, 396, 396, 396,
// 144 - 151
1712, 1712, 1712, 1712, 1744, 1744, 1744, 1744,
// 152 - 159
846, 846, 846, 846, 846, 846, 846, 846,
// 160 - 167
1264, 1264, 1264, 1264, 1296, 1296, 1296, 1296,
// 168 - 175
1328, 1328, 1328, 1328, 1360, 1360, 1360, 1360,
// 176 - 183
1392, 1392, 1392, 1392, 1424, 1424, 1424, 1424,
// 184 - 191
686, 686, 686, 686, 686, 686, 686, 686,
// 192 - 199
910, 910, 910, 910, 910, 910, 910, 910,
// 200 - 207
1968, 1968, 1968, 1968, 2000, 2000, 2000, 2000,
// 208 - 215
2032, 2032, 2032, 2032, 16, 16, 16, 16,
// 216 - 223
10257, 10257, 10257, 10257, 12305, 12305, 12305, 12305,
// 224 - 231
330, 330, 330, 330, 330, 330, 330, 330,
// 232 - 239
330, 330, 330, 330, 330, 330, 330, 330,
// 240 - 247
330, 330, 330, 330, 330, 330, 330, 330,
// 248 - 255
330, 330, 330, 330, 330, 330, 330, 330,
// 256 - 263
362, 362, 362, 362, 362, 362, 362, 362,
// 264 - 271
362, 362, 362, 362, 362, 362, 362, 362,
// 272 - 279
362, 362, 362, 362, 362, 362, 362, 362,
// 280 - 287
362, 362, 362, 362, 362, 362, 362, 362,
// 288 - 295
878, 878, 878, 878, 878, 878, 878, 878,
// 296 - 303
1904, 1904, 1904, 1904, 1936, 1936, 1936, 1936,
// 304 - 311
-18413, -18413, -16365, -16365, -14317, -14317, -10221, -10221,
// 312 - 319
590, 590, 590, 590, 590, 590, 590, 590,
// 320 - 327
782, 782, 782, 782, 782, 782, 782, 782,
// 328 - 335
1584, 1584, 1584, 1584, 1616, 1616, 1616, 1616,
// 336 - 343
1648, 1648, 1648, 1648, 1680, 1680, 1680, 1680,
// 344 - 351
814, 814, 814, 814, 814, 814, 814, 814,
// 352 - 359
1776, 1776, 1776, 1776, 1808, 1808, 1808, 1808,
// 360 - 367
1840, 1840, 1840, 1840, 1872, 1872, 1872, 1872,
// 368 - 375
6157, 6157, 6157, 6157, 6157, 6157, 6157, 6157,
// 376 - 383
6157, 6157, 6157, 6157, 6157, 6157, 6157, 6157,
// 384 - 391
-12275, -12275, -12275, -12275, -12275, -12275, -12275, -12275,
// 392 - 399
-12275, -12275, -12275, -12275, -12275, -12275, -12275, -12275,
// 400 - 407
14353, 14353, 14353, 14353, 16401, 16401, 16401, 16401,
// 408 - 415
22547, 22547, 24595, 24595, 20497, 20497, 20497, 20497,
// 416 - 423
18449, 18449, 18449, 18449, 26643, 26643, 28691, 28691,
// 424 - 431
30739, 30739, -32749, -32749, -30701, -30701, -28653, -28653,
// 432 - 439
-26605, -26605, -24557, -24557, -22509, -22509, -20461, -20461,
// 440 - 447
8207, 8207, 8207, 8207, 8207, 8207, 8207, 8207,
// 448 - 455
72, 72, 72, 72, 72, 72, 72, 72,
// 456 - 463
72, 72, 72, 72, 72, 72, 72, 72,
// 464 - 471
72, 72, 72, 72, 72, 72, 72, 72,
// 472 - 479
72, 72, 72, 72, 72, 72, 72, 72,
// 480 - 487
72, 72, 72, 72, 72, 72, 72, 72,
// 488 - 495
72, 72, 72, 72, 72, 72, 72, 72,
// 496 - 503
72, 72, 72, 72, 72, 72, 72, 72,
// 504 - 511
72, 72, 72, 72, 72, 72, 72, 72,
// 512 - 519
104, 104, 104, 104, 104, 104, 104, 104,
// 520 - 527
104, 104, 104, 104, 104, 104, 104, 104,
// 528 - 535
104, 104, 104, 104, 104, 104, 104, 104,
// 536 - 543
104, 104, 104, 104, 104, 104, 104, 104,
// 544 - 551
104, 104, 104, 104, 104, 104, 104, 104,
// 552 - 559
104, 104, 104, 104, 104, 104, 104, 104,
// 560 - 567
104, 104, 104, 104, 104, 104, 104, 104,
// 568 - 575
104, 104, 104, 104, 104, 104, 104, 104,
// 576 - 583
4107, 4107, 4107, 4107, 4107, 4107, 4107, 4107,
// 584 - 591
4107, 4107, 4107, 4107, 4107, 4107, 4107, 4107,
// 592 - 599
4107, 4107, 4107, 4107, 4107, 4107, 4107, 4107,
// 600 - 607
4107, 4107, 4107, 4107, 4107, 4107, 4107, 4107,
// 608 - 615
266, 266, 266, 266, 266, 266, 266, 266,
// 616 - 623
266, 266, 266, 266, 266, 266, 266, 266,
// 624 - 631
266, 266, 266, 266, 266, 266, 266, 266,
// 632 - 639
266, 266, 266, 266, 266, 266, 266, 266,
// 640 - 647
298, 298, 298, 298, 298, 298, 298, 298,
// 648 - 655
298, 298, 298, 298, 298, 298, 298, 298,
// 656 - 663
298, 298, 298, 298, 298, 298, 298, 298,
// 664 - 671
298, 298, 298, 298, 298, 298, 298, 298,
// 672 - 679
524, 524, 524, 524, 524, 524, 524, 524,
// 680 - 687
524, 524, 524, 524, 524, 524, 524, 524,
// 688 - 695
556, 556, 556, 556, 556, 556, 556, 556,
// 696 - 703
556, 556, 556, 556, 556, 556, 556, 556,
// 704 - 711
136, 136, 136, 136, 136, 136, 136, 136,
// 712 - 719
136, 136, 136, 136, 136, 136, 136, 136,
// 720 - 727
136, 136, 136, 136, 136, 136, 136, 136,
// 728 - 735
136, 136, 136, 136, 136, 136, 136, 136,
// 736 - 743
136, 136, 136, 136, 136, 136, 136, 136,
// 744 - 751
136, 136, 136, 136, 136, 136, 136, 136,
// 752 - 759
136, 136, 136, 136, 136, 136, 136, 136,
// 760 - 767
136, 136, 136, 136, 136, 136, 136, 136,
// 768 - 775
168, 168, 168, 168, 168, 168, 168, 168,
// 776 - 783
168, 168, 168, 168, 168, 168, 168, 168,
// 784 - 791
168, 168, 168, 168, 168, 168, 168, 168,
// 792 - 799
168, 168, 168, 168, 168, 168, 168, 168,
// 800 - 807
168, 168, 168, 168, 168, 168, 168, 168,
// 808 - 815
168, 168, 168, 168, 168, 168, 168, 168,
// 816 - 823
168, 168, 168, 168, 168, 168, 168, 168,
// 824 - 831
168, 168, 168, 168, 168, 168, 168, 168,
// 832 - 839
460, 460, 460, 460, 460, 460, 460, 460,
// 840 - 847
460, 460, 460, 460, 460, 460, 460, 460,
// 848 - 855
492, 492, 492, 492, 492, 492, 492, 492,
// 856 - 863
492, 492, 492, 492, 492, 492, 492, 492,
// 864 - 871
2059, 2059, 2059, 2059, 2059, 2059, 2059, 2059,
// 872 - 879
2059, 2059, 2059, 2059, 2059, 2059, 2059, 2059,
// 880 - 887
2059, 2059, 2059, 2059, 2059, 2059, 2059, 2059,
// 888 - 895
2059, 2059, 2059, 2059, 2059, 2059, 2059, 2059,
// 896 - 903
200, 200, 200, 200, 200, 200, 200, 200,
// 904 - 911
200, 200, 200, 200, 200, 200, 200, 200,
// 912 - 919
200, 200, 200, 200, 200, 200, 200, 200,
// 920 - 927
200, 200, 200, 200, 200, 200, 200, 200,
// 928 - 935
200, 200, 200, 200, 200, 200, 200, 200,
// 936 - 943
200, 200, 200, 200, 200, 200, 200, 200,
// 944 - 951
200, 200, 200, 200, 200, 200, 200, 200,
// 952 - 959
200, 200, 200, 200, 200, 200, 200, 200,
// 960 - 967
232, 232, 232, 232, 232, 232, 232, 232,
// 968 - 975
232, 232, 232, 232, 232, 232, 232, 232,
// 976 - 983
232, 232, 232, 232, 232, 232, 232, 232,
// 984 - 991
232, 232, 232, 232, 232, 232, 232, 232,
// 992 - 999
232, 232, 232, 232, 232, 232, 232, 232,
// 1000 - 1007
232, 232, 232, 232, 232, 232, 232, 232,
// 1008 - 1015
232, 232, 232, 232, 232, 232, 232, 232,
// 1016 - 1023
232, 232, 232, 232, 232, 232, 232, 232,
};
// Additional make up codes for both White and Black runs
static short[] additionalMakeup = {
28679, 28679, 31752, (short)32777,
(short)33801, (short)34825, (short)35849, (short)36873,
(short)29703, (short)29703, (short)30727, (short)30727,
(short)37897, (short)38921, (short)39945, (short)40969
};
// Initial black run look up table, uses the first 4 bits of a code
static short[] initBlack = {
// 0 - 7
3226, 6412, 200, 168, 38, 38, 134, 134,
// 8 - 15
100, 100, 100, 100, 68, 68, 68, 68
};
//
static short[] twoBitBlack = {292, 260, 226, 226}; // 0 - 3
// Main black run table, using the last 9 bits of possible 13 bit code
static short[] black = {
// 0 - 7
62, 62, 30, 30, 0, 0, 0, 0,
// 8 - 15
0, 0, 0, 0, 0, 0, 0, 0,
// 16 - 23
0, 0, 0, 0, 0, 0, 0, 0,
// 24 - 31
0, 0, 0, 0, 0, 0, 0, 0,
// 32 - 39
3225, 3225, 3225, 3225, 3225, 3225, 3225, 3225,
// 40 - 47
3225, 3225, 3225, 3225, 3225, 3225, 3225, 3225,
// 48 - 55
3225, 3225, 3225, 3225, 3225, 3225, 3225, 3225,
// 56 - 63
3225, 3225, 3225, 3225, 3225, 3225, 3225, 3225,
// 64 - 71
588, 588, 588, 588, 588, 588, 588, 588,
// 72 - 79
1680, 1680, 20499, 22547, 24595, 26643, 1776, 1776,
// 80 - 87
1808, 1808, -24557, -22509, -20461, -18413, 1904, 1904,
// 88 - 95
1936, 1936, -16365, -14317, 782, 782, 782, 782,
// 96 - 103
814, 814, 814, 814, -12269, -10221, 10257, 10257,
// 104 - 111
12305, 12305, 14353, 14353, 16403, 18451, 1712, 1712,
// 112 - 119
1744, 1744, 28691, 30739, -32749, -30701, -28653, -26605,
// 120 - 127
2061, 2061, 2061, 2061, 2061, 2061, 2061, 2061,
// 128 - 135
424, 424, 424, 424, 424, 424, 424, 424,
// 136 - 143
424, 424, 424, 424, 424, 424, 424, 424,
// 144 - 151
424, 424, 424, 424, 424, 424, 424, 424,
// 152 - 159
424, 424, 424, 424, 424, 424, 424, 424,
// 160 - 167
750, 750, 750, 750, 1616, 1616, 1648, 1648,
// 168 - 175
1424, 1424, 1456, 1456, 1488, 1488, 1520, 1520,
// 176 - 183
1840, 1840, 1872, 1872, 1968, 1968, 8209, 8209,
// 184 - 191
524, 524, 524, 524, 524, 524, 524, 524,
// 192 - 199
556, 556, 556, 556, 556, 556, 556, 556,
// 200 - 207
1552, 1552, 1584, 1584, 2000, 2000, 2032, 2032,
// 208 - 215
976, 976, 1008, 1008, 1040, 1040, 1072, 1072,
// 216 - 223
1296, 1296, 1328, 1328, 718, 718, 718, 718,
// 224 - 231
456, 456, 456, 456, 456, 456, 456, 456,
// 232 - 239
456, 456, 456, 456, 456, 456, 456, 456,
// 240 - 247
456, 456, 456, 456, 456, 456, 456, 456,
// 248 - 255
456, 456, 456, 456, 456, 456, 456, 456,
// 256 - 263
326, 326, 326, 326, 326, 326, 326, 326,
// 264 - 271
326, 326, 326, 326, 326, 326, 326, 326,
// 272 - 279
326, 326, 326, 326, 326, 326, 326, 326,
// 280 - 287
326, 326, 326, 326, 326, 326, 326, 326,
// 288 - 295
326, 326, 326, 326, 326, 326, 326, 326,
// 296 - 303
326, 326, 326, 326, 326, 326, 326, 326,
// 304 - 311
326, 326, 326, 326, 326, 326, 326, 326,
// 312 - 319
326, 326, 326, 326, 326, 326, 326, 326,
// 320 - 327
358, 358, 358, 358, 358, 358, 358, 358,
// 328 - 335
358, 358, 358, 358, 358, 358, 358, 358,
// 336 - 343
358, 358, 358, 358, 358, 358, 358, 358,
// 344 - 351
358, 358, 358, 358, 358, 358, 358, 358,
// 352 - 359
358, 358, 358, 358, 358, 358, 358, 358,
// 360 - 367
358, 358, 358, 358, 358, 358, 358, 358,
// 368 - 375
358, 358, 358, 358, 358, 358, 358, 358,
// 376 - 383
358, 358, 358, 358, 358, 358, 358, 358,
// 384 - 391
490, 490, 490, 490, 490, 490, 490, 490,
// 392 - 399
490, 490, 490, 490, 490, 490, 490, 490,
// 400 - 407
4113, 4113, 6161, 6161, 848, 848, 880, 880,
// 408 - 415
912, 912, 944, 944, 622, 622, 622, 622,
// 416 - 423
654, 654, 654, 654, 1104, 1104, 1136, 1136,
// 424 - 431
1168, 1168, 1200, 1200, 1232, 1232, 1264, 1264,
// 432 - 439
686, 686, 686, 686, 1360, 1360, 1392, 1392,
// 440 - 447
12, 12, 12, 12, 12, 12, 12, 12,
// 448 - 455
390, 390, 390, 390, 390, 390, 390, 390,
// 456 - 463
390, 390, 390, 390, 390, 390, 390, 390,
// 464 - 471
390, 390, 390, 390, 390, 390, 390, 390,
// 472 - 479
390, 390, 390, 390, 390, 390, 390, 390,
// 480 - 487
390, 390, 390, 390, 390, 390, 390, 390,
// 488 - 495
390, 390, 390, 390, 390, 390, 390, 390,
// 496 - 503
390, 390, 390, 390, 390, 390, 390, 390,
// 504 - 511
390, 390, 390, 390, 390, 390, 390, 390,
};
static byte[] twoDCodes = {
// 0 - 7
80, 88, 23, 71, 30, 30, 62, 62,
// 8 - 15
4, 4, 4, 4, 4, 4, 4, 4,
// 16 - 23
11, 11, 11, 11, 11, 11, 11, 11,
// 24 - 31
11, 11, 11, 11, 11, 11, 11, 11,
// 32 - 39
35, 35, 35, 35, 35, 35, 35, 35,
// 40 - 47
35, 35, 35, 35, 35, 35, 35, 35,
// 48 - 55
51, 51, 51, 51, 51, 51, 51, 51,
// 56 - 63
51, 51, 51, 51, 51, 51, 51, 51,
// 64 - 71
41, 41, 41, 41, 41, 41, 41, 41,
// 72 - 79
41, 41, 41, 41, 41, 41, 41, 41,
// 80 - 87
41, 41, 41, 41, 41, 41, 41, 41,
// 88 - 95
41, 41, 41, 41, 41, 41, 41, 41,
// 96 - 103
41, 41, 41, 41, 41, 41, 41, 41,
// 104 - 111
41, 41, 41, 41, 41, 41, 41, 41,
// 112 - 119
41, 41, 41, 41, 41, 41, 41, 41,
// 120 - 127
41, 41, 41, 41, 41, 41, 41, 41,
};
/**
* @param fillOrder The fill order of the compressed data bytes.
*/
public TIFFFaxDecoder(int fillOrder, int w, int h) {
this.fillOrder = fillOrder;
this.w = w;
this.h = h;
this.bitPointer = 0;
this.bytePointer = 0;
this.prevChangingElems = new int[w];
this.currChangingElems = new int[w];
}
// One-dimensional decoding methods
public void decode1D(byte[] buffer, byte[] compData,
int startX, int height) {
this.data = compData;
int lineOffset = 0;
int scanlineStride = (w + 7)/8;
bitPointer = 0;
bytePointer = 0;
for (int i = 0; i < height; i++) {
decodeNextScanline(buffer, lineOffset, startX);
lineOffset += scanlineStride;
}
}
public void decodeNextScanline(byte[] buffer,
int lineOffset, int bitOffset) {
int bits = 0, code = 0, isT = 0;
int current, entry, twoBits;
boolean isWhite = true;
// Initialize starting of the changing elements array
changingElemSize = 0;
// While scanline not complete
while (bitOffset < w) {
while (isWhite) {
// White run
current = nextNBits(10);
entry = white[current];
// Get the 3 fields from the entry
isT = entry & 0x0001;
bits = (entry >>> 1) & 0x0f;
if (bits == 12) { // Additional Make up code
// Get the next 2 bits
twoBits = nextLesserThan8Bits(2);
// Consolidate the 2 new bits and last 2 bits into 4 bits
current = ((current << 2) & 0x000c) | twoBits;
entry = additionalMakeup[current];
bits = (entry >>> 1) & 0x07; // 3 bits 0000 0111
code = (entry >>> 4) & 0x0fff; // 12 bits
bitOffset += code; // Skip white run
updatePointer(4 - bits);
} else if (bits == 0) { // ERROR
throw new Error("TIFFFaxDecoder0");
} else if (bits == 15) { // EOL
throw new Error("TIFFFaxDecoder1");
} else {
// 11 bits - 0000 0111 1111 1111 = 0x07ff
code = (entry >>> 5) & 0x07ff;
bitOffset += code;
updatePointer(10 - bits);
if (isT == 0) {
isWhite = false;
currChangingElems[changingElemSize++] = bitOffset;
}
}
}
// Check whether this run completed one width, if so
// advance to next byte boundary for compression = 2.
if (bitOffset == w) {
if (compression == 2) {
advancePointer();
}
break;
}
while ( ! isWhite ) {
// Black run
current = nextLesserThan8Bits(4);
entry = initBlack[current];
// Get the 3 fields from the entry
isT = entry & 0x0001;
bits = (entry >>> 1) & 0x000f;
code = (entry >>> 5) & 0x07ff;
if (code == 100) {
current = nextNBits(9);
entry = black[current];
// Get the 3 fields from the entry
isT = entry & 0x0001;
bits = (entry >>> 1) & 0x000f;
code = (entry >>> 5) & 0x07ff;
if (bits == 12) {
// Additional makeup codes
updatePointer(5);
current = nextLesserThan8Bits(4);
entry = additionalMakeup[current];
bits = (entry >>> 1) & 0x07; // 3 bits 0000 0111
code = (entry >>> 4) & 0x0fff; // 12 bits
setToBlack(buffer, lineOffset, bitOffset, code);
bitOffset += code;
updatePointer(4 - bits);
} else if (bits == 15) {
// EOL code
throw new Error("TIFFFaxDecoder2");
} else {
setToBlack(buffer, lineOffset, bitOffset, code);
bitOffset += code;
updatePointer(9 - bits);
if (isT == 0) {
isWhite = true;
currChangingElems[changingElemSize++] = bitOffset;
}
}
} else if (code == 200) {
// Is a Terminating code
current = nextLesserThan8Bits(2);
entry = twoBitBlack[current];
code = (entry >>> 5) & 0x07ff;
bits = (entry >>> 1) & 0x0f;
setToBlack(buffer, lineOffset, bitOffset, code);
bitOffset += code;
updatePointer(2 - bits);
isWhite = true;
currChangingElems[changingElemSize++] = bitOffset;
} else {
// Is a Terminating code
setToBlack(buffer, lineOffset, bitOffset, code);
bitOffset += code;
updatePointer(4 - bits);
isWhite = true;
currChangingElems[changingElemSize++] = bitOffset;
}
}
// Check whether this run completed one width
if (bitOffset == w) {
if (compression == 2) {
advancePointer();
}
break;
}
}
currChangingElems[changingElemSize++] = bitOffset;
}
// Two-dimensional decoding methods
public void decode2D(byte[] buffer,
byte[] compData,
int startX,
int height,
long tiffT4Options) {
this.data = compData;
compression = 3;
bitPointer = 0;
bytePointer = 0;
int scanlineStride = (w + 7)/8;
int a0, a1, b1, b2;
int[] b = new int[2];
int entry, code, bits;
boolean isWhite;
int currIndex = 0;
int[] temp;
// fillBits - dealt with this in readEOL
// 1D/2D encoding - dealt with this in readEOL
// uncompressedMode - haven't dealt with this yet.
oneD = (int)(tiffT4Options & 0x01);
uncompressedMode = (int)((tiffT4Options & 0x02) >> 1);
fillBits = (int)((tiffT4Options & 0x04) >> 2);
// The data must start with an EOL code
if (readEOL() != 1) {
throw new Error("TIFFFaxDecoder3");
}
int lineOffset = 0;
int bitOffset;
// Then the 1D encoded scanline data will occur, changing elements
// array gets set.
decodeNextScanline(buffer, lineOffset, startX);
lineOffset += scanlineStride;
for (int lines = 1; lines < height; lines++) {
// Every line must begin with an EOL followed by a bit which
// indicates whether the following scanline is 1D or 2D encoded.
if (readEOL() == 0) {
// 2D encoded scanline follows
// Initialize previous scanlines changing elements, and
// initialize current scanline's changing elements array
temp = prevChangingElems;
prevChangingElems = currChangingElems;
currChangingElems = temp;
currIndex = 0;
// a0 has to be set just before the start of this scanline.
a0 = -1;
isWhite = true;
bitOffset = startX;
lastChangingElement = 0;
while (bitOffset < w) {
// Get the next changing element
getNextChangingElement(a0, isWhite, b);
b1 = b[0];
b2 = b[1];
// Get the next seven bits
entry = nextLesserThan8Bits(7);
// Run these through the 2DCodes table
entry = (int)(twoDCodes[entry] & 0xff);
// Get the code and the number of bits used up
code = (entry & 0x78) >>> 3;
bits = entry & 0x07;
if (code == 0) {
if (!isWhite) {
setToBlack(buffer, lineOffset, bitOffset,
b2 - bitOffset);
}
bitOffset = a0 = b2;
// Set pointer to consume the correct number of bits.
updatePointer(7 - bits);
} else if (code == 1) {
// Horizontal
updatePointer(7 - bits);
// identify the next 2 codes.
int number;
if (isWhite) {
number = decodeWhiteCodeWord();
bitOffset += number;
currChangingElems[currIndex++] = bitOffset;
number = decodeBlackCodeWord();
setToBlack(buffer, lineOffset, bitOffset, number);
bitOffset += number;
currChangingElems[currIndex++] = bitOffset;
} else {
number = decodeBlackCodeWord();
setToBlack(buffer, lineOffset, bitOffset, number);
bitOffset += number;
currChangingElems[currIndex++] = bitOffset;
number = decodeWhiteCodeWord();
bitOffset += number;
currChangingElems[currIndex++] = bitOffset;
}
a0 = bitOffset;
} else if (code <= 8) {
// Vertical
a1 = b1 + (code - 5);
currChangingElems[currIndex++] = a1;
// We write the current color till a1 - 1 pos,
// since a1 is where the next color starts
if (!isWhite) {
setToBlack(buffer, lineOffset, bitOffset,
a1 - bitOffset);
}
bitOffset = a0 = a1;
isWhite = !isWhite;
updatePointer(7 - bits);
} else {
throw new Error("TIFFFaxDecoder4");
}
}
// Add the changing element beyond the current scanline for the
// other color too
currChangingElems[currIndex++] = bitOffset;
changingElemSize = currIndex;
} else {
// 1D encoded scanline follows
decodeNextScanline(buffer, lineOffset, startX);
}
lineOffset += scanlineStride;
}
}
public synchronized void decodeT6(byte[] buffer,
byte[] compData,
int startX,
int height,
long tiffT6Options) {
this.data = compData;
compression = 4;
bitPointer = 0;
bytePointer = 0;
int scanlineStride = (w + 7)/8;
int a0, a1, b1, b2;
int entry, code, bits;
boolean isWhite;
int currIndex;
int[] temp;
// Return values from getNextChangingElement
int[] b = new int[2];
// uncompressedMode - have written some code for this, but this
// has not been tested due to lack of test images using this optional
uncompressedMode = (int)((tiffT6Options & 0x02) >> 1);
// Local cached reference
int[] cce = currChangingElems;
// Assume invisible preceding row of all white pixels and insert
// both black and white changing elements beyond the end of this
// imaginary scanline.
changingElemSize = 0;
cce[changingElemSize++] = w;
cce[changingElemSize++] = w;
int lineOffset = 0;
int bitOffset;
for (int lines = 0; lines < height; lines++) {
// a0 has to be set just before the start of the scanline.
a0 = -1;
isWhite = true;
// Assign the changing elements of the previous scanline to
// prevChangingElems and start putting this new scanline's
// changing elements into the currChangingElems.
temp = prevChangingElems;
prevChangingElems = currChangingElems;
cce = currChangingElems = temp;
currIndex = 0;
// Start decoding the scanline at startX in the raster
bitOffset = startX;
// Reset search start position for getNextChangingElement
lastChangingElement = 0;
// Till one whole scanline is decoded
while (bitOffset < w) {
// Get the next changing element
getNextChangingElement(a0, isWhite, b);
b1 = b[0];
b2 = b[1];
// Get the next seven bits
entry = nextLesserThan8Bits(7);
// Run these through the 2DCodes table
entry = (int)(twoDCodes[entry] & 0xff);
// Get the code and the number of bits used up
code = (entry & 0x78) >>> 3;
bits = entry & 0x07;
if (code == 0) { // Pass
// We always assume WhiteIsZero format for fax.
if (!isWhite) {
setToBlack(buffer, lineOffset, bitOffset,
b2 - bitOffset);
}
bitOffset = a0 = b2;
// Set pointer to only consume the correct number of bits.
updatePointer(7 - bits);
} else if (code == 1) { // Horizontal
// Set pointer to only consume the correct number of bits.
updatePointer(7 - bits);
// identify the next 2 alternating color codes.
int number;
if (isWhite) {
// Following are white and black runs
number = decodeWhiteCodeWord();
bitOffset += number;
cce[currIndex++] = bitOffset;
number = decodeBlackCodeWord();
setToBlack(buffer, lineOffset, bitOffset, number);
bitOffset += number;
cce[currIndex++] = bitOffset;
} else {
// First a black run and then a white run follows
number = decodeBlackCodeWord();
setToBlack(buffer, lineOffset, bitOffset, number);
bitOffset += number;
cce[currIndex++] = bitOffset;
number = decodeWhiteCodeWord();
bitOffset += number;
cce[currIndex++] = bitOffset;
}
a0 = bitOffset;
} else if (code <= 8) { // Vertical
a1 = b1 + (code - 5);
cce[currIndex++] = a1;
// We write the current color till a1 - 1 pos,
// since a1 is where the next color starts
if (!isWhite) {
setToBlack(buffer, lineOffset, bitOffset,
a1 - bitOffset);
}
bitOffset = a0 = a1;
isWhite = !isWhite;
updatePointer(7 - bits);
} else if (code == 11) {
if (nextLesserThan8Bits(3) != 7) {
throw new Error("TIFFFaxDecoder5");
}
int zeros = 0;
boolean exit = false;
while (!exit) {
while (nextLesserThan8Bits(1) != 1) {
zeros++;
}
if (zeros > 5) {
// Exit code
// Zeros before exit code
zeros = zeros - 6;
if (!isWhite && (zeros > 0)) {
cce[currIndex++] = bitOffset;
}
// Zeros before the exit code
bitOffset += zeros;
if (zeros > 0) {
// Some zeros have been written
isWhite = true;
}
// Read in the bit which specifies the color of
// the following run
if (nextLesserThan8Bits(1) == 0) {
if (!isWhite) {
cce[currIndex++] = bitOffset;
}
isWhite = true;
} else {
if (isWhite) {
cce[currIndex++] = bitOffset;
}
isWhite = false;
}
exit = true;
}
if (zeros == 5) {
if (!isWhite) {
cce[currIndex++] = bitOffset;
}
bitOffset += zeros;
// Last thing written was white
isWhite = true;
} else {
bitOffset += zeros;
cce[currIndex++] = bitOffset;
setToBlack(buffer, lineOffset, bitOffset, 1);
++bitOffset;
// Last thing written was black
isWhite = false;
}
}
} else {
throw new Error("TIFFFaxDecoder5");
}
}
// Add the changing element beyond the current scanline for the
// other color too
cce[currIndex++] = bitOffset;
// Number of changing elements in this scanline.
changingElemSize = currIndex;
lineOffset += scanlineStride;
}
}
private void setToBlack(byte[] buffer,
int lineOffset, int bitOffset,
int numBits) {
int bitNum = 8*lineOffset + bitOffset;
int lastBit = bitNum + numBits;
int byteNum = bitNum >> 3;
// Handle bits in first byte
int shift = bitNum & 0x7;
if (shift > 0) {
int maskVal = 1 << (7 - shift);
byte val = buffer[byteNum];
while (maskVal > 0 && bitNum < lastBit) {
val |= maskVal;
maskVal >>= 1;
++bitNum;
}
buffer[byteNum] = val;
}
// Fill in 8 bits at a time
byteNum = bitNum >> 3;
while (bitNum < lastBit - 7) {
buffer[byteNum++] = (byte)255;
bitNum += 8;
}
// Fill in remaining bits
while (bitNum < lastBit) {
byteNum = bitNum >> 3;
buffer[byteNum] |= 1 << (7 - (bitNum & 0x7));
++bitNum;
}
}
// Returns run length
private int decodeWhiteCodeWord() {
int current, entry, bits, isT, twoBits, code = -1;
int runLength = 0;
boolean isWhite = true;
while (isWhite) {
current = nextNBits(10);
entry = white[current];
// Get the 3 fields from the entry
isT = entry & 0x0001;
bits = (entry >>> 1) & 0x0f;
if (bits == 12) { // Additional Make up code
// Get the next 2 bits
twoBits = nextLesserThan8Bits(2);
// Consolidate the 2 new bits and last 2 bits into 4 bits
current = ((current << 2) & 0x000c) | twoBits;
entry = additionalMakeup[current];
bits = (entry >>> 1) & 0x07; // 3 bits 0000 0111
code = (entry >>> 4) & 0x0fff; // 12 bits
runLength += code;
updatePointer(4 - bits);
} else if (bits == 0) { // ERROR
throw new Error("TIFFFaxDecoder0");
} else if (bits == 15) { // EOL
throw new Error("TIFFFaxDecoder1");
} else {
// 11 bits - 0000 0111 1111 1111 = 0x07ff
code = (entry >>> 5) & 0x07ff;
runLength += code;
updatePointer(10 - bits);
if (isT == 0) {
isWhite = false;
}
}
}
return runLength;
}
// Returns run length
private int decodeBlackCodeWord() {
int current, entry, bits, isT, code = -1;
int runLength = 0;
boolean isWhite = false;
while (!isWhite) {
current = nextLesserThan8Bits(4);
entry = initBlack[current];
// Get the 3 fields from the entry
isT = entry & 0x0001;
bits = (entry >>> 1) & 0x000f;
code = (entry >>> 5) & 0x07ff;
if (code == 100) {
current = nextNBits(9);
entry = black[current];
// Get the 3 fields from the entry
isT = entry & 0x0001;
bits = (entry >>> 1) & 0x000f;
code = (entry >>> 5) & 0x07ff;
if (bits == 12) {
// Additional makeup codes
updatePointer(5);
current = nextLesserThan8Bits(4);
entry = additionalMakeup[current];
bits = (entry >>> 1) & 0x07; // 3 bits 0000 0111
code = (entry >>> 4) & 0x0fff; // 12 bits
runLength += code;
updatePointer(4 - bits);
} else if (bits == 15) {
// EOL code
throw new Error("TIFFFaxDecoder2");
} else {
runLength += code;
updatePointer(9 - bits);
if (isT == 0) {
isWhite = true;
}
}
} else if (code == 200) {
// Is a Terminating code
current = nextLesserThan8Bits(2);
entry = twoBitBlack[current];
code = (entry >>> 5) & 0x07ff;
runLength += code;
bits = (entry >>> 1) & 0x0f;
updatePointer(2 - bits);
isWhite = true;
} else {
// Is a Terminating code
runLength += code;
updatePointer(4 - bits);
isWhite = true;
}
}
return runLength;
}
private int readEOL() {
if (fillBits == 0) {
if (nextNBits(12) != 1) {
throw new Error("TIFFFaxDecoder6");
}
} else if (fillBits == 1) {
// First EOL code word xxxx 0000 0000 0001 will occur
// As many fill bits will be present as required to make
// the EOL code of 12 bits end on a byte boundary.
int bitsLeft = 8 - bitPointer;
if (nextNBits(bitsLeft) != 0) {
throw new Error("TIFFFaxDecoder8");
}
// If the number of bitsLeft is less than 8, then to have a 12
// bit EOL sequence, two more bytes are certainly going to be
// required. The first of them has to be all zeros, so ensure
// that.
if (bitsLeft < 4) {
if (nextNBits(8) != 0) {
throw new Error("TIFFFaxDecoder8");
}
}
// There might be a random number of fill bytes with 0s, so
// loop till the EOL of 0000 0001 is found, as long as all
// the bytes preceding it are 0's.
int n;
while ((n = nextNBits(8)) != 1) {
// If not all zeros
if (n != 0) {
throw new Error("TIFFFaxDecoder8");
}
}
}
// If one dimensional encoding mode, then always return 1
if (oneD == 0) {
return 1;
} else {
// Otherwise for 2D encoding mode,
// The next one bit signifies 1D/2D encoding of next line.
return nextLesserThan8Bits(1);
}
}
private void getNextChangingElement(int a0, boolean isWhite, int[] ret) {
// Local copies of instance variables
int[] pce = this.prevChangingElems;
int ces = this.changingElemSize;
// If the previous match was at an odd element, we still
// have to search the preceeding element.
// int start = lastChangingElement & ~0x1;
int start = lastChangingElement > 0 ? lastChangingElement - 1 : 0;
if (isWhite) {
start &= ~0x1; // Search even numbered elements
} else {
start |= 0x1; // Search odd numbered elements
}
int i = start;
for (; i < ces; i += 2) {
int temp = pce[i];
if (temp > a0) {
lastChangingElement = i;
ret[0] = temp;
break;
}
}
if (i + 1 < ces) {
ret[1] = pce[i + 1];
}
}
private int nextNBits(int bitsToGet) {
byte b, next, next2next;
int l = data.length - 1;
int bp = this.bytePointer;
if (fillOrder == 1) {
b = data[bp];
if (bp == l) {
next = 0x00;
next2next = 0x00;
} else if ((bp + 1) == l) {
next = data[bp + 1];
next2next = 0x00;
} else {
next = data[bp + 1];
next2next = data[bp + 2];
}
} else if (fillOrder == 2) {
b = flipTable[data[bp] & 0xff];
if (bp == l) {
next = 0x00;
next2next = 0x00;
} else if ((bp + 1) == l) {
next = flipTable[data[bp + 1] & 0xff];
next2next = 0x00;
} else {
next = flipTable[data[bp + 1] & 0xff];
next2next = flipTable[data[bp + 2] & 0xff];
}
} else {
throw new Error("TIFFFaxDecoder7");
}
int bitsLeft = 8 - bitPointer;
int bitsFromNextByte = bitsToGet - bitsLeft;
int bitsFromNext2NextByte = 0;
if (bitsFromNextByte > 8) {
bitsFromNext2NextByte = bitsFromNextByte - 8;
bitsFromNextByte = 8;
}
bytePointer++;
int i1 = (b & table1[bitsLeft]) << (bitsToGet - bitsLeft);
int i2 = (next & table2[bitsFromNextByte]) >>> (8 - bitsFromNextByte);
int i3 = 0;
if (bitsFromNext2NextByte != 0) {
i2 <<= bitsFromNext2NextByte;
i3 = (next2next & table2[bitsFromNext2NextByte]) >>>
(8 - bitsFromNext2NextByte);
i2 |= i3;
bytePointer++;
bitPointer = bitsFromNext2NextByte;
} else {
if (bitsFromNextByte == 8) {
bitPointer = 0;
bytePointer++;
} else {
bitPointer = bitsFromNextByte;
}
}
int i = i1 | i2;
return i;
}
private int nextLesserThan8Bits(int bitsToGet) {
byte b, next;
int l = data.length - 1;
int bp = this.bytePointer;
if (fillOrder == 1) {
b = data[bp];
if (bp == l) {
next = 0x00;
} else {
next = data[bp + 1];
}
} else if (fillOrder == 2) {
b = flipTable[data[bp] & 0xff];
if (bp == l) {
next = 0x00;
} else {
next = flipTable[data[bp + 1] & 0xff];
}
} else {
throw new Error("TIFFFaxDecoder7");
}
int bitsLeft = 8 - bitPointer;
int bitsFromNextByte = bitsToGet - bitsLeft;
int shift = bitsLeft - bitsToGet;
int i1, i2;
if (shift >= 0) {
i1 = (b & table1[bitsLeft]) >>> shift;
bitPointer += bitsToGet;
if (bitPointer == 8) {
bitPointer = 0;
bytePointer++;
}
} else {
i1 = (b & table1[bitsLeft]) << (-shift);
i2 = (next & table2[bitsFromNextByte]) >>> (8 - bitsFromNextByte);
i1 |= i2;
bytePointer++;
bitPointer = bitsFromNextByte;
}
return i1;
}
// Move pointer backwards by given amount of bits
private void updatePointer(int bitsToMoveBack) {
int i = bitPointer - bitsToMoveBack;
if (i < 0) {
bytePointer--;
bitPointer = 8 + i;
} else {
bitPointer = i;
}
}
// Move to the next byte boundary
private boolean advancePointer() {
if (bitPointer != 0) {
bytePointer++;
bitPointer = 0;
}
return true;
}
}