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