00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017 #ifndef SkStream_DEFINED
00018 #define SkStream_DEFINED
00019
00020 #include "SkRefCnt.h"
00021 #include "SkScalar.h"
00022
00023 class SkStream : public SkRefCnt {
00024 public:
00025 virtual ~SkStream();
00029 virtual bool rewind() = 0;
00033 virtual const char* getFileName();
00042 virtual size_t read(void* buffer, size_t size) = 0;
00043
00046 size_t getLength() { return this->read(NULL, 0); }
00047
00051 size_t skip(size_t bytes);
00052
00058 virtual const void* getMemoryBase();
00059
00060 int8_t readS8();
00061 int16_t readS16();
00062 int32_t readS32();
00063
00064 uint8_t readU8() { return (uint8_t)this->readS8(); }
00065 uint16_t readU16() { return (uint16_t)this->readS16(); }
00066 uint32_t readU32() { return (uint32_t)this->readS32(); }
00067
00068 bool readBool() { return this->readU8() != 0; }
00069 SkScalar readScalar();
00070 size_t readPackedUInt();
00071 };
00072
00073 class SkWStream : SkNoncopyable {
00074 public:
00075 virtual ~SkWStream();
00076
00082 virtual bool write(const void* buffer, size_t size) = 0;
00083 virtual void newline();
00084 virtual void flush();
00085
00086
00087
00088 bool write8(U8CPU);
00089 bool write16(U16CPU);
00090 bool write32(uint32_t);
00091
00092 bool writeText(const char text[]);
00093 bool writeDecAsText(int32_t);
00094 bool writeHexAsText(uint32_t, int minDigits = 0);
00095 bool writeScalarAsText(SkScalar);
00096
00097 bool writeBool(bool v) { return this->write8(v); }
00098 bool writeScalar(SkScalar);
00099 bool writePackedUInt(size_t);
00100
00101 bool writeStream(SkStream* input, size_t length);
00102 };
00103
00105
00106 #include "SkString.h"
00107
00108 struct SkFILE;
00109
00113 class SkFILEStream : public SkStream {
00114 public:
00118 explicit SkFILEStream(const char path[] = NULL);
00119 virtual ~SkFILEStream();
00120
00123 bool isValid() const { return fFILE != NULL; }
00127 void setPath(const char path[]);
00128
00129 virtual bool rewind();
00130 virtual size_t read(void* buffer, size_t size);
00131 virtual const char* getFileName();
00132
00133 private:
00134 SkFILE* fFILE;
00135 SkString fName;
00136 };
00137
00140 class SkFDStream : public SkStream {
00141 public:
00146 SkFDStream(int fileDesc, bool closeWhenDone);
00147 virtual ~SkFDStream();
00148
00151 bool isValid() const { return fFD >= 0; }
00152
00153 virtual bool rewind();
00154 virtual size_t read(void* buffer, size_t size);
00155 virtual const char* getFileName() { return NULL; }
00156
00157 private:
00158 int fFD;
00159 bool fCloseWhenDone;
00160 };
00161
00162 class SkMemoryStream : public SkStream {
00163 public:
00164 SkMemoryStream();
00167 SkMemoryStream(size_t length);
00170 SkMemoryStream(const void* data, size_t length, bool copyData = false);
00171 virtual ~SkMemoryStream();
00172
00177 virtual void setMemory(const void* data, size_t length,
00178 bool copyData = false);
00179 void skipToAlign4();
00180 virtual bool rewind();
00181 virtual size_t read(void* buffer, size_t size);
00182 virtual const void* getMemoryBase();
00183 const void* getAtPos();
00184 size_t seek(size_t offset);
00185 size_t peek() const { return fOffset; }
00186
00187 private:
00188 const void* fSrc;
00189 size_t fSize, fOffset;
00190 SkBool8 fWeOwnTheData;
00191 };
00192
00198 class SkBufferStream : public SkStream {
00199 public:
00206 SkBufferStream(SkStream* proxy, size_t bufferSize = 0);
00214 SkBufferStream(SkStream* proxy, void* buffer, size_t bufferSize);
00215 virtual ~SkBufferStream();
00216
00217 virtual bool rewind();
00218 virtual const char* getFileName();
00219 virtual size_t read(void* buffer, size_t size);
00220 virtual const void* getMemoryBase();
00221
00222 private:
00223 enum {
00224 kDefaultBufferSize = 128
00225 };
00226
00227 SkBufferStream(const SkBufferStream&);
00228 SkBufferStream& operator=(const SkBufferStream&);
00229
00230 SkStream* fProxy;
00231 char* fBuffer;
00232 size_t fOrigBufferSize, fBufferSize, fBufferOffset;
00233 bool fWeOwnTheBuffer;
00234
00235 void init(void*, size_t);
00236 };
00237
00239
00240 class SkFILEWStream : public SkWStream {
00241 public:
00242 SkFILEWStream(const char path[]);
00243 virtual ~SkFILEWStream();
00244
00247 bool isValid() const { return fFILE != NULL; }
00248
00249 virtual bool write(const void* buffer, size_t size);
00250 virtual void flush();
00251 private:
00252 SkFILE* fFILE;
00253 };
00254
00255 class SkMemoryWStream : public SkWStream {
00256 public:
00257 SkMemoryWStream(void* buffer, size_t size);
00258 virtual bool write(const void* buffer, size_t size);
00259
00260 private:
00261 char* fBuffer;
00262 size_t fMaxLength;
00263 size_t fBytesWritten;
00264 };
00265
00266 class SkDynamicMemoryWStream : public SkWStream {
00267 public:
00268 SkDynamicMemoryWStream();
00269 virtual ~SkDynamicMemoryWStream();
00270 virtual bool write(const void* buffer, size_t size);
00271
00272
00273 bool write(const void* buffer, size_t offset, size_t size);
00274 bool read(void* buffer, size_t offset, size_t size);
00275 size_t getOffset() { return fBytesWritten; }
00276
00277
00278 void copyTo(void* dst) const;
00279
00280
00281
00282
00283 const char* getStream() const;
00284
00285
00286 const char* detach();
00287
00288
00289 void reset();
00290 void padToAlign4();
00291 private:
00292 struct Block;
00293 Block* fHead;
00294 Block* fTail;
00295 size_t fBytesWritten;
00296 mutable char* fCopyToCache;
00297 };
00298
00299
00300 class SkDebugWStream : public SkWStream {
00301 public:
00302
00303 virtual bool write(const void* buffer, size_t size);
00304 virtual void newline();
00305 };
00306
00307
00308 typedef SkFILEStream SkURLStream;
00309
00310 #endif
00311