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 #include "Lexer.h"
  29 #include "Decrypt.h"
  30 #include "GfxState.h"
  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   decrypt = NULL;
 276 }
 277
 278 BaseStream::~BaseStream() {
 279   dict.free();
 280   if (decrypt)
 281     delete decrypt;
 282 }
 283
 284 void BaseStream::doDecryption(Guchar *fileKey, int keyLength,
 285                               int objNum, int objGen) {
 286   decrypt = new Decrypt(fileKey, keyLength, objNum, objGen);
 287 }
 288
 289 //------------------------------------------------------------------------
 290 // FilterStream
 291 //------------------------------------------------------------------------
 292
 293 FilterStream::FilterStream(Stream *strA) {
 294   str = strA;
 295 }
 296
 297 FilterStream::~FilterStream() {
 298 }
 299
 300 void FilterStream::close() {
 301   str->close();
 302 }
 303
 304 void FilterStream::setPos(Guint pos, int dir) {
 305   error(-1, "Internal: called setPos() on FilterStream");
 306 }
 307
 308 //------------------------------------------------------------------------
 309 // ImageStream
 310 //------------------------------------------------------------------------
 311
 312 ImageStream::ImageStream(Stream *strA, int widthA, int nCompsA, int nBitsA) {
 313   int imgLineSize;
 314
 315   str = strA;
 316   width = widthA;
 317   nComps = nCompsA;
 318   nBits = nBitsA;
 319
 320   nVals = width * nComps;
 321   if (nBits == 1) {
 322     imgLineSize = (nVals + 7) & ~7;
 323   } else {
 324     imgLineSize = nVals;
 325   }
 326   imgLine = (Guchar *)gmallocn(imgLineSize, sizeof(Guchar));
 327   imgIdx = nVals;
 328 }
 329
 330 ImageStream::~ImageStream() {
 331   gfree(imgLine);
 332 }
 333
 334 void ImageStream::reset() {
 335   str->reset();
 336 }
 337
 338 GBool ImageStream::getPixel(Guchar *pix) {
 339   int i;
 340
 341   if (imgIdx >= nVals) {
 342     getLine();
 343     imgIdx = 0;
 344   }
 345   for (i = 0; i < nComps; ++i) {
 346     pix[i] = imgLine[imgIdx++];
 347   }
 348   return gTrue;
 349 }
 350
 351 Guchar *ImageStream::getLine() {
 352   Gulong buf, bitMask;
 353   int bits;
 354   int c;
 355   int i;
 356
 357   if (nBits == 1) {
 358     for (i = 0; i < nVals; i += 8) {
 359       c = str->getChar();
 360       imgLine[i+0] = (Guchar)((c >> 7) & 1);
 361       imgLine[i+1] = (Guchar)((c >> 6) & 1);
 362       imgLine[i+2] = (Guchar)((c >> 5) & 1);
 363       imgLine[i+3] = (Guchar)((c >> 4) & 1);
 364       imgLine[i+4] = (Guchar)((c >> 3) & 1);
 365       imgLine[i+5] = (Guchar)((c >> 2) & 1);
 366       imgLine[i+6] = (Guchar)((c >> 1) & 1);
 367       imgLine[i+7] = (Guchar)(c & 1);
 368     }
 369   } else if (nBits == 8) {
 370     for (i = 0; i < nVals; ++i) {
 371       imgLine[i] = str->getChar();
 372     }
 373   } else {
 374     bitMask = (1 << nBits) - 1;
 375     buf = 0;
 376     bits = 0;
 377     for (i = 0; i < nVals; ++i) {
 378       if (bits < nBits) {
 379         buf = (buf << 8) | (str->getChar() & 0xff);
 380         bits += 8;
 381       }
 382       imgLine[i] = (Guchar)((buf >> (bits - nBits)) & bitMask);
 383       bits -= nBits;
 384     }
 385   }
 386   return imgLine;
 387 }
 388
 389 void ImageStream::skipLine() {
 390   int n, i;
 391
 392   n = (nVals * nBits + 7) >> 3;
 393   for (i = 0; i < n; ++i) {
 394     str->getChar();
 395   }
 396 }
 397
 398 //------------------------------------------------------------------------
 399 // StreamPredictor
 400 //------------------------------------------------------------------------
 401
 402 StreamPredictor::StreamPredictor(Stream *strA, int predictorA,
 403                                  int widthA, int nCompsA, int nBitsA) {
 404   int totalBits;
 405
 406   str = strA;
 407   predictor = predictorA;
 408   width = widthA;
 409   nComps = nCompsA;
 410   nBits = nBitsA;
 411   predLine = NULL;
 412   ok = gFalse;
 413
 414   nVals = width * nComps;
 415   totalBits = nVals * nBits;
 416   if (totalBits == 0 ||
 417       (totalBits / nBits) / nComps != width ||
 418       totalBits + 7 < 0) {
 419     return;
 420   }
 421   pixBytes = (nComps * nBits + 7) >> 3;
 422   rowBytes = ((totalBits + 7) >> 3) + pixBytes;
 423   if (rowBytes < 0) {
 424     return;
 425   }
 426   predLine = (Guchar *)gmalloc(rowBytes);
 427   memset(predLine, 0, rowBytes);
 428   predIdx = rowBytes;
 429
 430   ok = gTrue;
 431 }
 432
 433 StreamPredictor::~StreamPredictor() {
 434   gfree(predLine);
 435 }
 436
 437 int StreamPredictor::lookChar() {
 438   if (predIdx >= rowBytes) {
 439     if (!getNextLine()) {
 440       return EOF;
 441     }
 442   }
 443   return predLine[predIdx];
 444 }
 445
 446 int StreamPredictor::getChar() {
 447   if (predIdx >= rowBytes) {
 448     if (!getNextLine()) {
 449       return EOF;
 450     }
 451   }
 452   return predLine[predIdx++];
 453 }
 454
 455 GBool StreamPredictor::getNextLine() {
 456   int curPred;
 457   Guchar upLeftBuf[gfxColorMaxComps * 2 + 1];
 458   int left, up, upLeft, p, pa, pb, pc;
 459   int c;
 460   Gulong inBuf, outBuf, bitMask;
 461   int inBits, outBits;
 462   int i, j, k, kk;
 463
 464   // get PNG optimum predictor number
 465   if (predictor >= 10) {
 466     if ((curPred = str->getRawChar()) == EOF) {
 467       return gFalse;
 468     }
 469     curPred += 10;
 470   } else {
 471     curPred = predictor;
 472   }
 473
 474   // read the raw line, apply PNG (byte) predictor
 475   memset(upLeftBuf, 0, pixBytes + 1);
 476   for (i = pixBytes; i < rowBytes; ++i) {
 477     for (j = pixBytes; j > 0; --j) {
 478       upLeftBuf[j] = upLeftBuf[j-1];
 479     }
 480     upLeftBuf[0] = predLine[i];
 481     if ((c = str->getRawChar()) == EOF) {
 482       if (i > pixBytes) {
 483         // this ought to return false, but some (broken) PDF files
 484         // contain truncated image data, and Adobe apparently reads the
 485         // last partial line
 486         break;
 487       }
 488       return gFalse;
 489     }
 490     switch (curPred) {
 491     case 11:                    // PNG sub
 492       predLine[i] = predLine[i - pixBytes] + (Guchar)c;
 493       break;
 494     case 12:                    // PNG up
 495       predLine[i] = predLine[i] + (Guchar)c;
 496       break;
 497     case 13:                    // PNG average
 498       predLine[i] = ((predLine[i - pixBytes] + predLine[i]) >> 1) +
 499                     (Guchar)c;
 500       break;
 501     case 14:                    // PNG Paeth
 502       left = predLine[i - pixBytes];
 503       up = predLine[i];
 504       upLeft = upLeftBuf[pixBytes];
 505       p = left + up - upLeft;
 506       if ((pa = p - left) < 0)
 507         pa = -pa;
 508       if ((pb = p - up) < 0)
 509         pb = -pb;
 510       if ((pc = p - upLeft) < 0)
 511         pc = -pc;
 512       if (pa <= pb && pa <= pc)
 513         predLine[i] = left + (Guchar)c;
 514       else if (pb <= pc)
 515         predLine[i] = up + (Guchar)c;
 516       else
 517         predLine[i] = upLeft + (Guchar)c;
 518       break;
 519     case 10:                    // PNG none
 520     default:                    // no predictor or TIFF predictor
 521       predLine[i] = (Guchar)c;
 522       break;
 523     }
 524   }
 525
 526   // apply TIFF (component) predictor
 527   if (predictor == 2) {
 528     if (nBits == 1) {
 529       inBuf = predLine[pixBytes - 1];
 530       for (i = pixBytes; i < rowBytes; i += 8) {
 531         // 1-bit add is just xor
 532         inBuf = (inBuf << 8) | predLine[i];
 533         predLine[i] ^= inBuf >> nComps;
 534       }
 535     } else if (nBits == 8) {
 536       for (i = pixBytes; i < rowBytes; ++i) {
 537         predLine[i] += predLine[i - nComps];
 538       }
 539     } else {
 540       memset(upLeftBuf, 0, nComps + 1);
 541       bitMask = (1 << nBits) - 1;
 542       inBuf = outBuf = 0;
 543       inBits = outBits = 0;
 544       j = k = pixBytes;
 545       for (i = 0; i < width; ++i) {
 546         for (kk = 0; kk < nComps; ++kk) {
 547           if (inBits < nBits) {
 548             inBuf = (inBuf << 8) | (predLine[j++] & 0xff);
 549             inBits += 8;
 550           }
 551           upLeftBuf[kk] = (upLeftBuf[kk] +
 552                            (inBuf >> (inBits - nBits))) & bitMask;
 553           inBits -= nBits;
 554           outBuf = (outBuf << nBits) | upLeftBuf[kk];
 555           outBits += nBits;
 556           if (outBits >= 8) {
 557             predLine[k++] = (Guchar)(outBuf >> (outBits - 8));
 558             outBits -= 8;
 559           }
 560         }
 561       }
 562       if (outBits > 0) {
 563         predLine[k++] = (Guchar)((outBuf << (8 - outBits)) +
 564                                  (inBuf & ((1 << (8 - outBits)) - 1)));
 565       }
 566     }
 567   }
 568
 569   // reset to start of line
 570   predIdx = pixBytes;
 571
 572   return gTrue;
 573 }
 574
 575 //------------------------------------------------------------------------
 576 // FileStream
 577 //------------------------------------------------------------------------
 578
 579 FileStream::FileStream(FILE *fA, Guint startA, GBool limitedA,
 580                        Guint lengthA, Object *dictA):
 581     BaseStream(dictA) {
 582   f = fA;
 583   start = startA;
 584   limited = limitedA;
 585   length = lengthA;
 586   bufPtr = bufEnd = buf;
 587   bufPos = start;
 588   savePos = 0;
 589   saved = gFalse;
 590 }
 591
 592 FileStream::~FileStream() {
 593   close();
 594 }
 595
 596 Stream *FileStream::makeSubStream(Guint startA, GBool limitedA,
 597                                   Guint lengthA, Object *dictA) {
 598   return new FileStream(f, startA, limitedA, lengthA, dictA);
 599 }
 600
 601 void FileStream::reset() {
 602 #if HAVE_FSEEKO
 603   savePos = (Guint)ftello(f);
 604   fseeko(f, start, SEEK_SET);
 605 #elif HAVE_FSEEK64
 606   savePos = (Guint)ftell64(f);
 607   fseek64(f, start, SEEK_SET);
 608 #else
 609   savePos = (Guint)ftell(f);
 610   fseek(f, start, SEEK_SET);
 611 #endif
 612   saved = gTrue;
 613   bufPtr = bufEnd = buf;
 614   bufPos = start;
 615   if (decrypt)
 616     decrypt->reset();
 617 }
 618
 619 void FileStream::close() {
 620   if (saved) {
 621 #if HAVE_FSEEKO
 622     fseeko(f, savePos, SEEK_SET);
 623 #elif HAVE_FSEEK64
 624     fseek64(f, savePos, SEEK_SET);
 625 #else
 626     fseek(f, savePos, SEEK_SET);
 627 #endif
 628     saved = gFalse;
 629   }
 630 }
 631
 632 GBool FileStream::fillBuf() {
 633   int n;
 634   char *p;
 635
 636   bufPos += bufEnd - buf;
 637   bufPtr = bufEnd = buf;
 638   if (limited && bufPos >= start + length) {
 639     return gFalse;
 640   }
 641   if (limited && bufPos + fileStreamBufSize > start + length) {
 642     n = start + length - bufPos;
 643   } else {
 644     n = fileStreamBufSize;
 645   }
 646   n = fread(buf, 1, n, f);
 647   bufEnd = buf + n;
 648   if (bufPtr >= bufEnd) {
 649     return gFalse;
 650   }
 651   if (decrypt) {
 652     for (p = buf; p < bufEnd; ++p) {
 653       *p = (char)decrypt->decryptByte((Guchar)*p);
 654     }
 655   }
 656   return gTrue;
 657 }
 658
 659 void FileStream::setPos(Guint pos, int dir) {
 660   Guint size;
 661
 662   if (dir >= 0) {
 663 #if HAVE_FSEEKO
 664     fseeko(f, pos, SEEK_SET);
 665 #elif HAVE_FSEEK64
 666     fseek64(f, pos, SEEK_SET);
 667 #else
 668     fseek(f, pos, SEEK_SET);
 669 #endif
 670     bufPos = pos;
 671   } else {
 672 #if HAVE_FSEEKO
 673     fseeko(f, 0, SEEK_END);
 674     size = (Guint)ftello(f);
 675 #elif HAVE_FSEEK64
 676     fseek64(f, 0, SEEK_END);
 677     size = (Guint)ftell64(f);
 678 #else
 679     fseek(f, 0, SEEK_END);
 680     size = (Guint)ftell(f);
 681 #endif
 682     if (pos > size)
 683       pos = (Guint)size;
 684 #ifdef __CYGWIN32__
 685     //~ work around a bug in cygwin's implementation of fseek
 686     rewind(f);
 687 #endif
 688 #if HAVE_FSEEKO
 689     fseeko(f, -(int)pos, SEEK_END);
 690     bufPos = (Guint)ftello(f);
 691 #elif HAVE_FSEEK64
 692     fseek64(f, -(int)pos, SEEK_END);
 693     bufPos = (Guint)ftell64(f);
 694 #else
 695     fseek(f, -(int)pos, SEEK_END);
 696     bufPos = (Guint)ftell(f);
 697 #endif
 698   }
 699   bufPtr = bufEnd = buf;
 700 }
 701
 702 void FileStream::moveStart(int delta) {
 703   start += delta;
 704   bufPtr = bufEnd = buf;
 705   bufPos = start;
 706 }
 707
 708 //------------------------------------------------------------------------
 709 // MemStream
 710 //------------------------------------------------------------------------
 711
 712 MemStream::MemStream(char *bufA, Guint startA, Guint lengthA, Object *dictA):
 713     BaseStream(dictA) {
 714   buf = bufA;
 715   start = startA;
 716   length = lengthA;
 717   bufEnd = buf + start + length;
 718   bufPtr = buf + start;
 719   needFree = gFalse;
 720 }
 721
 722 MemStream::~MemStream() {
 723   if (needFree) {
 724     gfree(buf);
 725   }
 726 }
 727
 728 Stream *MemStream::makeSubStream(Guint startA, GBool limited,
 729                                  Guint lengthA, Object *dictA) {
 730   MemStream *subStr;
 731   Guint newLength;
 732
 733   if (!limited || startA + lengthA > start + length) {
 734     newLength = start + length - startA;
 735   } else {
 736     newLength = lengthA;
 737   }
 738   subStr = new MemStream(buf, startA, newLength, dictA);
 739   return subStr;
 740 }
 741
 742 void MemStream::reset() {
 743   bufPtr = buf + start;
 744   if (decrypt) {
 745     decrypt->reset();
 746   }
 747 }
 748
 749 void MemStream::close() {
 750 }
 751
 752 void MemStream::setPos(Guint pos, int dir) {
 753   Guint i;
 754
 755   if (dir >= 0) {
 756     i = pos;
 757   } else {
 758     i = start + length - pos;
 759   }
 760   if (i < start) {
 761     i = start;
 762   } else if (i > start + length) {
 763     i = start + length;
 764   }
 765   bufPtr = buf + i;
 766 }
 767
 768 void MemStream::moveStart(int delta) {
 769   start += delta;
 770   length -= delta;
 771   bufPtr = buf + start;
 772 }
 773
 774 void MemStream::doDecryption(Guchar *fileKey, int keyLength,
 775                              int objNum, int objGen) {
 776   char *newBuf;
 777   char *p, *q;
 778
 779   this->BaseStream::doDecryption(fileKey, keyLength, objNum, objGen);
 780   if (decrypt) {
 781     newBuf = (char *)gmalloc(length);
 782     for (p = buf + start, q = newBuf; p < bufEnd; ++p, ++q) {
 783       *q = (char)decrypt->decryptByte((Guchar)*p);
 784     }
 785     bufEnd = newBuf + length;
 786     bufPtr = newBuf + (bufPtr - (buf + start));
 787     start = 0;
 788     buf = newBuf;
 789     needFree = gTrue;
 790   }
 791 }
 792
 793 //------------------------------------------------------------------------
 794 // EmbedStream
 795 //------------------------------------------------------------------------
 796
 797 EmbedStream::EmbedStream(Stream *strA, Object *dictA,
 798                          GBool limitedA, Guint lengthA):
 799     BaseStream(dictA) {
 800   str = strA;
 801   limited = limitedA;
 802   length = lengthA;
 803 }
 804
 805 EmbedStream::~EmbedStream() {
 806 }
 807
 808 Stream *EmbedStream::makeSubStream(Guint start, GBool limitedA,
 809                                    Guint lengthA, Object *dictA) {
 810   error(-1, "Internal: called makeSubStream() on EmbedStream");
 811   return NULL;
 812 }
 813
 814 int EmbedStream::getChar() {
 815   if (limited && !length) {
 816     return EOF;
 817   }
 818   --length;
 819   return str->getChar();
 820 }
 821
 822 int EmbedStream::lookChar() {
 823   if (limited && !length) {
 824     return EOF;
 825   }
 826   return str->lookChar();
 827 }
 828
 829 void EmbedStream::setPos(Guint pos, int dir) {
 830   error(-1, "Internal: called setPos() on EmbedStream");
 831 }
 832
 833 Guint EmbedStream::getStart() {
 834   error(-1, "Internal: called getStart() on EmbedStream");
 835   return 0;
 836 }
 837
 838 void EmbedStream::moveStart(int delta) {
 839   error(-1, "Internal: called moveStart() on EmbedStream");
 840 }
 841
 842 //------------------------------------------------------------------------
 843 // ASCIIHexStream
 844 //------------------------------------------------------------------------
 845
 846 ASCIIHexStream::ASCIIHexStream(Stream *strA):
 847     FilterStream(strA) {
 848   buf = EOF;
 849   eof = gFalse;
 850 }
 851
 852 ASCIIHexStream::~ASCIIHexStream() {
 853   delete str;
 854 }
 855
 856 void ASCIIHexStream::reset() {
 857   str->reset();
 858   buf = EOF;
 859   eof = gFalse;
 860 }
 861
 862 int ASCIIHexStream::lookChar() {
 863   int c1, c2, x;
 864
 865   if (buf != EOF)
 866     return buf;
 867   if (eof) {
 868     buf = EOF;
 869     return EOF;
 870   }
 871   do {
 872     c1 = str->getChar();
 873   } while (isspace(c1));
 874   if (c1 == '>') {
 875     eof = gTrue;
 876     buf = EOF;
 877     return buf;
 878   }
 879   do {
 880     c2 = str->getChar();
 881   } while (isspace(c2));
 882   if (c2 == '>') {
 883     eof = gTrue;
 884     c2 = '0';
 885   }
 886   if (c1 >= '0' && c1 <= '9') {
 887     x = (c1 - '0') << 4;
 888   } else if (c1 >= 'A' && c1 <= 'F') {
 889     x = (c1 - 'A' + 10) << 4;
 890   } else if (c1 >= 'a' && c1 <= 'f') {
 891     x = (c1 - 'a' + 10) << 4;
 892   } else if (c1 == EOF) {
 893     eof = gTrue;
 894     x = 0;
 895   } else {
 896     error(getPos(), "Illegal character <%02x> in ASCIIHex stream", c1);
 897     x = 0;
 898   }
 899   if (c2 >= '0' && c2 <= '9') {
 900     x += c2 - '0';
 901   } else if (c2 >= 'A' && c2 <= 'F') {
 902     x += c2 - 'A' + 10;
 903   } else if (c2 >= 'a' && c2 <= 'f') {
 904     x += c2 - 'a' + 10;
 905   } else if (c2 == EOF) {
 906     eof = gTrue;
 907     x = 0;
 908   } else {
 909     error(getPos(), "Illegal character <%02x> in ASCIIHex stream", c2);
 910   }
 911   buf = x & 0xff;
 912   return buf;
 913 }
 914
 915 GString *ASCIIHexStream::getPSFilter(int psLevel, char *indent) {
 916   GString *s;
 917
 918   if (psLevel < 2) {
 919     return NULL;
 920   }
 921   if (!(s = str->getPSFilter(psLevel, indent))) {
 922     return NULL;
 923   }
 924   s->append(indent)->append("/ASCIIHexDecode filter\n");
 925   return s;
 926 }
 927
 928 GBool ASCIIHexStream::isBinary(GBool last) {
 929   return str->isBinary(gFalse);
 930 }
 931
 932 //------------------------------------------------------------------------
 933 // ASCII85Stream
 934 //------------------------------------------------------------------------
 935
 936 ASCII85Stream::ASCII85Stream(Stream *strA):
 937     FilterStream(strA) {
 938   index = n = 0;
 939   eof = gFalse;
 940 }
 941
 942 ASCII85Stream::~ASCII85Stream() {
 943   delete str;
 944 }
 945
 946 void ASCII85Stream::reset() {
 947   str->reset();
 948   index = n = 0;
 949   eof = gFalse;
 950 }
 951
 952 int ASCII85Stream::lookChar() {
 953   int k;
 954   Gulong t;
 955
 956   if (index >= n) {
 957     if (eof)
 958       return EOF;
 959     index = 0;
 960     do {
 961       c[0] = str->getChar();
 962     } while (Lexer::isSpace(c[0]));
 963     if (c[0] == '~' || c[0] == EOF) {
 964       eof = gTrue;
 965       n = 0;
 966       return EOF;
 967     } else if (c[0] == 'z') {
 968       b[0] = b[1] = b[2] = b[3] = 0;
 969       n = 4;
 970     } else {
 971       for (k = 1; k < 5; ++k) {
 972         do {
 973           c[k] = str->getChar();
 974         } while (Lexer::isSpace(c[k]));
 975         if (c[k] == '~' || c[k] == EOF)
 976           break;
 977       }
 978       n = k - 1;
 979       if (k < 5 && (c[k] == '~' || c[k] == EOF)) {
 980         for (++k; k < 5; ++k)
 981           c[k] = 0x21 + 84;
 982         eof = gTrue;
 983       }
 984       t = 0;
 985       for (k = 0; k < 5; ++k)
 986         t = t * 85 + (c[k] - 0x21);
 987       for (k = 3; k >= 0; --k) {
 988         b[k] = (int)(t & 0xff);
 989         t >>= 8;
 990       }
 991     }
 992   }
 993   return b[index];
 994 }
 995
 996 GString *ASCII85Stream::getPSFilter(int psLevel, char *indent) {
 997   GString *s;
 998
 999   if (psLevel < 2) {
1000     return NULL;
1001   }
1002   if (!(s = str->getPSFilter(psLevel, indent))) {
1003     return NULL;
1004   }
1005   s->append(indent)->append("/ASCII85Decode filter\n");
1006   return s;
1007 }
1008
1009 GBool ASCII85Stream::isBinary(GBool last) {
1010   return str->isBinary(gFalse);
1011 }
1012
1013 //------------------------------------------------------------------------
1014 // LZWStream
1015 //------------------------------------------------------------------------
1016
1017 LZWStream::LZWStream(Stream *strA, int predictor, int columns, int colors,
1018                      int bits, int earlyA):
1019     FilterStream(strA) {
1020   if (predictor != 1) {
1021     pred = new StreamPredictor(this, predictor, columns, colors, bits);
1022     if (!pred->isOk()) {
1023       delete pred;
1024       pred = NULL;
1025     }
1026   } else {
1027     pred = NULL;
1028   }
1029   early = earlyA;
1030   eof = gFalse;
1031   inputBits = 0;
1032   clearTable();
1033 }
1034
1035 LZWStream::~LZWStream() {
1036   if (pred) {
1037     delete pred;
1038   }
1039   delete str;
1040 }
1041
1042 int LZWStream::getChar() {
1043   if (pred) {
1044     return pred->getChar();
1045   }
1046   if (eof) {
1047     return EOF;
1048   }
1049   if (seqIndex >= seqLength) {
1050     if (!processNextCode()) {
1051       return EOF;
1052     }
1053   }
1054   return seqBuf[seqIndex++];
1055 }
1056
1057 int LZWStream::lookChar() {
1058   if (pred) {
1059     return pred->lookChar();
1060   }
1061   if (eof) {
1062     return EOF;
1063   }
1064   if (seqIndex >= seqLength) {
1065     if (!processNextCode()) {
1066       return EOF;
1067     }
1068   }
1069   return seqBuf[seqIndex];
1070 }
1071
1072 int LZWStream::getRawChar() {
1073   if (eof) {
1074     return EOF;
1075   }
1076   if (seqIndex >= seqLength) {
1077     if (!processNextCode()) {
1078       return EOF;
1079     }
1080   }
1081   return seqBuf[seqIndex++];
1082 }
1083
1084 void LZWStream::reset() {
1085   str->reset();
1086   eof = gFalse;
1087   inputBits = 0;
1088   clearTable();
1089 }
1090
1091 GBool LZWStream::processNextCode() {
1092   int code;
1093   int nextLength;
1094   int i, j;
1095
1096   // check for EOF
1097   if (eof) {
1098     return gFalse;
1099   }
1100
1101   // check for eod and clear-table codes
1102  start:
1103   code = getCode();
1104   if (code == EOF || code == 257) {
1105     eof = gTrue;
1106     return gFalse;
1107   }
1108   if (code == 256) {
1109     clearTable();
1110     goto start;
1111   }
1112   if (nextCode >= 4097) {
1113     error(getPos(), "Bad LZW stream - expected clear-table code");
1114     clearTable();
1115   }
1116
1117   // process the next code
1118   nextLength = seqLength + 1;
1119   if (code < 256) {
1120     seqBuf[0] = code;
1121     seqLength = 1;
1122   } else if (code < nextCode) {
1123     seqLength = table[code].length;
1124     for (i = seqLength - 1, j = code; i > 0; --i) {
1125       seqBuf[i] = table[j].tail;
1126       j = table[j].head;
1127     }
1128     seqBuf[0] = j;
1129   } else if (code == nextCode) {
1130     seqBuf[seqLength] = newChar;
1131     ++seqLength;
1132   } else {
1133     error(getPos(), "Bad LZW stream - unexpected code");
1134     eof = gTrue;
1135     return gFalse;
1136   }
1137   newChar = seqBuf[0];
1138   if (first) {
1139     first = gFalse;
1140   } else {
1141     table[nextCode].length = nextLength;
1142     table[nextCode].head = prevCode;
1143     table[nextCode].tail = newChar;
1144     ++nextCode;
1145     if (nextCode + early == 512)
1146       nextBits = 10;
1147     else if (nextCode + early == 1024)
1148       nextBits = 11;
1149     else if (nextCode + early == 2048)
1150       nextBits = 12;
1151   }
1152   prevCode = code;
1153
1154   // reset buffer
1155   seqIndex = 0;
1156
1157   return gTrue;
1158 }
1159
1160 void LZWStream::clearTable() {
1161   nextCode = 258;
1162   nextBits = 9;
1163   seqIndex = seqLength = 0;
1164   first = gTrue;
1165 }
1166
1167 int LZWStream::getCode() {
1168   int c;
1169   int code;
1170
1171   while (inputBits < nextBits) {
1172     if ((c = str->getChar()) == EOF)
1173       return EOF;
1174     inputBuf = (inputBuf << 8) | (c & 0xff);
1175     inputBits += 8;
1176   }
1177   code = (inputBuf >> (inputBits - nextBits)) & ((1 << nextBits) - 1);
1178   inputBits -= nextBits;
1179   return code;
1180 }
1181
1182 GString *LZWStream::getPSFilter(int psLevel, char *indent) {
1183   GString *s;
1184
1185   if (psLevel < 2 || pred) {
1186     return NULL;
1187   }
1188   if (!(s = str->getPSFilter(psLevel, indent))) {
1189     return NULL;
1190   }
1191   s->append(indent)->append("<< ");
1192   if (!early) {
1193     s->append("/EarlyChange 0 ");
1194   }
1195   s->append(">> /LZWDecode filter\n");
1196   return s;
1197 }
1198
1199 GBool LZWStream::isBinary(GBool last) {
1200   return str->isBinary(gTrue);
1201 }
1202
1203 //------------------------------------------------------------------------
1204 // RunLengthStream
1205 //------------------------------------------------------------------------
1206
1207 RunLengthStream::RunLengthStream(Stream *strA):
1208     FilterStream(strA) {
1209   bufPtr = bufEnd = buf;
1210   eof = gFalse;
1211 }
1212
1213 RunLengthStream::~RunLengthStream() {
1214   delete str;
1215 }
1216
1217 void RunLengthStream::reset() {
1218   str->reset();
1219   bufPtr = bufEnd = buf;
1220   eof = gFalse;
1221 }
1222
1223 GString *RunLengthStream::getPSFilter(int psLevel, char *indent) {
1224   GString *s;
1225
1226   if (psLevel < 2) {
1227     return NULL;
1228   }
1229   if (!(s = str->getPSFilter(psLevel, indent))) {
1230     return NULL;
1231   }
1232   s->append(indent)->append("/RunLengthDecode filter\n");
1233   return s;
1234 }
1235
1236 GBool RunLengthStream::isBinary(GBool last) {
1237   return str->isBinary(gTrue);
1238 }
1239
1240 GBool RunLengthStream::fillBuf() {
1241   int c;
1242   int n, i;
1243
1244   if (eof)
1245     return gFalse;
1246   c = str->getChar();
1247   if (c == 0x80 || c == EOF) {
1248     eof = gTrue;
1249     return gFalse;
1250   }
1251   if (c < 0x80) {
1252     n = c + 1;
1253     for (i = 0; i < n; ++i)
1254       buf[i] = (char)str->getChar();
1255   } else {
1256     n = 0x101 - c;
1257     c = str->getChar();
1258     for (i = 0; i < n; ++i)
1259       buf[i] = (char)c;
1260   }
1261   bufPtr = buf;
1262   bufEnd = buf + n;
1263   return gTrue;
1264 }
1265
1266 //------------------------------------------------------------------------
1267 // CCITTFaxStream
1268 //------------------------------------------------------------------------
1269
1270 CCITTFaxStream::CCITTFaxStream(Stream *strA, int encodingA, GBool endOfLineA,
1271                                GBool byteAlignA, int columnsA, int rowsA,
1272                                GBool endOfBlockA, GBool blackA):
1273     FilterStream(strA) {
1274   encoding = encodingA;
1275   endOfLine = endOfLineA;
1276   byteAlign = byteAlignA;
1277   columns = columnsA;
1278   if (columns < 1) {
1279     columns = 1;
1280   }
1281   rows = rowsA;
1282   endOfBlock = endOfBlockA;
1283   black = blackA;
1284   refLine = (short *)gmallocn(columns + 4, sizeof(short));
1285   codingLine = (short *)gmallocn(columns + 3, sizeof(short));
1286
1287   eof = gFalse;
1288   row = 0;
1289   nextLine2D = encoding < 0;
1290   inputBits = 0;
1291   codingLine[0] = 0;
1292   codingLine[1] = refLine[2] = columns;
1293   a0 = 1;
1294
1295   buf = EOF;
1296 }
1297
1298 CCITTFaxStream::~CCITTFaxStream() {
1299   delete str;
1300   gfree(refLine);
1301   gfree(codingLine);
1302 }
1303
1304 void CCITTFaxStream::reset() {
1305   short code1;
1306
1307   str->reset();
1308   eof = gFalse;
1309   row = 0;
1310   nextLine2D = encoding < 0;
1311   inputBits = 0;
1312   codingLine[0] = 0;
1313   codingLine[1] = refLine[2] = columns;
1314   a0 = 1;
1315   buf = EOF;
1316
1317   // skip any initial zero bits and end-of-line marker, and get the 2D
1318   // encoding tag
1319   while ((code1 = lookBits(12)) == 0) {
1320     eatBits(1);
1321   }
1322   if (code1 == 0x001) {
1323     eatBits(12);
1324   }
1325   if (encoding > 0) {
1326     nextLine2D = !lookBits(1);
1327     eatBits(1);
1328   }
1329 }
1330
1331 int CCITTFaxStream::lookChar() {
1332   short code1, code2, code3;
1333   int a0New;
1334   GBool err, gotEOL;
1335   int ret;
1336   int bits, i;
1337
1338   // if at eof just return EOF
1339   if (eof && codingLine[a0] >= columns) {
1340     return EOF;
1341   }
1342
1343   // read the next row
1344   err = gFalse;
1345   if (codingLine[a0] >= columns) {
1346
1347     // 2-D encoding
1348     if (nextLine2D) {
1349       for (i = 0; codingLine[i] < columns; ++i)
1350         refLine[i] = codingLine[i];
1351       refLine[i] = refLine[i + 1] = columns;
1352       b1 = 1;
1353       a0New = codingLine[a0 = 0] = 0;
1354       do {
1355         code1 = getTwoDimCode();
1356         switch (code1) {
1357         case twoDimPass:
1358           if (refLine[b1] < columns) {
1359             a0New = refLine[b1 + 1];
1360             b1 += 2;
1361           }
1362           break;
1363         case twoDimHoriz:
1364           if ((a0 & 1) == 0) {
1365             code1 = code2 = 0;
1366             do {
1367               code1 += code3 = getWhiteCode();
1368             } while (code3 >= 64);
1369             do {
1370               code2 += code3 = getBlackCode();
1371             } while (code3 >= 64);
1372           } else {
1373             code1 = code2 = 0;
1374             do {
1375               code1 += code3 = getBlackCode();
1376             } while (code3 >= 64);
1377             do {
1378               code2 += code3 = getWhiteCode();
1379             } while (code3 >= 64);
1380           }
1381           if (code1 > 0 || code2 > 0) {
1382             codingLine[a0 + 1] = a0New + code1;
1383             ++a0;
1384             a0New = codingLine[a0 + 1] = codingLine[a0] + code2;
1385             ++a0;
1386             while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1387               b1 += 2;
1388           }
1389           break;
1390         case twoDimVert0:
1391           a0New = codingLine[++a0] = refLine[b1];
1392           if (refLine[b1] < columns) {
1393             ++b1;
1394             while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1395               b1 += 2;
1396           }
1397           break;
1398         case twoDimVertR1:
1399           a0New = codingLine[++a0] = refLine[b1] + 1;
1400           if (refLine[b1] < columns) {
1401             ++b1;
1402             while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1403               b1 += 2;
1404           }
1405           break;
1406         case twoDimVertL1:
1407           if (a0 == 0 || refLine[b1] - 1 > a0New) {
1408             a0New = codingLine[++a0] = refLine[b1] - 1;
1409             --b1;
1410             while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1411               b1 += 2;
1412           }
1413           break;
1414         case twoDimVertR2:
1415           a0New = codingLine[++a0] = refLine[b1] + 2;
1416           if (refLine[b1] < columns) {
1417             ++b1;
1418             while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1419               b1 += 2;
1420           }
1421           break;
1422         case twoDimVertL2:
1423           if (a0 == 0 || refLine[b1] - 2 > a0New) {
1424             a0New = codingLine[++a0] = refLine[b1] - 2;
1425             --b1;
1426             while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1427               b1 += 2;
1428           }
1429           break;
1430         case twoDimVertR3:
1431           a0New = codingLine[++a0] = refLine[b1] + 3;
1432           if (refLine[b1] < columns) {
1433             ++b1;
1434             while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1435               b1 += 2;
1436           }
1437           break;
1438         case twoDimVertL3:
1439           if (a0 == 0 || refLine[b1] - 3 > a0New) {
1440             a0New = codingLine[++a0] = refLine[b1] - 3;
1441             --b1;
1442             while (refLine[b1] <= codingLine[a0] && refLine[b1] < columns)
1443               b1 += 2;
1444           }
1445           break;
1446         case EOF:
1447           eof = gTrue;
1448           codingLine[a0 = 0] = columns;
1449           return EOF;
1450         default:
1451           error(getPos(), "Bad 2D code %04x in CCITTFax stream", code1);
1452           err = gTrue;
1453           break;
1454         }
1455       } while (codingLine[a0] < columns);
1456
1457     // 1-D encoding
1458     } else {
1459       codingLine[a0 = 0] = 0;
1460       while (1) {
1461         code1 = 0;
1462         do {
1463           code1 += code3 = getWhiteCode();
1464         } while (code3 >= 64);
1465         codingLine[a0+1] = codingLine[a0] + code1;
1466         ++a0;
1467         if (codingLine[a0] >= columns)
1468           break;
1469         code2 = 0;
1470         do {
1471           code2 += code3 = getBlackCode();
1472         } while (code3 >= 64);
1473         codingLine[a0+1] = codingLine[a0] + code2;
1474         ++a0;
1475         if (codingLine[a0] >= columns)
1476           break;
1477       }
1478     }
1479
1480     if (codingLine[a0] != columns) {
1481       error(getPos(), "CCITTFax row is wrong length (%d)", codingLine[a0]);
1482       // force the row to be the correct length
1483       while (codingLine[a0] > columns) {
1484         --a0;
1485       }
1486       codingLine[++a0] = columns;
1487       err = gTrue;
1488     }
1489
1490     // byte-align the row
1491     if (byteAlign) {
1492       inputBits &= ~7;
1493     }
1494
1495     // check for end-of-line marker, skipping over any extra zero bits
1496     gotEOL = gFalse;
1497     if (!endOfBlock && row == rows - 1) {
1498       eof = gTrue;
1499     } else {
1500       code1 = lookBits(12);
1501       while (code1 == 0) {
1502         eatBits(1);
1503         code1 = lookBits(12);
1504       }
1505       if (code1 == 0x001) {
1506         eatBits(12);
1507         gotEOL = gTrue;
1508       } else if (code1 == EOF) {
1509         eof = gTrue;
1510       }
1511     }
1512
1513     // get 2D encoding tag
1514     if (!eof && encoding > 0) {
1515       nextLine2D = !lookBits(1);
1516       eatBits(1);
1517     }
1518
1519     // check for end-of-block marker
1520     if (endOfBlock && gotEOL) {
1521       code1 = lookBits(12);
1522       if (code1 == 0x001) {
1523         eatBits(12);
1524         if (encoding > 0) {
1525           lookBits(1);
1526           eatBits(1);
1527         }
1528         if (encoding >= 0) {
1529           for (i = 0; i < 4; ++i) {
1530             code1 = lookBits(12);
1531             if (code1 != 0x001) {
1532               error(getPos(), "Bad RTC code in CCITTFax stream");
1533             }
1534             eatBits(12);
1535             if (encoding > 0) {
1536               lookBits(1);
1537               eatBits(1);
1538             }
1539           }
1540         }
1541         eof = gTrue;
1542       }
1543
1544     // look for an end-of-line marker after an error -- we only do
1545     // this if we know the stream contains end-of-line markers because
1546     // the "just plow on" technique tends to work better otherwise
1547     } else if (err && endOfLine) {
1548       do {
1549         if (code1 == EOF) {
1550           eof = gTrue;
1551           return EOF;
1552         }
1553         eatBits(1);
1554         code1 = lookBits(13);
1555       } while ((code1 >> 1) != 0x001);
1556       eatBits(12);
1557       if (encoding > 0) {
1558         eatBits(1);
1559         nextLine2D = !(code1 & 1);
1560       }
1561     }
1562
1563     a0 = 0;
1564     outputBits = codingLine[1] - codingLine[0];
1565     if (outputBits == 0) {
1566       a0 = 1;
1567       outputBits = codingLine[2] - codingLine[1];
1568     }
1569
1570     ++row;
1571   }
1572
1573   // get a byte
1574   if (outputBits >= 8) {
1575     ret = ((a0 & 1) == 0) ? 0xff : 0x00;
1576     if ((outputBits -= 8) == 0) {
1577       ++a0;
1578       if (codingLine[a0] < columns) {
1579         outputBits = codingLine[a0 + 1] - codingLine[a0];
1580       }
1581     }
1582   } else {
1583     bits = 8;
1584     ret = 0;
1585     do {
1586       if (outputBits > bits) {
1587         i = bits;
1588         bits = 0;
1589         if ((a0 & 1) == 0) {
1590           ret |= 0xff >> (8 - i);
1591         }
1592         outputBits -= i;
1593       } else {
1594         i = outputBits;
1595         bits -= outputBits;
1596         if ((a0 & 1) == 0) {
1597           ret |= (0xff >> (8 - i)) << bits;
1598         }
1599         outputBits = 0;
1600         ++a0;
1601         if (codingLine[a0] < columns) {
1602           outputBits = codingLine[a0 + 1] - codingLine[a0];
1603         }
1604       }
1605     } while (bits > 0 && codingLine[a0] < columns);
1606   }
1607   buf = black ? (ret ^ 0xff) : ret;
1608   return buf;
1609 }
1610
1611 short CCITTFaxStream::getTwoDimCode() {
1612   short code;
1613   CCITTCode *p;
1614   int n;
1615
1616   code = 0; // make gcc happy
1617   if (endOfBlock) {
1618     code = lookBits(7);
1619     p = &twoDimTab1[code];
1620     if (p->bits > 0) {
1621       eatBits(p->bits);
1622       return p->n;
1623     }
1624   } else {
1625     for (n = 1; n <= 7; ++n) {
1626       code = lookBits(n);
1627       if (n < 7) {
1628         code <<= 7 - n;
1629       }
1630       p = &twoDimTab1[code];
1631       if (p->bits == n) {
1632         eatBits(n);
1633         return p->n;
1634       }
1635     }
1636   }
1637   error(getPos(), "Bad two dim code (%04x) in CCITTFax stream", code);
1638   return EOF;
1639 }
1640
1641 short CCITTFaxStream::getWhiteCode() {
1642   short code;
1643   CCITTCode *p;
1644   int n;
1645
1646   code = 0; // make gcc happy
1647   if (endOfBlock) {
1648     code = lookBits(12);
1649     if ((code >> 5) == 0) {
1650       p = &whiteTab1[code];
1651     } else {
1652       p = &whiteTab2[code >> 3];
1653     }
1654     if (p->bits > 0) {
1655       eatBits(p->bits);
1656       return p->n;
1657     }
1658   } else {
1659     for (n = 1; n <= 9; ++n) {
1660       code = lookBits(n);
1661       if (n < 9) {
1662         code <<= 9 - n;
1663       }
1664       p = &whiteTab2[code];
1665       if (p->bits == n) {
1666         eatBits(n);
1667         return p->n;
1668       }
1669     }
1670     for (n = 11; n <= 12; ++n) {
1671       code = lookBits(n);
1672       if (n < 12) {
1673         code <<= 12 - n;
1674       }
1675       p = &whiteTab1[code];
1676       if (p->bits == n) {
1677         eatBits(n);
1678         return p->n;
1679       }
1680     }
1681   }
1682   error(getPos(), "Bad white code (%04x) in CCITTFax stream", code);
1683   // eat a bit and return a positive number so that the caller doesn't
1684   // go into an infinite loop
1685   eatBits(1);
1686   return 1;
1687 }
1688
1689 short CCITTFaxStream::getBlackCode() {
1690   short code;
1691   CCITTCode *p;
1692   int n;
1693
1694   code = 0; // make gcc happy
1695   if (endOfBlock) {
1696     code = lookBits(13);
1697     if ((code >> 7) == 0) {
1698       p = &blackTab1[code];
1699     } else if ((code >> 9) == 0) {
1700       p = &blackTab2[(code >> 1) - 64];
1701     } else {
1702       p = &blackTab3[code >> 7];
1703     }
1704     if (p->bits > 0) {
1705       eatBits(p->bits);
1706       return p->n;
1707     }
1708   } else {
1709     for (n = 2; n <= 6; ++n) {
1710       code = lookBits(n);
1711       if (n < 6) {
1712         code <<= 6 - n;
1713       }
1714       p = &blackTab3[code];
1715       if (p->bits == n) {
1716         eatBits(n);
1717         return p->n;
1718       }
1719     }
1720     for (n = 7; n <= 12; ++n) {
1721       code = lookBits(n);
1722       if (n < 12) {
1723         code <<= 12 - n;
1724       }
1725       if (code >= 64) {
1726         p = &blackTab2[code - 64];
1727         if (p->bits == n) {
1728           eatBits(n);
1729           return p->n;
1730         }
1731       }
1732     }
1733     for (n = 10; n <= 13; ++n) {
1734       code = lookBits(n);
1735       if (n < 13) {
1736         code <<= 13 - n;
1737       }
1738       p = &blackTab1[code];
1739       if (p->bits == n) {
1740         eatBits(n);
1741         return p->n;
1742       }
1743     }
1744   }
1745   error(getPos(), "Bad black code (%04x) in CCITTFax stream", code);
1746   // eat a bit and return a positive number so that the caller doesn't
1747   // go into an infinite loop
1748   eatBits(1);
1749   return 1;
1750 }
1751
1752 short CCITTFaxStream::lookBits(int n) {
1753   int c;
1754
1755   while (inputBits < n) {
1756     if ((c = str->getChar()) == EOF) {
1757       if (inputBits == 0) {
1758         return EOF;
1759       }
1760       // near the end of the stream, the caller may ask for more bits
1761       // than are available, but there may still be a valid code in
1762       // however many bits are available -- we need to return correct
1763       // data in this case
1764       return (inputBuf << (n - inputBits)) & (0xffff >> (16 - n));
1765     }
1766     inputBuf = (inputBuf << 8) + c;
1767     inputBits += 8;
1768   }
1769   return (inputBuf >> (inputBits - n)) & (0xffff >> (16 - n));
1770 }
1771
1772 GString *CCITTFaxStream::getPSFilter(int psLevel, char *indent) {
1773   GString *s;
1774   char s1[50];
1775
1776   if (psLevel < 2) {
1777     return NULL;
1778   }
1779   if (!(s = str->getPSFilter(psLevel, indent))) {
1780     return NULL;
1781   }
1782   s->append(indent)->append("<< ");
1783   if (encoding != 0) {
1784     sprintf(s1, "/K %d ", encoding);
1785     s->append(s1);
1786   }
1787   if (endOfLine) {
1788     s->append("/EndOfLine true ");
1789   }
1790   if (byteAlign) {
1791     s->append("/EncodedByteAlign true ");
1792   }
1793   sprintf(s1, "/Columns %d ", columns);
1794   s->append(s1);
1795   if (rows != 0) {
1796     sprintf(s1, "/Rows %d ", rows);
1797     s->append(s1);
1798   }
1799   if (!endOfBlock) {
1800     s->append("/EndOfBlock false ");
1801   }
1802   if (black) {
1803     s->append("/BlackIs1 true ");
1804   }
1805   s->append(">> /CCITTFaxDecode filter\n");
1806   return s;
1807 }
1808
1809 GBool CCITTFaxStream::isBinary(GBool last) {
1810   return str->isBinary(gTrue);
1811 }
1812
1813 //------------------------------------------------------------------------
1814 // DCTStream
1815 //------------------------------------------------------------------------
1816
1817 // IDCT constants (20.12 fixed point format)
1818 #define dctCos1    4017         // cos(pi/16)
1819 #define dctSin1     799         // sin(pi/16)
1820 #define dctCos3    3406         // cos(3*pi/16)
1821 #define dctSin3    2276         // sin(3*pi/16)
1822 #define dctCos6    1567         // cos(6*pi/16)
1823 #define dctSin6    3784         // sin(6*pi/16)
1824 #define dctSqrt2   5793         // sqrt(2)
1825 #define dctSqrt1d2 2896         // sqrt(2) / 2
1826
1827 // color conversion parameters (16.16 fixed point format)
1828 #define dctCrToR   91881        //  1.4020
1829 #define dctCbToG  -22553        // -0.3441363
1830 #define dctCrToG  -46802        // -0.71413636
1831 #define dctCbToB  116130        //  1.772
1832
1833 // clip [-256,511] --> [0,255]
1834 #define dctClipOffset 256
1835 static Guchar dctClip[768];
1836 static int dctClipInit = 0;
1837
1838 // zig zag decode map
1839 static int dctZigZag[64] = {
1840    0,
1841    1,  8,
1842   16,  9,  2,
1843    3, 10, 17, 24,
1844   32, 25, 18, 11, 4,
1845    5, 12, 19, 26, 33, 40,
1846   48, 41, 34, 27, 20, 13,  6,
1847    7, 14, 21, 28, 35, 42, 49, 56,
1848   57, 50, 43, 36, 29, 22, 15,
1849   23, 30, 37, 44, 51, 58,
1850   59, 52, 45, 38, 31,
1851   39, 46, 53, 60,
1852   61, 54, 47,
1853   55, 62,
1854   63
1855 };
1856
1857 DCTStream::DCTStream(Stream *strA):
1858     FilterStream(strA) {
1859   int i, j;
1860
1861   progressive = interleaved = gFalse;
1862   width = height = 0;
1863   mcuWidth = mcuHeight = 0;
1864   numComps = 0;
1865   comp = 0;
1866   x = y = dy = 0;
1867   for (i = 0; i < 4; ++i) {
1868     for (j = 0; j < 32; ++j) {
1869       rowBuf[i][j] = NULL;
1870     }
1871     frameBuf[i] = NULL;
1872   }
1873
1874   if (!dctClipInit) {
1875     for (i = -256; i < 0; ++i)
1876       dctClip[dctClipOffset + i] = 0;
1877     for (i = 0; i < 256; ++i)
1878       dctClip[dctClipOffset + i] = i;
1879     for (i = 256; i < 512; ++i)
1880       dctClip[dctClipOffset + i] = 255;
1881     dctClipInit = 1;
1882   }
1883 }
1884
1885 DCTStream::~DCTStream() {
1886   int i, j;
1887
1888   delete str;
1889   if (progressive || !interleaved) {
1890     for (i = 0; i < numComps; ++i) {
1891       gfree(frameBuf[i]);
1892     }
1893   } else {
1894     for (i = 0; i < numComps; ++i) {
1895       for (j = 0; j < mcuHeight; ++j) {
1896         gfree(rowBuf[i][j]);
1897       }
1898     }
1899   }
1900 }
1901
1902 void DCTStream::reset() {
1903   int i, j;
1904
1905   str->reset();
1906
1907   progressive = interleaved = gFalse;
1908   width = height = 0;
1909   numComps = 0;
1910   numQuantTables = 0;
1911   numDCHuffTables = 0;
1912   numACHuffTables = 0;
1913   colorXform = 0;
1914   gotJFIFMarker = gFalse;
1915   gotAdobeMarker = gFalse;
1916   restartInterval = 0;
1917
1918   if (!readHeader()) {
1919     y = height;
1920     return;
1921   }
1922
1923   // compute MCU size
1924   if (numComps == 1) {
1925     compInfo[0].hSample = compInfo[0].vSample = 1;
1926   }
1927   mcuWidth = compInfo[0].hSample;
1928   mcuHeight = compInfo[0].vSample;
1929   for (i = 1; i < numComps; ++i) {
1930     if (compInfo[i].hSample > mcuWidth) {
1931       mcuWidth = compInfo[i].hSample;
1932     }
1933     if (compInfo[i].vSample > mcuHeight) {
1934       mcuHeight = compInfo[i].vSample;
1935     }
1936   }
1937   mcuWidth *= 8;
1938   mcuHeight *= 8;
1939
1940   // figure out color transform
1941   if (!gotAdobeMarker && numComps == 3) {
1942     if (gotJFIFMarker) {
1943       colorXform = 1;
1944     } else if (compInfo[0].id == 82 && compInfo[1].id == 71 &&
1945                compInfo[2].id == 66) { // ASCII "RGB"
1946       colorXform = 0;
1947     } else {
1948       colorXform = 1;
1949     }
1950   }
1951
1952   if (progressive || !interleaved) {
1953
1954     // allocate a buffer for the whole image
1955     bufWidth = ((width + mcuWidth - 1) / mcuWidth) * mcuWidth;
1956     bufHeight = ((height + mcuHeight - 1) / mcuHeight) * mcuHeight;
1957     for (i = 0; i < numComps; ++i) {
1958       frameBuf[i] = (int *)gmallocn(bufWidth * bufHeight, sizeof(int));
1959       memset(frameBuf[i], 0, bufWidth * bufHeight * sizeof(int));
1960     }
1961
1962     // read the image data
1963     do {
1964       restartMarker = 0xd0;
1965       restart();
1966       readScan();
1967     } while (readHeader());
1968
1969     // decode
1970     decodeImage();
1971
1972     // initialize counters
1973     comp = 0;
1974     x = 0;
1975     y = 0;
1976
1977   } else {
1978
1979     // allocate a buffer for one row of MCUs
1980     bufWidth = ((width + mcuWidth - 1) / mcuWidth) * mcuWidth;
1981     for (i = 0; i < numComps; ++i) {
1982       for (j = 0; j < mcuHeight; ++j) {
1983         rowBuf[i][j] = (Guchar *)gmallocn(bufWidth, sizeof(Guchar));
1984       }
1985     }
1986
1987     // initialize counters
1988     comp = 0;
1989     x = 0;
1990     y = 0;
1991     dy = mcuHeight;
1992
1993     restartMarker = 0xd0;
1994     restart();
1995   }
1996 }
1997
1998 int DCTStream::getChar() {
1999   int c;
2000
2001   if (y >= height) {
2002     return EOF;
2003   }
2004   if (progressive || !interleaved) {
2005     c = frameBuf[comp][y * bufWidth + x];
2006     if (++comp == numComps) {
2007       comp = 0;
2008       if (++x == width) {
2009         x = 0;
2010         ++y;
2011       }
2012     }
2013   } else {
2014     if (dy >= mcuHeight) {
2015       if (!readMCURow()) {
2016         y = height;
2017         return EOF;
2018       }
2019       comp = 0;
2020       x = 0;
2021       dy = 0;
2022     }
2023     c = rowBuf[comp][dy][x];
2024     if (++comp == numComps) {
2025       comp = 0;
2026       if (++x == width) {
2027         x = 0;
2028         ++y;
2029         ++dy;
2030         if (y == height) {
2031           readTrailer();
2032         }
2033       }
2034     }
2035   }
2036   return c;
2037 }
2038
2039 int DCTStream::lookChar() {
2040   if (y >= height) {
2041     return EOF;
2042   }
2043   if (progressive || !interleaved) {
2044     return frameBuf[comp][y * bufWidth + x];
2045   } else {
2046     if (dy >= mcuHeight) {
2047       if (!readMCURow()) {
2048         y = height;
2049         return EOF;
2050       }
2051       comp = 0;
2052       x = 0;
2053       dy = 0;
2054     }
2055     return rowBuf[comp][dy][x];
2056   }
2057 }
2058
2059 void DCTStream::restart() {
2060   int i;
2061
2062   inputBits = 0;
2063   restartCtr = restartInterval;
2064   for (i = 0; i < numComps; ++i) {
2065     compInfo[i].prevDC = 0;
2066   }
2067   eobRun = 0;
2068 }
2069
2070 // Read one row of MCUs from a sequential JPEG stream.
2071 GBool DCTStream::readMCURow() {
2072   int data1[64];
2073   Guchar data2[64];
2074   Guchar *p1, *p2;
2075   int pY, pCb, pCr, pR, pG, pB;
2076   int h, v, horiz, vert, hSub, vSub;
2077   int x1, x2, y2, x3, y3, x4, y4, x5, y5, cc, i;
2078   int c;
2079
2080   for (x1 = 0; x1 < width; x1 += mcuWidth) {
2081
2082     // deal with restart marker
2083     if (restartInterval > 0 && restartCtr == 0) {
2084       c = readMarker();
2085       if (c != restartMarker) {
2086         error(getPos(), "Bad DCT data: incorrect restart marker");
2087         return gFalse;
2088       }
2089       if (++restartMarker == 0xd8)
2090         restartMarker = 0xd0;
2091       restart();
2092     }
2093
2094     // read one MCU
2095     for (cc = 0; cc < numComps; ++cc) {
2096       h = compInfo[cc].hSample;
2097       v = compInfo[cc].vSample;
2098       horiz = mcuWidth / h;
2099       vert = mcuHeight / v;
2100       hSub = horiz / 8;
2101       vSub = vert / 8;
2102       for (y2 = 0; y2 < mcuHeight; y2 += vert) {
2103         for (x2 = 0; x2 < mcuWidth; x2 += horiz) {
2104           if (!readDataUnit(&dcHuffTables[scanInfo.dcHuffTable[cc]],
2105                             &acHuffTables[scanInfo.acHuffTable[cc]],
2106                             &compInfo[cc].prevDC,
2107                             data1)) {
2108             return gFalse;
2109           }
2110           transformDataUnit(quantTables[compInfo[cc].quantTable],
2111                             data1, data2);
2112           if (hSub == 1 && vSub == 1) {
2113             for (y3 = 0, i = 0; y3 < 8; ++y3, i += 8) {
2114               p1 = &rowBuf[cc][y2+y3][x1+x2];
2115               p1[0] = data2[i];
2116               p1[1] = data2[i+1];
2117               p1[2] = data2[i+2];
2118               p1[3] = data2[i+3];
2119               p1[4] = data2[i+4];
2120               p1[5] = data2[i+5];
2121               p1[6] = data2[i+6];
2122               p1[7] = data2[i+7];
2123             }
2124           } else if (hSub == 2 && vSub == 2) {
2125             for (y3 = 0, i = 0; y3 < 16; y3 += 2, i += 8) {
2126               p1 = &rowBuf[cc][y2+y3][x1+x2];
2127               p2 = &rowBuf[cc][y2+y3+1][x1+x2];
2128               p1[0] = p1[1] = p2[0] = p2[1] = data2[i];
2129               p1[2] = p1[3] = p2[2] = p2[3] = data2[i+1];
2130               p1[4] = p1[5] = p2[4] = p2[5] = data2[i+2];
2131               p1[6] = p1[7] = p2[6] = p2[7] = data2[i+3];
2132               p1[8] = p1[9] = p2[8] = p2[9] = data2[i+4];
2133               p1[10] = p1[11] = p2[10] = p2[11] = data2[i+5];
2134               p1[12] = p1[13] = p2[12] = p2[13] = data2[i+6];
2135               p1[14] = p1[15] = p2[14] = p2[15] = data2[i+7];
2136             }
2137           } else {
2138             i = 0;
2139             for (y3 = 0, y4 = 0; y3 < 8; ++y3, y4 += vSub) {
2140               for (x3 = 0, x4 = 0; x3 < 8; ++x3, x4 += hSub) {
2141                 for (y5 = 0; y5 < vSub; ++y5)
2142                   for (x5 = 0; x5 < hSub; ++x5)
2143                     rowBuf[cc][y2+y4+y5][x1+x2+x4+x5] = data2[i];
2144                 ++i;
2145               }
2146             }
2147           }
2148         }
2149       }
2150     }
2151     --restartCtr;
2152
2153     // color space conversion
2154     if (colorXform) {
2155       // convert YCbCr to RGB
2156       if (numComps == 3) {
2157         for (y2 = 0; y2 < mcuHeight; ++y2) {
2158           for (x2 = 0; x2 < mcuWidth; ++x2) {
2159             pY = rowBuf[0][y2][x1+x2];
2160             pCb = rowBuf[1][y2][x1+x2] - 128;
2161             pCr = rowBuf[2][y2][x1+x2] - 128;
2162             pR = ((pY << 16) + dctCrToR * pCr + 32768) >> 16;
2163             rowBuf[0][y2][x1+x2] = dctClip[dctClipOffset + pR];
2164             pG = ((pY << 16) + dctCbToG * pCb + dctCrToG * pCr + 32768) >> 16;
2165             rowBuf[1][y2][x1+x2] = dctClip[dctClipOffset + pG];
2166             pB = ((pY << 16) + dctCbToB * pCb + 32768) >> 16;
2167             rowBuf[2][y2][x1+x2] = dctClip[dctClipOffset + pB];
2168           }
2169         }
2170       // convert YCbCrK to CMYK (K is passed through unchanged)
2171       } else if (numComps == 4) {
2172         for (y2 = 0; y2 < mcuHeight; ++y2) {
2173           for (x2 = 0; x2 < mcuWidth; ++x2) {
2174             pY = rowBuf[0][y2][x1+x2];
2175             pCb = rowBuf[1][y2][x1+x2] - 128;
2176             pCr = rowBuf[2][y2][x1+x2] - 128;
2177             pR = ((pY << 16) + dctCrToR * pCr + 32768) >> 16;
2178             rowBuf[0][y2][x1+x2] = 255 - dctClip[dctClipOffset + pR];
2179             pG = ((pY << 16) + dctCbToG * pCb + dctCrToG * pCr + 32768) >> 16;
2180             rowBuf[1][y2][x1+x2] = 255 - dctClip[dctClipOffset + pG];
2181             pB = ((pY << 16) + dctCbToB * pCb + 32768) >> 16;
2182             rowBuf[2][y2][x1+x2] = 255 - dctClip[dctClipOffset + pB];
2183           }
2184         }
2185       }
2186     }
2187   }
2188   return gTrue;
2189 }
2190
2191 // Read one scan from a progressive or non-interleaved JPEG stream.
2192 void DCTStream::readScan() {
2193   int data[64];
2194   int x1, y1, dx1, dy1, x2, y2, y3, cc, i;
2195   int h, v, horiz, vert, vSub;
2196   int *p1;
2197   int c;
2198
2199   if (scanInfo.numComps == 1) {
2200     for (cc = 0; cc < numComps; ++cc) {
2201       if (scanInfo.comp[cc]) {
2202         break;
2203       }
2204     }
2205     dx1 = mcuWidth / compInfo[cc].hSample;
2206     dy1 = mcuHeight / compInfo[cc].vSample;
2207   } else {
2208     dx1 = mcuWidth;
2209     dy1 = mcuHeight;
2210   }
2211
2212   for (y1 = 0; y1 < height; y1 += dy1) {
2213     for (x1 = 0; x1 < width; x1 += dx1) {
2214
2215       // deal with restart marker
2216       if (restartInterval > 0 && restartCtr == 0) {
2217         c = readMarker();
2218         if (c != restartMarker) {
2219           error(getPos(), "Bad DCT data: incorrect restart marker");
2220           return;
2221         }
2222         if (++restartMarker == 0xd8) {
2223           restartMarker = 0xd0;
2224         }
2225         restart();
2226       }
2227
2228       // read one MCU
2229       for (cc = 0; cc < numComps; ++cc) {
2230         if (!scanInfo.comp[cc]) {
2231           continue;
2232         }
2233
2234         h = compInfo[cc].hSample;
2235         v = compInfo[cc].vSample;
2236         horiz = mcuWidth / h;
2237         vert = mcuHeight / v;
2238         vSub = vert / 8;
2239         for (y2 = 0; y2 < dy1; y2 += vert) {
2240           for (x2 = 0; x2 < dx1; x2 += horiz) {
2241
2242             // pull out the current values
2243             p1 = &frameBuf[cc][(y1+y2) * bufWidth + (x1+x2)];
2244             for (y3 = 0, i = 0; y3 < 8; ++y3, i += 8) {
2245               data[i] = p1[0];
2246               data[i+1] = p1[1];
2247               data[i+2] = p1[2];
2248               data[i+3] = p1[3];
2249               data[i+4] = p1[4];
2250               data[i+5] = p1[5];
2251               data[i+6] = p1[6];
2252               data[i+7] = p1[7];
2253               p1 += bufWidth * vSub;
2254             }
2255
2256             // read one data unit
2257             if (progressive) {
2258               if (!readProgressiveDataUnit(
2259                        &dcHuffTables[scanInfo.dcHuffTable[cc]],
2260                        &acHuffTables[scanInfo.acHuffTable[cc]],
2261                        &compInfo[cc].prevDC,
2262                        data)) {
2263                 return;
2264               }
2265             } else {
2266               if (!readDataUnit(&dcHuffTables[scanInfo.dcHuffTable[cc]],
2267                                 &acHuffTables[scanInfo.acHuffTable[cc]],
2268                                 &compInfo[cc].prevDC,
2269                                 data)) {
2270                 return;
2271               }
2272             }
2273
2274             // add the data unit into frameBuf
2275             p1 = &frameBuf[cc][(y1+y2) * bufWidth + (x1+x2)];
2276             for (y3 = 0, i = 0; y3 < 8; ++y3, i += 8) {
2277               p1[0] = data[i];
2278               p1[1] = data[i+1];
2279               p1[2] = data[i+2];
2280               p1[3] = data[i+3];
2281               p1[4] = data[i+4];
2282               p1[5] = data[i+5];
2283               p1[6] = data[i+6];
2284               p1[7] = data[i+7];
2285               p1 += bufWidth * vSub;
2286             }
2287           }
2288         }
2289       }
2290       --restartCtr;
2291     }
2292   }
2293 }
2294
2295 // Read one data unit from a sequential JPEG stream.
2296 GBool DCTStream::readDataUnit(DCTHuffTable *dcHuffTable,
2297                               DCTHuffTable *acHuffTable,
2298                               int *prevDC, int data[64]) {
2299   int run, size, amp;
2300   int c;
2301   int i, j;
2302
2303   if ((size = readHuffSym(dcHuffTable)) == 9999) {
2304     return gFalse;
2305   }
2306   if (size > 0) {
2307     if ((amp = readAmp(size)) == 9999) {
2308       return gFalse;
2309     }
2310   } else {
2311     amp = 0;
2312   }
2313   data[0] = *prevDC += amp;
2314   for (i = 1; i < 64; ++i) {
2315     data[i] = 0;
2316   }
2317   i = 1;
2318   while (i < 64) {
2319     run = 0;
2320     while ((c = readHuffSym(acHuffTable)) == 0xf0 && run < 0x30) {
2321       run += 0x10;
2322     }
2323     if (c == 9999) {
2324       return gFalse;
2325     }
2326     if (c == 0x00) {
2327       break;
2328     } else {
2329       run += (c >> 4) & 0x0f;
2330       size = c & 0x0f;
2331       amp = readAmp(size);
2332       if (amp == 9999) {
2333         return gFalse;
2334       }
2335       i += run;
2336       if (i < 64) {
2337         j = dctZigZag[i++];
2338         data[j] = amp;
2339       }
2340     }
2341   }
2342   return gTrue;
2343 }
2344
2345 // Read one data unit from a sequential JPEG stream.
2346 GBool DCTStream::readProgressiveDataUnit(DCTHuffTable *dcHuffTable,
2347                                          DCTHuffTable *acHuffTable,
2348                                          int *prevDC, int data[64]) {
2349   int run, size, amp, bit, c;
2350   int i, j, k;
2351
2352   // get the DC coefficient
2353   i = scanInfo.firstCoeff;
2354   if (i == 0) {
2355     if (scanInfo.ah == 0) {
2356       if ((size = readHuffSym(dcHuffTable)) == 9999) {
2357         return gFalse;
2358       }
2359       if (size > 0) {
2360         if ((amp = readAmp(size)) == 9999) {
2361           return gFalse;
2362         }
2363       } else {
2364         amp = 0;
2365       }
2366       data[0] += (*prevDC += amp) << scanInfo.al;
2367     } else {
2368       if ((bit = readBit()) == 9999) {
2369         return gFalse;
2370       }
2371       data[0] += bit << scanInfo.al;
2372     }
2373     ++i;
2374   }
2375   if (scanInfo.lastCoeff == 0) {
2376     return gTrue;
2377   }
2378
2379   // check for an EOB run
2380   if (eobRun > 0) {
2381     while (i <= scanInfo.lastCoeff) {
2382       j = dctZigZag[i++];
2383       if (data[j] != 0) {
2384         if ((bit = readBit()) == EOF) {
2385           return gFalse;
2386         }
2387         if (bit) {
2388           data[j] += 1 << scanInfo.al;
2389         }
2390       }
2391     }
2392     --eobRun;
2393     return gTrue;
2394   }
2395
2396   // read the AC coefficients
2397   while (i <= scanInfo.lastCoeff) {
2398     if ((c = readHuffSym(acHuffTable)) == 9999) {
2399       return gFalse;
2400     }
2401
2402     // ZRL
2403     if (c == 0xf0) {
2404       k = 0;
2405       while (k < 16) {
2406         j = dctZigZag[i++];
2407         if (data[j] == 0) {
2408           ++k;
2409         } else {
2410           if ((bit = readBit()) == EOF) {
2411             return gFalse;
2412           }
2413           if (bit) {
2414             data[j] += 1 << scanInfo.al;
2415           }
2416         }
2417       }
2418
2419     // EOB run
2420     } else if ((c & 0x0f) == 0x00) {
2421       j = c >> 4;
2422       eobRun = 0;
2423       for (k = 0; k < j; ++k) {
2424         if ((bit = readBit()) == EOF) {
2425           return gFalse;
2426         }
2427         eobRun = (eobRun << 1) | bit;
2428       }
2429       eobRun += 1 << j;
2430       while (i <= scanInfo.lastCoeff) {
2431         j = dctZigZag[i++];
2432         if (data[j] != 0) {
2433           if ((bit = readBit()) == EOF) {
2434             return gFalse;
2435           }
2436           if (bit) {
2437             data[j] += 1 << scanInfo.al;
2438           }
2439         }
2440       }
2441       --eobRun;
2442       break;
2443
2444     // zero run and one AC coefficient
2445     } else {
2446       run = (c >> 4) & 0x0f;
2447       size = c & 0x0f;
2448       if ((amp = readAmp(size)) == 9999) {
2449         return gFalse;
2450       }
2451       k = 0;
2452       do {
2453         j = dctZigZag[i++];
2454         while (data[j] != 0) {
2455           if ((bit = readBit()) == EOF) {
2456             return gFalse;
2457           }
2458           if (bit) {
2459             data[j] += 1 << scanInfo.al;
2460           }
2461           j = dctZigZag[i++];
2462         }
2463         ++k;
2464       } while (k <= run);
2465       data[j] = amp << scanInfo.al;
2466     }
2467   }
2468
2469   return gTrue;
2470 }
2471
2472 // Decode a progressive JPEG image.
2473 void DCTStream::decodeImage() {
2474   int dataIn[64];
2475   Guchar dataOut[64];
2476   Gushort *quantTable;
2477   int pY, pCb, pCr, pR, pG, pB;
2478   int x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, cc, i;
2479   int h, v, horiz, vert, hSub, vSub;
2480   int *p0, *p1, *p2;
2481
2482   for (y1 = 0; y1 < bufHeight; y1 += mcuHeight) {
2483     for (x1 = 0; x1 < bufWidth; x1 += mcuWidth) {
2484       for (cc = 0; cc < numComps; ++cc) {
2485         quantTable = quantTables[compInfo[cc].quantTable];
2486         h = compInfo[cc].hSample;
2487         v = compInfo[cc].vSample;
2488         horiz = mcuWidth / h;
2489         vert = mcuHeight / v;
2490         hSub = horiz / 8;
2491         vSub = vert / 8;
2492         for (y2 = 0; y2 < mcuHeight; y2 += vert) {
2493           for (x2 = 0; x2 < mcuWidth; x2 += horiz) {
2494
2495             // pull out the coded data unit
2496             p1 = &frameBuf[cc][(y1+y2) * bufWidth + (x1+x2)];
2497             for (y3 = 0, i = 0; y3 < 8; ++y3, i += 8) {
2498               dataIn[i]   = p1[0];
2499               dataIn[i+1] = p1[1];
2500               dataIn[i+2] = p1[2];
2501               dataIn[i+3] = p1[3];
2502               dataIn[i+4] = p1[4];
2503               dataIn[i+5] = p1[5];
2504               dataIn[i+6] = p1[6];
2505               dataIn[i+7] = p1[7];
2506               p1 += bufWidth * vSub;
2507             }
2508
2509             // transform
2510             transformDataUnit(quantTable, dataIn, dataOut);
2511
2512             // store back into frameBuf, doing replication for
2513             // subsampled components
2514             p1 = &frameBuf[cc][(y1+y2) * bufWidth + (x1+x2)];
2515             if (hSub == 1 && vSub == 1) {
2516               for (y3 = 0, i = 0; y3 < 8; ++y3, i += 8) {
2517                 p1[0] = dataOut[i] & 0xff;
2518                 p1[1] = dataOut[i+1] & 0xff;
2519                 p1[2] = dataOut[i+2] & 0xff;
2520                 p1[3] = dataOut[i+3] & 0xff;
2521                 p1[4] = dataOut[i+4] & 0xff;
2522                 p1[5] = dataOut[i+5] & 0xff;
2523                 p1[6] = dataOut[i+6] & 0xff;
2524                 p1[7] = dataOut[i+7] & 0xff;
2525                 p1 += bufWidth;
2526               }
2527             } else if (hSub == 2 && vSub == 2) {
2528               p2 = p1 + bufWidth;
2529               for (y3 = 0, i = 0; y3 < 16; y3 += 2, i += 8) {
2530                 p1[0] = p1[1] = p2[0] = p2[1] = dataOut[i] & 0xff;
2531                 p1[2] = p1[3] = p2[2] = p2[3] = dataOut[i+1] & 0xff;
2532                 p1[4] = p1[5] = p2[4] = p2[5] = dataOut[i+2] & 0xff;
2533                 p1[6] = p1[7] = p2[6] = p2[7] = dataOut[i+3] & 0xff;
2534                 p1[8] = p1[9] = p2[8] = p2[9] = dataOut[i+4] & 0xff;
2535                 p1[10] = p1[11] = p2[10] = p2[11] = dataOut[i+5] & 0xff;
2536                 p1[12] = p1[13] = p2[12] = p2[13] = dataOut[i+6] & 0xff;
2537                 p1[14] = p1[15] = p2[14] = p2[15] = dataOut[i+7] & 0xff;
2538                 p1 += bufWidth * 2;
2539                 p2 += bufWidth * 2;
2540               }
2541             } else {
2542               i = 0;
2543               for (y3 = 0, y4 = 0; y3 < 8; ++y3, y4 += vSub) {
2544                 for (x3 = 0, x4 = 0; x3 < 8; ++x3, x4 += hSub) {
2545                   p2 = p1 + x4;
2546                   for (y5 = 0; y5 < vSub; ++y5) {
2547                     for (x5 = 0; x5 < hSub; ++x5) {
2548                       p2[x5] = dataOut[i] & 0xff;
2549                     }
2550                     p2 += bufWidth;
2551                   }
2552                   ++i;
2553                 }
2554                 p1 += bufWidth * vSub;
2555               }
2556             }
2557           }
2558         }
2559       }
2560
2561       // color space conversion
2562       if (colorXform) {
2563         // convert YCbCr to RGB
2564         if (numComps == 3) {
2565           for (y2 = 0; y2 < mcuHeight; ++y2) {
2566             p0 = &frameBuf[0][(y1+y2) * bufWidth + x1];
2567             p1 = &frameBuf[1][(y1+y2) * bufWidth + x1];
2568             p2 = &frameBuf[2][(y1+y2) * bufWidth + x1];
2569             for (x2 = 0; x2 < mcuWidth; ++x2) {
2570               pY = *p0;
2571               pCb = *p1 - 128;
2572               pCr = *p2 - 128;
2573               pR = ((pY << 16) + dctCrToR * pCr + 32768) >> 16;
2574               *p0++ = dctClip[dctClipOffset + pR];
2575               pG = ((pY << 16) + dctCbToG * pCb + dctCrToG * pCr +
2576                     32768) >> 16;
2577               *p1++ = dctClip[dctClipOffset + pG];
2578               pB = ((pY << 16) + dctCbToB * pCb + 32768) >> 16;
2579               *p2++ = dctClip[dctClipOffset + pB];
2580             }
2581           }
2582         // convert YCbCrK to CMYK (K is passed through unchanged)
2583         } else if (numComps == 4) {
2584           for (y2 = 0; y2 < mcuHeight; ++y2) {
2585             p0 = &frameBuf[0][(y1+y2) * bufWidth + x1];
2586             p1 = &frameBuf[1][(y1+y2) * bufWidth + x1];
2587             p2 = &frameBuf[2][(y1+y2) * bufWidth + x1];
2588             for (x2 = 0; x2 < mcuWidth; ++x2) {
2589               pY = *p0;
2590               pCb = *p1 - 128;
2591               pCr = *p2 - 128;
2592               pR = ((pY << 16) + dctCrToR * pCr + 32768) >> 16;
2593               *p0++ = 255 - dctClip[dctClipOffset + pR];
2594               pG = ((pY << 16) + dctCbToG * pCb + dctCrToG * pCr +
2595                     32768) >> 16;
2596               *p1++ = 255 - dctClip[dctClipOffset + pG];
2597               pB = ((pY << 16) + dctCbToB * pCb + 32768) >> 16;
2598               *p2++ = 255 - dctClip[dctClipOffset + pB];
2599             }
2600           }
2601         }
2602       }
2603     }
2604   }
2605 }
2606
2607 // Transform one data unit -- this performs the dequantization and
2608 // IDCT steps.  This IDCT algorithm is taken from:
2609 //   Christoph Loeffler, Adriaan Ligtenberg, George S. Moschytz,
2610 //   "Practical Fast 1-D DCT Algorithms with 11 Multiplications",
2611 //   IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989,
2612 //   988-991.
2613 // The stage numbers mentioned in the comments refer to Figure 1 in this
2614 // paper.
2615 void DCTStream::transformDataUnit(Gushort *quantTable,
2616                                   int dataIn[64], Guchar dataOut[64]) {
2617   int v0, v1, v2, v3, v4, v5, v6, v7, t;
2618   int *p;
2619   int i;
2620
2621   // dequant
2622   for (i = 0; i < 64; ++i) {
2623     dataIn[i] *= quantTable[i];
2624   }
2625
2626   // inverse DCT on rows
2627   for (i = 0; i < 64; i += 8) {
2628     p = dataIn + i;
2629
2630     // check for all-zero AC coefficients
2631     if (p[1] == 0 && p[2] == 0 && p[3] == 0 &&
2632         p[4] == 0 && p[5] == 0 && p[6] == 0 && p[7] == 0) {
2633       t = (dctSqrt2 * p[0] + 512) >> 10;
2634       p[0] = t;
2635       p[1] = t;
2636       p[2] = t;
2637       p[3] = t;
2638       p[4] = t;
2639       p[5] = t;
2640       p[6] = t;
2641       p[7] = t;
2642       continue;
2643     }
2644
2645     // stage 4
2646     v0 = (dctSqrt2 * p[0] + 128) >> 8;
2647     v1 = (dctSqrt2 * p[4] + 128) >> 8;
2648     v2 = p[2];
2649     v3 = p[6];
2650     v4 = (dctSqrt1d2 * (p[1] - p[7]) + 128) >> 8;
2651     v7 = (dctSqrt1d2 * (p[1] + p[7]) + 128) >> 8;
2652     v5 = p[3] << 4;
2653     v6 = p[5] << 4;
2654
2655     // stage 3
2656     t = (v0 - v1+ 1) >> 1;
2657     v0 = (v0 + v1 + 1) >> 1;
2658     v1 = t;
2659     t = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8;
2660     v2 = (v2 * dctCos6 - v3 * dctSin6 + 128) >> 8;
2661     v3 = t;
2662     t = (v4 - v6 + 1) >> 1;
2663     v4 = (v4 + v6 + 1) >> 1;
2664     v6 = t;
2665     t = (v7 + v5 + 1) >> 1;
2666     v5 = (v7 - v5 + 1) >> 1;
2667     v7 = t;
2668
2669     // stage 2
2670     t = (v0 - v3 + 1) >> 1;
2671     v0 = (v0 + v3 + 1) >> 1;
2672     v3 = t;
2673     t = (v1 - v2 + 1) >> 1;
2674     v1 = (v1 + v2 + 1) >> 1;
2675     v2 = t;
2676     t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;
2677     v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;
2678     v7 = t;
2679     t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;
2680     v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;
2681     v6 = t;
2682
2683     // stage 1
2684     p[0] = v0 + v7;
2685     p[7] = v0 - v7;
2686     p[1] = v1 + v6;
2687     p[6] = v1 - v6;
2688     p[2] = v2 + v5;
2689     p[5] = v2 - v5;
2690     p[3] = v3 + v4;
2691     p[4] = v3 - v4;
2692   }
2693
2694   // inverse DCT on columns
2695   for (i = 0; i < 8; ++i) {
2696     p = dataIn + i;
2697
2698     // check for all-zero AC coefficients
2699     if (p[1*8] == 0 && p[2*8] == 0 && p[3*8] == 0 &&
2700         p[4*8] == 0 && p[5*8] == 0 && p[6*8] == 0 && p[7*8] == 0) {
2701       t = (dctSqrt2 * dataIn[i+0] + 8192) >> 14;
2702       p[0*8] = t;
2703       p[1*8] = t;
2704       p[2*8] = t;
2705       p[3*8] = t;
2706       p[4*8] = t;
2707       p[5*8] = t;
2708       p[6*8] = t;
2709       p[7*8] = t;
2710       continue;
2711     }
2712
2713     // stage 4
2714     v0 = (dctSqrt2 * p[0*8] + 2048) >> 12;
2715     v1 = (dctSqrt2 * p[4*8] + 2048) >> 12;
2716     v2 = p[2*8];
2717     v3 = p[6*8];
2718     v4 = (dctSqrt1d2 * (p[1*8] - p[7*8]) + 2048) >> 12;
2719     v7 = (dctSqrt1d2 * (p[1*8] + p[7*8]) + 2048) >> 12;
2720     v5 = p[3*8];
2721     v6 = p[5*8];
2722
2723     // stage 3
2724     t = (v0 - v1 + 1) >> 1;
2725     v0 = (v0 + v1 + 1) >> 1;
2726     v1 = t;
2727     t = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12;
2728     v2 = (v2 * dctCos6 - v3 * dctSin6 + 2048) >> 12;
2729     v3 = t;
2730     t = (v4 - v6 + 1) >> 1;
2731     v4 = (v4 + v6 + 1) >> 1;
2732     v6 = t;
2733     t = (v7 + v5 + 1) >> 1;
2734     v5 = (v7 - v5 + 1) >> 1;
2735     v7 = t;
2736
2737     // stage 2
2738     t = (v0 - v3 + 1) >> 1;
2739     v0 = (v0 + v3 + 1) >> 1;
2740     v3 = t;
2741     t = (v1 - v2 + 1) >> 1;
2742     v1 = (v1 + v2 + 1) >> 1;
2743     v2 = t;
2744     t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;
2745     v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;
2746     v7 = t;
2747     t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;
2748     v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;
2749     v6 = t;
2750
2751     // stage 1
2752     p[0*8] = v0 + v7;
2753     p[7*8] = v0 - v7;
2754     p[1*8] = v1 + v6;
2755     p[6*8] = v1 - v6;
2756     p[2*8] = v2 + v5;
2757     p[5*8] = v2 - v5;
2758     p[3*8] = v3 + v4;
2759     p[4*8] = v3 - v4;
2760   }
2761
2762   // convert to 8-bit integers
2763   for (i = 0; i < 64; ++i) {
2764     dataOut[i] = dctClip[dctClipOffset + 128 + ((dataIn[i] + 8) >> 4)];
2765   }
2766 }
2767
2768 int DCTStream::readHuffSym(DCTHuffTable *table) {
2769   Gushort code;
2770   int bit;
2771   int codeBits;
2772
2773   code = 0;
2774   codeBits = 0;
2775   do {
2776     // add a bit to the code
2777     if ((bit = readBit()) == EOF)
2778       return 9999;
2779     code = (code << 1) + bit;
2780     ++codeBits;
2781
2782     // look up code
2783     if (code - table->firstCode[codeBits] < table->numCodes[codeBits]) {
2784       code -= table->firstCode[codeBits];
2785       return table->sym[table->firstSym[codeBits] + code];
2786     }
2787   } while (codeBits < 16);
2788
2789   error(getPos(), "Bad Huffman code in DCT stream");
2790   return 9999;
2791 }
2792
2793 int DCTStream::readAmp(int size) {
2794   int amp, bit;
2795   int bits;
2796
2797   amp = 0;
2798   for (bits = 0; bits < size; ++bits) {
2799     if ((bit = readBit()) == EOF)
2800       return 9999;
2801     amp = (amp << 1) + bit;
2802   }
2803   if (amp < (1 << (size - 1)))
2804     amp -= (1 << size) - 1;
2805   return amp;
2806 }
2807
2808 int DCTStream::readBit() {
2809   int bit;
2810   int c, c2;
2811
2812   if (inputBits == 0) {
2813     if ((c = str->getChar()) == EOF)
2814       return EOF;
2815     if (c == 0xff) {
2816       do {
2817         c2 = str->getChar();
2818       } while (c2 == 0xff);
2819       if (c2 != 0x00) {
2820         error(getPos(), "Bad DCT data: missing 00 after ff");
2821         return EOF;
2822       }
2823     }
2824     inputBuf = c;
2825     inputBits = 8;
2826   }
2827   bit = (inputBuf >> (inputBits - 1)) & 1;
2828   --inputBits;
2829   return bit;
2830 }
2831
2832 GBool DCTStream::readHeader() {
2833   GBool doScan;
2834   int n;
2835   int c = 0;
2836   int i;
2837
2838   // read headers
2839   doScan = gFalse;
2840   while (!doScan) {
2841     c = readMarker();
2842     switch (c) {
2843     case 0xc0:                  // SOF0 (sequential)
2844     case 0xc1:                  // SOF1 (extended sequential)
2845       if (!readBaselineSOF()) {
2846         return gFalse;
2847       }
2848       break;
2849     case 0xc2:                  // SOF2 (progressive)
2850       if (!readProgressiveSOF()) {
2851         return gFalse;
2852       }
2853       break;
2854     case 0xc4:                  // DHT
2855       if (!readHuffmanTables()) {
2856         return gFalse;
2857       }
2858       break;
2859     case 0xd8:                  // SOI
2860       break;
2861     case 0xd9:                  // EOI
2862       return gFalse;
2863     case 0xda:                  // SOS
2864       if (!readScanInfo()) {
2865         return gFalse;
2866       }
2867       doScan = gTrue;
2868       break;
2869     case 0xdb:                  // DQT
2870       if (!readQuantTables()) {
2871         return gFalse;
2872       }
2873       break;
2874     case 0xdd:                  // DRI
2875       if (!readRestartInterval()) {
2876         return gFalse;
2877       }
2878       break;
2879     case 0xe0:                  // APP0
2880       if (!readJFIFMarker()) {
2881         return gFalse;
2882       }
2883       break;
2884     case 0xee:                  // APP14
2885       if (!readAdobeMarker()) {
2886         return gFalse;
2887       }
2888       break;
2889     case EOF:
2890       error(getPos(), "Bad DCT header");
2891       return gFalse;
2892     default:
2893       // skip APPn / COM / etc.
2894       if (c >= 0xe0) {
2895         n = read16() - 2;
2896         for (i = 0; i < n; ++i) {
2897           str->getChar();
2898         }
2899       } else {
2900         error(getPos(), "Unknown DCT marker <%02x>", c);
2901         return gFalse;
2902       }
2903       break;
2904     }
2905   }
2906
2907   return gTrue;
2908 }
2909
2910 GBool DCTStream::readBaselineSOF() {
2911   int length;
2912   int prec;
2913   int i;
2914   int c;
2915
2916   length = read16();
2917   prec = str->getChar();
2918   height = read16();
2919   width = read16();
2920   numComps = str->getChar();
2921   if (numComps <= 0 || numComps > 4) {
2922     error(getPos(), "Bad number of components in DCT stream", prec);
2923     return gFalse;
2924   }
2925   if (numComps <= 0 || numComps > 4) {
2926     error(getPos(), "Bad number of components in DCT stream", prec);
2927     return gFalse;
2928   }
2929   if (prec != 8) {
2930     error(getPos(), "Bad DCT precision %d", prec);
2931     return gFalse;
2932   }
2933   for (i = 0; i < numComps; ++i) {
2934     compInfo[i].id = str->getChar();
2935     c = str->getChar();
2936     compInfo[i].hSample = (c >> 4) & 0x0f;
2937     compInfo[i].vSample = c & 0x0f;
2938     compInfo[i].quantTable = str->getChar();
2939   }
2940   progressive = gFalse;
2941   return gTrue;
2942 }
2943
2944 GBool DCTStream::readProgressiveSOF() {
2945   int length;
2946   int prec;
2947   int i;
2948   int c;
2949
2950   length = read16();
2951   prec = str->getChar();
2952   height = read16();
2953   width = read16();
2954   numComps = str->getChar();
2955   if (prec != 8) {
2956     error(getPos(), "Bad DCT precision %d", prec);
2957     return gFalse;
2958   }
2959   for (i = 0; i < numComps; ++i) {
2960     compInfo[i].id = str->getChar();
2961     c = str->getChar();
2962     compInfo[i].hSample = (c >> 4) & 0x0f;
2963     compInfo[i].vSample = c & 0x0f;
2964     compInfo[i].quantTable = str->getChar();
2965   }
2966   progressive = gTrue;
2967   return gTrue;
2968 }
2969
2970 GBool DCTStream::readScanInfo() {
2971   int length;
2972   int id, c;
2973   int i, j;
2974
2975   length = read16() - 2;
2976   scanInfo.numComps = str->getChar();
2977   --length;
2978   if (length != 2 * scanInfo.numComps + 3) {
2979     error(getPos(), "Bad DCT scan info block");
2980     return gFalse;
2981   }
2982   interleaved = scanInfo.numComps == numComps;
2983   for (j = 0; j < numComps; ++j) {
2984     scanInfo.comp[j] = gFalse;
2985   }
2986   for (i = 0; i < scanInfo.numComps; ++i) {
2987     id = str->getChar();
2988     // some (broken) DCT streams reuse ID numbers, but at least they
2989     // keep the components in order, so we check compInfo[i] first to
2990     // work around the problem
2991     if (id == compInfo[i].id) {
2992       j = i;
2993     } else {
2994       for (j = 0; j < numComps; ++j) {
2995         if (id == compInfo[j].id) {
2996           break;
2997         }
2998       }
2999       if (j == numComps) {
3000         error(getPos(), "Bad DCT component ID in scan info block");
3001         return gFalse;
3002       }
3003     }
3004     scanInfo.comp[j] = gTrue;
3005     c = str->getChar();
3006     scanInfo.dcHuffTable[j] = (c >> 4) & 0x0f;
3007     scanInfo.acHuffTable[j] = c & 0x0f;
3008   }
3009   scanInfo.firstCoeff = str->getChar();
3010   scanInfo.lastCoeff = str->getChar();
3011   c = str->getChar();
3012   scanInfo.ah = (c >> 4) & 0x0f;
3013   scanInfo.al = c & 0x0f;
3014   return gTrue;
3015 }
3016
3017 GBool DCTStream::readQuantTables() {
3018   int length, prec, i, index;
3019
3020   length = read16() - 2;
3021   while (length > 0) {
3022     index = str->getChar();
3023     prec = (index >> 4) & 0x0f;
3024     index &= 0x0f;
3025     if (prec > 1 || index >= 4) {
3026       error(getPos(), "Bad DCT quantization table");
3027       return gFalse;
3028     }
3029     if (index == numQuantTables) {
3030       numQuantTables = index + 1;
3031     }
3032     for (i = 0; i < 64; ++i) {
3033       if (prec) {
3034         quantTables[index][dctZigZag[i]] = read16();
3035       } else {
3036         quantTables[index][dctZigZag[i]] = str->getChar();
3037       }
3038     }
3039     if (prec) {
3040       length -= 129;
3041     } else {
3042       length -= 65;
3043     }
3044   }
3045   return gTrue;
3046 }
3047
3048 GBool DCTStream::readHuffmanTables() {
3049   DCTHuffTable *tbl;
3050   int length;
3051   int index;
3052   Gushort code;
3053   Guchar sym;
3054   int i;
3055   int c;
3056
3057   length = read16() - 2;
3058   while (length > 0) {
3059     index = str->getChar();
3060     --length;
3061     if ((index & 0x0f) >= 4) {
3062       error(getPos(), "Bad DCT Huffman table");
3063       return gFalse;
3064     }
3065     if (index & 0x10) {
3066       index &= 0x0f;
3067       if (index >= numACHuffTables)
3068         numACHuffTables = index+1;
3069       tbl = &acHuffTables[index];
3070     } else {
3071       if (index >= numDCHuffTables)
3072         numDCHuffTables = index+1;
3073       tbl = &dcHuffTables[index];
3074     }
3075     sym = 0;
3076     code = 0;
3077     for (i = 1; i <= 16; ++i) {
3078       c = str->getChar();
3079       tbl->firstSym[i] = sym;
3080       tbl->firstCode[i] = code;
3081       tbl->numCodes[i] = c;
3082       sym += c;
3083       code = (code + c) << 1;
3084     }
3085     length -= 16;
3086     for (i = 0; i < sym; ++i)
3087       tbl->sym[i] = str->getChar();
3088     length -= sym;
3089   }
3090   return gTrue;
3091 }
3092
3093 GBool DCTStream::readRestartInterval() {
3094   int length;
3095
3096   length = read16();
3097   if (length != 4) {
3098     error(getPos(), "Bad DCT restart interval");
3099     return gFalse;
3100   }
3101   restartInterval = read16();
3102   return gTrue;
3103 }
3104
3105 GBool DCTStream::readJFIFMarker() {
3106   int length, i;
3107   char buf[5];
3108   int c;
3109
3110   length = read16();
3111   length -= 2;
3112   if (length >= 5) {
3113     for (i = 0; i < 5; ++i) {
3114       if ((c = str->getChar()) == EOF) {
3115         error(getPos(), "Bad DCT APP0 marker");
3116         return gFalse;
3117       }
3118       buf[i] = c;
3119     }
3120     length -= 5;
3121     if (!memcmp(buf, "JFIF\0", 5)) {
3122       gotJFIFMarker = gTrue;
3123     }
3124   }
3125   while (length > 0) {
3126     if (str->getChar() == EOF) {
3127       error(getPos(), "Bad DCT APP0 marker");
3128       return gFalse;
3129     }
3130     --length;
3131   }
3132   return gTrue;
3133 }
3134
3135 GBool DCTStream::readAdobeMarker() {
3136   int length, i;
3137   char buf[12];
3138   int c;
3139
3140   length = read16();
3141   if (length < 14) {
3142     goto err;
3143   }
3144   for (i = 0; i < 12; ++i) {
3145     if ((c = str->getChar()) == EOF) {
3146       goto err;
3147     }
3148     buf[i] = c;
3149   }
3150   if (strncmp(buf, "Adobe", 5)) {
3151     goto err;
3152   }
3153   colorXform = buf[11];
3154   gotAdobeMarker = gTrue;
3155   for (i = 14; i < length; ++i) {
3156     if (str->getChar() == EOF) {
3157       goto err;
3158     }
3159   }
3160   return gTrue;
3161
3162  err:
3163   error(getPos(), "Bad DCT Adobe APP14 marker");
3164   return gFalse;
3165 }
3166
3167 GBool DCTStream::readTrailer() {
3168   int c;
3169
3170   c = readMarker();
3171   if (c != 0xd9) {              // EOI
3172     error(getPos(), "Bad DCT trailer");
3173     return gFalse;
3174   }
3175   return gTrue;
3176 }
3177
3178 int DCTStream::readMarker() {
3179   int c;
3180
3181   do {
3182     do {
3183       c = str->getChar();
3184     } while (c != 0xff && c != EOF);
3185     do {
3186       c = str->getChar();
3187     } while (c == 0xff);
3188   } while (c == 0x00);
3189   return c;
3190 }
3191
3192 int DCTStream::read16() {
3193   int c1, c2;
3194
3195   if ((c1 = str->getChar()) == EOF)
3196     return EOF;
3197   if ((c2 = str->getChar()) == EOF)
3198     return EOF;
3199   return (c1 << 8) + c2;
3200 }
3201
3202 GString *DCTStream::getPSFilter(int psLevel, char *indent) {
3203   GString *s;
3204
3205   if (psLevel < 2) {
3206     return NULL;
3207   }
3208   if (!(s = str->getPSFilter(psLevel, indent))) {
3209     return NULL;
3210   }
3211   s->append(indent)->append("<< >> /DCTDecode filter\n");
3212   return s;
3213 }
3214
3215 GBool DCTStream::isBinary(GBool last) {
3216   return str->isBinary(gTrue);
3217 }
3218
3219 //------------------------------------------------------------------------
3220 // FlateStream
3221 //------------------------------------------------------------------------
3222
3223 int FlateStream::codeLenCodeMap[flateMaxCodeLenCodes] = {
3224   16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
3225 };
3226
3227 FlateDecode FlateStream::lengthDecode[flateMaxLitCodes-257] = {
3228   {0,   3},
3229   {0,   4},
3230   {0,   5},
3231   {0,   6},
3232   {0,   7},
3233   {0,   8},
3234   {0,   9},
3235   {0,  10},
3236   {1,  11},
3237   {1,  13},
3238   {1,  15},
3239   {1,  17},
3240   {2,  19},
3241   {2,  23},
3242   {2,  27},
3243   {2,  31},
3244   {3,  35},
3245   {3,  43},
3246   {3,  51},
3247   {3,  59},
3248   {4,  67},
3249   {4,  83},
3250   {4,  99},
3251   {4, 115},
3252   {5, 131},
3253   {5, 163},
3254   {5, 195},
3255   {5, 227},
3256   {0, 258},
3257   {0, 258},
3258   {0, 258}
3259 };
3260
3261 FlateDecode FlateStream::distDecode[flateMaxDistCodes] = {
3262   { 0,     1},
3263   { 0,     2},
3264   { 0,     3},
3265   { 0,     4},
3266   { 1,     5},
3267   { 1,     7},
3268   { 2,     9},
3269   { 2,    13},
3270   { 3,    17},
3271   { 3,    25},
3272   { 4,    33},
3273   { 4,    49},
3274   { 5,    65},
3275   { 5,    97},
3276   { 6,   129},
3277   { 6,   193},
3278   { 7,   257},
3279   { 7,   385},
3280   { 8,   513},
3281   { 8,   769},
3282   { 9,  1025},
3283   { 9,  1537},
3284   {10,  2049},
3285   {10,  3073},
3286   {11,  4097},
3287   {11,  6145},
3288   {12,  8193},
3289   {12, 12289},
3290   {13, 16385},
3291   {13, 24577}
3292 };
3293
3294 static FlateCode flateFixedLitCodeTabCodes[512] = {
3295   {7, 0x0100},
3296   {8, 0x0050},
3297   {8, 0x0010},
3298   {8, 0x0118},
3299   {7, 0x0110},
3300   {8, 0x0070},
3301   {8, 0x0030},
3302   {9, 0x00c0},
3303   {7, 0x0108},
3304   {8, 0x0060},
3305   {8, 0x0020},
3306   {9, 0x00a0},
3307   {8, 0x0000},
3308   {8, 0x0080},
3309   {8, 0x0040},
3310   {9, 0x00e0},
3311   {7, 0x0104},
3312   {8, 0x0058},
3313   {8, 0x0018},
3314   {9, 0x0090},
3315   {7, 0x0114},
3316   {8, 0x0078},
3317   {8, 0x0038},
3318   {9, 0x00d0},
3319   {7, 0x010c},
3320   {8, 0x0068},
3321   {8, 0x0028},
3322   {9, 0x00b0},
3323   {8, 0x0008},
3324   {8, 0x0088},
3325   {8, 0x0048},
3326   {9, 0x00f0},
3327   {7, 0x0102},
3328   {8, 0x0054},
3329   {8, 0x0014},
3330   {8, 0x011c},
3331   {7, 0x0112},
3332   {8, 0x0074},
3333   {8, 0x0034},
3334   {9, 0x00c8},
3335   {7, 0x010a},
3336   {8, 0x0064},
3337   {8, 0x0024},
3338   {9, 0x00a8},
3339   {8, 0x0004},
3340   {8, 0x0084},
3341   {8, 0x0044},
3342   {9, 0x00e8},
3343   {7, 0x0106},
3344   {8, 0x005c},
3345   {8, 0x001c},
3346   {9, 0x0098},
3347   {7, 0x0116},
3348   {8, 0x007c},
3349   {8, 0x003c},
3350   {9, 0x00d8},
3351   {7, 0x010e},
3352   {8, 0x006c},
3353   {8, 0x002c},
3354   {9, 0x00b8},
3355   {8, 0x000c},
3356   {8, 0x008c},
3357   {8, 0x004c},
3358   {9, 0x00f8},
3359   {7, 0x0101},
3360   {8, 0x0052},
3361   {8, 0x0012},
3362   {8, 0x011a},
3363   {7, 0x0111},
3364   {8, 0x0072},
3365   {8, 0x0032},
3366   {9, 0x00c4},
3367   {7, 0x0109},
3368   {8, 0x0062},
3369   {8, 0x0022},
3370   {9, 0x00a4},
3371   {8, 0x0002},
3372   {8, 0x0082},
3373   {8, 0x0042},
3374   {9, 0x00e4},
3375   {7, 0x0105},
3376   {8, 0x005a},
3377   {8, 0x001a},
3378   {9, 0x0094},
3379   {7, 0x0115},
3380   {8, 0x007a},
3381   {8, 0x003a},
3382   {9, 0x00d4},
3383   {7, 0x010d},
3384   {8, 0x006a},
3385   {8, 0x002a},
3386   {9, 0x00b4},
3387   {8, 0x000a},
3388   {8, 0x008a},
3389   {8, 0x004a},
3390   {9, 0x00f4},
3391   {7, 0x0103},
3392   {8, 0x0056},
3393   {8, 0x0016},
3394   {8, 0x011e},
3395   {7, 0x0113},
3396   {8, 0x0076},
3397   {8, 0x0036},
3398   {9, 0x00cc},
3399   {7, 0x010b},
3400   {8, 0x0066},
3401   {8, 0x0026},
3402   {9, 0x00ac},
3403   {8, 0x0006},
3404   {8, 0x0086},
3405   {8, 0x0046},
3406   {9, 0x00ec},
3407   {7, 0x0107},
3408   {8, 0x005e},
3409   {8, 0x001e},
3410   {9, 0x009c},
3411   {7, 0x0117},
3412   {8, 0x007e},
3413   {8, 0x003e},
3414   {9, 0x00dc},
3415   {7, 0x010f},
3416   {8, 0x006e},
3417   {8, 0x002e},
3418   {9, 0x00bc},
3419   {8, 0x000e},
3420   {8, 0x008e},
3421   {8, 0x004e},
3422   {9, 0x00fc},
3423   {7, 0x0100},
3424   {8, 0x0051},
3425   {8, 0x0011},
3426   {8, 0x0119},
3427   {7, 0x0110},
3428   {8, 0x0071},
3429   {8, 0x0031},
3430   {9, 0x00c2},
3431   {7, 0x0108},
3432   {8, 0x0061},
3433   {8, 0x0021},
3434   {9, 0x00a2},
3435   {8, 0x0001},
3436   {8, 0x0081},
3437   {8, 0x0041},
3438   {9, 0x00e2},
3439   {7, 0x0104},
3440   {8, 0x0059},
3441   {8, 0x0019},
3442   {9, 0x0092},
3443   {7, 0x0114},
3444   {8, 0x0079},
3445   {8, 0x0039},
3446   {9, 0x00d2},
3447   {7, 0x010c},
3448   {8, 0x0069},
3449   {8, 0x0029},
3450   {9, 0x00b2},
3451   {8, 0x0009},
3452   {8, 0x0089},
3453   {8, 0x0049},
3454   {9, 0x00f2},
3455   {7, 0x0102},
3456   {8, 0x0055},
3457   {8, 0x0015},
3458   {8, 0x011d},
3459   {7, 0x0112},
3460   {8, 0x0075},
3461   {8, 0x0035},
3462   {9, 0x00ca},
3463   {7, 0x010a},
3464   {8, 0x0065},
3465   {8, 0x0025},
3466   {9, 0x00aa},
3467   {8, 0x0005},
3468   {8, 0x0085},
3469   {8, 0x0045},
3470   {9, 0x00ea},
3471   {7, 0x0106},
3472   {8, 0x005d},
3473   {8, 0x001d},
3474   {9, 0x009a},
3475   {7, 0x0116},
3476   {8, 0x007d},
3477   {8, 0x003d},
3478   {9, 0x00da},
3479   {7, 0x010e},
3480   {8, 0x006d},
3481   {8, 0x002d},
3482   {9, 0x00ba},
3483   {8, 0x000d},
3484   {8, 0x008d},
3485   {8, 0x004d},
3486   {9, 0x00fa},
3487   {7, 0x0101},
3488   {8, 0x0053},
3489   {8, 0x0013},
3490   {8, 0x011b},
3491   {7, 0x0111},
3492   {8, 0x0073},
3493   {8, 0x0033},
3494   {9, 0x00c6},
3495   {7, 0x0109},
3496   {8, 0x0063},
3497   {8, 0x0023},
3498   {9, 0x00a6},
3499   {8, 0x0003},
3500   {8, 0x0083},
3501   {8, 0x0043},
3502   {9, 0x00e6},
3503   {7, 0x0105},
3504   {8, 0x005b},
3505   {8, 0x001b},
3506   {9, 0x0096},
3507   {7, 0x0115},
3508   {8, 0x007b},
3509   {8, 0x003b},
3510   {9, 0x00d6},
3511   {7, 0x010d},
3512   {8, 0x006b},
3513   {8, 0x002b},
3514   {9, 0x00b6},
3515   {8, 0x000b},
3516   {8, 0x008b},
3517   {8, 0x004b},
3518   {9, 0x00f6},
3519   {7, 0x0103},
3520   {8, 0x0057},
3521   {8, 0x0017},
3522   {8, 0x011f},
3523   {7, 0x0113},
3524   {8, 0x0077},
3525   {8, 0x0037},
3526   {9, 0x00ce},
3527   {7, 0x010b},
3528   {8, 0x0067},
3529   {8, 0x0027},
3530   {9, 0x00ae},
3531   {8, 0x0007},
3532   {8, 0x0087},
3533   {8, 0x0047},
3534   {9, 0x00ee},
3535   {7, 0x0107},
3536   {8, 0x005f},
3537   {8, 0x001f},
3538   {9, 0x009e},
3539   {7, 0x0117},
3540   {8, 0x007f},
3541   {8, 0x003f},
3542   {9, 0x00de},
3543   {7, 0x010f},
3544   {8, 0x006f},
3545   {8, 0x002f},
3546   {9, 0x00be},
3547   {8, 0x000f},
3548   {8, 0x008f},
3549   {8, 0x004f},
3550   {9, 0x00fe},
3551   {7, 0x0100},
3552   {8, 0x0050},
3553   {8, 0x0010},
3554   {8, 0x0118},
3555   {7, 0x0110},
3556   {8, 0x0070},
3557   {8, 0x0030},
3558   {9, 0x00c1},
3559   {7, 0x0108},
3560   {8, 0x0060},
3561   {8, 0x0020},
3562   {9, 0x00a1},
3563   {8, 0x0000},
3564   {8, 0x0080},
3565   {8, 0x0040},
3566   {9, 0x00e1},
3567   {7, 0x0104},
3568   {8, 0x0058},
3569   {8, 0x0018},
3570   {9, 0x0091},
3571   {7, 0x0114},
3572   {8, 0x0078},
3573   {8, 0x0038},
3574   {9, 0x00d1},
3575   {7, 0x010c},
3576   {8, 0x0068},
3577   {8, 0x0028},
3578   {9, 0x00b1},
3579   {8, 0x0008},
3580   {8, 0x0088},
3581   {8, 0x0048},
3582   {9, 0x00f1},
3583   {7, 0x0102},
3584   {8, 0x0054},
3585   {8, 0x0014},
3586   {8, 0x011c},
3587   {7, 0x0112},
3588   {8, 0x0074},
3589   {8, 0x0034},
3590   {9, 0x00c9},
3591   {7, 0x010a},
3592   {8, 0x0064},
3593   {8, 0x0024},
3594   {9, 0x00a9},
3595   {8, 0x0004},
3596   {8, 0x0084},
3597   {8, 0x0044},
3598   {9, 0x00e9},
3599   {7, 0x0106},
3600   {8, 0x005c},
3601   {8, 0x001c},
3602   {9, 0x0099},
3603   {7, 0x0116},
3604   {8, 0x007c},
3605   {8, 0x003c},
3606   {9, 0x00d9},
3607   {7, 0x010e},
3608   {8, 0x006c},
3609   {8, 0x002c},
3610   {9, 0x00b9},
3611   {8, 0x000c},
3612   {8, 0x008c},
3613   {8, 0x004c},
3614   {9, 0x00f9},
3615   {7, 0x0101},
3616   {8, 0x0052},
3617   {8, 0x0012},
3618   {8, 0x011a},
3619   {7, 0x0111},
3620   {8, 0x0072},
3621   {8, 0x0032},
3622   {9, 0x00c5},
3623   {7, 0x0109},
3624   {8, 0x0062},
3625   {8, 0x0022},
3626   {9, 0x00a5},
3627   {8, 0x0002},
3628   {8, 0x0082},
3629   {8, 0x0042},
3630   {9, 0x00e5},
3631   {7, 0x0105},
3632   {8, 0x005a},
3633   {8, 0x001a},
3634   {9, 0x0095},
3635   {7, 0x0115},
3636   {8, 0x007a},
3637   {8, 0x003a},
3638   {9, 0x00d5},
3639   {7, 0x010d},
3640   {8, 0x006a},
3641   {8, 0x002a},
3642   {9, 0x00b5},
3643   {8, 0x000a},
3644   {8, 0x008a},
3645   {8, 0x004a},
3646   {9, 0x00f5},
3647   {7, 0x0103},
3648   {8, 0x0056},
3649   {8, 0x0016},
3650   {8, 0x011e},
3651   {7, 0x0113},
3652   {8, 0x0076},
3653   {8, 0x0036},
3654   {9, 0x00cd},
3655   {7, 0x010b},
3656   {8, 0x0066},
3657   {8, 0x0026},
3658   {9, 0x00ad},
3659   {8, 0x0006},
3660   {8, 0x0086},
3661   {8, 0x0046},
3662   {9, 0x00ed},
3663   {7, 0x0107},
3664   {8, 0x005e},
3665   {8, 0x001e},
3666   {9, 0x009d},
3667   {7, 0x0117},
3668   {8, 0x007e},
3669   {8, 0x003e},
3670   {9, 0x00dd},
3671   {7, 0x010f},
3672   {8, 0x006e},
3673   {8, 0x002e},
3674   {9, 0x00bd},
3675   {8, 0x000e},
3676   {8, 0x008e},
3677   {8, 0x004e},
3678   {9, 0x00fd},
3679   {7, 0x0100},
3680   {8, 0x0051},
3681   {8, 0x0011},
3682   {8, 0x0119},
3683   {7, 0x0110},
3684   {8, 0x0071},
3685   {8, 0x0031},
3686   {9, 0x00c3},
3687   {7, 0x0108},
3688   {8, 0x0061},
3689   {8, 0x0021},
3690   {9, 0x00a3},
3691   {8, 0x0001},
3692   {8, 0x0081},
3693   {8, 0x0041},
3694   {9, 0x00e3},
3695   {7, 0x0104},
3696   {8, 0x0059},
3697   {8, 0x0019},
3698   {9, 0x0093},
3699   {7, 0x0114},
3700   {8, 0x0079},
3701   {8, 0x0039},
3702   {9, 0x00d3},
3703   {7, 0x010c},
3704   {8, 0x0069},
3705   {8, 0x0029},
3706   {9, 0x00b3},
3707   {8, 0x0009},
3708   {8, 0x0089},
3709   {8, 0x0049},
3710   {9, 0x00f3},
3711   {7, 0x0102},
3712   {8, 0x0055},
3713   {8, 0x0015},
3714   {8, 0x011d},
3715   {7, 0x0112},
3716   {8, 0x0075},
3717   {8, 0x0035},
3718   {9, 0x00cb},
3719   {7, 0x010a},
3720   {8, 0x0065},
3721   {8, 0x0025},
3722   {9, 0x00ab},
3723   {8, 0x0005},
3724   {8, 0x0085},
3725   {8, 0x0045},
3726   {9, 0x00eb},
3727   {7, 0x0106},
3728   {8, 0x005d},
3729   {8, 0x001d},
3730   {9, 0x009b},
3731   {7, 0x0116},
3732   {8, 0x007d},
3733   {8, 0x003d},
3734   {9, 0x00db},
3735   {7, 0x010e},
3736   {8, 0x006d},
3737   {8, 0x002d},
3738   {9, 0x00bb},
3739   {8, 0x000d},
3740   {8, 0x008d},
3741   {8, 0x004d},
3742   {9, 0x00fb},
3743   {7, 0x0101},
3744   {8, 0x0053},
3745   {8, 0x0013},
3746   {8, 0x011b},
3747   {7, 0x0111},
3748   {8, 0x0073},
3749   {8, 0x0033},
3750   {9, 0x00c7},
3751   {7, 0x0109},
3752   {8, 0x0063},
3753   {8, 0x0023},
3754   {9, 0x00a7},
3755   {8, 0x0003},
3756   {8, 0x0083},
3757   {8, 0x0043},
3758   {9, 0x00e7},
3759   {7, 0x0105},
3760   {8, 0x005b},
3761   {8, 0x001b},
3762   {9, 0x0097},
3763   {7, 0x0115},
3764   {8, 0x007b},
3765   {8, 0x003b},
3766   {9, 0x00d7},
3767   {7, 0x010d},
3768   {8, 0x006b},
3769   {8, 0x002b},
3770   {9, 0x00b7},
3771   {8, 0x000b},
3772   {8, 0x008b},
3773   {8, 0x004b},
3774   {9, 0x00f7},
3775   {7, 0x0103},
3776   {8, 0x0057},
3777   {8, 0x0017},
3778   {8, 0x011f},
3779   {7, 0x0113},
3780   {8, 0x0077},
3781   {8, 0x0037},
3782   {9, 0x00cf},
3783   {7, 0x010b},
3784   {8, 0x0067},
3785   {8, 0x0027},
3786   {9, 0x00af},
3787   {8, 0x0007},
3788   {8, 0x0087},
3789   {8, 0x0047},
3790   {9, 0x00ef},
3791   {7, 0x0107},
3792   {8, 0x005f},
3793   {8, 0x001f},
3794   {9, 0x009f},
3795   {7, 0x0117},
3796   {8, 0x007f},
3797   {8, 0x003f},
3798   {9, 0x00df},
3799   {7, 0x010f},
3800   {8, 0x006f},
3801   {8, 0x002f},
3802   {9, 0x00bf},
3803   {8, 0x000f},
3804   {8, 0x008f},
3805   {8, 0x004f},
3806   {9, 0x00ff}
3807 };
3808
3809 FlateHuffmanTab FlateStream::fixedLitCodeTab = {
3810   flateFixedLitCodeTabCodes, 9
3811 };
3812
3813 static FlateCode flateFixedDistCodeTabCodes[32] = {
3814   {5, 0x0000},
3815   {5, 0x0010},
3816   {5, 0x0008},
3817   {5, 0x0018},
3818   {5, 0x0004},
3819   {5, 0x0014},
3820   {5, 0x000c},
3821   {5, 0x001c},
3822   {5, 0x0002},
3823   {5, 0x0012},
3824   {5, 0x000a},
3825   {5, 0x001a},
3826   {5, 0x0006},
3827   {5, 0x0016},
3828   {5, 0x000e},
3829   {0, 0x0000},
3830   {5, 0x0001},
3831   {5, 0x0011},
3832   {5, 0x0009},
3833   {5, 0x0019},
3834   {5, 0x0005},
3835   {5, 0x0015},
3836   {5, 0x000d},
3837   {5, 0x001d},
3838   {5, 0x0003},
3839   {5, 0x0013},
3840   {5, 0x000b},
3841   {5, 0x001b},
3842   {5, 0x0007},
3843   {5, 0x0017},
3844   {5, 0x000f},
3845   {0, 0x0000}
3846 };
3847
3848 FlateHuffmanTab FlateStream::fixedDistCodeTab = {
3849   flateFixedDistCodeTabCodes, 5
3850 };
3851
3852 FlateStream::FlateStream(Stream *strA, int predictor, int columns,
3853                          int colors, int bits):
3854     FilterStream(strA) {
3855   if (predictor != 1) {
3856     pred = new StreamPredictor(this, predictor, columns, colors, bits);
3857     if (!pred->isOk()) {
3858       delete pred;
3859       pred = NULL;
3860     }
3861   } else {
3862     pred = NULL;
3863   }
3864   litCodeTab.codes = NULL;
3865   distCodeTab.codes = NULL;
3866 }
3867
3868 FlateStream::~FlateStream() {
3869   if (litCodeTab.codes != fixedLitCodeTab.codes) {
3870     gfree(litCodeTab.codes);
3871   }
3872   if (distCodeTab.codes != fixedDistCodeTab.codes) {
3873     gfree(distCodeTab.codes);
3874   }
3875   if (pred) {
3876     delete pred;
3877   }
3878   delete str;
3879 }
3880
3881 void FlateStream::reset() {
3882   int cmf, flg;
3883
3884   index = 0;
3885   remain = 0;
3886   codeBuf = 0;
3887   codeSize = 0;
3888   compressedBlock = gFalse;
3889   endOfBlock = gTrue;
3890   eof = gTrue;
3891
3892   str->reset();
3893
3894   // read header
3895   //~ need to look at window size?
3896   endOfBlock = eof = gTrue;
3897   cmf = str->getChar();
3898   flg = str->getChar();
3899   if (cmf == EOF || flg == EOF)
3900     return;
3901   if ((cmf & 0x0f) != 0x08) {
3902     error(getPos(), "Unknown compression method in flate stream");
3903     return;
3904   }
3905   if ((((cmf << 8) + flg) % 31) != 0) {
3906     error(getPos(), "Bad FCHECK in flate stream");
3907     return;
3908   }
3909   if (flg & 0x20) {
3910     error(getPos(), "FDICT bit set in flate stream");
3911     return;
3912   }
3913
3914   eof = gFalse;
3915 }
3916
3917 int FlateStream::getChar() {
3918   int c;
3919
3920   if (pred) {
3921     return pred->getChar();
3922   }
3923   while (remain == 0) {
3924     if (endOfBlock && eof)
3925       return EOF;
3926     readSome();
3927   }
3928   c = buf[index];
3929   index = (index + 1) & flateMask;
3930   --remain;
3931   return c;
3932 }
3933
3934 int FlateStream::lookChar() {
3935   int c;
3936
3937   if (pred) {
3938     return pred->lookChar();
3939   }
3940   while (remain == 0) {
3941     if (endOfBlock && eof)
3942       return EOF;
3943     readSome();
3944   }
3945   c = buf[index];
3946   return c;
3947 }
3948
3949 int FlateStream::getRawChar() {
3950   int c;
3951
3952   while (remain == 0) {
3953     if (endOfBlock && eof)
3954       return EOF;
3955     readSome();
3956   }
3957   c = buf[index];
3958   index = (index + 1) & flateMask;
3959   --remain;
3960   return c;
3961 }
3962
3963 GString *FlateStream::getPSFilter(int psLevel, char *indent) {
3964   GString *s;
3965
3966   if (psLevel < 3 || pred) {
3967     return NULL;
3968   }
3969   if (!(s = str->getPSFilter(psLevel, indent))) {
3970     return NULL;
3971   }
3972   s->append(indent)->append("<< >> /FlateDecode filter\n");
3973   return s;
3974 }
3975
3976 GBool FlateStream::isBinary(GBool last) {
3977   return str->isBinary(gTrue);
3978 }
3979
3980 void FlateStream::readSome() {
3981   int code1, code2;
3982   int len, dist;
3983   int i, j, k;
3984   int c;
3985
3986   if (endOfBlock) {
3987     if (!startBlock())
3988       return;
3989   }
3990
3991   if (compressedBlock) {
3992     if ((code1 = getHuffmanCodeWord(&litCodeTab)) == EOF)
3993       goto err;
3994     if (code1 < 256) {
3995       buf[index] = code1;
3996       remain = 1;
3997     } else if (code1 == 256) {
3998       endOfBlock = gTrue;
3999       remain = 0;
4000     } else {
4001       code1 -= 257;
4002       code2 = lengthDecode[code1].bits;
4003       if (code2 > 0 && (code2 = getCodeWord(code2)) == EOF)
4004         goto err;
4005       len = lengthDecode[code1].first + code2;
4006       if ((code1 = getHuffmanCodeWord(&distCodeTab)) == EOF)
4007         goto err;
4008       code2 = distDecode[code1].bits;
4009       if (code2 > 0 && (code2 = getCodeWord(code2)) == EOF)
4010         goto err;
4011       dist = distDecode[code1].first + code2;
4012       i = index;
4013       j = (index - dist) & flateMask;
4014       for (k = 0; k < len; ++k) {
4015         buf[i] = buf[j];
4016         i = (i + 1) & flateMask;
4017         j = (j + 1) & flateMask;
4018       }
4019       remain = len;
4020     }
4021
4022   } else {
4023     len = (blockLen < flateWindow) ? blockLen : flateWindow;
4024     for (i = 0, j = index; i < len; ++i, j = (j + 1) & flateMask) {
4025       if ((c = str->getChar()) == EOF) {
4026         endOfBlock = eof = gTrue;
4027         break;
4028       }
4029       buf[j] = c & 0xff;
4030     }
4031     remain = i;
4032     blockLen -= len;
4033     if (blockLen == 0)
4034       endOfBlock = gTrue;
4035   }
4036
4037   return;
4038
4039 err:
4040   error(getPos(), "Unexpected end of file in flate stream");
4041   endOfBlock = eof = gTrue;
4042   remain = 0;
4043 }
4044
4045 GBool FlateStream::startBlock() {
4046   int blockHdr;
4047   int c;
4048   int check;
4049
4050   // free the code tables from the previous block
4051   if (litCodeTab.codes != fixedLitCodeTab.codes) {
4052     gfree(litCodeTab.codes);
4053   }
4054   litCodeTab.codes = NULL;
4055   if (distCodeTab.codes != fixedDistCodeTab.codes) {
4056     gfree(distCodeTab.codes);
4057   }
4058   distCodeTab.codes = NULL;
4059
4060   // read block header
4061   blockHdr = getCodeWord(3);
4062   if (blockHdr & 1)
4063     eof = gTrue;
4064   blockHdr >>= 1;
4065
4066   // uncompressed block
4067   if (blockHdr == 0) {
4068     compressedBlock = gFalse;
4069     if ((c = str->getChar()) == EOF)
4070       goto err;
4071     blockLen = c & 0xff;
4072     if ((c = str->getChar()) == EOF)
4073       goto err;
4074     blockLen |= (c & 0xff) << 8;
4075     if ((c = str->getChar()) == EOF)
4076       goto err;
4077     check = c & 0xff;
4078     if ((c = str->getChar()) == EOF)
4079       goto err;
4080     check |= (c & 0xff) << 8;
4081     if (check != (~blockLen & 0xffff))
4082       error(getPos(), "Bad uncompressed block length in flate stream");
4083     codeBuf = 0;
4084     codeSize = 0;
4085
4086   // compressed block with fixed codes
4087   } else if (blockHdr == 1) {
4088     compressedBlock = gTrue;
4089     loadFixedCodes();
4090
4091   // compressed block with dynamic codes
4092   } else if (blockHdr == 2) {
4093     compressedBlock = gTrue;
4094     if (!readDynamicCodes()) {
4095       goto err;
4096     }
4097
4098   // unknown block type
4099   } else {
4100     goto err;
4101   }
4102
4103   endOfBlock = gFalse;
4104   return gTrue;
4105
4106 err:
4107   error(getPos(), "Bad block header in flate stream");
4108   endOfBlock = eof = gTrue;
4109   return gFalse;
4110 }
4111
4112 void FlateStream::loadFixedCodes() {
4113   litCodeTab.codes = fixedLitCodeTab.codes;
4114   litCodeTab.maxLen = fixedLitCodeTab.maxLen;
4115   distCodeTab.codes = fixedDistCodeTab.codes;
4116   distCodeTab.maxLen = fixedDistCodeTab.maxLen;
4117 }
4118
4119 GBool FlateStream::readDynamicCodes() {
4120   int numCodeLenCodes;
4121   int numLitCodes;
4122   int numDistCodes;
4123   int codeLenCodeLengths[flateMaxCodeLenCodes];
4124   FlateHuffmanTab codeLenCodeTab;
4125   int len, repeat, code;
4126   int i;
4127
4128   codeLenCodeTab.codes = NULL;
4129
4130   // read lengths
4131   if ((numLitCodes = getCodeWord(5)) == EOF) {
4132     goto err;
4133   }
4134   numLitCodes += 257;
4135   if ((numDistCodes = getCodeWord(5)) == EOF) {
4136     goto err;
4137   }
4138   numDistCodes += 1;
4139   if ((numCodeLenCodes = getCodeWord(4)) == EOF) {
4140     goto err;
4141   }
4142   numCodeLenCodes += 4;
4143   if (numLitCodes > flateMaxLitCodes ||
4144       numDistCodes > flateMaxDistCodes ||
4145       numCodeLenCodes > flateMaxCodeLenCodes) {
4146     goto err;
4147   }
4148
4149   // build the code length code table
4150   for (i = 0; i < flateMaxCodeLenCodes; ++i) {
4151     codeLenCodeLengths[i] = 0;
4152   }
4153   for (i = 0; i < numCodeLenCodes; ++i) {
4154     if ((codeLenCodeLengths[codeLenCodeMap[i]] = getCodeWord(3)) == -1) {
4155       goto err;
4156     }
4157   }
4158   compHuffmanCodes(codeLenCodeLengths, flateMaxCodeLenCodes, &codeLenCodeTab);
4159
4160   // build the literal and distance code tables
4161   len = 0;
4162   repeat = 0;
4163   i = 0;
4164   while (i < numLitCodes + numDistCodes) {
4165     if ((code = getHuffmanCodeWord(&codeLenCodeTab)) == EOF) {
4166       goto err;
4167     }
4168     if (code == 16) {
4169       if ((repeat = getCodeWord(2)) == EOF) {
4170         goto err;
4171       }
4172       repeat += 3;
4173       if (i + repeat > numLitCodes + numDistCodes) {
4174         goto err;
4175       }
4176       for (; repeat > 0; --repeat) {
4177         codeLengths[i++] = len;
4178       }
4179     } else if (code == 17) {
4180       if ((repeat = getCodeWord(3)) == EOF) {
4181         goto err;
4182       }
4183       repeat += 3;
4184       if (i + repeat > numLitCodes + numDistCodes) {
4185         goto err;
4186       }
4187       len = 0;
4188       for (; repeat > 0; --repeat) {
4189         codeLengths[i++] = 0;
4190       }
4191     } else if (code == 18) {
4192       if ((repeat = getCodeWord(7)) == EOF) {
4193         goto err;
4194       }
4195       repeat += 11;
4196       if (i + repeat > numLitCodes + numDistCodes) {
4197         goto err;
4198       }
4199       len = 0;
4200       for (; repeat > 0; --repeat) {
4201         codeLengths[i++] = 0;
4202       }
4203     } else {
4204       codeLengths[i++] = len = code;
4205     }
4206   }
4207   compHuffmanCodes(codeLengths, numLitCodes, &litCodeTab);
4208   compHuffmanCodes(codeLengths + numLitCodes, numDistCodes, &distCodeTab);
4209
4210   gfree(codeLenCodeTab.codes);
4211   return gTrue;
4212
4213 err:
4214   error(getPos(), "Bad dynamic code table in flate stream");
4215   gfree(codeLenCodeTab.codes);
4216   return gFalse;
4217 }
4218
4219 // Convert an array <lengths> of <n> lengths, in value order, into a
4220 // Huffman code lookup table.
4221 void FlateStream::compHuffmanCodes(int *lengths, int n, FlateHuffmanTab *tab) {
4222   int tabSize, len, code, code2, skip, val, i, t;
4223
4224   // find max code length
4225   tab->maxLen = 0;
4226   for (val = 0; val < n; ++val) {
4227     if (lengths[val] > tab->maxLen) {
4228       tab->maxLen = lengths[val];
4229     }
4230   }
4231
4232   // allocate the table
4233   tabSize = 1 << tab->maxLen;
4234   tab->codes = (FlateCode *)gmallocn(tabSize, sizeof(FlateCode));
4235
4236   // clear the table
4237   for (i = 0; i < tabSize; ++i) {
4238     tab->codes[i].len = 0;
4239     tab->codes[i].val = 0;
4240   }
4241
4242   // build the table
4243   for (len = 1, code = 0, skip = 2;
4244        len <= tab->maxLen;
4245        ++len, code <<= 1, skip <<= 1) {
4246     for (val = 0; val < n; ++val) {
4247       if (lengths[val] == len) {
4248
4249         // bit-reverse the code
4250         code2 = 0;
4251         t = code;
4252         for (i = 0; i < len; ++i) {
4253           code2 = (code2 << 1) | (t & 1);
4254           t >>= 1;
4255         }
4256
4257         // fill in the table entries
4258         for (i = code2; i < tabSize; i += skip) {
4259           tab->codes[i].len = (Gushort)len;
4260           tab->codes[i].val = (Gushort)val;
4261         }
4262
4263         ++code;
4264       }
4265     }
4266   }
4267 }
4268
4269 int FlateStream::getHuffmanCodeWord(FlateHuffmanTab *tab) {
4270   FlateCode *code;
4271   int c;
4272
4273   while (codeSize < tab->maxLen) {
4274     if ((c = str->getChar()) == EOF) {
4275       break;
4276     }
4277     codeBuf |= (c & 0xff) << codeSize;
4278     codeSize += 8;
4279   }
4280   code = &tab->codes[codeBuf & ((1 << tab->maxLen) - 1)];
4281   if (codeSize == 0 || codeSize < code->len || code->len == 0) {
4282     return EOF;
4283   }
4284   codeBuf >>= code->len;
4285   codeSize -= code->len;
4286   return (int)code->val;
4287 }
4288
4289 int FlateStream::getCodeWord(int bits) {
4290   int c;
4291
4292   while (codeSize < bits) {
4293     if ((c = str->getChar()) == EOF)
4294       return EOF;
4295     codeBuf |= (c & 0xff) << codeSize;
4296     codeSize += 8;
4297   }
4298   c = codeBuf & ((1 << bits) - 1);
4299   codeBuf >>= bits;
4300   codeSize -= bits;
4301   return c;
4302 }
4303
4304 //------------------------------------------------------------------------
4305 // EOFStream
4306 //------------------------------------------------------------------------
4307
4308 EOFStream::EOFStream(Stream *strA):
4309     FilterStream(strA) {
4310 }
4311
4312 EOFStream::~EOFStream() {
4313   delete str;
4314 }
4315
4316 //------------------------------------------------------------------------
4317 // FixedLengthEncoder
4318 //------------------------------------------------------------------------
4319
4320 FixedLengthEncoder::FixedLengthEncoder(Stream *strA, int lengthA):
4321     FilterStream(strA) {
4322   length = lengthA;
4323   count = 0;
4324 }
4325
4326 FixedLengthEncoder::~FixedLengthEncoder() {
4327   if (str->isEncoder())
4328     delete str;
4329 }
4330
4331 void FixedLengthEncoder::reset() {
4332   str->reset();
4333   count = 0;
4334 }
4335
4336 int FixedLengthEncoder::getChar() {
4337   if (length >= 0 && count >= length)
4338     return EOF;
4339   ++count;
4340   return str->getChar();
4341 }
4342
4343 int FixedLengthEncoder::lookChar() {
4344   if (length >= 0 && count >= length)
4345     return EOF;
4346   return str->getChar();
4347 }
4348
4349 GBool FixedLengthEncoder::isBinary(GBool last) {
4350   return str->isBinary(gTrue);
4351 }
4352
4353 //------------------------------------------------------------------------
4354 // ASCIIHexEncoder
4355 //------------------------------------------------------------------------
4356
4357 ASCIIHexEncoder::ASCIIHexEncoder(Stream *strA):
4358     FilterStream(strA) {
4359   bufPtr = bufEnd = buf;
4360   lineLen = 0;
4361   eof = gFalse;
4362 }
4363
4364 ASCIIHexEncoder::~ASCIIHexEncoder() {
4365   if (str->isEncoder()) {
4366     delete str;
4367   }
4368 }
4369
4370 void ASCIIHexEncoder::reset() {
4371   str->reset();
4372   bufPtr = bufEnd = buf;
4373   lineLen = 0;
4374   eof = gFalse;
4375 }
4376
4377 GBool ASCIIHexEncoder::fillBuf() {
4378   static char *hex = "0123456789abcdef";
4379   int c;
4380
4381   if (eof) {
4382     return gFalse;
4383   }
4384   bufPtr = bufEnd = buf;
4385   if ((c = str->getChar()) == EOF) {
4386     *bufEnd++ = '>';
4387     eof = gTrue;
4388   } else {
4389     if (lineLen >= 64) {
4390       *bufEnd++ = '\n';
4391       lineLen = 0;
4392     }
4393     *bufEnd++ = hex[(c >> 4) & 0x0f];
4394     *bufEnd++ = hex[c & 0x0f];
4395     lineLen += 2;
4396   }
4397   return gTrue;
4398 }
4399
4400 //------------------------------------------------------------------------
4401 // ASCII85Encoder
4402 //------------------------------------------------------------------------
4403
4404 ASCII85Encoder::ASCII85Encoder(Stream *strA):
4405     FilterStream(strA) {
4406   bufPtr = bufEnd = buf;
4407   lineLen = 0;
4408   eof = gFalse;
4409 }
4410
4411 ASCII85Encoder::~ASCII85Encoder() {
4412   if (str->isEncoder())
4413     delete str;
4414 }
4415
4416 void ASCII85Encoder::reset() {
4417   str->reset();
4418   bufPtr = bufEnd = buf;
4419   lineLen = 0;
4420   eof = gFalse;
4421 }
4422
4423 GBool ASCII85Encoder::fillBuf() {
4424   Gulong t;
4425   char buf1[5];
4426   int c;
4427   int n, i;
4428
4429   if (eof)
4430     return gFalse;
4431   t = 0;
4432   for (n = 0; n < 4; ++n) {
4433     if ((c = str->getChar()) == EOF)
4434       break;
4435     t = (t << 8) + c;
4436   }
4437   bufPtr = bufEnd = buf;
4438   if (n > 0) {
4439     if (n == 4 && t == 0) {
4440       *bufEnd++ = 'z';
4441       if (++lineLen == 65) {
4442         *bufEnd++ = '\n';
4443         lineLen = 0;
4444       }
4445     } else {
4446       if (n < 4)
4447         t <<= 8 * (4 - n);
4448       for (i = 4; i >= 0; --i) {
4449         buf1[i] = (char)(t % 85 + 0x21);
4450         t /= 85;
4451       }
4452       for (i = 0; i <= n; ++i) {
4453         *bufEnd++ = buf1[i];
4454         if (++lineLen == 65) {
4455           *bufEnd++ = '\n';
4456           lineLen = 0;
4457         }
4458       }
4459     }
4460   }
4461   if (n < 4) {
4462     *bufEnd++ = '~';
4463     *bufEnd++ = '>';
4464     eof = gTrue;
4465   }
4466   return bufPtr < bufEnd;
4467 }
4468
4469 //------------------------------------------------------------------------
4470 // RunLengthEncoder
4471 //------------------------------------------------------------------------
4472
4473 RunLengthEncoder::RunLengthEncoder(Stream *strA):
4474     FilterStream(strA) {
4475   bufPtr = bufEnd = nextEnd = buf;
4476   eof = gFalse;
4477 }
4478
4479 RunLengthEncoder::~RunLengthEncoder() {
4480   if (str->isEncoder())
4481     delete str;
4482 }
4483
4484 void RunLengthEncoder::reset() {
4485   str->reset();
4486   bufPtr = bufEnd = nextEnd = buf;
4487   eof = gFalse;
4488 }
4489
4490 //
4491 // When fillBuf finishes, buf[] looks like this:
4492 //   +-----+--------------+-----------------+--
4493 //   + tag | ... data ... | next 0, 1, or 2 |
4494 //   +-----+--------------+-----------------+--
4495 //    ^                    ^                 ^
4496 //    bufPtr               bufEnd            nextEnd
4497 //
4498 GBool RunLengthEncoder::fillBuf() {
4499   int c, c1, c2;
4500   int n;
4501
4502   // already hit EOF?
4503   if (eof)
4504     return gFalse;
4505
4506   // grab two bytes
4507   if (nextEnd < bufEnd + 1) {
4508     if ((c1 = str->getChar()) == EOF) {
4509       eof = gTrue;
4510       return gFalse;
4511     }
4512   } else {
4513     c1 = bufEnd[0] & 0xff;
4514   }
4515   if (nextEnd < bufEnd + 2) {
4516     if ((c2 = str->getChar()) == EOF) {
4517       eof = gTrue;
4518       buf[0] = 0;
4519       buf[1] = c1;
4520       bufPtr = buf;
4521       bufEnd = &buf[2];
4522       return gTrue;
4523     }
4524   } else {
4525     c2 = bufEnd[1] & 0xff;
4526   }
4527
4528   // check for repeat
4529   c = 0; // make gcc happy
4530   if (c1 == c2) {
4531     n = 2;
4532     while (n < 128 && (c = str->getChar()) == c1)
4533       ++n;
4534     buf[0] = (char)(257 - n);
4535     buf[1] = c1;
4536     bufEnd = &buf[2];
4537     if (c == EOF) {
4538       eof = gTrue;
4539     } else if (n < 128) {
4540       buf[2] = c;
4541       nextEnd = &buf[3];
4542     } else {
4543       nextEnd = bufEnd;
4544     }
4545
4546   // get up to 128 chars
4547   } else {
4548     buf[1] = c1;
4549     buf[2] = c2;
4550     n = 2;
4551     while (n < 128) {
4552       if ((c = str->getChar()) == EOF) {
4553         eof = gTrue;
4554         break;
4555       }
4556       ++n;
4557       buf[n] = c;
4558       if (buf[n] == buf[n-1])
4559         break;
4560     }
4561     if (buf[n] == buf[n-1]) {
4562       buf[0] = (char)(n-2-1);
4563       bufEnd = &buf[n-1];
4564       nextEnd = &buf[n+1];
4565     } else {
4566       buf[0] = (char)(n-1);
4567       bufEnd = nextEnd = &buf[n+1];
4568     }
4569   }
4570   bufPtr = buf;
4571   return gTrue;
4572 }