implemented type 3 transparency.
[swftools.git] / pdf2swf / xpdf / Stream.h
1 //========================================================================
2 //
3 // Stream.h
4 //
5 // Copyright 1996-2002 Glyph & Cog, LLC
6 //
7 //========================================================================
8
9 #ifndef STREAM_H
10 #define STREAM_H
11
12 #ifdef __GNUC__
13 #pragma interface
14 #endif
15
16 #include <stdio.h>
17 #include "gtypes.h"
18 #include "Object.h"
19
20 #ifndef NO_DECRYPTION
21 class Decrypt;
22 #endif
23 class BaseStream;
24
25 //------------------------------------------------------------------------
26
27 enum StreamKind {
28   strFile,
29   strASCIIHex,
30   strASCII85,
31   strLZW,
32   strRunLength,
33   strCCITTFax,
34   strDCT,
35   strFlate,
36   strWeird                      // internal-use stream types
37 };
38
39 //------------------------------------------------------------------------
40 // Stream (base class)
41 //------------------------------------------------------------------------
42
43 class Stream {
44 public:
45
46   // Constructor.
47   Stream();
48
49   // Destructor.
50   virtual ~Stream();
51
52   // Reference counting.
53   int incRef() { return ++ref; }
54   int decRef() { return --ref; }
55
56   // Get kind of stream.
57   virtual StreamKind getKind() = 0;
58
59   // Reset stream to beginning.
60   virtual void reset() = 0;
61
62   // Close down the stream.
63   virtual void close();
64
65   // Get next char from stream.
66   virtual int getChar() = 0;
67
68   // Peek at next char in stream.
69   virtual int lookChar() = 0;
70
71   // Get next char from stream without using the predictor.
72   // This is only used by StreamPredictor.
73   virtual int getRawChar();
74
75   // Get next line from stream.
76   virtual char *getLine(char *buf, int size);
77
78   // Get current position in file.
79   virtual int getPos() = 0;
80
81   // Go to a position in the stream.  If <dir> is negative, the
82   // position is from the end of the file; otherwise the position is
83   // from the start of the file.
84   virtual void setPos(Guint pos, int dir = 0) = 0;
85
86   // Get PostScript command for the filter(s).
87   virtual GString *getPSFilter(char *indent);
88
89   // Does this stream type potentially contain non-printable chars?
90   virtual GBool isBinary(GBool last = gTrue) = 0;
91
92   // Get the BaseStream or EmbedStream of this stream.
93   virtual BaseStream *getBaseStream() = 0;
94
95   // Get the dictionary associated with this stream.
96   virtual Dict *getDict() = 0;
97
98   // Is this an encoding filter?
99   virtual GBool isEncoder() { return gFalse; }
100
101   // Add filters to this stream according to the parameters in <dict>.
102   // Returns the new stream.
103   Stream *addFilters(Object *dict);
104
105 private:
106
107   Stream *makeFilter(char *name, Stream *str, Object *params);
108
109   int ref;                      // reference count
110 };
111
112 //------------------------------------------------------------------------
113 // BaseStream
114 //
115 // This is the base class for all streams that read directly from a file.
116 //------------------------------------------------------------------------
117
118 class BaseStream: public Stream {
119 public:
120
121   BaseStream(Object *dictA);
122   virtual ~BaseStream();
123   virtual Stream *makeSubStream(Guint start, GBool limited,
124                                 Guint length, Object *dict) = 0;
125   virtual void setPos(Guint pos, int dir = 0) = 0;
126   virtual BaseStream *getBaseStream() { return this; }
127   virtual Dict *getDict() { return dict.getDict(); }
128
129   // Get/set position of first byte of stream within the file.
130   virtual Guint getStart() = 0;
131   virtual void moveStart(int delta) = 0;
132
133 #ifndef NO_DECRYPTION
134   // Set decryption for this stream.
135   virtual void doDecryption(Guchar *fileKey, int keyLength,
136                             int objNum, int objGen);
137 #endif
138
139 #ifndef NO_DECRYPTION
140 protected:
141
142   Decrypt *decrypt;
143 #endif
144
145 private:
146
147   Object dict;
148 };
149
150 //------------------------------------------------------------------------
151 // FilterStream
152 //
153 // This is the base class for all streams that filter another stream.
154 //------------------------------------------------------------------------
155
156 class FilterStream: public Stream {
157 public:
158
159   FilterStream(Stream *strA);
160   virtual ~FilterStream();
161   virtual void close();
162   virtual int getPos() { return str->getPos(); }
163   virtual void setPos(Guint pos, int dir = 0);
164   virtual BaseStream *getBaseStream() { return str->getBaseStream(); }
165   virtual Dict *getDict() { return str->getDict(); }
166
167 protected:
168
169   Stream *str;
170 };
171
172 //------------------------------------------------------------------------
173 // ImageStream
174 //------------------------------------------------------------------------
175
176 class ImageStream {
177 public:
178
179   // Create an image stream object for an image with the specified
180   // parameters.  Note that these are the actual image parameters,
181   // which may be different from the predictor parameters.
182   ImageStream(Stream *strA, int widthA, int nCompsA, int nBitsA);
183
184   ~ImageStream();
185
186   // Reset the stream.
187   void reset();
188
189   // Gets the next pixel from the stream.  <pix> should be able to hold
190   // at least nComps elements.  Returns false at end of file.
191   GBool getPixel(Guchar *pix);
192
193   // Skip an entire line from the image.
194   void skipLine();
195
196 private:
197
198   Stream *str;                  // base stream
199   int width;                    // pixels per line
200   int nComps;                   // components per pixel
201   int nBits;                    // bits per component
202   int nVals;                    // components per line
203   Guchar *imgLine;              // line buffer
204   int imgIdx;                   // current index in imgLine
205 };
206
207 //------------------------------------------------------------------------
208 // StreamPredictor
209 //------------------------------------------------------------------------
210
211 class StreamPredictor {
212 public:
213
214   // Create a predictor object.  Note that the parameters are for the
215   // predictor, and may not match the actual image parameters.
216   StreamPredictor(Stream *strA, int predictorA,
217                   int widthA, int nCompsA, int nBitsA);
218
219   ~StreamPredictor();
220
221   int lookChar();
222   int getChar();
223
224 private:
225
226   GBool getNextLine();
227
228   Stream *str;                  // base stream
229   int predictor;                // predictor
230   int width;                    // pixels per line
231   int nComps;                   // components per pixel
232   int nBits;                    // bits per component
233   int nVals;                    // components per line
234   int pixBytes;                 // bytes per pixel
235   int rowBytes;                 // bytes per line
236   Guchar *predLine;             // line buffer
237   int predIdx;                  // current index in predLine
238 };
239
240 //------------------------------------------------------------------------
241 // FileStream
242 //------------------------------------------------------------------------
243
244 #define fileStreamBufSize 256
245
246 class FileStream: public BaseStream {
247 public:
248
249   FileStream(FILE *fA, Guint startA, GBool limitedA,
250              Guint lengthA, Object *dictA);
251   virtual ~FileStream();
252   virtual Stream *makeSubStream(Guint startA, GBool limitedA,
253                                 Guint lengthA, Object *dictA);
254   virtual StreamKind getKind() { return strFile; }
255   virtual void reset();
256   virtual void close();
257   virtual int getChar()
258     { return (bufPtr >= bufEnd && !fillBuf()) ? EOF : (*bufPtr++ & 0xff); }
259   virtual int lookChar()
260     { return (bufPtr >= bufEnd && !fillBuf()) ? EOF : (*bufPtr & 0xff); }
261   virtual int getPos() { return bufPos + (bufPtr - buf); }
262   virtual void setPos(Guint pos, int dir = 0);
263   virtual GBool isBinary(GBool last = gTrue) { return last; }
264   virtual Guint getStart() { return start; }
265   virtual void moveStart(int delta);
266
267 private:
268
269   GBool fillBuf();
270
271   FILE *f;
272   Guint start;
273   GBool limited;
274   Guint length;
275   char buf[fileStreamBufSize];
276   char *bufPtr;
277   char *bufEnd;
278   Guint bufPos;
279   int savePos;
280   GBool saved;
281 };
282
283 //------------------------------------------------------------------------
284 // MemStream
285 //------------------------------------------------------------------------
286
287 class MemStream: public BaseStream {
288 public:
289
290   MemStream(char *bufA, Guint lengthA, Object *dictA);
291   virtual ~MemStream();
292   virtual Stream *makeSubStream(Guint start, GBool limited,
293                                 Guint lengthA, Object *dictA);
294   virtual StreamKind getKind() { return strWeird; }
295   virtual void reset();
296   virtual void close();
297   virtual int getChar()
298     { return (bufPtr < bufEnd) ? (*bufPtr++ & 0xff) : EOF; }
299   virtual int lookChar()
300     { return (bufPtr < bufEnd) ? (*bufPtr & 0xff) : EOF; }
301   virtual int getPos() { return bufPtr - buf; }
302   virtual void setPos(Guint pos, int dir = 0);
303   virtual GBool isBinary(GBool last = gTrue) { return last; }
304   virtual Guint getStart() { return 0; }
305   virtual void moveStart(int delta);
306 #ifndef NO_DECRYPTION
307   virtual void doDecryption(Guchar *fileKey, int keyLength,
308                             int objNum, int objGen);
309 #endif
310
311 private:
312
313   char *buf;
314   Guint length;
315   GBool needFree;
316   char *bufEnd;
317   char *bufPtr;
318 };
319
320 //------------------------------------------------------------------------
321 // EmbedStream
322 //
323 // This is a special stream type used for embedded streams (inline
324 // images).  It reads directly from the base stream -- after the
325 // EmbedStream is deleted, reads from the base stream will proceed where
326 // the BaseStream left off.  Note that this is very different behavior
327 // that creating a new FileStream (using makeSubStream).
328 //------------------------------------------------------------------------
329
330 class EmbedStream: public BaseStream {
331 public:
332
333   EmbedStream(Stream *strA, Object *dictA);
334   virtual ~EmbedStream();
335   virtual Stream *makeSubStream(Guint start, GBool limited,
336                                 Guint length, Object *dictA);
337   virtual StreamKind getKind() { return str->getKind(); }
338   virtual void reset() {}
339   virtual int getChar() { return str->getChar(); }
340   virtual int lookChar() { return str->lookChar(); }
341   virtual int getPos() { return str->getPos(); }
342   virtual void setPos(Guint pos, int dir = 0);
343   virtual GBool isBinary(GBool last = gTrue) { return last; }
344   virtual Guint getStart();
345   virtual void moveStart(int delta);
346
347 private:
348
349   Stream *str;
350 };
351
352 //------------------------------------------------------------------------
353 // ASCIIHexStream
354 //------------------------------------------------------------------------
355
356 class ASCIIHexStream: public FilterStream {
357 public:
358
359   ASCIIHexStream(Stream *strA);
360   virtual ~ASCIIHexStream();
361   virtual StreamKind getKind() { return strASCIIHex; }
362   virtual void reset();
363   virtual int getChar()
364     { int c = lookChar(); buf = EOF; return c; }
365   virtual int lookChar();
366   virtual GString *getPSFilter(char *indent);
367   virtual GBool isBinary(GBool last = gTrue);
368
369 private:
370
371   int buf;
372   GBool eof;
373 };
374
375 //------------------------------------------------------------------------
376 // ASCII85Stream
377 //------------------------------------------------------------------------
378
379 class ASCII85Stream: public FilterStream {
380 public:
381
382   ASCII85Stream(Stream *strA);
383   virtual ~ASCII85Stream();
384   virtual StreamKind getKind() { return strASCII85; }
385   virtual void reset();
386   virtual int getChar()
387     { int ch = lookChar(); ++index; return ch; }
388   virtual int lookChar();
389   virtual GString *getPSFilter(char *indent);
390   virtual GBool isBinary(GBool last = gTrue);
391
392 private:
393
394   int c[5];
395   int b[4];
396   int index, n;
397   GBool eof;
398 };
399
400 //------------------------------------------------------------------------
401 // LZWStream
402 //------------------------------------------------------------------------
403
404 class LZWStream: public FilterStream {
405 public:
406
407   LZWStream(Stream *strA, int predictor, int columns, int colors,
408             int bits, int earlyA);
409   virtual ~LZWStream();
410   virtual StreamKind getKind() { return strLZW; }
411   virtual void reset();
412   virtual int getChar();
413   virtual int lookChar();
414   virtual int getRawChar();
415   virtual GString *getPSFilter(char *indent);
416   virtual GBool isBinary(GBool last = gTrue);
417
418 private:
419
420   StreamPredictor *pred;        // predictor
421   int early;                    // early parameter
422   FILE *zPipe;                  // uncompress pipe
423   GString *zName;               // .Z file name
424   int inputBuf;                 // input buffer
425   int inputBits;                // number of bits in input buffer
426   int inCodeBits;               // size of input code
427   char buf[256];                // buffer
428   char *bufPtr;                 // next char to read
429   char *bufEnd;                 // end of buffer
430
431   void dumpFile(FILE *f);
432   int getCode();
433   GBool fillBuf();
434 };
435
436 //------------------------------------------------------------------------
437 // RunLengthStream
438 //------------------------------------------------------------------------
439
440 class RunLengthStream: public FilterStream {
441 public:
442
443   RunLengthStream(Stream *strA);
444   virtual ~RunLengthStream();
445   virtual StreamKind getKind() { return strRunLength; }
446   virtual void reset();
447   virtual int getChar()
448     { return (bufPtr >= bufEnd && !fillBuf()) ? EOF : (*bufPtr++ & 0xff); }
449   virtual int lookChar()
450     { return (bufPtr >= bufEnd && !fillBuf()) ? EOF : (*bufPtr & 0xff); }
451   virtual GString *getPSFilter(char *indent);
452   virtual GBool isBinary(GBool last = gTrue);
453
454 private:
455
456   char buf[128];                // buffer
457   char *bufPtr;                 // next char to read
458   char *bufEnd;                 // end of buffer
459   GBool eof;
460
461   GBool fillBuf();
462 };
463
464 //------------------------------------------------------------------------
465 // CCITTFaxStream
466 //------------------------------------------------------------------------
467
468 struct CCITTCodeTable;
469
470 class CCITTFaxStream: public FilterStream {
471 public:
472
473   CCITTFaxStream(Stream *strA, int encodingA, GBool endOfLineA,
474                  GBool byteAlignA, int columnsA, int rowsA,
475                  GBool endOfBlockA, GBool blackA);
476   virtual ~CCITTFaxStream();
477   virtual StreamKind getKind() { return strCCITTFax; }
478   virtual void reset();
479   virtual int getChar()
480     { int c = lookChar(); buf = EOF; return c; }
481   virtual int lookChar();
482   virtual GString *getPSFilter(char *indent);
483   virtual GBool isBinary(GBool last = gTrue);
484
485 private:
486
487   int encoding;                 // 'K' parameter
488   GBool endOfLine;              // 'EndOfLine' parameter
489   GBool byteAlign;              // 'EncodedByteAlign' parameter
490   int columns;                  // 'Columns' parameter
491   int rows;                     // 'Rows' parameter
492   GBool endOfBlock;             // 'EndOfBlock' parameter
493   GBool black;                  // 'BlackIs1' parameter
494   GBool eof;                    // true if at eof
495   GBool nextLine2D;             // true if next line uses 2D encoding
496   int row;                      // current row
497   int inputBuf;                 // input buffer
498   int inputBits;                // number of bits in input buffer
499   short *refLine;               // reference line changing elements
500   int b1;                       // index into refLine
501   short *codingLine;            // coding line changing elements
502   int a0;                       // index into codingLine
503   int outputBits;               // remaining ouput bits
504   int buf;                      // character buffer
505
506   short getTwoDimCode();
507   short getWhiteCode();
508   short getBlackCode();
509   short lookBits(int n);
510   void eatBits(int n) { inputBits -= n; }
511 };
512
513 //------------------------------------------------------------------------
514 // DCTStream
515 //------------------------------------------------------------------------
516
517 // DCT component info
518 struct DCTCompInfo {
519   int id;                       // component ID
520   GBool inScan;                 // is this component in the current scan?
521   int hSample, vSample;         // horiz/vert sampling resolutions
522   int quantTable;               // quantization table number
523   int dcHuffTable, acHuffTable; // Huffman table numbers
524   int prevDC;                   // DC coefficient accumulator
525 };
526
527 // DCT Huffman decoding table
528 struct DCTHuffTable {
529   Guchar firstSym[17];          // first symbol for this bit length
530   Gushort firstCode[17];        // first code for this bit length
531   Gushort numCodes[17];         // number of codes of this bit length
532   Guchar sym[256];              // symbols
533 };
534
535 class DCTStream: public FilterStream {
536 public:
537
538   DCTStream(Stream *strA);
539   virtual ~DCTStream();
540   virtual StreamKind getKind() { return strDCT; }
541   virtual void reset();
542   virtual int getChar();
543   virtual int lookChar();
544   virtual GString *getPSFilter(char *indent);
545   virtual GBool isBinary(GBool last = gTrue);
546   Stream *getRawStream() { return str; }
547
548 private:
549
550   int width, height;            // image size
551   int mcuWidth, mcuHeight;      // size of min coding unit, in data units
552   DCTCompInfo compInfo[4];      // info for each component
553   int numComps;                 // number of components in image
554   int colorXform;               // need YCbCr-to-RGB transform?
555   GBool gotAdobeMarker;         // set if APP14 Adobe marker was present
556   int restartInterval;          // restart interval, in MCUs
557   Guchar quantTables[4][64];    // quantization tables
558   int numQuantTables;           // number of quantization tables
559   DCTHuffTable dcHuffTables[4]; // DC Huffman tables
560   DCTHuffTable acHuffTables[4]; // AC Huffman tables
561   int numDCHuffTables;          // number of DC Huffman tables
562   int numACHuffTables;          // number of AC Huffman tables
563   Guchar *rowBuf[4][32];        // buffer for one MCU
564   int comp, x, y, dy;           // current position within image/MCU
565   int restartCtr;               // MCUs left until restart
566   int restartMarker;            // next restart marker
567   int inputBuf;                 // input buffer for variable length codes
568   int inputBits;                // number of valid bits in input buffer
569
570   void restart();
571   GBool readMCURow();
572   GBool readDataUnit(DCTHuffTable *dcHuffTable, DCTHuffTable *acHuffTable,
573                      Guchar quantTable[64], int *prevDC, Guchar data[64]);
574   int readHuffSym(DCTHuffTable *table);
575   int readAmp(int size);
576   int readBit();
577   GBool readHeader();
578   GBool readFrameInfo();
579   GBool readScanInfo();
580   GBool readQuantTables();
581   GBool readHuffmanTables();
582   GBool readRestartInterval();
583   GBool readAdobeMarker();
584   GBool readTrailer();
585   int readMarker();
586   int read16();
587 };
588
589 //------------------------------------------------------------------------
590 // FlateStream
591 //------------------------------------------------------------------------
592
593 #define flateWindow          32768    // buffer size
594 #define flateMask            (flateWindow-1)
595 #define flateMaxHuffman         15    // max Huffman code length
596 #define flateMaxCodeLenCodes    19    // max # code length codes
597 #define flateMaxLitCodes       288    // max # literal codes
598 #define flateMaxDistCodes       30    // max # distance codes
599
600 // Huffman code table entry
601 struct FlateCode {
602   int len;                      // code length in bits
603   int code;                     // code word
604   int val;                      // value represented by this code
605 };
606
607 // Huffman code table
608 struct FlateHuffmanTab {
609   int start[flateMaxHuffman+2]; // indexes of first code of each length
610   FlateCode *codes;             // codes, sorted by length and code word
611 };
612
613 // Decoding info for length and distance code words
614 struct FlateDecode {
615   int bits;                     // # extra bits
616   int first;                    // first length/distance
617 };
618
619 class FlateStream: public FilterStream {
620 public:
621
622   FlateStream(Stream *strA, int predictor, int columns,
623               int colors, int bits);
624   virtual ~FlateStream();
625   virtual StreamKind getKind() { return strFlate; }
626   virtual void reset();
627   virtual int getChar();
628   virtual int lookChar();
629   virtual int getRawChar();
630   virtual GString *getPSFilter(char *indent);
631   virtual GBool isBinary(GBool last = gTrue);
632
633 private:
634
635   StreamPredictor *pred;        // predictor
636   Guchar buf[flateWindow];      // output data buffer
637   int index;                    // current index into output buffer
638   int remain;                   // number valid bytes in output buffer
639   int codeBuf;                  // input buffer
640   int codeSize;                 // number of bits in input buffer
641   FlateCode                     // literal and distance codes
642     allCodes[flateMaxLitCodes + flateMaxDistCodes];
643   FlateHuffmanTab litCodeTab;   // literal code table
644   FlateHuffmanTab distCodeTab;  // distance code table
645   GBool compressedBlock;        // set if reading a compressed block
646   int blockLen;                 // remaining length of uncompressed block
647   GBool endOfBlock;             // set when end of block is reached
648   GBool eof;                    // set when end of stream is reached
649
650   static int                    // code length code reordering
651     codeLenCodeMap[flateMaxCodeLenCodes];
652   static FlateDecode            // length decoding info
653     lengthDecode[flateMaxLitCodes-257];
654   static FlateDecode            // distance decoding info
655     distDecode[flateMaxDistCodes];
656
657   void readSome();
658   GBool startBlock();
659   void loadFixedCodes();
660   GBool readDynamicCodes();
661   void compHuffmanCodes(FlateHuffmanTab *tab, int n);
662   int getHuffmanCodeWord(FlateHuffmanTab *tab);
663   int getCodeWord(int bits);
664 };
665
666 //------------------------------------------------------------------------
667 // EOFStream
668 //------------------------------------------------------------------------
669
670 class EOFStream: public FilterStream {
671 public:
672
673   EOFStream(Stream *strA);
674   virtual ~EOFStream();
675   virtual StreamKind getKind() { return strWeird; }
676   virtual void reset() {}
677   virtual int getChar() { return EOF; }
678   virtual int lookChar() { return EOF; }
679   virtual GString *getPSFilter(char *indent)  { return NULL; }
680   virtual GBool isBinary(GBool last = gTrue) { return gFalse; }
681 };
682
683 //------------------------------------------------------------------------
684 // FixedLengthEncoder
685 //------------------------------------------------------------------------
686
687 class FixedLengthEncoder: public FilterStream {
688 public:
689
690   FixedLengthEncoder(Stream *strA, int lengthA);
691   ~FixedLengthEncoder();
692   virtual StreamKind getKind() { return strWeird; }
693   virtual void reset();
694   virtual void close();
695   virtual int getChar();
696   virtual int lookChar();
697   virtual GString *getPSFilter(char *indent) { return NULL; }
698   virtual GBool isBinary(GBool last = gTrue) { return gFalse; }
699   virtual GBool isEncoder() { return gTrue; }
700
701 private:
702
703   int length;
704   int count;
705 };
706
707 //------------------------------------------------------------------------
708 // ASCIIHexEncoder
709 //------------------------------------------------------------------------
710
711 class ASCIIHexEncoder: public FilterStream {
712 public:
713
714   ASCIIHexEncoder(Stream *strA);
715   virtual ~ASCIIHexEncoder();
716   virtual StreamKind getKind() { return strWeird; }
717   virtual void reset();
718   virtual void close();
719   virtual int getChar()
720     { return (bufPtr >= bufEnd && !fillBuf()) ? EOF : (*bufPtr++ & 0xff); }
721   virtual int lookChar()
722     { return (bufPtr >= bufEnd && !fillBuf()) ? EOF : (*bufPtr & 0xff); }
723   virtual GString *getPSFilter(char *indent) { return NULL; }
724   virtual GBool isBinary(GBool last = gTrue) { return gFalse; }
725   virtual GBool isEncoder() { return gTrue; }
726
727 private:
728
729   char buf[4];
730   char *bufPtr;
731   char *bufEnd;
732   int lineLen;
733   GBool eof;
734
735   GBool fillBuf();
736 };
737
738 //------------------------------------------------------------------------
739 // ASCII85Encoder
740 //------------------------------------------------------------------------
741
742 class ASCII85Encoder: public FilterStream {
743 public:
744
745   ASCII85Encoder(Stream *strA);
746   virtual ~ASCII85Encoder();
747   virtual StreamKind getKind() { return strWeird; }
748   virtual void reset();
749   virtual void close();
750   virtual int getChar()
751     { return (bufPtr >= bufEnd && !fillBuf()) ? EOF : (*bufPtr++ & 0xff); }
752   virtual int lookChar()
753     { return (bufPtr >= bufEnd && !fillBuf()) ? EOF : (*bufPtr & 0xff); }
754   virtual GString *getPSFilter(char *indent) { return NULL; }
755   virtual GBool isBinary(GBool last = gTrue) { return gFalse; }
756   virtual GBool isEncoder() { return gTrue; }
757
758 private:
759
760   char buf[8];
761   char *bufPtr;
762   char *bufEnd;
763   int lineLen;
764   GBool eof;
765
766   GBool fillBuf();
767 };
768
769 //------------------------------------------------------------------------
770 // RunLengthEncoder
771 //------------------------------------------------------------------------
772
773 class RunLengthEncoder: public FilterStream {
774 public:
775
776   RunLengthEncoder(Stream *strA);
777   virtual ~RunLengthEncoder();
778   virtual StreamKind getKind() { return strWeird; }
779   virtual void reset();
780   virtual void close();
781   virtual int getChar()
782     { return (bufPtr >= bufEnd && !fillBuf()) ? EOF : (*bufPtr++ & 0xff); }
783   virtual int lookChar()
784     { return (bufPtr >= bufEnd && !fillBuf()) ? EOF : (*bufPtr & 0xff); }
785   virtual GString *getPSFilter(char *indent) { return NULL; }
786   virtual GBool isBinary(GBool last = gTrue) { return gFalse; }
787   virtual GBool isEncoder() { return gTrue; }
788
789 private:
790
791   char buf[131];
792   char *bufPtr;
793   char *bufEnd;
794   char *nextEnd;
795   GBool eof;
796
797   GBool fillBuf();
798 };
799
800 #endif