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