?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fixed windows access violation which occurs if one tries to retrieve
[swftools.git] / pdf2swf / xpdf / Stream.cc
blobc47c5af0e5300264e96a21ddbc8bb1a76685de4d
1 //========================================================================
2 //
3 // Stream.cc
4 //
5 // Copyright 1996-2002 Glyph & Cog, LLC
6 //
7 //========================================================================
8
9 #ifdef __GNUC__
10 #pragma implementation
11 #endif
12
13 #include <aconf.h>
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <stddef.h>
17 #ifndef WIN32
18 #include <unistd.h>
19 #else
20 extern "C" int unlink(char *filename);
21 #endif
22 #include <string.h>
23 #include <ctype.h>
24 #include "gmem.h"
25 #include "gfile.h"
26 #include "config.h"
27 #include "Error.h"
28 #include "Object.h"
29 #ifndef NO_DECRYPTION
30 #include "Decrypt.h"
31 #endif
32 #include "Stream.h"
33 #include "Stream-CCITT.h"
34
35 #ifdef __DJGPP__
36 static GBool setDJSYSFLAGS = gFalse;
37 #endif
38
39 #ifdef VMS
40 #if (__VMS_VER < 70000000)
41 extern "C" int unlink(char *filename);
42 #endif
43 #ifdef __GNUC__
44 #define SEEK_SET 0
45 #define SEEK_CUR 1
46 #define SEEK_END 2
47 #endif
48 #endif
49
50 #ifdef MACOS
51 #include "StuffItEngineLib.h"
52 #endif
53
54 //------------------------------------------------------------------------
55 // Stream (base class)
56 //------------------------------------------------------------------------
57
58 Stream::Stream() {
59 ref = 1;
60 }
61
62 Stream::~Stream() {
63 }
64
65 void Stream::close() {
66 }
67
68 int Stream::getRawChar() {
69 error(-1, "Internal: called getRawChar() on non-predictor stream");
70 return EOF;
71 }
72
73 char *Stream::getLine(char *buf, int size) {
74 int i;
75 int c;
76
77 if (lookChar() == EOF)
78 return NULL;
79 for (i = 0; i < size - 1; ++i) {
80 c = getChar();
81 if (c == EOF || c == '\n')
82 break;
83 if (c == '\r') {
84 if ((c = lookChar()) == '\n')
85 getChar();
86 break;
87 }
88 buf[i] = c;
89 }
90 buf[i] = '\0';
91 return buf;
92 }
93
94 GString *Stream::getPSFilter(char *indent) {
95 return new GString();
96 }
97
98 Stream *Stream::addFilters(Object *dict) {
99 Object obj, obj2;
100 Object params, params2;
101 Stream *str;
102 int i;
103
104 str = this;
105 dict->dictLookup("Filter", &obj);
106 if (obj.isNull()) {
107 obj.free();
108 dict->dictLookup("F", &obj);
109 }
110 dict->dictLookup("DecodeParms", &params);
111 if (params.isNull()) {
112 params.free();
113 dict->dictLookup("DP", &params);
114 }
115 if (obj.isName()) {
116 str = makeFilter(obj.getName(), str, &params);
117 } else if (obj.isArray()) {
118 for (i = 0; i < obj.arrayGetLength(); ++i) {
119 obj.arrayGet(i, &obj2);
120 if (params.isArray())
121 params.arrayGet(i, &params2);
122 else
123 params2.initNull();
124 if (obj2.isName()) {
125 str = makeFilter(obj2.getName(), str, &params2);
126 } else {
127 error(getPos(), "Bad filter name");
128 str = new EOFStream(str);
129 }
130 obj2.free();
131 params2.free();
132 }
133 } else if (!obj.isNull()) {
134 error(getPos(), "Bad 'Filter' attribute in stream");
135 }
136 obj.free();
137 params.free();
138
139 return str;
140 }
141
142 Stream *Stream::makeFilter(char *name, Stream *str, Object *params) {
143 int pred; // parameters
144 int colors;
145 int bits;
146 int early;
147 int encoding;
148 GBool endOfLine, byteAlign, endOfBlock, black;
149 int columns, rows;
150 Object obj;
151
152 if (!strcmp(name, "ASCIIHexDecode") || !strcmp(name, "AHx")) {
153 str = new ASCIIHexStream(str);
154 } else if (!strcmp(name, "ASCII85Decode") || !strcmp(name, "A85")) {
155 str = new ASCII85Stream(str);
156 } else if (!strcmp(name, "LZWDecode") || !strcmp(name, "LZW")) {
157 pred = 1;
158 columns = 1;
159 colors = 1;
160 bits = 8;
161 early = 1;
162 if (params->isDict()) {
163 params->dictLookup("Predictor", &obj);
164 if (obj.isInt())
165 pred = obj.getInt();
166 obj.free();
167 params->dictLookup("Columns", &obj);
168 if (obj.isInt())
169 columns = obj.getInt();
170 obj.free();
171 params->dictLookup("Colors", &obj);
172 if (obj.isInt())
173 colors = obj.getInt();
174 obj.free();
175 params->dictLookup("BitsPerComponent", &obj);
176 if (obj.isInt())
177 bits = obj.getInt();
178 obj.free();
179 params->dictLookup("EarlyChange", &obj);
180 if (obj.isInt())
181 early = obj.getInt();
182 obj.free();
183 }
184 str = new LZWStream(str, pred, columns, colors, bits, early);
185 } else if (!strcmp(name, "RunLengthDecode") || !strcmp(name, "RL")) {
186 str = new RunLengthStream(str);
187 } else if (!strcmp(name, "CCITTFaxDecode") || !strcmp(name, "CCF")) {
188 encoding = 0;
189 endOfLine = gFalse;
190 byteAlign = gFalse;
191 columns = 1728;
192 rows = 0;
193 endOfBlock = gTrue;
194 black = gFalse;
195 if (params->isDict()) {
196 params->dictLookup("K", &obj);
197 if (obj.isInt()) {
198 encoding = obj.getInt();
199 }
200 obj.free();
201 params->dictLookup("EndOfLine", &obj);
202 if (obj.isBool()) {
203 endOfLine = obj.getBool();
204 }
205 obj.free();
206 params->dictLookup("EncodedByteAlign", &obj);
207 if (obj.isBool()) {
208 byteAlign = obj.getBool();
209 }
210 obj.free();
211 params->dictLookup("Columns", &obj);
212 if (obj.isInt()) {
213 columns = obj.getInt();
214 }
215 obj.free();
216 params->dictLookup("Rows", &obj);
217 if (obj.isInt()) {
218 rows = obj.getInt();
219 }
220 obj.free();
221 params->dictLookup("EndOfBlock", &obj);
222 if (obj.isBool()) {
223 endOfBlock = obj.getBool();
224 }
225 obj.free();
226 params->dictLookup("BlackIs1", &obj);
227 if (obj.isBool()) {
228 black = obj.getBool();
229 }
230 obj.free();
231 }
232 str = new CCITTFaxStream(str, encoding, endOfLine, byteAlign,
233 columns, rows, endOfBlock, black);
234 } else if (!strcmp(name, "DCTDecode") || !strcmp(name, "DCT")) {
235 str = new DCTStream(str);
236 } else if (!strcmp(name, "FlateDecode") || !strcmp(name, "Fl")) {
237 pred = 1;
238 columns = 1;
239 colors = 1;
240 bits = 8;
241 if (params->isDict()) {
242 params->dictLookup("Predictor", &obj);
243 if (obj.isInt())
244 pred = obj.getInt();
245 obj.free();
246 params->dictLookup("Columns", &obj);
247 if (obj.isInt())
248 columns = obj.getInt();
249 obj.free();
250 params->dictLookup("Colors", &obj);
251 if (obj.isInt())
252 colors = obj.getInt();
253 obj.free();
254 params->dictLookup("BitsPerComponent", &obj);
255 if (obj.isInt())
256 bits = obj.getInt();
257 obj.free();
258 }
259 str = new FlateStream(str, pred, columns, colors, bits);
260 } else {
261 error(getPos(), "Unknown filter '%s'", name);
262 str = new EOFStream(str);
263 }
264 return str;
265 }
266
267 //------------------------------------------------------------------------
268 // BaseStream
269 //------------------------------------------------------------------------
270
271 BaseStream::BaseStream(Object *dictA) {
272 dict = *dictA;
273 #ifndef NO_DECRYPTION
274 decrypt = NULL;
275 #endif
276 }
277
278 BaseStream::~BaseStream() {
279 dict.free();
280 #ifndef NO_DECRYPTION
281 if (decrypt)
282 delete decrypt;
283 #endif
284 }
285
286 #ifndef NO_DECRYPTION
287 void BaseStream::doDecryption(Guchar *fileKey, int keyLength,
288 int objNum, int objGen) {
289 decrypt = new Decrypt(fileKey, keyLength, objNum, objGen);
290 }
291 #endif
292
293 //------------------------------------------------------------------------
294 // FilterStream
295 //------------------------------------------------------------------------
296
297 FilterStream::FilterStream(Stream *strA) {
298 str = strA;
299 }
300
301 FilterStream::~FilterStream() {
302 }
303
304 void FilterStream::close() {
305 str->close();
306 }
307
308 void FilterStream::setPos(Guint pos, int dir) {
309 error(-1, "Internal: called setPos() on FilterStream");
310 }
311
312 //------------------------------------------------------------------------
313 // ImageStream
314 //------------------------------------------------------------------------
315
316 ImageStream::ImageStream(Stream *strA, int widthA, int nCompsA, int nBitsA) {
317 int imgLineSize;
318
319 str = strA;
320 width = widthA;
321 nComps = nCompsA;
322 nBits = nBitsA;
323
324 nVals = width * nComps;
325 if (nBits == 1) {
326 imgLineSize = (nVals + 7) & ~7;
327 } else {
328 imgLineSize = nVals;
329 }
330 imgLine = (Guchar *)gmalloc(imgLineSize * sizeof(Guchar));
331 imgIdx = nVals;
332 }
333
334 ImageStream::~ImageStream() {
335 gfree(imgLine);
336 }
337
338 void ImageStream::reset() {
339 str->reset();
340 }
341
342 GBool ImageStream::getPixel(Guchar *pix) {
343 Gulong buf, bitMask;
344 int bits;
345 int c;
346 int i;
347
348 if (imgIdx >= nVals) {
349
350 // read one line of image pixels
351 if (nBits == 1) {
352 for (i = 0; i < nVals; i += 8) {
353 c = str->getChar();
354 imgLine[i+0] = (Guchar)((c >> 7) & 1);
355 imgLine[i+1] = (Guchar)((c >> 6) & 1);
356 imgLine[i+2] = (Guchar)((c >> 5) & 1);
357 imgLine[i+3] = (Guchar)((c >> 4) & 1);
358 imgLine[i+4] = (Guchar)((c >> 3) & 1);
359 imgLine[i+5] = (Guchar)((c >> 2) & 1);
360 imgLine[i+6] = (Guchar)((c >> 1) & 1);
361 imgLine[i+7] = (Guchar)(c & 1);
362 }
363 } else if (nBits == 8) {
364 for (i = 0; i < nVals; ++i) {
365 imgLine[i] = str->getChar();
366 }
367 } else {
368 bitMask = (1 << nBits) - 1;
369 buf = 0;
370 bits = 0;
371 for (i = 0; i < nVals; ++i) {
372 if (bits < nBits) {
373 buf = (buf << 8) | (str->getChar() & 0xff);
374 bits += 8;
375 }
376 imgLine[i] = (Guchar)((buf >> (bits - nBits)) & bitMask);
377 bits -= nBits;
378 }
379 }
380
381 // reset to start of line
382 imgIdx = 0;
383 }
384
385 for (i = 0; i < nComps; ++i)
386 pix[i] = imgLine[imgIdx++];
387 return gTrue;
388 }
389
390 void ImageStream::skipLine() {
391 int n, i;
392
393 n = (nVals * nBits + 7) >> 3;
394 for (i = 0; i < n; ++i) {
395 str->getChar();
396 }
397 }
398
399 //------------------------------------------------------------------------
400 // StreamPredictor
401 //------------------------------------------------------------------------
402
403 StreamPredictor::StreamPredictor(Stream *strA, int predictorA,
404 int widthA, int nCompsA, int nBitsA) {
405 str = strA;
406 predictor = predictorA;
407 width = widthA;
408 nComps = nCompsA;
409 nBits = nBitsA;
410
411 nVals = width * nComps;
412 pixBytes = (nComps * nBits + 7) >> 3;
413 rowBytes = ((nVals * nBits + 7) >> 3) + pixBytes;
414 predLine = (Guchar *)gmalloc(rowBytes);
415 memset(predLine, 0, rowBytes);
416 predIdx = rowBytes;
417 }
418
419 StreamPredictor::~StreamPredictor() {
420 gfree(predLine);
421 }
422
423 int StreamPredictor::lookChar() {
424 if (predIdx >= rowBytes) {
425 if (!getNextLine()) {
426 return EOF;
427 }
428 }
429 return predLine[predIdx];
430 }
431
432 int StreamPredictor::getChar() {
433 if (predIdx >= rowBytes) {
434 if (!getNextLine()) {
435 return EOF;
436 }
437 }
438 return predLine[predIdx++];
439 }
440
441 GBool StreamPredictor::getNextLine() {
442 int curPred;
443 Guchar upLeftBuf[4];
444 int left, up, upLeft, p, pa, pb, pc;
445 int c;
446 Gulong inBuf, outBuf, bitMask;
447 int inBits, outBits;
448 int i, j, k;
449
450 // get PNG optimum predictor number
451 if (predictor == 15) {
452 if ((curPred = str->getRawChar()) == EOF) {
453 return gFalse;
454 }
455 curPred += 10;
456 } else {
457 curPred = predictor;
458 }
459
460 // read the raw line, apply PNG (byte) predictor
461 upLeftBuf[0] = upLeftBuf[1] = upLeftBuf[2] = upLeftBuf[3] = 0;
462 for (i = pixBytes; i < rowBytes; ++i) {
463 upLeftBuf[3] = upLeftBuf[2];
464 upLeftBuf[2] = upLeftBuf[1];
465 upLeftBuf[1] = upLeftBuf[0];
466 upLeftBuf[0] = predLine[i];
467 if ((c = str->getRawChar()) == EOF) {
468 break;
469 }
470 switch (curPred) {
471 case 11: // PNG sub
472 predLine[i] = predLine[i - pixBytes] + (Guchar)c;
473 break;
474 case 12: // PNG up
475 predLine[i] = predLine[i] + (Guchar)c;
476 break;
477 case 13: // PNG average
478 predLine[i] = ((predLine[i - pixBytes] + predLine[i]) >> 1) +
479 (Guchar)c;
480 break;
481 case 14: // PNG Paeth
482 left = predLine[i - pixBytes];
483 up = predLine[i];
484 upLeft = upLeftBuf[pixBytes];
485 p = left + up - upLeft;
486 if ((pa = p - left) < 0)
487 pa = -pa;
488 if ((pb = p - up) < 0)
489 pb = -pb;
490 if ((pc = p - upLeft) < 0)
491 pc = -pc;
492 if (pa <= pb && pa <= pc)
493 predLine[i] = left + (Guchar)c;
494 else if (pb <= pc)
495 predLine[i] = up + (Guchar)c;
496 else
497 predLine[i] = upLeft + (Guchar)c;
498 break;
499 case 10: // PNG none
500 default: // no predictor or TIFF predictor
501 predLine[i] = (Guchar)c;
502 break;
503 }
504 }
505
506 // apply TIFF (component) predictor
507 //~ this is completely untested
508 if (predictor == 2) {
509 if (nBits == 1) {
510 inBuf = predLine[pixBytes - 1];
511 for (i = pixBytes; i < rowBytes; i += 8) {
512 // 1-bit add is just xor
513 inBuf = (inBuf << 8) | predLine[i];
514 predLine[i] ^= inBuf >> nComps;
515 }
516 } else if (nBits == 8) {
517 for (i = pixBytes; i < rowBytes; ++i) {
518 predLine[i] += predLine[i - nComps];
519 }
520 } else {
521 upLeftBuf[0] = upLeftBuf[1] = upLeftBuf[2] = upLeftBuf[3] = 0;
522 bitMask = (1 << nBits) - 1;
523 inBuf = outBuf = 0;
524 inBits = outBits = 0;
525 j = k = pixBytes;
526 for (i = 0; i < nVals; ++i) {
527 if (inBits < nBits) {
528 inBuf = (inBuf << 8) | (predLine[j++] & 0xff);
529 inBits += 8;
530 }
531 upLeftBuf[3] = upLeftBuf[2];
532 upLeftBuf[2] = upLeftBuf[1];
533 upLeftBuf[1] = upLeftBuf[0];
534 upLeftBuf[0] = (upLeftBuf[nComps] +
535 (inBuf >> (inBits - nBits))) & bitMask;
536 outBuf = (outBuf << nBits) | upLeftBuf[0];
537 inBits -= nBits;
538 outBits += nBits;
539 if (outBits > 8) {
540 predLine[k++] = (Guchar)(outBuf >> (outBits - 8));
541 }
542 }
543 if (outBits > 0) {
544 predLine[k++] = (Guchar)(outBuf << (8 - outBits));
545 }
546 }
547 }
548
549 // reset to start of line
550 predIdx = pixBytes;
551
552 return gTrue;
553 }
554
555 //------------------------------------------------------------------------
556 // FileStream
557 //------------------------------------------------------------------------
558
559 FileStream::FileStream(FILE *fA, Guint startA, GBool limitedA,
560 Guint lengthA, Object *dictA):
561 BaseStream(dictA) {
562 f = fA;
563 start = startA;
564 limited = limitedA;
565 length = lengthA;
566 bufPtr = bufEnd = buf;
567 bufPos = start;
568 savePos = 0;
569 saved = gFalse;
570 }
571
572 FileStream::~FileStream() {
573 close();
574 }
575
576 Stream *FileStream::makeSubStream(Guint startA, GBool limitedA,
577 Guint lengthA, Object *dictA) {
578 return new FileStream(f, startA, limitedA, lengthA, dictA);
579 }
580
581 void FileStream::reset() {
582 #if HAVE_FSEEK64
583 savePos = (Guint)ftell64(f);
584 fseek64(f, start, SEEK_SET);
585 #else
586 savePos = (Guint)ftell(f);
587 fseek(f, start, SEEK_SET);
588 #endif
589 saved = gTrue;
590 bufPtr = bufEnd = buf;
591 bufPos = start;
592 #ifndef NO_DECRYPTION
593 if (decrypt)
594 decrypt->reset();
595 #endif
596 }
597
598 void FileStream::close() {
599 if (saved) {
600 #if HAVE_FSEEK64
601 fseek64(f, savePos, SEEK_SET);
602 #else
603 fseek(f, savePos, SEEK_SET);
604 #endif
605 saved = gFalse;
606 }
607 }
608
609 GBool FileStream::fillBuf() {
610 int n;
611 #ifndef NO_DECRYPTION
612 char *p;
613 #endif
614
615 bufPos += bufEnd - buf;
616 bufPtr = bufEnd = buf;
617 if (limited && bufPos >= start + length) {
618 return gFalse;
619 }
620 if (limited && bufPos + fileStreamBufSize > start + length) {
621 n = start + length - bufPos;
622 } else {
623 n = fileStreamBufSize;
624 }
625 n = fread(buf, 1, n, f);
626 bufEnd = buf + n;
627 if (bufPtr >= bufEnd) {
628 return gFalse;
629 }
630 #ifndef NO_DECRYPTION
631 if (decrypt) {
632 for (p = buf; p < bufEnd; ++p) {
633 *p = (char)decrypt->decryptByte((Guchar)*p);
634 }
635 }
636 #endif
637 return gTrue;
638 }
639
640 void FileStream::setPos(Guint pos, int dir) {
641 Guint size;
642
643 if (dir >= 0) {
644 #if HAVE_FSEEK64
645 fseek64(f, pos, SEEK_SET);
646 #else
647 fseek(f, pos, SEEK_SET);
648 #endif
649 bufPos = pos;
650 } else {
651 #if HAVE_FSEEK64
652 fseek64(f, 0, SEEK_END);
653 size = (Guint)ftell64(f);
654 #else
655 fseek(f, 0, SEEK_END);
656 size = (Guint)ftell(f);
657 #endif
658 if (pos > size)
659 pos = (Guint)size;
660 #ifdef __CYGWIN32__
661 //~ work around a bug in cygwin's implementation of fseek
662 rewind(f);
663 #endif
664 #if HAVE_FSEEK64
665 fseek64(f, -(int)pos, SEEK_END);
666 bufPos = (Guint)ftell64(f);
667 #else
668 fseek(f, -(int)pos, SEEK_END);
669 bufPos = (Guint)ftell(f);
670 #endif
671 }
672 bufPtr = bufEnd = buf;
673 }
674
675 void FileStream::moveStart(int delta) {
676 start += delta;
677 bufPtr = bufEnd = buf;
678 bufPos = start;
679 }
680
681 //------------------------------------------------------------------------
682 // MemStream
683 //------------------------------------------------------------------------
684
685 MemStream::MemStream(char *bufA, Guint lengthA, Object *dictA):
686 BaseStream(dictA) {
687 buf = bufA;
688 needFree = gFalse;
689 length = lengthA;
690 bufEnd = buf + length;
691 bufPtr = buf;
692 }
693
694 MemStream::~MemStream() {
695 if (needFree) {
696 gfree(buf);
697 }
698 }
699
700 Stream *MemStream::makeSubStream(Guint start, GBool limited,
701 Guint lengthA, Object *dictA) {
702 Guint newLength;
703
704 if (!limited || start + lengthA > length) {
705 newLength = length - start;
706 } else {
707 newLength = lengthA;
708 }
709 return new MemStream(buf + start, newLength, dictA);
710 }
711
712 void MemStream::reset() {
713 bufPtr = buf;
714 #ifndef NO_DECRYPTION
715 if (decrypt) {
716 decrypt->reset();
717 }
718 #endif
719 }
720
721 void MemStream::close() {
722 }
723
724 void MemStream::setPos(Guint pos, int dir) {
725 if (dir >= 0) {
726 if (pos > length) {
727 bufPtr = bufEnd;
728 } else {
729 bufPtr = buf + pos;
730 }
731 } else {
732 if (pos > length) {
733 bufPtr = buf;
734 } else {
735 bufPtr = bufEnd - pos;
736 }
737 }
738 }
739
740 void MemStream::moveStart(int delta) {
741 buf += delta;
742 bufPtr = buf;
743 }
744
745 #ifndef NO_DECRYPTION
746 void MemStream::doDecryption(Guchar *fileKey, int keyLength,
747 int objNum, int objGen) {
748 char *newBuf;
749 char *p, *q;
750
751 this->BaseStream::doDecryption(fileKey, keyLength, objNum, objGen);
752 if (decrypt) {
753 newBuf = (char *)gmalloc(bufEnd - buf);
754 for (p = buf, q = newBuf; p < bufEnd; ++p, ++q) {
755 *q = (char)decrypt->decryptByte((Guchar)*p);
756 }
757 bufEnd = newBuf + (bufEnd - buf);
758 bufPtr = newBuf + (bufPtr - buf);
759 buf = newBuf;
760 needFree = gTrue;
761 }
762 }
763 #endif
764
765 //------------------------------------------------------------------------
766 // EmbedStream
767 //------------------------------------------------------------------------
768
769 EmbedStream::EmbedStream(Stream *strA, Object *dictA):
770 BaseStream(dictA) {
771 str = strA;
772 }
773
774 EmbedStream::~EmbedStream() {
775 }
776
777 Stream *EmbedStream::makeSubStream(Guint start, GBool limited,
778 Guint length, Object *dictA) {
779 error(-1, "Internal: called makeSubStream() on EmbedStream");
780 return NULL;
781 }
782
783 void EmbedStream::setPos(Guint pos, int dir) {
784 error(-1, "Internal: called setPos() on EmbedStream");
785 }
786
787 Guint EmbedStream::getStart() {
788 error(-1, "Internal: called getStart() on EmbedStream");
789 return 0;
790 }
791
792 void EmbedStream::moveStart(int delta) {
793 error(-1, "Internal: called moveStart() on EmbedStream");
794 }
795
796 //------------------------------------------------------------------------
797 // ASCIIHexStream
798 //------------------------------------------------------------------------
799
800 ASCIIHexStream::ASCIIHexStream(Stream *strA):
801 FilterStream(strA) {
802 buf = EOF;
803 eof = gFalse;
804 }
805
806 ASCIIHexStream::~ASCIIHexStream() {
807 delete str;
808 }
809
810 void ASCIIHexStream::reset() {
811 str->reset();
812 buf = EOF;
813 eof = gFalse;
814 }
815
816 int ASCIIHexStream::lookChar() {
817 int c1, c2, x;
818
819 if (buf != EOF)
820 return buf;
821 if (eof) {
822 buf = EOF;
823 return EOF;
824 }
825 do {
826 c1 = str->getChar();
827 } while (isspace(c1));
828 if (c1 == '>') {
829 eof = gTrue;
830 buf = EOF;
831 return buf;
832 }
833 do {
834 c2 = str->getChar();
835 } while (isspace(c2));
836 if (c2 == '>') {
837 eof = gTrue;
838 c2 = '0';
839 }
840 if (c1 >= '0' && c1 <= '9') {
841 x = (c1 - '0') << 4;
842 } else if (c1 >= 'A' && c1 <= 'F') {
843 x = (c1 - 'A' + 10) << 4;
844 } else if (c1 >= 'a' && c1 <= 'f') {
845 x = (c1 - 'a' + 10) << 4;
846 } else if (c1 == EOF) {
847 eof = gTrue;
848 x = 0;
849 } else {
850 error(getPos(), "Illegal character <%02x> in ASCIIHex stream", c1);
851 x = 0;
852 }
853 if (c2 >= '0' && c2 <= '9') {
854 x += c2 - '0';
855 } else if (c2 >= 'A' && c2 <= 'F') {
856 x += c2 - 'A' + 10;
857 } else if (c2 >= 'a' && c2 <= 'f') {
858 x += c2 - 'a' + 10;
859 } else if (c2 == EOF) {
860 eof = gTrue;
861 x = 0;
862 } else {
863 error(getPos(), "Illegal character <%02x> in ASCIIHex stream", c2);
864 }
865 buf = x & 0xff;
866 return buf;
867 }
868
869 GString *ASCIIHexStream::getPSFilter(char *indent) {
870 GString *s;
871
872 if (!(s = str->getPSFilter(indent))) {
873 return NULL;
874 }
875 s->append(indent)->append("/ASCIIHexDecode filter\n");
876 return s;
877 }
878
879 GBool ASCIIHexStream::isBinary(GBool last) {
880 return str->isBinary(gFalse);
881 }
882
883 //------------------------------------------------------------------------
884 // ASCII85Stream
885 //------------------------------------------------------------------------
886
887 ASCII85Stream::ASCII85Stream(Stream *strA):
888 FilterStream(strA) {
889 index = n = 0;
890 eof = gFalse;
891 }
892
893 ASCII85Stream::~ASCII85Stream() {
894 delete str;
895 }
896
897 void ASCII85Stream::reset() {
898 str->reset();
899 index = n = 0;
900 eof = gFalse;
901 }
902
903 int ASCII85Stream::lookChar() {
904 int k;
905 Gulong t;
906
907 if (index >= n) {
908 if (eof)
909 return EOF;
910 index = 0;
911 do {
912 c[0] = str->getChar();
913 } while (c[0] == '\n' || c[0] == '\r');
914 if (c[0] == '~' || c[0] == EOF) {
915 eof = gTrue;
916 n = 0;
917 return EOF;
918 } else if (c[0] == 'z') {
919 b[0] = b[1] = b[2] = b[3] = 0;
920 n = 4;
921 } else {
922 for (k = 1; k < 5; ++k) {
923 do {
924 c[k] = str->getChar();
925 } while (c[k] == '\n' || c[k] == '\r');
926 if (c[k] == '~' || c[k] == EOF)
927 break;
928 }
929 n = k - 1;
930 if (k < 5 && (c[k] == '~' || c[k] == EOF)) {
931 for (++k; k < 5; ++k)
932 c[k] = 0x21 + 84;
933 eof = gTrue;
934 }
935 t = 0;
936 for (k = 0; k < 5; ++k)
937 t = t * 85 + (c[k] - 0x21);
938 for (k = 3; k >= 0; --k) {
939 b[k] = (int)(t & 0xff);
940 t >>= 8;
941 }
942 }
943 }
944 return b[index];
945 }
946
947 GString *ASCII85Stream::getPSFilter(char *indent) {
948 GString *s;
949
950 if (!(s = str->getPSFilter(indent))) {
951 return NULL;
952 }
953 s->append(indent)->append("/ASCII85Decode filter\n");
954 return s;
955 }
956
957 GBool ASCII85Stream::isBinary(GBool last) {
958 return str->isBinary(gFalse);
959 }
960
961 //------------------------------------------------------------------------
962 // LZWStream
963 //------------------------------------------------------------------------
964
965 LZWStream::LZWStream(Stream *strA, int predictor, int columns, int colors,
966 int bits, int earlyA):
967 FilterStream(strA) {
968 if (predictor != 1) {
969 pred = new StreamPredictor(this, predictor, columns, colors, bits);
970 } else {
971 pred = NULL;
972 }
973 early = earlyA;
974 zPipe = NULL;
975 bufPtr = bufEnd = buf;
976 }
977
978 LZWStream::~LZWStream() {
979 if (zPipe) {
980 #ifdef HAVE_POPEN
981 pclose(zPipe);
982 #else
983 fclose(zPipe);
984 #endif
985 zPipe = NULL;
986 unlink(zName->getCString());
987 delete zName;
988 }
989 if (pred) {
990 delete pred;
991 }
992 delete str;
993 }
994
995 int LZWStream::getChar() {
996 if (pred) {
997 return pred->getChar();
998 }
999 return (bufPtr >= bufEnd && !fillBuf()) ? EOF : (*bufPtr++ & 0xff);
1000 }
1001
1002 int LZWStream::lookChar() {
1003 if (pred) {
1004 return pred->lookChar();
1005 }
1006 return (bufPtr >= bufEnd && !fillBuf()) ? EOF : (*bufPtr & 0xff);
1007 }
1008
1009 int LZWStream::getRawChar() {
1010 return (bufPtr >= bufEnd && !fillBuf()) ? EOF : (*bufPtr++ & 0xff);
1011 }
1012
1013 void LZWStream::reset() {
1014 FILE *f;
1015 GString *zCmd;
1016
1017 //----- close old LZW stream
1018 if (zPipe) {
1019 #ifdef HAVE_POPEN
1020 pclose(zPipe);
1021 #else
1022 fclose(zPipe);
1023 #endif
1024 zPipe = NULL;
1025 unlink(zName->getCString());
1026 delete zName;
1027 }
1028
1029 //----- tell Delorie runtime to spawn a new instance of COMMAND.COM
1030 // to run gzip
1031 #if __DJGPP__
1032 if (!setDJSYSFLAGS) {
1033 setenv("DJSYSFLAGS", "0x0002", 0);
1034 setDJSYSFLAGS = gTrue;
1035 }
1036 #endif
1037
1038 //----- create the .Z file
1039 if (!openTempFile(&zName, &f, "wb", ".Z")) {
1040 error(getPos(), "Couldn't create temporary file for LZW stream");
1041 return;
1042 }
1043 dumpFile(f);
1044 fclose(f);
1045
1046 //----- execute uncompress / gzip
1047 #ifdef WIN32
1048 zCmd = new GString("c:\\swftools\\gzip.exe");
1049 #else
1050 zCmd = new GString(uncompressCmd);
1051 #endif
1052 zCmd->append(' ');
1053 zCmd->append(zName);
1054 #if defined(MACOS)
1055 long magicCookie;
1056 // first we open the engine up
1057 OSErr err = OpenSITEngine(kUseExternalEngine, &magicCookie);
1058 // if we found it - let's use it!
1059 if (!err && magicCookie) {
1060 // make sure we have the correct version of the Engine
1061 if (GetSITEngineVersion(magicCookie) >= kFirstSupportedEngine) {
1062 FSSpec myFSS;
1063 Str255 pName;
1064 strcpy((char *)pName, zName->getCString());
1065 c2pstr((char *)pName);
1066 FSMakeFSSpec(0, 0, pName, &myFSS);
1067 short ftype = DetermineFileType(magicCookie, &myFSS);
1068 OSErr expandErr = ExpandFSSpec(magicCookie, ftype, &myFSS,
1069 NULL, NULL, kCreateFolderNever,
1070 kDeleteOriginal, kTextConvertSmart);
1071 }
1072 }
1073 #elif defined(HAVE_POPEN)
1074 if (!(zPipe = popen(zCmd->getCString(), POPEN_READ_MODE))) {
1075 error(getPos(), "Couldn't popen '%s'", zCmd->getCString());
1076 unlink(zName->getCString());
1077 delete zName;
1078 return;
1079 }
1080 #else // HAVE_POPEN
1081 if (!executeCommand(zCmd->getCString())) {
1082 error(getPos(), "Couldn't execute '%s'", zCmd->getCString());
1083 unlink(zName->getCString());
1084 delete zName;
1085 return;
1086 }
1087 zName->del(zName->getLength() - 2, 2);
1088 if (!(zPipe = fopen(zName->getCString(), "rb"))) {
1089 error(getPos(), "Couldn't open uncompress file '%s'", zName->getCString());
1090 unlink(zName->getCString());
1091 delete zName;
1092 return;
1093 }
1094 #endif // HAVE_POPEN
1095
1096 //----- clean up
1097 delete zCmd;
1098
1099 //----- initialize buffer
1100 bufPtr = bufEnd = buf;
1101 }
1102
1103 void LZWStream::dumpFile(FILE *f) {
1104 int outCodeBits; // size of output code
1105 int outBits; // max output code
1106 int outBuf[8]; // output buffer
1107 int outData; // temporary output buffer
1108 int inCode, outCode; // input and output codes
1109 int nextCode; // next code index
1110 GBool eof; // set when EOF is reached
1111 GBool clear; // set if table needs to be cleared
1112 GBool first; // indicates first code word after clear
1113 int i, j;
1114
1115 str->reset();
1116
1117 // magic number
1118 fputc(0x1f, f);
1119 fputc(0x9d, f);
1120
1121 // max code length, block mode flag
1122 fputc(0x8c, f);
1123
1124 // init input side
1125 inCodeBits = 9;
1126 inputBuf = 0;
1127 inputBits = 0;
1128 eof = gFalse;
1129
1130 // init output side
1131 outCodeBits = 9;
1132
1133 // clear table
1134 first = gTrue;
1135 nextCode = 258;
1136
1137 clear = gFalse;
1138 do {
1139 for (i = 0; i < 8; ++i) {
1140 // check for table overflow
1141 if (nextCode + early > 0x1001) {
1142 inCode = 256;
1143
1144 // read input code
1145 } else {
1146 do {
1147 inCode = getCode();
1148 if (inCode == EOF) {
1149 eof = gTrue;
1150 inCode = 0;
1151 }
1152 } while (first && inCode == 256);
1153 }
1154
1155 // compute output code
1156 if (inCode < 256) {
1157 outCode = inCode;
1158 } else if (inCode == 256) {
1159 outCode = 256;
1160 clear = gTrue;
1161 } else if (inCode == 257) {
1162 outCode = 0;
1163 eof = gTrue;
1164 } else {
1165 outCode = inCode - 1;
1166 }
1167 outBuf[i] = outCode;
1168
1169 // next code index
1170 if (first)
1171 first = gFalse;
1172 else
1173 ++nextCode;
1174
1175 // check input code size
1176 if (nextCode + early == 0x200)
1177 inCodeBits = 10;
1178 else if (nextCode + early == 0x400) {
1179 inCodeBits = 11;
1180 } else if (nextCode + early == 0x800) {
1181 inCodeBits = 12;
1182 }
1183
1184 // check for eof/clear
1185 if (eof)
1186 break;
1187 if (clear) {
1188 i = 8;
1189 break;
1190 }
1191 }
1192
1193 // write output block
1194 outData = 0;
1195 outBits = 0;
1196 j = 0;
1197 while (j < i || outBits > 0) {
1198 if (outBits < 8 && j < i) {
1199 outData = outData | (outBuf[j++] << outBits);
1200 outBits += outCodeBits;
1201 }
1202 fputc(outData & 0xff, f);
1203 outData >>= 8;
1204 outBits -= 8;
1205 }
1206
1207 // check output code size
1208 if (nextCode - 1 == 512 ||
1209 nextCode - 1 == 1024 ||
1210 nextCode - 1 == 2048 ||
1211 nextCode - 1 == 4096) {
1212 outCodeBits = inCodeBits;
1213 }
1214
1215 // clear table if necessary
1216 if (clear) {
1217 inCodeBits = 9;
1218 outCodeBits = 9;
1219 first = gTrue;
1220 nextCode = 258;
1221 clear = gFalse;
1222 }
1223 } while (!eof);
1224 }
1225
1226 int LZWStream::getCode() {
1227 int c;
1228 int code;
1229
1230 while (inputBits < inCodeBits) {
1231 if ((c = str->getChar()) == EOF)
1232 return EOF;
1233 inputBuf = (inputBuf << 8) | (c & 0xff);
1234 inputBits += 8;
1235 }
1236 code = (inputBuf >> (inputBits - inCodeBits)) & ((1 << inCodeBits) - 1);
1237 inputBits -= inCodeBits;
1238 return code;
1239 }
1240
1241 GBool LZWStream::fillBuf() {
1242 int n;
1243
1244 if (!zPipe)
1245 return gFalse;
1246 if ((n = fread(buf, 1, 256, zPipe)) < 256) {
1247 #ifdef HAVE_POPEN
1248 pclose(zPipe);
1249 #else
1250 fclose(zPipe);
1251 #endif
1252 zPipe = NULL;
1253 unlink(zName->getCString());
1254 delete zName;
1255 }
1256 bufPtr = buf;
1257 bufEnd = buf + n;
1258 return n > 0;
1259 }
1260
1261 GString *LZWStream::getPSFilter(char *indent) {
1262 GString *s;
1263
1264 if (pred) {
1265 return NULL;
1266 }
1267 if (!(s = str->getPSFilter(indent))) {
1268 return NULL;
1269 }
1270 s->append(indent)->append("/LZWDecode filter\n");
1271 return s;
1272 }
1273
1274 GBool LZWStream::isBinary(GBool last) {
1275 return str->isBinary(gTrue);
1276 }
1277
1278 //------------------------------------------------------------------------
1279 // RunLengthStream
1280 //------------------------------------------------------------------------
1281
1282 RunLengthStream::RunLengthStream(Stream *strA):
1283 FilterStream(strA) {
1284 bufPtr = bufEnd = buf;
1285 eof = gFalse;
1286 }
1287
1288 RunLengthStream::~RunLengthStream() {
1289 delete str;
1290 }
1291
1292 void RunLengthStream::reset() {
1293 str->reset();
1294 bufPtr = bufEnd = buf;
1295 eof = gFalse;
1296 }
1297
1298 GString *RunLengthStream::getPSFilter(char *indent) {
1299 GString *s;
1300
1301 if (!(s = str->getPSFilter(indent))) {
1302 return NULL;
1303 }
1304 s->append(indent)->append("/RunLengthDecode filter\n");
1305 return s;
1306 }
1307
1308 GBool RunLengthStream::isBinary(GBool last) {
1309 return str->isBinary(gTrue);
1310 }
1311
1312 GBool RunLengthStream::fillBuf() {
1313 int c;
1314 int n, i;
1315
1316 if (eof)
1317 return gFalse;
1318 c = str->getChar();
1319 if (c == 0x80 || c == EOF) {
1320 eof = gTrue;
1321 return gFalse;
1322 }
1323 if (c < 0x80) {
1324 n = c + 1;
1325 for (i = 0; i < n; ++i)
1326 buf[i] = (char)str->getChar();
1327 } else {
1328 n = 0x101 - c;
1329 c = str->getChar();
1330 for (i = 0; i < n; ++i)
1331 buf[i] = (char)c;
1332 }
1333 bufPtr = buf;
1334 bufEnd = buf + n;
1335 return gTrue;
1336 }
1337
1338 //------------------------------------------------------------------------
1339 // CCITTFaxStream
1340 //------------------------------------------------------------------------
1341
1342 CCITTFaxStream::CCITTFaxStream(Stream *strA, int encodingA, GBool endOfLineA,
1343 GBool byteAlignA, int columnsA, int rowsA,
1344 GBool endOfBlockA, GBool blackA):
1345 FilterStream(strA) {
1346 encoding = encodingA;
1347 endOfLine = endOfLineA;
1348 byteAlign = byteAlignA;
1349 columns = columnsA;
1350 rows = rowsA;
1351 endOfBlock = endOfBlockA;
1352 black = blackA;
1353 refLine = (short *)gmalloc((columns + 3) * sizeof(short));
1354 codingLine = (short *)gmalloc((columns + 2) * sizeof(short));
1355
1356 eof = gFalse;
1357 row = 0;
1358 nextLine2D = encoding < 0;
1359 inputBits = 0;
1360 codingLine[0] = 0;
1361 codingLine[1] = refLine[2] = columns;
1362 a0 = 1;
1363
1364 buf = EOF;
1365 }
1366
1367 CCITTFaxStream::~CCITTFaxStream() {
1368 delete str;
1369 gfree(refLine);
1370 gfree(codingLine);
1371 }
1372
1373 void CCITTFaxStream::reset() {
1374 int n;
1375
1376 str->reset();
1377 eof = gFalse;
1378 row = 0;
1379 nextLine2D = encoding < 0;
1380 inputBits = 0;
1381 codingLine[0] = 0;
1382 codingLine[1] = refLine[2] = columns;
1383 a0 = 1;
1384 buf = EOF;
1385
1386 // get initial end-of-line marker and 2D encoding tag
1387 if (endOfBlock) {
1388 if (lookBits(12) == 0x001) {
1389 eatBits(12);
1390 }
1391 } else {
1392 for (n = 0; n < 11 && lookBits(n) == 0; ++n) ;
1393 if (n == 11 && lookBits(12) == 0x001) {
1394 eatBits(12);
1395 }
1396 }
1397 if (encoding > 0) {
1398 nextLine2D = !lookBits(1);
1399 eatBits(1);
1400 }
1401 }
1402
1403 int CCITTFaxStream::lookChar() {
1404 short code1, code2, code3;
1405 int a0New;
1406 #if 0
1407 GBool err;
1408 #endif
1409 GBool gotEOL;
1410 int ret;
1411 int bits, i;
1412
1413 // if at eof just return EOF
1414 if (eof && codingLine[a0] >= columns) {
1415 return EOF;
1416 }
1417
1418 // read the next row
1419 #if 0
1420 err = gFalse;
1421 #endif
1422 if (codingLine[a0] >= columns) {
1423
1424 // 2-D encoding
1425 if (nextLine2D) {
1426 for (i = 0; codingLine[i] < columns; ++i)
1427 refLine[i] = codingLine[i];
1428 refLine[i] = refLine[i + 1] = columns;
1429 b1 = 1;
1430 a0New = codingLine[a0 = 0] = 0;
1431 do {
1432 code1 = getTwoDimCode();
1433 switch (code1) {
1434 case twoDimPass:
1435 if (refLine[b1] < columns) {
1436 a0New = refLine[b1 + 1];
1437 b1 += 2;
1438 }
1439 break;
1440 case twoDimHoriz:
1441 if ((a0 & 1) == 0) {
1442 code1 = code2 = 0;
1443 do {
1444 code1 += code3 = getWhiteCode();
1445 } while (code3 >= 64);
1446 do {
1447 code2 += code3 = getBlackCode();
1448 } while (code3 >= 64);
1449 } else {
1450 code1 = code2 = 0;
1451 do {
1452 code1 += code3 = getBlackCode();
1453 } while (code3 >= 64);
1454 do {
1455 code2 += code3 = getWhiteCode();
1456 } while (code3 >= 64);
1457 }
1458 codingLine[a0 + 1] = a0New + code1;
1459 ++a0;
1460 a0New = codingLine[a0 + 1] = codingLine[a0] + code2;
1461 ++a0;
1462 while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1463 b1 += 2;
1464 break;
1465 case twoDimVert0:
1466 a0New = codingLine[++a0] = refLine[b1];
1467 if (refLine[b1] < columns) {
1468 ++b1;
1469 while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1470 b1 += 2;
1471 }
1472 break;
1473 case twoDimVertR1:
1474 a0New = codingLine[++a0] = refLine[b1] + 1;
1475 if (refLine[b1] < columns) {
1476 ++b1;
1477 while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1478 b1 += 2;
1479 }
1480 break;
1481 case twoDimVertL1:
1482 a0New = codingLine[++a0] = refLine[b1] - 1;
1483 --b1;
1484 while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1485 b1 += 2;
1486 break;
1487 case twoDimVertR2:
1488 a0New = codingLine[++a0] = refLine[b1] + 2;
1489 if (refLine[b1] < columns) {
1490 ++b1;
1491 while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1492 b1 += 2;
1493 }
1494 break;
1495 case twoDimVertL2:
1496 a0New = codingLine[++a0] = refLine[b1] - 2;
1497 --b1;
1498 while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1499 b1 += 2;
1500 break;
1501 case twoDimVertR3:
1502 a0New = codingLine[++a0] = refLine[b1] + 3;
1503 if (refLine[b1] < columns) {
1504 ++b1;
1505 while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1506 b1 += 2;
1507 }
1508 break;
1509 case twoDimVertL3:
1510 a0New = codingLine[++a0] = refLine[b1] - 3;
1511 --b1;
1512 while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1513 b1 += 2;
1514 break;
1515 case EOF:
1516 eof = gTrue;
1517 codingLine[a0 = 0] = columns;
1518 return EOF;
1519 default:
1520 error(getPos(), "Bad 2D code %04x in CCITTFax stream", code1);
1521 #if 0
1522 err = gTrue;
1523 break;
1524 #else
1525 eof = gTrue;
1526 return EOF;
1527 #endif
1528 }
1529 } while (codingLine[a0] < columns);
1530
1531 // 1-D encoding
1532 } else {
1533 codingLine[a0 = 0] = 0;
1534 while (1) {
1535 code1 = 0;
1536 do {
1537 code1 += code3 = getWhiteCode();
1538 } while (code3 >= 64);
1539 codingLine[a0+1] = codingLine[a0] + code1;
1540 ++a0;
1541 if (codingLine[a0] >= columns)
1542 break;
1543 code2 = 0;
1544 do {
1545 code2 += code3 = getBlackCode();
1546 } while (code3 >= 64);
1547 codingLine[a0+1] = codingLine[a0] + code2;
1548 ++a0;
1549 if (codingLine[a0] >= columns)
1550 break;
1551 }
1552 }
1553
1554 if (codingLine[a0] != columns) {
1555 error(getPos(), "CCITTFax row is wrong length (%d)", codingLine[a0]);
1556 #if 0
1557 err = gTrue;
1558 #endif
1559 }
1560
1561 // byte-align the row
1562 if (byteAlign) {
1563 inputBits &= ~7;
1564 }
1565
1566 // check for end-of-line marker, skipping over any extra zero bits
1567 gotEOL = gFalse;
1568 if (!endOfBlock && row == rows - 1) {
1569 eof = gTrue;
1570 } else {
1571 code1 = lookBits(12);
1572 while (code1 == 0) {
1573 eatBits(1);
1574 code1 = lookBits(12);
1575 }
1576 if (code1 == 0x001) {
1577 eatBits(12);
1578 gotEOL = gTrue;
1579 } else if (code1 == EOF) {
1580 eof = gTrue;
1581 }
1582 }
1583
1584 // get 2D encoding tag
1585 if (!eof && encoding > 0) {
1586 nextLine2D = !lookBits(1);
1587 eatBits(1);
1588 }
1589
1590 // check for end-of-block marker
1591 if (endOfBlock && gotEOL) {
1592 code1 = lookBits(12);
1593 if (code1 == 0x001) {
1594 eatBits(12);
1595 if (encoding > 0) {
1596 lookBits(1);
1597 eatBits(1);
1598 }
1599 if (encoding >= 0) {
1600 for (i = 0; i < 4; ++i) {
1601 code1 = lookBits(12);
1602 if (code1 != 0x001) {
1603 error(getPos(), "Bad RTC code in CCITTFax stream");
1604 }
1605 eatBits(12);
1606 if (encoding > 0) {
1607 lookBits(1);
1608 eatBits(1);
1609 }
1610 }
1611 }
1612 eof = gTrue;
1613 }
1614 }
1615
1616 #if 0
1617 // This looks for an end-of-line marker after an error, however
1618 // some (most?) CCITT streams in PDF files don't use end-of-line
1619 // markers, and the just-plow-on technique works better in those
1620 // cases.
1621 else if (err) {
1622 do {
1623 if (code1 == EOF) {
1624 eof = gTrue;
1625 return EOF;
1626 }
1627 eatBits(1);
1628 code1 = look13Bits();
1629 } while ((code1 >> 1) != 0x001);
1630 eatBits(12);
1631 codingLine[++a0] = columns;
1632 if (encoding > 0) {
1633 eatBits(1);
1634 nextLine2D = !(code1 & 1);
1635 }
1636 }
1637 #endif
1638
1639 a0 = 0;
1640 outputBits = codingLine[1] - codingLine[0];
1641 if (outputBits == 0) {
1642 a0 = 1;
1643 outputBits = codingLine[2] - codingLine[1];
1644 }
1645
1646 ++row;
1647 }
1648
1649 // get a byte
1650 if (outputBits >= 8) {
1651 ret = ((a0 & 1) == 0) ? 0xff : 0x00;
1652 if ((outputBits -= 8) == 0) {
1653 ++a0;
1654 if (codingLine[a0] < columns) {
1655 outputBits = codingLine[a0 + 1] - codingLine[a0];
1656 }
1657 }
1658 } else {
1659 bits = 8;
1660 ret = 0;
1661 do {
1662 if (outputBits > bits) {
1663 i = bits;
1664 bits = 0;
1665 if ((a0 & 1) == 0) {
1666 ret |= 0xff >> (8 - i);
1667 }
1668 outputBits -= i;
1669 } else {
1670 i = outputBits;
1671 bits -= outputBits;
1672 if ((a0 & 1) == 0) {
1673 ret |= (0xff >> (8 - i)) << bits;
1674 }
1675 outputBits = 0;
1676 ++a0;
1677 if (codingLine[a0] < columns) {
1678 outputBits = codingLine[a0 + 1] - codingLine[a0];
1679 }
1680 }
1681 } while (bits > 0 && codingLine[a0] < columns);
1682 }
1683 buf = black ? (ret ^ 0xff) : ret;
1684 return buf;
1685 }
1686
1687 short CCITTFaxStream::getTwoDimCode() {
1688 short code;
1689 CCITTCode *p;
1690 int n;
1691
1692 code = 0; // make gcc happy
1693 if (endOfBlock) {
1694 code = lookBits(7);
1695 p = &twoDimTab1[code];
1696 if (p->bits > 0) {
1697 eatBits(p->bits);
1698 return p->n;
1699 }
1700 } else {
1701 for (n = 1; n <= 7; ++n) {
1702 code = lookBits(n);
1703 if (n < 7) {
1704 code <<= 7 - n;
1705 }
1706 p = &twoDimTab1[code];
1707 if (p->bits == n) {
1708 eatBits(n);
1709 return p->n;
1710 }
1711 }
1712 }
1713 error(getPos(), "Bad two dim code (%04x) in CCITTFax stream", code);
1714 return EOF;
1715 }
1716
1717 short CCITTFaxStream::getWhiteCode() {
1718 short code;
1719 CCITTCode *p;
1720 int n;
1721
1722 code = 0; // make gcc happy
1723 if (endOfBlock) {
1724 code = lookBits(12);
1725 if ((code >> 5) == 0) {
1726 p = &whiteTab1[code];
1727 } else {
1728 p = &whiteTab2[code >> 3];
1729 }
1730 if (p->bits > 0) {
1731 eatBits(p->bits);
1732 return p->n;
1733 }
1734 } else {
1735 for (n = 1; n <= 9; ++n) {
1736 code = lookBits(n);
1737 if (n < 9) {
1738 code <<= 9 - n;
1739 }
1740 p = &whiteTab2[code];
1741 if (p->bits == n) {
1742 eatBits(n);
1743 return p->n;
1744 }
1745 }
1746 for (n = 11; n <= 12; ++n) {
1747 code = lookBits(n);
1748 if (n < 12) {
1749 code <<= 12 - n;
1750 }
1751 p = &whiteTab1[code];
1752 if (p->bits == n) {
1753 eatBits(n);
1754 return p->n;
1755 }
1756 }
1757 }
1758 error(getPos(), "Bad white code (%04x) in CCITTFax stream", code);
1759 // eat a bit and return a positive number so that the caller doesn't
1760 // go into an infinite loop
1761 eatBits(1);
1762 return 1;
1763 }
1764
1765 short CCITTFaxStream::getBlackCode() {
1766 short code;
1767 CCITTCode *p;
1768 int n;
1769
1770 code = 0; // make gcc happy
1771 if (endOfBlock) {
1772 code = lookBits(13);
1773 if ((code >> 7) == 0) {
1774 p = &blackTab1[code];
1775 } else if ((code >> 9) == 0) {
1776 p = &blackTab2[(code >> 1) - 64];
1777 } else {
1778 p = &blackTab3[code >> 7];
1779 }
1780 if (p->bits > 0) {
1781 eatBits(p->bits);
1782 return p->n;
1783 }
1784 } else {
1785 for (n = 2; n <= 6; ++n) {
1786 code = lookBits(n);
1787 if (n < 6) {
1788 code <<= 6 - n;
1789 }
1790 p = &blackTab3[code];
1791 if (p->bits == n) {
1792 eatBits(n);
1793 return p->n;
1794 }
1795 }
1796 for (n = 7; n <= 12; ++n) {
1797 code = lookBits(n);
1798 if (n < 12) {
1799 code <<= 12 - n;
1800 }
1801 if (code >= 64) {
1802 p = &blackTab2[code - 64];
1803 if (p->bits == n) {
1804 eatBits(n);
1805 return p->n;
1806 }
1807 }
1808 }
1809 for (n = 10; n <= 13; ++n) {
1810 code = lookBits(n);
1811 if (n < 13) {
1812 code <<= 13 - n;
1813 }
1814 p = &blackTab1[code];
1815 if (p->bits == n) {
1816 eatBits(n);
1817 return p->n;
1818 }
1819 }
1820 }
1821 error(getPos(), "Bad black code (%04x) in CCITTFax stream", code);
1822 // eat a bit and return a positive number so that the caller doesn't
1823 // go into an infinite loop
1824 eatBits(1);
1825 return 1;
1826 }
1827
1828 short CCITTFaxStream::lookBits(int n) {
1829 int c;
1830
1831 while (inputBits < n) {
1832 if ((c = str->getChar()) == EOF) {
1833 if (inputBits == 0) {
1834 return EOF;
1835 }
1836 // near the end of the stream, the caller may ask for more bits
1837 // than are available, but there may still be a valid code in
1838 // however many bits are available -- we need to return correct
1839 // data in this case
1840 return (inputBuf << (n - inputBits)) & (0xffff >> (16 - n));
1841 }
1842 inputBuf = (inputBuf << 8) + c;
1843 inputBits += 8;
1844 }
1845 return (inputBuf >> (inputBits - n)) & (0xffff >> (16 - n));
1846 }
1847
1848 GString *CCITTFaxStream::getPSFilter(char *indent) {
1849 GString *s;
1850 char s1[50];
1851
1852 if (!(s = str->getPSFilter(indent))) {
1853 return NULL;
1854 }
1855 s->append(indent)->append("<< ");
1856 if (encoding != 0) {
1857 sprintf(s1, "/K %d ", encoding);
1858 s->append(s1);
1859 }
1860 if (endOfLine) {
1861 s->append("/EndOfLine true ");
1862 }
1863 if (byteAlign) {
1864 s->append("/EncodedByteAlign true ");
1865 }
1866 sprintf(s1, "/Columns %d ", columns);
1867 s->append(s1);
1868 if (rows != 0) {
1869 sprintf(s1, "/Rows %d ", rows);
1870 s->append(s1);
1871 }
1872 if (!endOfBlock) {
1873 s->append("/EndOfBlock false ");
1874 }
1875 if (black) {
1876 s->append("/BlackIs1 true ");
1877 }
1878 s->append(">> /CCITTFaxDecode filter\n");
1879 return s;
1880 }
1881
1882 GBool CCITTFaxStream::isBinary(GBool last) {
1883 return str->isBinary(gTrue);
1884 }
1885
1886 //------------------------------------------------------------------------
1887 // DCTStream
1888 //------------------------------------------------------------------------
1889
1890 // IDCT constants (20.12 fixed point format)
1891 #ifndef FP_IDCT
1892 #define dctCos1 4017 // cos(pi/16)
1893 #define dctSin1 799 // sin(pi/16)
1894 #define dctCos3 3406 // cos(3*pi/16)
1895 #define dctSin3 2276 // sin(3*pi/16)
1896 #define dctCos6 1567 // cos(6*pi/16)
1897 #define dctSin6 3784 // sin(6*pi/16)
1898 #define dctSqrt2 5793 // sqrt(2)
1899 #define dctSqrt1d2 2896 // sqrt(2) / 2
1900 #endif
1901
1902 // IDCT constants
1903 #ifdef FP_IDCT
1904 #define dctCos1 0.98078528 // cos(pi/16)
1905 #define dctSin1 0.19509032 // sin(pi/16)
1906 #define dctCos3 0.83146961 // cos(3*pi/16)
1907 #define dctSin3 0.55557023 // sin(3*pi/16)
1908 #define dctCos6 0.38268343 // cos(6*pi/16)
1909 #define dctSin6 0.92387953 // sin(6*pi/16)
1910 #define dctSqrt2 1.41421356 // sqrt(2)
1911 #define dctSqrt1d2 0.70710678 // sqrt(2) / 2
1912 #endif
1913
1914 // color conversion parameters (16.16 fixed point format)
1915 #define dctCrToR 91881 // 1.4020
1916 #define dctCbToG -22553 // -0.3441363
1917 #define dctCrToG -46802 // -0.71413636
1918 #define dctCbToB 116130 // 1.772
1919
1920 // clip [-256,511] --> [0,255]
1921 #define dctClipOffset 256
1922 static Guchar dctClip[768];
1923 static int dctClipInit = 0;
1924
1925 // zig zag decode map
1926 static int dctZigZag[64] = {
1927 0,
1928 1, 8,
1929 16, 9, 2,
1930 3, 10, 17, 24,
1931 32, 25, 18, 11, 4,
1932 5, 12, 19, 26, 33, 40,
1933 48, 41, 34, 27, 20, 13, 6,
1934 7, 14, 21, 28, 35, 42, 49, 56,
1935 57, 50, 43, 36, 29, 22, 15,
1936 23, 30, 37, 44, 51, 58,
1937 59, 52, 45, 38, 31,
1938 39, 46, 53, 60,
1939 61, 54, 47,
1940 55, 62,
1941 63
1942 };
1943
1944 DCTStream::DCTStream(Stream *strA):
1945 FilterStream(strA) {
1946 int i, j;
1947
1948 width = height = 0;
1949 mcuWidth = mcuHeight = 0;
1950 numComps = 0;
1951 comp = 0;
1952 x = y = dy = 0;
1953 for (i = 0; i < 4; ++i)
1954 for (j = 0; j < 32; ++j)
1955 rowBuf[i][j] = NULL;
1956
1957 if (!dctClipInit) {
1958 for (i = -256; i < 0; ++i)
1959 dctClip[dctClipOffset + i] = 0;
1960 for (i = 0; i < 256; ++i)
1961 dctClip[dctClipOffset + i] = i;
1962 for (i = 256; i < 512; ++i)
1963 dctClip[dctClipOffset + i] = 255;
1964 dctClipInit = 1;
1965 }
1966 }
1967
1968 DCTStream::~DCTStream() {
1969 int i, j;
1970
1971 delete str;
1972 for (i = 0; i < numComps; ++i)
1973 for (j = 0; j < mcuHeight; ++j)
1974 gfree(rowBuf[i][j]);
1975 }
1976
1977 void DCTStream::reset() {
1978 str->reset();
1979 if (!readHeader()) {
1980 y = height;
1981 return;
1982 }
1983 restartMarker = 0xd0;
1984 restart();
1985 }
1986
1987 int DCTStream::getChar() {
1988 int c;
1989
1990 c = lookChar();
1991 if (c == EOF)
1992 return EOF;
1993 if (++comp == numComps) {
1994 comp = 0;
1995 if (++x == width) {
1996 x = 0;
1997 ++y;
1998 ++dy;
1999 }
2000 }
2001 if (y == height)
2002 readTrailer();
2003 return c;
2004 }
2005
2006 int DCTStream::lookChar() {
2007 if (y >= height)
2008 return EOF;
2009 if (dy >= mcuHeight) {
2010 if (!readMCURow()) {
2011 y = height;
2012 return EOF;
2013 }
2014 comp = 0;
2015 x = 0;
2016 dy = 0;
2017 }
2018 return rowBuf[comp][dy][x];
2019 }
2020
2021 void DCTStream::restart() {
2022 int i;
2023
2024 inputBits = 0;
2025 restartCtr = restartInterval;
2026 for (i = 0; i < numComps; ++i)
2027 compInfo[i].prevDC = 0;
2028 }
2029
2030 GBool DCTStream::readMCURow() {
2031 Guchar data[64];
2032 Guchar *p1, *p2;
2033 int pY, pCb, pCr, pR, pG, pB;
2034 int h, v, horiz, vert, hSub, vSub;
2035 int x1, x2, y2, x3, y3, x4, y4, x5, y5, cc, i;
2036 int c;
2037
2038 for (x1 = 0; x1 < width; x1 += mcuWidth) {
2039
2040 // deal with restart marker
2041 if (restartInterval > 0 && restartCtr == 0) {
2042 c = readMarker();
2043 if (c != restartMarker) {
2044 error(getPos(), "Bad DCT data: incorrect restart marker");
2045 return gFalse;
2046 }
2047 if (++restartMarker == 0xd8)
2048 restartMarker = 0xd0;
2049 restart();
2050 }
2051
2052 // read one MCU
2053 for (cc = 0; cc < numComps; ++cc) {
2054 h = compInfo[cc].hSample;
2055 v = compInfo[cc].vSample;
2056 horiz = mcuWidth / h;
2057 vert = mcuHeight / v;
2058 hSub = horiz / 8;
2059 vSub = vert / 8;
2060 for (y2 = 0; y2 < mcuHeight; y2 += vert) {
2061 for (x2 = 0; x2 < mcuWidth; x2 += horiz) {
2062 if (!readDataUnit(&dcHuffTables[compInfo[cc].dcHuffTable],
2063 &acHuffTables[compInfo[cc].acHuffTable],
2064 quantTables[compInfo[cc].quantTable],
2065 &compInfo[cc].prevDC,
2066 data))
2067 return gFalse;
2068 if (hSub == 1 && vSub == 1) {
2069 for (y3 = 0, i = 0; y3 < 8; ++y3, i += 8) {
2070 p1 = &rowBuf[cc][y2+y3][x1+x2];
2071 p1[0] = data[i];
2072 p1[1] = data[i+1];
2073 p1[2] = data[i+2];
2074 p1[3] = data[i+3];
2075 p1[4] = data[i+4];
2076 p1[5] = data[i+5];
2077 p1[6] = data[i+6];
2078 p1[7] = data[i+7];
2079 }
2080 } else if (hSub == 2 && vSub == 2) {
2081 for (y3 = 0, i = 0; y3 < 16; y3 += 2, i += 8) {
2082 p1 = &rowBuf[cc][y2+y3][x1+x2];
2083 p2 = &rowBuf[cc][y2+y3+1][x1+x2];
2084 p1[0] = p1[1] = p2[0] = p2[1] = data[i];
2085 p1[2] = p1[3] = p2[2] = p2[3] = data[i+1];
2086 p1[4] = p1[5] = p2[4] = p2[5] = data[i+2];
2087 p1[6] = p1[7] = p2[6] = p2[7] = data[i+3];
2088 p1[8] = p1[9] = p2[8] = p2[9] = data[i+4];
2089 p1[10] = p1[11] = p2[10] = p2[11] = data[i+5];
2090 p1[12] = p1[13] = p2[12] = p2[13] = data[i+6];
2091 p1[14] = p1[15] = p2[14] = p2[15] = data[i+7];
2092 }
2093 } else {
2094 i = 0;
2095 for (y3 = 0, y4 = 0; y3 < 8; ++y3, y4 += vSub) {
2096 for (x3 = 0, x4 = 0; x3 < 8; ++x3, x4 += hSub) {
2097 for (y5 = 0; y5 < vSub; ++y5)
2098 for (x5 = 0; x5 < hSub; ++x5)
2099 rowBuf[cc][y2+y4+y5][x1+x2+x4+x5] = data[i];
2100 ++i;
2101 }
2102 }
2103 }
2104 }
2105 }
2106 }
2107 --restartCtr;
2108
2109 // color space conversion
2110 if (colorXform) {
2111 // convert YCbCr to RGB
2112 if (numComps == 3) {
2113 for (y2 = 0; y2 < mcuHeight; ++y2) {
2114 for (x2 = 0; x2 < mcuWidth; ++x2) {
2115 pY = rowBuf[0][y2][x1+x2];
2116 pCb = rowBuf[1][y2][x1+x2] - 128;
2117 pCr = rowBuf[2][y2][x1+x2] - 128;
2118 pR = ((pY << 16) + dctCrToR * pCr + 32768) >> 16;
2119 rowBuf[0][y2][x1+x2] = dctClip[dctClipOffset + pR];
2120 pG = ((pY << 16) + dctCbToG * pCb + dctCrToG * pCr + 32768) >> 16;
2121 rowBuf[1][y2][x1+x2] = dctClip[dctClipOffset + pG];
2122 pB = ((pY << 16) + dctCbToB * pCb + 32768) >> 16;
2123 rowBuf[2][y2][x1+x2] = dctClip[dctClipOffset + pB];
2124 }
2125 }
2126 // convert YCbCrK to CMYK (K is passed through unchanged)
2127 } else if (numComps == 4) {
2128 for (y2 = 0; y2 < mcuHeight; ++y2) {
2129 for (x2 = 0; x2 < mcuWidth; ++x2) {
2130 pY = rowBuf[0][y2][x1+x2];
2131 pCb = rowBuf[1][y2][x1+x2] - 128;
2132 pCr = rowBuf[2][y2][x1+x2] - 128;
2133 pR = ((pY << 16) + dctCrToR * pCr + 32768) >> 16;
2134 rowBuf[0][y2][x1+x2] = 255 - dctClip[dctClipOffset + pR];
2135 pG = ((pY << 16) + dctCbToG * pCb + dctCrToG * pCr + 32768) >> 16;
2136 rowBuf[1][y2][x1+x2] = 255 - dctClip[dctClipOffset + pG];
2137 pB = ((pY << 16) + dctCbToB * pCb + 32768) >> 16;
2138 rowBuf[2][y2][x1+x2] = 255 - dctClip[dctClipOffset + pB];
2139 }
2140 }
2141 }
2142 }
2143 }
2144 return gTrue;
2145 }
2146
2147 // This IDCT algorithm is taken from:
2148 // Christoph Loeffler, Adriaan Ligtenberg, George S. Moschytz,
2149 // "Practical Fast 1-D DCT Algorithms with 11 Multiplications",
2150 // IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989,
2151 // 988-991.
2152 // The stage numbers mentioned in the comments refer to Figure 1 in this
2153 // paper.
2154 #ifndef FP_IDCT
2155 GBool DCTStream::readDataUnit(DCTHuffTable *dcHuffTable,
2156 DCTHuffTable *acHuffTable,
2157 Guchar quantTable[64], int *prevDC,
2158 Guchar data[64]) {
2159 int tmp1[64];
2160 int v0, v1, v2, v3, v4, v5, v6, v7, t;
2161 int run, size, amp;
2162 int c;
2163 int i, j;
2164
2165 // Huffman decode and dequantize
2166 size = readHuffSym(dcHuffTable);
2167 if (size == 9999)
2168 return gFalse;
2169 if (size > 0) {
2170 amp = readAmp(size);
2171 if (amp == 9999)
2172 return gFalse;
2173 } else {
2174 amp = 0;
2175 }
2176 tmp1[0] = (*prevDC += amp) * quantTable[0];
2177 for (i = 1; i < 64; ++i)
2178 tmp1[i] = 0;
2179 i = 1;
2180 while (i < 64) {
2181 run = 0;
2182 while ((c = readHuffSym(acHuffTable)) == 0xf0 && run < 0x30)
2183 run += 0x10;
2184 if (c == 9999)
2185 return gFalse;
2186 if (c == 0x00) {
2187 break;
2188 } else {
2189 run += (c >> 4) & 0x0f;
2190 size = c & 0x0f;
2191 amp = readAmp(size);
2192 if (amp == 9999)
2193 return gFalse;
2194 i += run;
2195 j = dctZigZag[i++];
2196 tmp1[j] = amp * quantTable[j];
2197 }
2198 }
2199
2200 // inverse DCT on rows
2201 for (i = 0; i < 64; i += 8) {
2202
2203 // stage 4
2204 v0 = (dctSqrt2 * tmp1[i+0] + 128) >> 8;
2205 v1 = (dctSqrt2 * tmp1[i+4] + 128) >> 8;
2206 v2 = tmp1[i+2];
2207 v3 = tmp1[i+6];
2208 v4 = (dctSqrt1d2 * (tmp1[i+1] - tmp1[i+7]) + 128) >> 8;
2209 v7 = (dctSqrt1d2 * (tmp1[i+1] + tmp1[i+7]) + 128) >> 8;
2210 v5 = tmp1[i+3] << 4;
2211 v6 = tmp1[i+5] << 4;
2212
2213 // stage 3
2214 t = (v0 - v1+ 1) >> 1;
2215 v0 = (v0 + v1 + 1) >> 1;
2216 v1 = t;
2217 t = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8;
2218 v2 = (v2 * dctCos6 - v3 * dctSin6 + 128) >> 8;
2219 v3 = t;
2220 t = (v4 - v6 + 1) >> 1;
2221 v4 = (v4 + v6 + 1) >> 1;
2222 v6 = t;
2223 t = (v7 + v5 + 1) >> 1;
2224 v5 = (v7 - v5 + 1) >> 1;
2225 v7 = t;
2226
2227 // stage 2
2228 t = (v0 - v3 + 1) >> 1;
2229 v0 = (v0 + v3 + 1) >> 1;
2230 v3 = t;
2231 t = (v1 - v2 + 1) >> 1;
2232 v1 = (v1 + v2 + 1) >> 1;
2233 v2 = t;
2234 t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;
2235 v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;
2236 v7 = t;
2237 t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;
2238 v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;
2239 v6 = t;
2240
2241 // stage 1
2242 tmp1[i+0] = v0 + v7;
2243 tmp1[i+7] = v0 - v7;
2244 tmp1[i+1] = v1 + v6;
2245 tmp1[i+6] = v1 - v6;
2246 tmp1[i+2] = v2 + v5;
2247 tmp1[i+5] = v2 - v5;
2248 tmp1[i+3] = v3 + v4;
2249 tmp1[i+4] = v3 - v4;
2250 }
2251
2252 // inverse DCT on columns
2253 for (i = 0; i < 8; ++i) {
2254
2255 // stage 4
2256 v0 = (dctSqrt2 * tmp1[0*8+i] + 2048) >> 12;
2257 v1 = (dctSqrt2 * tmp1[4*8+i] + 2048) >> 12;
2258 v2 = tmp1[2*8+i];
2259 v3 = tmp1[6*8+i];
2260 v4 = (dctSqrt1d2 * (tmp1[1*8+i] - tmp1[7*8+i]) + 2048) >> 12;
2261 v7 = (dctSqrt1d2 * (tmp1[1*8+i] + tmp1[7*8+i]) + 2048) >> 12;
2262 v5 = tmp1[3*8+i];
2263 v6 = tmp1[5*8+i];
2264
2265 // stage 3
2266 t = (v0 - v1 + 1) >> 1;
2267 v0 = (v0 + v1 + 1) >> 1;
2268 v1 = t;
2269 t = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12;
2270 v2 = (v2 * dctCos6 - v3 * dctSin6 + 2048) >> 12;
2271 v3 = t;
2272 t = (v4 - v6 + 1) >> 1;
2273 v4 = (v4 + v6 + 1) >> 1;
2274 v6 = t;
2275 t = (v7 + v5 + 1) >> 1;
2276 v5 = (v7 - v5 + 1) >> 1;
2277 v7 = t;
2278
2279 // stage 2
2280 t = (v0 - v3 + 1) >> 1;
2281 v0 = (v0 + v3 + 1) >> 1;
2282 v3 = t;
2283 t = (v1 - v2 + 1) >> 1;
2284 v1 = (v1 + v2 + 1) >> 1;
2285 v2 = t;
2286 t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;
2287 v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;
2288 v7 = t;
2289 t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;
2290 v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;
2291 v6 = t;
2292
2293 // stage 1
2294 tmp1[0*8+i] = v0 + v7;
2295 tmp1[7*8+i] = v0 - v7;
2296 tmp1[1*8+i] = v1 + v6;
2297 tmp1[6*8+i] = v1 - v6;
2298 tmp1[2*8+i] = v2 + v5;
2299 tmp1[5*8+i] = v2 - v5;
2300 tmp1[3*8+i] = v3 + v4;
2301 tmp1[4*8+i] = v3 - v4;
2302 }
2303
2304 // convert to 8-bit integers
2305 for (i = 0; i < 64; ++i)
2306 data[i] = dctClip[dctClipOffset + 128 + ((tmp1[i] + 8) >> 4)];
2307
2308 return gTrue;
2309 }
2310 #endif
2311
2312 #ifdef FP_IDCT
2313 GBool DCTStream::readDataUnit(DCTHuffTable *dcHuffTable,
2314 DCTHuffTable *acHuffTable,
2315 Guchar quantTable[64], int *prevDC,
2316 Guchar data[64]) {
2317 double tmp1[64];
2318 double v0, v1, v2, v3, v4, v5, v6, v7, t;
2319 int run, size, amp;
2320 int c;
2321 int i, j;
2322
2323 // Huffman decode and dequantize
2324 size = readHuffSym(dcHuffTable);
2325 if (size == 9999)
2326 return gFalse;
2327 if (size > 0) {
2328 amp = readAmp(size);
2329 if (amp == 9999)
2330 return gFalse;
2331 } else {
2332 amp = 0;
2333 }
2334 tmp1[0] = (*prevDC += amp) * quantTable[0];
2335 for (i = 1; i < 64; ++i)
2336 tmp1[i] = 0;
2337 i = 1;
2338 while (i < 64) {
2339 run = 0;
2340 while ((c = readHuffSym(acHuffTable)) == 0xf0 && run < 0x30)
2341 run += 0x10;
2342 if (c == 9999)
2343 return gFalse;
2344 if (c == 0x00) {
2345 break;
2346 } else {
2347 run += (c >> 4) & 0x0f;
2348 size = c & 0x0f;
2349 amp = readAmp(size);
2350 if (amp == 9999)
2351 return gFalse;
2352 i += run;
2353 j = dctZigZag[i++];
2354 tmp1[j] = amp * quantTable[j];
2355 }
2356 }
2357
2358 // inverse DCT on rows
2359 for (i = 0; i < 64; i += 8) {
2360
2361 // stage 4
2362 v0 = dctSqrt2 * tmp1[i+0];
2363 v1 = dctSqrt2 * tmp1[i+4];
2364 v2 = tmp1[i+2];
2365 v3 = tmp1[i+6];
2366 v4 = dctSqrt1d2 * (tmp1[i+1] - tmp1[i+7]);
2367 v7 = dctSqrt1d2 * (tmp1[i+1] + tmp1[i+7]);
2368 v5 = tmp1[i+3];
2369 v6 = tmp1[i+5];
2370
2371 // stage 3
2372 t = 0.5 * (v0 - v1);
2373 v0 = 0.5 * (v0 + v1);
2374 v1 = t;
2375 t = v2 * dctSin6 + v3 * dctCos6;
2376 v2 = v2 * dctCos6 - v3 * dctSin6;
2377 v3 = t;
2378 t = 0.5 * (v4 - v6);
2379 v4 = 0.5 * (v4 + v6);
2380 v6 = t;
2381 t = 0.5 * (v7 + v5);
2382 v5 = 0.5 * (v7 - v5);
2383 v7 = t;
2384
2385 // stage 2
2386 t = 0.5 * (v0 - v3);
2387 v0 = 0.5 * (v0 + v3);
2388 v3 = t;
2389 t = 0.5 * (v1 - v2);
2390 v1 = 0.5 * (v1 + v2);
2391 v2 = t;
2392 t = v4 * dctSin3 + v7 * dctCos3;
2393 v4 = v4 * dctCos3 - v7 * dctSin3;
2394 v7 = t;
2395 t = v5 * dctSin1 + v6 * dctCos1;
2396 v5 = v5 * dctCos1 - v6 * dctSin1;
2397 v6 = t;
2398
2399 // stage 1
2400 tmp1[i+0] = v0 + v7;
2401 tmp1[i+7] = v0 - v7;
2402 tmp1[i+1] = v1 + v6;
2403 tmp1[i+6] = v1 - v6;
2404 tmp1[i+2] = v2 + v5;
2405 tmp1[i+5] = v2 - v5;
2406 tmp1[i+3] = v3 + v4;
2407 tmp1[i+4] = v3 - v4;
2408 }
2409
2410 // inverse DCT on columns
2411 for (i = 0; i < 8; ++i) {
2412
2413 // stage 4
2414 v0 = dctSqrt2 * tmp1[0*8+i];
2415 v1 = dctSqrt2 * tmp1[4*8+i];
2416 v2 = tmp1[2*8+i];
2417 v3 = tmp1[6*8+i];
2418 v4 = dctSqrt1d2 * (tmp1[1*8+i] - tmp1[7*8+i]);
2419 v7 = dctSqrt1d2 * (tmp1[1*8+i] + tmp1[7*8+i]);
2420 v5 = tmp1[3*8+i];
2421 v6 = tmp1[5*8+i];
2422
2423 // stage 3
2424 t = 0.5 * (v0 - v1);
2425 v0 = 0.5 * (v0 + v1);
2426 v1 = t;
2427 t = v2 * dctSin6 + v3 * dctCos6;
2428 v2 = v2 * dctCos6 - v3 * dctSin6;
2429 v3 = t;
2430 t = 0.5 * (v4 - v6);
2431 v4 = 0.5 * (v4 + v6);
2432 v6 = t;
2433 t = 0.5 * (v7 + v5);
2434 v5 = 0.5 * (v7 - v5);
2435 v7 = t;
2436
2437 // stage 2
2438 t = 0.5 * (v0 - v3);
2439 v0 = 0.5 * (v0 + v3);
2440 v3 = t;
2441 t = 0.5 * (v1 - v2);
2442 v1 = 0.5 * (v1 + v2);
2443 v2 = t;
2444 t = v4 * dctSin3 + v7 * dctCos3;
2445 v4 = v4 * dctCos3 - v7 * dctSin3;
2446 v7 = t;
2447 t = v5 * dctSin1 + v6 * dctCos1;
2448 v5 = v5 * dctCos1 - v6 * dctSin1;
2449 v6 = t;
2450
2451 // stage 1
2452 tmp1[0*8+i] = v0 + v7;
2453 tmp1[7*8+i] = v0 - v7;
2454 tmp1[1*8+i] = v1 + v6;
2455 tmp1[6*8+i] = v1 - v6;
2456 tmp1[2*8+i] = v2 + v5;
2457 tmp1[5*8+i] = v2 - v5;
2458 tmp1[3*8+i] = v3 + v4;
2459 tmp1[4*8+i] = v3 - v4;
2460 }
2461
2462 // convert to 8-bit integers
2463 for (i = 0; i < 64; ++i)
2464 data[i] = dctClip[dctClipOffset + (int)(tmp1[i] + 128.5)];
2465
2466 return gTrue;
2467 }
2468 #endif
2469
2470 int DCTStream::readHuffSym(DCTHuffTable *table) {
2471 Gushort code;
2472 int bit;
2473 int codeBits;
2474
2475 code = 0;
2476 codeBits = 0;
2477 do {
2478 // add a bit to the code
2479 if ((bit = readBit()) == EOF)
2480 return 9999;
2481 code = (code << 1) + bit;
2482 ++codeBits;
2483
2484 // look up code
2485 if (code - table->firstCode[codeBits] < table->numCodes[codeBits]) {
2486 code -= table->firstCode[codeBits];
2487 return table->sym[table->firstSym[codeBits] + code];
2488 }
2489 } while (codeBits < 16);
2490
2491 error(getPos(), "Bad Huffman code in DCT stream");
2492 return 9999;
2493 }
2494
2495 int DCTStream::readAmp(int size) {
2496 int amp, bit;
2497 int bits;
2498
2499 amp = 0;
2500 for (bits = 0; bits < size; ++bits) {
2501 if ((bit = readBit()) == EOF)
2502 return 9999;
2503 amp = (amp << 1) + bit;
2504 }
2505 if (amp < (1 << (size - 1)))
2506 amp -= (1 << size) - 1;
2507 return amp;
2508 }
2509
2510 int DCTStream::readBit() {
2511 int bit;
2512 int c, c2;
2513
2514 if (inputBits == 0) {
2515 if ((c = str->getChar()) == EOF)
2516 return EOF;
2517 if (c == 0xff) {
2518 do {
2519 c2 = str->getChar();
2520 } while (c2 == 0xff);
2521 if (c2 != 0x00) {
2522 error(getPos(), "Bad DCT data: missing 00 after ff");
2523 return EOF;
2524 }
2525 }
2526 inputBuf = c;
2527 inputBits = 8;
2528 }
2529 bit = (inputBuf >> (inputBits - 1)) & 1;
2530 --inputBits;
2531 return bit;
2532 }
2533
2534 GBool DCTStream::readHeader() {
2535 GBool doScan;
2536 int minHSample, minVSample;
2537 int bufWidth;
2538 int n;
2539 int c = 0;
2540 int i, j;
2541
2542 width = height = 0;
2543 numComps = 0;
2544 numQuantTables = 0;
2545 numDCHuffTables = 0;
2546 numACHuffTables = 0;
2547 colorXform = 0;
2548 gotAdobeMarker = gFalse;
2549 restartInterval = 0;
2550
2551 // read headers
2552 doScan = gFalse;
2553 while (!doScan) {
2554 c = readMarker();
2555 switch (c) {
2556 case 0xc0: // SOF0
2557 if (!readFrameInfo())
2558 return gFalse;
2559 break;
2560 case 0xc4: // DHT
2561 if (!readHuffmanTables())
2562 return gFalse;
2563 break;
2564 case 0xd8: // SOI
2565 break;
2566 case 0xda: // SOS
2567 if (!readScanInfo())
2568 return gFalse;
2569 doScan = gTrue;
2570 break;
2571 case 0xdb: // DQT
2572 if (!readQuantTables())
2573 return gFalse;
2574 break;
2575 case 0xdd: // DRI
2576 if (!readRestartInterval())
2577 return gFalse;
2578 break;
2579 case 0xee: // APP14
2580 if (!readAdobeMarker())
2581 return gFalse;
2582 break;
2583 case EOF:
2584 error(getPos(), "Bad DCT header");
2585 return gFalse;
2586 default:
2587 // skip APPn / COM / etc.
2588 if (c >= 0xe0) {
2589 n = read16() - 2;
2590 for (i = 0; i < n; ++i)
2591 str->getChar();
2592 } else {
2593 error(getPos(), "Unknown DCT marker <%02x>", c);
2594 return gFalse;
2595 }
2596 break;
2597 }
2598 }
2599
2600 // compute MCU size
2601 mcuWidth = minHSample = compInfo[0].hSample;
2602 mcuHeight = minVSample = compInfo[0].vSample;
2603 for (i = 1; i < numComps; ++i) {
2604 if (compInfo[i].hSample < minHSample)
2605 minHSample = compInfo[i].hSample;
2606 if (compInfo[i].vSample < minVSample)
2607 minVSample = compInfo[i].vSample;
2608 if (compInfo[i].hSample > mcuWidth)
2609 mcuWidth = compInfo[i].hSample;
2610 if (compInfo[i].vSample > mcuHeight)
2611 mcuHeight = compInfo[i].vSample;
2612 }
2613 for (i = 0; i < numComps; ++i) {
2614 compInfo[i].hSample /= minHSample;
2615 compInfo[i].vSample /= minVSample;
2616 }
2617 mcuWidth = (mcuWidth / minHSample) * 8;
2618 mcuHeight = (mcuHeight / minVSample) * 8;
2619
2620 // allocate buffers
2621 bufWidth = ((width + mcuWidth - 1) / mcuWidth) * mcuWidth;
2622 for (i = 0; i < numComps; ++i)
2623 for (j = 0; j < mcuHeight; ++j)
2624 rowBuf[i][j] = (Guchar *)gmalloc(bufWidth * sizeof(Guchar));
2625
2626 // figure out color transform
2627 if (!gotAdobeMarker && numComps == 3) {
2628 if (compInfo[0].id == 1 && compInfo[1].id == 2 && compInfo[2].id == 3) {
2629 colorXform = 1;
2630 }
2631 }
2632
2633 // initialize counters
2634 comp = 0;
2635 x = 0;
2636 y = 0;
2637 dy = mcuHeight;
2638
2639 return gTrue;
2640 }
2641
2642 GBool DCTStream::readFrameInfo() {
2643 int length;
2644 int prec;
2645 int i;
2646 int c;
2647
2648 length = read16() - 2;
2649 prec = str->getChar();
2650 height = read16();
2651 width = read16();
2652 numComps = str->getChar();
2653 length -= 6;
2654 if (prec != 8) {
2655 error(getPos(), "Bad DCT precision %d", prec);
2656 return gFalse;
2657 }
2658 for (i = 0; i < numComps; ++i) {
2659 compInfo[i].id = str->getChar();
2660 compInfo[i].inScan = gFalse;
2661 c = str->getChar();
2662 compInfo[i].hSample = (c >> 4) & 0x0f;
2663 compInfo[i].vSample = c & 0x0f;
2664 compInfo[i].quantTable = str->getChar();
2665 compInfo[i].dcHuffTable = 0;
2666 compInfo[i].acHuffTable = 0;
2667 }
2668 return gTrue;
2669 }
2670
2671 GBool DCTStream::readScanInfo() {
2672 int length;
2673 int scanComps, id, c;
2674 int i, j;
2675
2676 length = read16() - 2;
2677 scanComps = str->getChar();
2678 --length;
2679 if (length != 2 * scanComps + 3) {
2680 error(getPos(), "Bad DCT scan info block");
2681 return gFalse;
2682 }
2683 for (i = 0; i < scanComps; ++i) {
2684 id = str->getChar();
2685 for (j = 0; j < numComps; ++j) {
2686 if (id == compInfo[j].id)
2687 break;
2688 }
2689 if (j == numComps) {
2690 error(getPos(), "Bad DCT component ID in scan info block");
2691 return gFalse;
2692 }
2693 compInfo[j].inScan = gTrue;
2694 c = str->getChar();
2695 compInfo[j].dcHuffTable = (c >> 4) & 0x0f;
2696 compInfo[j].acHuffTable = c & 0x0f;
2697 }
2698 str->getChar();
2699 str->getChar();
2700 str->getChar();
2701 return gTrue;
2702 }
2703
2704 GBool DCTStream::readQuantTables() {
2705 int length;
2706 int i;
2707 int index;
2708
2709 length = read16() - 2;
2710 while (length > 0) {
2711 index = str->getChar();
2712 if ((index & 0xf0) || index >= 4) {
2713 error(getPos(), "Bad DCT quantization table");
2714 return gFalse;
2715 }
2716 if (index == numQuantTables)
2717 numQuantTables = index + 1;
2718 for (i = 0; i < 64; ++i)
2719 quantTables[index][dctZigZag[i]] = str->getChar();
2720 length -= 65;
2721 }
2722 return gTrue;
2723 }
2724
2725 GBool DCTStream::readHuffmanTables() {
2726 DCTHuffTable *tbl;
2727 int length;
2728 int index;
2729 Gushort code;
2730 Guchar sym;
2731 int i;
2732 int c;
2733
2734 length = read16() - 2;
2735 while (length > 0) {
2736 index = str->getChar();
2737 --length;
2738 if ((index & 0x0f) >= 4) {
2739 error(getPos(), "Bad DCT Huffman table");
2740 return gFalse;
2741 }
2742 if (index & 0x10) {
2743 index &= 0x0f;
2744 if (index >= numACHuffTables)
2745 numACHuffTables = index+1;
2746 tbl = &acHuffTables[index];
2747 } else {
2748 if (index >= numDCHuffTables)
2749 numDCHuffTables = index+1;
2750 tbl = &dcHuffTables[index];
2751 }
2752 sym = 0;
2753 code = 0;
2754 for (i = 1; i <= 16; ++i) {
2755 c = str->getChar();
2756 tbl->firstSym[i] = sym;
2757 tbl->firstCode[i] = code;
2758 tbl->numCodes[i] = c;
2759 sym += c;
2760 code = (code + c) << 1;
2761 }
2762 length -= 16;
2763 for (i = 0; i < sym; ++i)
2764 tbl->sym[i] = str->getChar();
2765 length -= sym;
2766 }
2767 return gTrue;
2768 }
2769
2770 GBool DCTStream::readRestartInterval() {
2771 int length;
2772
2773 length = read16();
2774 if (length != 4) {
2775 error(getPos(), "Bad DCT restart interval");
2776 return gFalse;
2777 }
2778 restartInterval = read16();
2779 return gTrue;
2780 }
2781
2782 GBool DCTStream::readAdobeMarker() {
2783 int length, i;
2784 char buf[12];
2785 int c;
2786
2787 length = read16();
2788 if (length != 14)
2789 goto err;
2790 for (i = 0; i < 12; ++i) {
2791 if ((c = str->getChar()) == EOF)
2792 goto err;
2793 buf[i] = c;
2794 }
2795 if (strncmp(buf, "Adobe", 5))
2796 goto err;
2797 colorXform = buf[11];
2798 gotAdobeMarker = gTrue;
2799 return gTrue;
2800
2801 err:
2802 error(getPos(), "Bad DCT Adobe APP14 marker");
2803 return gFalse;
2804 }
2805
2806 GBool DCTStream::readTrailer() {
2807 int c;
2808
2809 c = readMarker();
2810 if (c != 0xd9) { // EOI
2811 error(getPos(), "Bad DCT trailer");
2812 return gFalse;
2813 }
2814 return gTrue;
2815 }
2816
2817 int DCTStream::readMarker() {
2818 int c;
2819
2820 do {
2821 do {
2822 c = str->getChar();
2823 } while (c != 0xff);
2824 do {
2825 c = str->getChar();
2826 } while (c == 0xff);
2827 } while (c == 0x00);
2828 return c;
2829 }
2830
2831 int DCTStream::read16() {
2832 int c1, c2;
2833
2834 if ((c1 = str->getChar()) == EOF)
2835 return EOF;
2836 if ((c2 = str->getChar()) == EOF)
2837 return EOF;
2838 return (c1 << 8) + c2;
2839 }
2840
2841 GString *DCTStream::getPSFilter(char *indent) {
2842 GString *s;
2843
2844 if (!(s = str->getPSFilter(indent))) {
2845 return NULL;
2846 }
2847 s->append(indent)->append("<< >> /DCTDecode filter\n");
2848 return s;
2849 }
2850
2851 GBool DCTStream::isBinary(GBool last) {
2852 return str->isBinary(gTrue);
2853 }
2854
2855 //------------------------------------------------------------------------
2856 // FlateStream
2857 //------------------------------------------------------------------------
2858
2859 int FlateStream::codeLenCodeMap[flateMaxCodeLenCodes] = {
2860 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
2861 };
2862
2863 FlateDecode FlateStream::lengthDecode[flateMaxLitCodes-257] = {
2864 {0, 3},
2865 {0, 4},
2866 {0, 5},
2867 {0, 6},
2868 {0, 7},
2869 {0, 8},
2870 {0, 9},
2871 {0, 10},
2872 {1, 11},
2873 {1, 13},
2874 {1, 15},
2875 {1, 17},
2876 {2, 19},
2877 {2, 23},
2878 {2, 27},
2879 {2, 31},
2880 {3, 35},
2881 {3, 43},
2882 {3, 51},
2883 {3, 59},
2884 {4, 67},
2885 {4, 83},
2886 {4, 99},
2887 {4, 115},
2888 {5, 131},
2889 {5, 163},
2890 {5, 195},
2891 {5, 227},
2892 {0, 258}
2893 };
2894
2895 FlateDecode FlateStream::distDecode[flateMaxDistCodes] = {
2896 { 0, 1},
2897 { 0, 2},
2898 { 0, 3},
2899 { 0, 4},
2900 { 1, 5},
2901 { 1, 7},
2902 { 2, 9},
2903 { 2, 13},
2904 { 3, 17},
2905 { 3, 25},
2906 { 4, 33},
2907 { 4, 49},
2908 { 5, 65},
2909 { 5, 97},
2910 { 6, 129},
2911 { 6, 193},
2912 { 7, 257},
2913 { 7, 385},
2914 { 8, 513},
2915 { 8, 769},
2916 { 9, 1025},
2917 { 9, 1537},
2918 {10, 2049},
2919 {10, 3073},
2920 {11, 4097},
2921 {11, 6145},
2922 {12, 8193},
2923 {12, 12289},
2924 {13, 16385},
2925 {13, 24577}
2926 };
2927
2928 FlateStream::FlateStream(Stream *strA, int predictor, int columns,
2929 int colors, int bits):
2930 FilterStream(strA) {
2931 if (predictor != 1) {
2932 pred = new StreamPredictor(this, predictor, columns, colors, bits);
2933 } else {
2934 pred = NULL;
2935 }
2936 }
2937
2938 FlateStream::~FlateStream() {
2939 if (pred) {
2940 delete pred;
2941 }
2942 delete str;
2943 }
2944
2945 void FlateStream::reset() {
2946 int cmf, flg;
2947
2948 index = 0;
2949 remain = 0;
2950 codeBuf = 0;
2951 codeSize = 0;
2952 compressedBlock = gFalse;
2953 endOfBlock = gTrue;
2954 eof = gTrue;
2955
2956 str->reset();
2957
2958 // read header
2959 //~ need to look at window size?
2960 endOfBlock = eof = gTrue;
2961 cmf = str->getChar();
2962 flg = str->getChar();
2963 if (cmf == EOF || flg == EOF)
2964 return;
2965 if ((cmf & 0x0f) != 0x08) {
2966 error(getPos(), "Unknown compression method in flate stream");
2967 return;
2968 }
2969 if ((((cmf << 8) + flg) % 31) != 0) {
2970 error(getPos(), "Bad FCHECK in flate stream");
2971 return;
2972 }
2973 if (flg & 0x20) {
2974 error(getPos(), "FDICT bit set in flate stream");
2975 return;
2976 }
2977
2978 eof = gFalse;
2979 }
2980
2981 int FlateStream::getChar() {
2982 int c;
2983
2984 if (pred) {
2985 return pred->getChar();
2986 }
2987 while (remain == 0) {
2988 if (endOfBlock && eof)
2989 return EOF;
2990 readSome();
2991 }
2992 c = buf[index];
2993 index = (index + 1) & flateMask;
2994 --remain;
2995 return c;
2996 }
2997
2998 int FlateStream::lookChar() {
2999 int c;
3000
3001 if (pred) {
3002 return pred->lookChar();
3003 }
3004 while (remain == 0) {
3005 if (endOfBlock && eof)
3006 return EOF;
3007 readSome();
3008 }
3009 c = buf[index];
3010 return c;
3011 }
3012
3013 int FlateStream::getRawChar() {
3014 int c;
3015
3016 while (remain == 0) {
3017 if (endOfBlock && eof)
3018 return EOF;
3019 readSome();
3020 }
3021 c = buf[index];
3022 index = (index + 1) & flateMask;
3023 --remain;
3024 return c;
3025 }
3026
3027 GString *FlateStream::getPSFilter(char *indent) {
3028 return NULL;
3029 }
3030
3031 GBool FlateStream::isBinary(GBool last) {
3032 return str->isBinary(gTrue);
3033 }
3034
3035 void FlateStream::readSome() {
3036 int code1, code2;
3037 int len, dist;
3038 int i, j, k;
3039 int c;
3040
3041 if (endOfBlock) {
3042 if (!startBlock())
3043 return;
3044 }
3045
3046 if (compressedBlock) {
3047 if ((code1 = getHuffmanCodeWord(&litCodeTab)) == EOF)
3048 goto err;
3049 if (code1 < 256) {
3050 buf[index] = code1;
3051 remain = 1;
3052 } else if (code1 == 256) {
3053 endOfBlock = gTrue;
3054 remain = 0;
3055 } else {
3056 code1 -= 257;
3057 code2 = lengthDecode[code1].bits;
3058 if (code2 > 0 && (code2 = getCodeWord(code2)) == EOF)
3059 goto err;
3060 len = lengthDecode[code1].first + code2;
3061 if ((code1 = getHuffmanCodeWord(&distCodeTab)) == EOF)
3062 goto err;
3063 code2 = distDecode[code1].bits;
3064 if (code2 > 0 && (code2 = getCodeWord(code2)) == EOF)
3065 goto err;
3066 dist = distDecode[code1].first + code2;
3067 i = index;
3068 j = (index - dist) & flateMask;
3069 for (k = 0; k < len; ++k) {
3070 buf[i] = buf[j];
3071 i = (i + 1) & flateMask;
3072 j = (j + 1) & flateMask;
3073 }
3074 remain = len;
3075 }
3076
3077 } else {
3078 len = (blockLen < flateWindow) ? blockLen : flateWindow;
3079 for (i = 0, j = index; i < len; ++i, j = (j + 1) & flateMask) {
3080 if ((c = str->getChar()) == EOF) {
3081 endOfBlock = eof = gTrue;
3082 break;
3083 }
3084 buf[j] = c & 0xff;
3085 }
3086 remain = i;
3087 blockLen -= len;
3088 if (blockLen == 0)
3089 endOfBlock = gTrue;
3090 }
3091
3092 return;
3093
3094 err:
3095 error(getPos(), "Unexpected end of file in flate stream");
3096 endOfBlock = eof = gTrue;
3097 remain = 0;
3098 }
3099
3100 GBool FlateStream::startBlock() {
3101 int blockHdr;
3102 int c;
3103 int check;
3104
3105 // read block header
3106 blockHdr = getCodeWord(3);
3107 if (blockHdr & 1)
3108 eof = gTrue;
3109 blockHdr >>= 1;
3110
3111 // uncompressed block
3112 if (blockHdr == 0) {
3113 compressedBlock = gFalse;
3114 if ((c = str->getChar()) == EOF)
3115 goto err;
3116 blockLen = c & 0xff;
3117 if ((c = str->getChar()) == EOF)
3118 goto err;
3119 blockLen |= (c & 0xff) << 8;
3120 if ((c = str->getChar()) == EOF)
3121 goto err;
3122 check = c & 0xff;
3123 if ((c = str->getChar()) == EOF)
3124 goto err;
3125 check |= (c & 0xff) << 8;
3126 if (check != (~blockLen & 0xffff))
3127 error(getPos(), "Bad uncompressed block length in flate stream");
3128 codeBuf = 0;
3129 codeSize = 0;
3130
3131 // compressed block with fixed codes
3132 } else if (blockHdr == 1) {
3133 compressedBlock = gTrue;
3134 loadFixedCodes();
3135
3136 // compressed block with dynamic codes
3137 } else if (blockHdr == 2) {
3138 compressedBlock = gTrue;
3139 if (!readDynamicCodes())
3140 goto err;
3141
3142 // unknown block type
3143 } else {
3144 goto err;
3145 }
3146
3147 endOfBlock = gFalse;
3148 return gTrue;
3149
3150 err:
3151 error(getPos(), "Bad block header in flate stream");
3152 endOfBlock = eof = gTrue;
3153 return gFalse;
3154 }
3155
3156 void FlateStream::loadFixedCodes() {
3157 int i;
3158
3159 // set up code arrays
3160 litCodeTab.codes = allCodes;
3161 distCodeTab.codes = allCodes + flateMaxLitCodes;
3162
3163 // initialize literal code table
3164 for (i = 0; i <= 143; ++i)
3165 litCodeTab.codes[i].len = 8;
3166 for (i = 144; i <= 255; ++i)
3167 litCodeTab.codes[i].len = 9;
3168 for (i = 256; i <= 279; ++i)
3169 litCodeTab.codes[i].len = 7;
3170 for (i = 280; i <= 287; ++i)
3171 litCodeTab.codes[i].len = 8;
3172 compHuffmanCodes(&litCodeTab, flateMaxLitCodes);
3173
3174 // initialize distance code table
3175 for (i = 0; i <= 5; ++i) {
3176 distCodeTab.start[i] = 0;
3177 }
3178 for (i = 6; i <= flateMaxHuffman+1; ++i) {
3179 distCodeTab.start[i] = flateMaxDistCodes;
3180 }
3181 for (i = 0; i < flateMaxDistCodes; ++i) {
3182 distCodeTab.codes[i].len = 5;
3183 distCodeTab.codes[i].code = i;
3184 distCodeTab.codes[i].val = i;
3185 }
3186 }
3187
3188 GBool FlateStream::readDynamicCodes() {
3189 int numCodeLenCodes;
3190 int numLitCodes;
3191 int numDistCodes;
3192 FlateCode codeLenCodes[flateMaxCodeLenCodes];
3193 FlateHuffmanTab codeLenCodeTab;
3194 int len, repeat, code;
3195 int i;
3196
3197 // read lengths
3198 if ((numLitCodes = getCodeWord(5)) == EOF)
3199 goto err;
3200 numLitCodes += 257;
3201 if ((numDistCodes = getCodeWord(5)) == EOF)
3202 goto err;
3203 numDistCodes += 1;
3204 if ((numCodeLenCodes = getCodeWord(4)) == EOF)
3205 goto err;
3206 numCodeLenCodes += 4;
3207 if (numLitCodes > flateMaxLitCodes ||
3208 numDistCodes > flateMaxDistCodes ||
3209 numCodeLenCodes > flateMaxCodeLenCodes)
3210 goto err;
3211
3212 // read code length code table
3213 codeLenCodeTab.codes = codeLenCodes;
3214 for (i = 0; i < flateMaxCodeLenCodes; ++i)
3215 codeLenCodes[i].len = 0;
3216 for (i = 0; i < numCodeLenCodes; ++i) {
3217 if ((codeLenCodes[codeLenCodeMap[i]].len = getCodeWord(3)) == -1)
3218 goto err;
3219 }
3220 compHuffmanCodes(&codeLenCodeTab, flateMaxCodeLenCodes);
3221
3222 // set up code arrays
3223 litCodeTab.codes = allCodes;
3224 distCodeTab.codes = allCodes + numLitCodes;
3225
3226 // read literal and distance code tables
3227 len = 0;
3228 repeat = 0;
3229 i = 0;
3230 while (i < numLitCodes + numDistCodes) {
3231 if ((code = getHuffmanCodeWord(&codeLenCodeTab)) == EOF)
3232 goto err;
3233 if (code == 16) {
3234 if ((repeat = getCodeWord(2)) == EOF)
3235 goto err;
3236 for (repeat += 3; repeat > 0; --repeat)
3237 allCodes[i++].len = len;
3238 } else if (code == 17) {
3239 if ((repeat = getCodeWord(3)) == EOF)
3240 goto err;
3241 len = 0;
3242 for (repeat += 3; repeat > 0; --repeat)
3243 allCodes[i++].len = 0;
3244 } else if (code == 18) {
3245 if ((repeat = getCodeWord(7)) == EOF)
3246 goto err;
3247 len = 0;
3248 for (repeat += 11; repeat > 0; --repeat)
3249 allCodes[i++].len = 0;
3250 } else {
3251 allCodes[i++].len = len = code;
3252 }
3253 }
3254 compHuffmanCodes(&litCodeTab, numLitCodes);
3255 compHuffmanCodes(&distCodeTab, numDistCodes);
3256
3257 return gTrue;
3258
3259 err:
3260 error(getPos(), "Bad dynamic code table in flate stream");
3261 return gFalse;
3262 }
3263
3264 // On entry, the <tab->codes> array contains the lengths of each code,
3265 // stored in code value order. This function computes the code words.
3266 // The result is sorted in order of (1) code length and (2) code word.
3267 // The length values are no longer valid. The <tab->start> array is
3268 // filled with the indexes of the first code of each length.
3269 void FlateStream::compHuffmanCodes(FlateHuffmanTab *tab, int n) {
3270 int numLengths[flateMaxHuffman+1];
3271 int nextCode[flateMaxHuffman+1];
3272 int nextIndex[flateMaxHuffman+2];
3273 int code;
3274 int i, j;
3275
3276 // count number of codes for each code length
3277 for (i = 0; i <= flateMaxHuffman; ++i)
3278 numLengths[i] = 0;
3279 for (i = 0; i < n; ++i)
3280 ++numLengths[tab->codes[i].len];
3281
3282 // compute first index for each length
3283 tab->start[0] = nextIndex[0] = 0;
3284 for (i = 1; i <= flateMaxHuffman + 1; ++i)
3285 tab->start[i] = nextIndex[i] = tab->start[i-1] + numLengths[i-1];
3286
3287 // compute first code for each length
3288 code = 0;
3289 numLengths[0] = 0;
3290 for (i = 1; i <= flateMaxHuffman; ++i) {
3291 code = (code + numLengths[i-1]) << 1;
3292 nextCode[i] = code;
3293 }
3294
3295 // compute the codes -- this permutes the codes array from value
3296 // order to length/code order
3297 for (i = 0; i < n; ++i) {
3298 j = nextIndex[tab->codes[i].len]++;
3299 if (tab->codes[i].len == 0)
3300 tab->codes[j].code = 0;
3301 else
3302 tab->codes[j].code = nextCode[tab->codes[i].len]++;
3303 tab->codes[j].val = i;
3304 }
3305 }
3306
3307 int FlateStream::getHuffmanCodeWord(FlateHuffmanTab *tab) {
3308 int len;
3309 int code;
3310 int c;
3311 int i, j;
3312
3313 code = 0;
3314 for (len = 1; len <= flateMaxHuffman; ++len) {
3315
3316 // add a bit to the code
3317 if (codeSize == 0) {
3318 if ((c = str->getChar()) == EOF)
3319 return EOF;
3320 codeBuf = c & 0xff;
3321 codeSize = 8;
3322 }
3323 code = (code << 1) | (codeBuf & 1);
3324 codeBuf >>= 1;
3325 --codeSize;
3326
3327 // look for code
3328 i = tab->start[len];
3329 j = tab->start[len + 1];
3330 if (i < j && code >= tab->codes[i].code && code <= tab->codes[j-1].code) {
3331 i += code - tab->codes[i].code;
3332 return tab->codes[i].val;
3333 }
3334 }
3335
3336 // not found
3337 error(getPos(), "Bad code (%04x) in flate stream", code);
3338 return EOF;
3339 }
3340
3341 int FlateStream::getCodeWord(int bits) {
3342 int c;
3343
3344 while (codeSize < bits) {
3345 if ((c = str->getChar()) == EOF)
3346 return EOF;
3347 codeBuf |= (c & 0xff) << codeSize;
3348 codeSize += 8;
3349 }
3350 c = codeBuf & ((1 << bits) - 1);
3351 codeBuf >>= bits;
3352 codeSize -= bits;
3353 return c;
3354 }
3355
3356 //------------------------------------------------------------------------
3357 // EOFStream
3358 //------------------------------------------------------------------------
3359
3360 EOFStream::EOFStream(Stream *strA):
3361 FilterStream(strA) {
3362 }
3363
3364 EOFStream::~EOFStream() {
3365 delete str;
3366 }
3367
3368 //------------------------------------------------------------------------
3369 // FixedLengthEncoder
3370 //------------------------------------------------------------------------
3371
3372 FixedLengthEncoder::FixedLengthEncoder(Stream *strA, int lengthA):
3373 FilterStream(strA) {
3374 length = lengthA;
3375 count = 0;
3376 }
3377
3378 FixedLengthEncoder::~FixedLengthEncoder() {
3379 if (str->isEncoder())
3380 delete str;
3381 }
3382
3383 void FixedLengthEncoder::reset() {
3384 str->reset();
3385 count = 0;
3386 }
3387
3388 void FixedLengthEncoder::close() {
3389 }
3390
3391 int FixedLengthEncoder::getChar() {
3392 if (length >= 0 && count >= length)
3393 return EOF;
3394 ++count;
3395 return str->getChar();
3396 }
3397
3398 int FixedLengthEncoder::lookChar() {
3399 if (length >= 0 && count >= length)
3400 return EOF;
3401 return str->getChar();
3402 }
3403
3404 //------------------------------------------------------------------------
3405 // ASCIIHexEncoder
3406 //------------------------------------------------------------------------
3407
3408 ASCIIHexEncoder::ASCIIHexEncoder(Stream *strA):
3409 FilterStream(strA) {
3410 bufPtr = bufEnd = buf;
3411 lineLen = 0;
3412 eof = gFalse;
3413 }
3414
3415 ASCIIHexEncoder::~ASCIIHexEncoder() {
3416 if (str->isEncoder()) {
3417 delete str;
3418 }
3419 }
3420
3421 void ASCIIHexEncoder::reset() {
3422 str->reset();
3423 bufPtr = bufEnd = buf;
3424 lineLen = 0;
3425 eof = gFalse;
3426 }
3427
3428 void ASCIIHexEncoder::close() {
3429 }
3430
3431 GBool ASCIIHexEncoder::fillBuf() {
3432 static char *hex = "0123456789abcdef";
3433 int c;
3434
3435 if (eof) {
3436 return gFalse;
3437 }
3438 bufPtr = bufEnd = buf;
3439 if ((c = str->getChar()) == EOF) {
3440 *bufEnd++ = '>';
3441 eof = gTrue;
3442 } else {
3443 if (lineLen >= 64) {
3444 *bufEnd++ = '\n';
3445 lineLen = 0;
3446 }
3447 *bufEnd++ = hex[(c >> 4) & 0x0f];
3448 *bufEnd++ = hex[c & 0x0f];
3449 lineLen += 2;
3450 }
3451 return gTrue;
3452 }
3453
3454 //------------------------------------------------------------------------
3455 // ASCII85Encoder
3456 //------------------------------------------------------------------------
3457
3458 ASCII85Encoder::ASCII85Encoder(Stream *strA):
3459 FilterStream(strA) {
3460 bufPtr = bufEnd = buf;
3461 lineLen = 0;
3462 eof = gFalse;
3463 }
3464
3465 ASCII85Encoder::~ASCII85Encoder() {
3466 if (str->isEncoder())
3467 delete str;
3468 }
3469
3470 void ASCII85Encoder::reset() {
3471 str->reset();
3472 bufPtr = bufEnd = buf;
3473 lineLen = 0;
3474 eof = gFalse;
3475 }
3476
3477 void ASCII85Encoder::close() {
3478 }
3479
3480 GBool ASCII85Encoder::fillBuf() {
3481 Gulong t;
3482 char buf1[5];
3483 int c;
3484 int n, i;
3485
3486 if (eof)
3487 return gFalse;
3488 t = 0;
3489 for (n = 0; n < 4; ++n) {
3490 if ((c = str->getChar()) == EOF)
3491 break;
3492 t = (t << 8) + c;
3493 }
3494 bufPtr = bufEnd = buf;
3495 if (n > 0) {
3496 if (n == 4 && t == 0) {
3497 *bufEnd++ = 'z';
3498 if (++lineLen == 65) {
3499 *bufEnd++ = '\n';
3500 lineLen = 0;
3501 }
3502 } else {
3503 if (n < 4)
3504 t <<= 8 * (4 - n);
3505 for (i = 4; i >= 0; --i) {
3506 buf1[i] = (char)(t % 85 + 0x21);
3507 t /= 85;
3508 }
3509 for (i = 0; i <= n; ++i) {
3510 *bufEnd++ = buf1[i];
3511 if (++lineLen == 65) {
3512 *bufEnd++ = '\n';
3513 lineLen = 0;
3514 }
3515 }
3516 }
3517 }
3518 if (n < 4) {
3519 *bufEnd++ = '~';
3520 *bufEnd++ = '>';
3521 eof = gTrue;
3522 }
3523 return bufPtr < bufEnd;
3524 }
3525
3526 //------------------------------------------------------------------------
3527 // RunLengthEncoder
3528 //------------------------------------------------------------------------
3529
3530 RunLengthEncoder::RunLengthEncoder(Stream *strA):
3531 FilterStream(strA) {
3532 bufPtr = bufEnd = nextEnd = buf;
3533 eof = gFalse;
3534 }
3535
3536 RunLengthEncoder::~RunLengthEncoder() {
3537 if (str->isEncoder())
3538 delete str;
3539 }
3540
3541 void RunLengthEncoder::reset() {
3542 str->reset();
3543 bufPtr = bufEnd = nextEnd = buf;
3544 eof = gFalse;
3545 }
3546
3547 void RunLengthEncoder::close() {
3548 }
3549
3550 //
3551 // When fillBuf finishes, buf[] looks like this:
3552 // +-----+--------------+-----------------+--
3553 // + tag | ... data ... | next 0, 1, or 2 |
3554 // +-----+--------------+-----------------+--
3555 // ^ ^ ^
3556 // bufPtr bufEnd nextEnd
3557 //
3558 GBool RunLengthEncoder::fillBuf() {
3559 int c, c1, c2;
3560 int n;
3561
3562 // already hit EOF?
3563 if (eof)
3564 return gFalse;
3565
3566 // grab two bytes
3567 if (nextEnd < bufEnd + 1) {
3568 if ((c1 = str->getChar()) == EOF) {
3569 eof = gTrue;
3570 return gFalse;
3571 }
3572 } else {
3573 c1 = bufEnd[0] & 0xff;
3574 }
3575 if (nextEnd < bufEnd + 2) {
3576 if ((c2 = str->getChar()) == EOF) {
3577 eof = gTrue;
3578 buf[0] = 0;
3579 buf[1] = c1;
3580 bufPtr = buf;
3581 bufEnd = &buf[2];
3582 return gTrue;
3583 }
3584 } else {
3585 c2 = bufEnd[1] & 0xff;
3586 }
3587
3588 // check for repeat
3589 c = 0; // make gcc happy
3590 if (c1 == c2) {
3591 n = 2;
3592 while (n < 128 && (c = str->getChar()) == c1)
3593 ++n;
3594 buf[0] = (char)(257 - n);
3595 buf[1] = c1;
3596 bufEnd = &buf[2];
3597 if (c == EOF) {
3598 eof = gTrue;
3599 } else if (n < 128) {
3600 buf[2] = c;
3601 nextEnd = &buf[3];
3602 } else {
3603 nextEnd = bufEnd;
3604 }
3605
3606 // get up to 128 chars
3607 } else {
3608 buf[1] = c1;
3609 buf[2] = c2;
3610 n = 2;
3611 while (n < 128) {
3612 if ((c = str->getChar()) == EOF) {
3613 eof = gTrue;
3614 break;
3615 }
3616 ++n;
3617 buf[n] = c;
3618 if (buf[n] == buf[n-1])
3619 break;
3620 }
3621 if (buf[n] == buf[n-1]) {
3622 buf[0] = (char)(n-2-1);
3623 bufEnd = &buf[n-1];
3624 nextEnd = &buf[n+1];
3625 } else {
3626 buf[0] = (char)(n-1);
3627 bufEnd = nextEnd = &buf[n+1];
3628 }
3629 }
3630 bufPtr = buf;
3631 return gTrue;
3632 }
SWFTools is a collection of utilities for working with Adobe Flash files