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