pdf2swf/xpdf/Stream.cc

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