source: trunk/poppler/mypoppler/poppler/Stream.h @ 2

Last change on this file since 2 was 2, checked in by Eugene Romanenko, 16 years ago

First import

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