blob: 7afce712401c98e78f560ad8f4853f7395123092 [file] [log] [blame]
reed@android.com8a1c16f2008-12-17 15:59:43 +00001/*
epoger@google.comec3ed6a2011-07-28 14:26:00 +00002 * Copyright 2006 The Android Open Source Project
reed@android.com8a1c16f2008-12-17 15:59:43 +00003 *
epoger@google.comec3ed6a2011-07-28 14:26:00 +00004 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
reed@android.com8a1c16f2008-12-17 15:59:43 +00006 */
7
8#ifndef SkStream_DEFINED
9#define SkStream_DEFINED
10
reedfde05112016-03-11 13:02:28 -080011#include "SkData.h"
reed@android.com8a1c16f2008-12-17 15:59:43 +000012#include "SkRefCnt.h"
13#include "SkScalar.h"
14
bungeman@google.com6cab1a42013-05-29 13:43:31 +000015class SkStream;
16class SkStreamRewindable;
17class SkStreamSeekable;
18class SkStreamAsset;
19class SkStreamMemory;
20
reed@google.com3b345052013-05-07 15:59:16 +000021/**
22 * SkStream -- abstraction for a source of bytes. Subclasses can be backed by
23 * memory, or a file, or something else.
24 *
25 * NOTE:
26 *
27 * Classic "streams" APIs are sort of async, in that on a request for N
28 * bytes, they may return fewer than N bytes on a given call, in which case
29 * the caller can "try again" to get more bytes, eventually (modulo an error)
30 * receiving their total N bytes.
skia.committer@gmail.com2b34fe02013-05-08 07:01:40 +000031 *
reed@google.com3b345052013-05-07 15:59:16 +000032 * Skia streams behave differently. They are effectively synchronous, and will
33 * always return all N bytes of the request if possible. If they return fewer
34 * (the read() call returns the number of bytes read) then that means there is
35 * no more data (at EOF or hit an error). The caller should *not* call again
36 * in hopes of fulfilling more of the request.
37 */
scroggoa1193e42015-01-21 12:09:53 -080038class SK_API SkStream : public SkNoncopyable {
reed@android.com8a1c16f2008-12-17 15:59:43 +000039public:
scroggoa1193e42015-01-21 12:09:53 -080040 virtual ~SkStream() {}
41
42 /**
bungemanf93d7112016-09-16 06:24:20 -070043 * Attempts to open the specified file as a stream, returns nullptr on failure.
reed@google.come1575aa2013-03-18 21:08:46 +000044 */
bungemanf93d7112016-09-16 06:24:20 -070045 static std::unique_ptr<SkStreamAsset> MakeFromFile(const char path[]);
skia.committer@gmail.com8eaddb02013-03-19 07:15:10 +000046
bungeman@google.com6cab1a42013-05-29 13:43:31 +000047 /** Reads or skips size number of bytes.
48 * If buffer == NULL, skip size bytes, return how many were skipped.
49 * If buffer != NULL, copy size bytes into buffer, return how many were copied.
50 * @param buffer when NULL skip size bytes, otherwise copy size bytes into buffer
51 * @param size the number of bytes to skip or copy
bungeman@google.com88682b72013-07-19 13:55:41 +000052 * @return the number of bytes actually read.
bungeman@google.com6cab1a42013-05-29 13:43:31 +000053 */
reed@android.com8a1c16f2008-12-17 15:59:43 +000054 virtual size_t read(void* buffer, size_t size) = 0;
55
bungeman@google.com6cab1a42013-05-29 13:43:31 +000056 /** Skip size number of bytes.
57 * @return the actual number bytes that could be skipped.
58 */
59 size_t skip(size_t size) {
bungeman@google.com04306922013-11-13 19:53:46 +000060 return this->read(NULL, size);
bungeman@google.com6cab1a42013-05-29 13:43:31 +000061 }
rmistry@google.comfbfcd562012-08-23 18:09:54 +000062
scroggo028a4132015-04-02 13:19:51 -070063 /**
64 * Attempt to peek at size bytes.
scroggod61c3842015-12-07 11:37:13 -080065 * If this stream supports peeking, copy min(size, peekable bytes) into
66 * buffer, and return the number of bytes copied.
67 * If the stream does not support peeking, or cannot peek any bytes,
68 * return 0 and leave buffer unchanged.
scroggo028a4132015-04-02 13:19:51 -070069 * The stream is guaranteed to be in the same visible state after this
70 * call, regardless of success or failure.
scroggod61c3842015-12-07 11:37:13 -080071 * @param buffer Must not be NULL, and must be at least size bytes. Destination
72 * to copy bytes.
scroggo028a4132015-04-02 13:19:51 -070073 * @param size Number of bytes to copy.
scroggod61c3842015-12-07 11:37:13 -080074 * @return The number of bytes peeked/copied.
scroggo028a4132015-04-02 13:19:51 -070075 */
scroggod61c3842015-12-07 11:37:13 -080076 virtual size_t peek(void* /*buffer*/, size_t /*size*/) const { return 0; }
scroggo028a4132015-04-02 13:19:51 -070077
bungeman@google.com88682b72013-07-19 13:55:41 +000078 /** Returns true when all the bytes in the stream have been read.
79 * This may return true early (when there are no more bytes to be read)
80 * or late (after the first unsuccessful read).
bungeman@google.com6cab1a42013-05-29 13:43:31 +000081 */
bungeman@google.com04306922013-11-13 19:53:46 +000082 virtual bool isAtEnd() const = 0;
reed@android.com8a1c16f2008-12-17 15:59:43 +000083
84 int8_t readS8();
85 int16_t readS16();
86 int32_t readS32();
87
88 uint8_t readU8() { return (uint8_t)this->readS8(); }
89 uint16_t readU16() { return (uint16_t)this->readS16(); }
90 uint32_t readU32() { return (uint32_t)this->readS32(); }
91
92 bool readBool() { return this->readU8() != 0; }
93 SkScalar readScalar();
94 size_t readPackedUInt();
robertphillips@google.com15e9d3e2012-06-21 20:25:03 +000095
bungeman@google.com6cab1a42013-05-29 13:43:31 +000096//SkStreamRewindable
scroggo@google.com4d213ab2013-08-28 13:08:54 +000097 /** Rewinds to the beginning of the stream. Returns true if the stream is known
98 * to be at the beginning after this call returns.
99 */
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000100 virtual bool rewind() { return false; }
101
102 /** Duplicates this stream. If this cannot be done, returns NULL.
103 * The returned stream will be positioned at the beginning of its data.
104 */
105 virtual SkStreamRewindable* duplicate() const { return NULL; }
106
107//SkStreamSeekable
108 /** Returns true if this stream can report it's current position. */
109 virtual bool hasPosition() const { return false; }
110 /** Returns the current position in the stream. If this cannot be done, returns 0. */
111 virtual size_t getPosition() const { return 0; }
112
113 /** Seeks to an absolute position in the stream. If this cannot be done, returns false.
114 * If an attempt is made to seek past the end of the stream, the position will be set
115 * to the end of the stream.
116 */
djsollenc87dd2c2014-11-14 11:11:46 -0800117 virtual bool seek(size_t /*position*/) { return false; }
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000118
119 /** Seeks to an relative offset in the stream. If this cannot be done, returns false.
120 * If an attempt is made to move to a position outside the stream, the position will be set
121 * to the closest point within the stream (beginning or end).
122 */
djsollenc87dd2c2014-11-14 11:11:46 -0800123 virtual bool move(long /*offset*/) { return false; }
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000124
125 /** Duplicates this stream. If this cannot be done, returns NULL.
126 * The returned stream will be positioned the same as this stream.
127 */
128 virtual SkStreamSeekable* fork() const { return NULL; }
129
130//SkStreamAsset
131 /** Returns true if this stream can report it's total length. */
132 virtual bool hasLength() const { return false; }
133 /** Returns the total length of the stream. If this cannot be done, returns 0. */
bungeman@google.com04306922013-11-13 19:53:46 +0000134 virtual size_t getLength() const { return 0; }
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000135
136//SkStreamMemory
137 /** Returns the starting address for the data. If this cannot be done, returns NULL. */
138 //TODO: replace with virtual const SkData* getData()
139 virtual const void* getMemoryBase() { return NULL; }
reed@android.com8a1c16f2008-12-17 15:59:43 +0000140};
141
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000142/** SkStreamRewindable is a SkStream for which rewind and duplicate are required. */
143class SK_API SkStreamRewindable : public SkStream {
144public:
mtklein36352bf2015-03-25 18:17:31 -0700145 bool rewind() override = 0;
146 SkStreamRewindable* duplicate() const override = 0;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000147};
148
149/** SkStreamSeekable is a SkStreamRewindable for which position, seek, move, and fork are required. */
150class SK_API SkStreamSeekable : public SkStreamRewindable {
151public:
mtklein36352bf2015-03-25 18:17:31 -0700152 SkStreamSeekable* duplicate() const override = 0;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000153
mtklein36352bf2015-03-25 18:17:31 -0700154 bool hasPosition() const override { return true; }
155 size_t getPosition() const override = 0;
156 bool seek(size_t position) override = 0;
157 bool move(long offset) override = 0;
158 SkStreamSeekable* fork() const override = 0;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000159};
160
161/** SkStreamAsset is a SkStreamSeekable for which getLength is required. */
162class SK_API SkStreamAsset : public SkStreamSeekable {
163public:
mtklein36352bf2015-03-25 18:17:31 -0700164 SkStreamAsset* duplicate() const override = 0;
165 SkStreamAsset* fork() const override = 0;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000166
mtklein36352bf2015-03-25 18:17:31 -0700167 bool hasLength() const override { return true; }
168 size_t getLength() const override = 0;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000169};
170
171/** SkStreamMemory is a SkStreamAsset for which getMemoryBase is required. */
172class SK_API SkStreamMemory : public SkStreamAsset {
173public:
mtklein36352bf2015-03-25 18:17:31 -0700174 SkStreamMemory* duplicate() const override = 0;
175 SkStreamMemory* fork() const override = 0;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000176
mtklein36352bf2015-03-25 18:17:31 -0700177 const void* getMemoryBase() override = 0;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000178};
179
ctguil@chromium.orgdfc5ffe2011-03-30 20:14:49 +0000180class SK_API SkWStream : SkNoncopyable {
reed@android.com8a1c16f2008-12-17 15:59:43 +0000181public:
182 virtual ~SkWStream();
183
184 /** Called to write bytes to a SkWStream. Returns true on success
185 @param buffer the address of at least size bytes to be written to the stream
186 @param size The number of bytes in buffer to write to the stream
187 @return true on success
188 */
189 virtual bool write(const void* buffer, size_t size) = 0;
190 virtual void newline();
191 virtual void flush();
192
commit-bot@chromium.org490fb6b2014-03-06 17:16:26 +0000193 virtual size_t bytesWritten() const = 0;
194
reed@android.com8a1c16f2008-12-17 15:59:43 +0000195 // helpers
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000196
reed@android.com8a1c16f2008-12-17 15:59:43 +0000197 bool write8(U8CPU);
198 bool write16(U16CPU);
199 bool write32(uint32_t);
200
halcanarycbc060a2016-04-11 19:41:48 -0700201 bool writeText(const char text[]) {
202 SkASSERT(text);
203 return this->write(text, strlen(text));
204 }
reed@android.com8a1c16f2008-12-17 15:59:43 +0000205 bool writeDecAsText(int32_t);
vandebo@chromium.orgd877fdb2010-10-12 23:08:13 +0000206 bool writeBigDecAsText(int64_t, int minDigits = 0);
reed@android.com8a1c16f2008-12-17 15:59:43 +0000207 bool writeHexAsText(uint32_t, int minDigits = 0);
208 bool writeScalarAsText(SkScalar);
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000209
reed@android.com8a1c16f2008-12-17 15:59:43 +0000210 bool writeBool(bool v) { return this->write8(v); }
211 bool writeScalar(SkScalar);
212 bool writePackedUInt(size_t);
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000213
commit-bot@chromium.orgdcb8e542014-03-05 18:25:20 +0000214 bool writeStream(SkStream* input, size_t length);
reed@google.com8a85d0c2011-06-24 19:12:12 +0000215
epoger@google.com8e3fb2d2013-03-20 15:56:03 +0000216 /**
commit-bot@chromium.orgdcb8e542014-03-05 18:25:20 +0000217 * This returns the number of bytes in the stream required to store
218 * 'value'.
219 */
220 static int SizeOfPackedUInt(size_t value);
reed@android.com8a1c16f2008-12-17 15:59:43 +0000221};
222
223////////////////////////////////////////////////////////////////////////////////////////
224
225#include "SkString.h"
bungeman@google.comfab44db2013-10-11 18:50:45 +0000226#include <stdio.h>
reed@android.com8a1c16f2008-12-17 15:59:43 +0000227
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000228/** A stream that wraps a C FILE* file stream. */
229class SK_API SkFILEStream : public SkStreamAsset {
reed@android.com8a1c16f2008-12-17 15:59:43 +0000230public:
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000231 /** Initialize the stream by calling sk_fopen on the specified path.
232 * This internal stream will be closed in the destructor.
reed@android.com8a1c16f2008-12-17 15:59:43 +0000233 */
234 explicit SkFILEStream(const char path[] = NULL);
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000235
236 enum Ownership {
237 kCallerPasses_Ownership,
238 kCallerRetains_Ownership
239 };
240 /** Initialize the stream with an existing C file stream.
241 * While this stream exists, it assumes exclusive access to the C file stream.
242 * The C file stream will be closed in the destructor unless the caller specifies
243 * kCallerRetains_Ownership.
244 */
245 explicit SkFILEStream(FILE* file, Ownership ownership = kCallerPasses_Ownership);
246
reed@android.com8a1c16f2008-12-17 15:59:43 +0000247 virtual ~SkFILEStream();
248
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000249 /** Returns true if the current path could be opened. */
reed@android.com8a1c16f2008-12-17 15:59:43 +0000250 bool isValid() const { return fFILE != NULL; }
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000251
252 /** Close the current file, and open a new file with the specified path.
253 * If path is NULL, just close the current file.
254 */
reed@android.com8a1c16f2008-12-17 15:59:43 +0000255 void setPath(const char path[]);
256
mtklein36352bf2015-03-25 18:17:31 -0700257 size_t read(void* buffer, size_t size) override;
258 bool isAtEnd() const override;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000259
mtklein36352bf2015-03-25 18:17:31 -0700260 bool rewind() override;
261 SkStreamAsset* duplicate() const override;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000262
mtklein36352bf2015-03-25 18:17:31 -0700263 size_t getPosition() const override;
264 bool seek(size_t position) override;
265 bool move(long offset) override;
266 SkStreamAsset* fork() const override;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000267
mtklein36352bf2015-03-25 18:17:31 -0700268 size_t getLength() const override;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000269
mtklein36352bf2015-03-25 18:17:31 -0700270 const void* getMemoryBase() override;
reed@android.com8a1c16f2008-12-17 15:59:43 +0000271
272private:
reedfde05112016-03-11 13:02:28 -0800273 FILE* fFILE;
reed@android.com8a1c16f2008-12-17 15:59:43 +0000274 SkString fName;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000275 Ownership fOwnership;
276 // fData is lazilly initialized when needed.
reedfde05112016-03-11 13:02:28 -0800277 mutable sk_sp<SkData> fData;
reed@google.com3b429982012-06-26 15:30:08 +0000278
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000279 typedef SkStreamAsset INHERITED;
reed@android.com8a1c16f2008-12-17 15:59:43 +0000280};
281
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000282class SK_API SkMemoryStream : public SkStreamMemory {
reed@android.com8a1c16f2008-12-17 15:59:43 +0000283public:
284 SkMemoryStream();
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000285
286 /** We allocate (and free) the memory. Write to it via getMemoryBase() */
reed@android.com8a1c16f2008-12-17 15:59:43 +0000287 SkMemoryStream(size_t length);
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000288
289 /** If copyData is true, the stream makes a private copy of the data. */
reed@android.com8a1c16f2008-12-17 15:59:43 +0000290 SkMemoryStream(const void* data, size_t length, bool copyData = false);
scroggo@google.come4904202013-01-09 22:02:58 +0000291
reed42943c82016-09-12 12:01:44 -0700292#ifdef SK_SUPPORT_LEGACY_STREAM_DATA
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000293 /** Use the specified data as the memory for this stream.
294 * The stream will call ref() on the data (assuming it is not NULL).
reedfde05112016-03-11 13:02:28 -0800295 * DEPRECATED
scroggo@google.come4904202013-01-09 22:02:58 +0000296 */
297 SkMemoryStream(SkData*);
reed42943c82016-09-12 12:01:44 -0700298#endif
scroggo@google.come4904202013-01-09 22:02:58 +0000299
reedfde05112016-03-11 13:02:28 -0800300 /** Creates the stream to read from the specified data */
301 SkMemoryStream(sk_sp<SkData>);
reed@android.com8a1c16f2008-12-17 15:59:43 +0000302
303 /** Resets the stream to the specified data and length,
304 just like the constructor.
305 if copyData is true, the stream makes a private copy of the data
306 */
307 virtual void setMemory(const void* data, size_t length,
308 bool copyData = false);
djsollen@google.com57f49692011-02-23 20:46:31 +0000309 /** Replace any memory buffer with the specified buffer. The caller
310 must have allocated data with sk_malloc or sk_realloc, since it
311 will be freed with sk_free.
312 */
313 void setMemoryOwned(const void* data, size_t length);
reed@google.com8a85d0c2011-06-24 19:12:12 +0000314
reed42943c82016-09-12 12:01:44 -0700315 sk_sp<SkData> asData() const { return fData; }
316 void setData(sk_sp<SkData>);
317#ifdef SK_SUPPORT_LEGACY_STREAM_DATA
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000318 /** Return the stream's data in a SkData.
319 * The caller must call unref() when it is finished using the data.
reed@google.com8a85d0c2011-06-24 19:12:12 +0000320 */
reed42943c82016-09-12 12:01:44 -0700321 SkData* copyToData() const { return asData().release(); }
reed@google.com8a85d0c2011-06-24 19:12:12 +0000322
323 /**
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000324 * Use the specified data as the memory for this stream.
325 * The stream will call ref() on the data (assuming it is not NULL).
326 * The function returns the data parameter as a convenience.
reed@google.com8a85d0c2011-06-24 19:12:12 +0000327 */
reed42943c82016-09-12 12:01:44 -0700328 SkData* setData(SkData* data) {
329 this->setData(sk_ref_sp(data));
330 return data;
331 }
332#endif
reed@google.com8a85d0c2011-06-24 19:12:12 +0000333
reed@android.com8a1c16f2008-12-17 15:59:43 +0000334 void skipToAlign4();
reed@android.com8a1c16f2008-12-17 15:59:43 +0000335 const void* getAtPos();
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000336
mtklein36352bf2015-03-25 18:17:31 -0700337 size_t read(void* buffer, size_t size) override;
338 bool isAtEnd() const override;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000339
scroggod61c3842015-12-07 11:37:13 -0800340 size_t peek(void* buffer, size_t size) const override;
scroggo028a4132015-04-02 13:19:51 -0700341
mtklein36352bf2015-03-25 18:17:31 -0700342 bool rewind() override;
343 SkMemoryStream* duplicate() const override;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000344
mtklein36352bf2015-03-25 18:17:31 -0700345 size_t getPosition() const override;
346 bool seek(size_t position) override;
347 bool move(long offset) override;
348 SkMemoryStream* fork() const override;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000349
mtklein36352bf2015-03-25 18:17:31 -0700350 size_t getLength() const override;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000351
mtklein36352bf2015-03-25 18:17:31 -0700352 const void* getMemoryBase() override;
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000353
reed@android.com8a1c16f2008-12-17 15:59:43 +0000354private:
reedfde05112016-03-11 13:02:28 -0800355 sk_sp<SkData> fData;
356 size_t fOffset;
reed@google.com3b429982012-06-26 15:30:08 +0000357
bungeman@google.com6cab1a42013-05-29 13:43:31 +0000358 typedef SkStreamMemory INHERITED;
reed@android.com8a1c16f2008-12-17 15:59:43 +0000359};
360
361/////////////////////////////////////////////////////////////////////////////////////////////
362
alokp@chromium.orgf7751ae2012-07-17 19:10:36 +0000363class SK_API SkFILEWStream : public SkWStream {
reed@android.com8a1c16f2008-12-17 15:59:43 +0000364public:
reed@google.com3b429982012-06-26 15:30:08 +0000365 SkFILEWStream(const char path[]);
reed@android.com8a1c16f2008-12-17 15:59:43 +0000366 virtual ~SkFILEWStream();
367
368 /** Returns true if the current path could be opened.
369 */
370 bool isValid() const { return fFILE != NULL; }
371
mtklein36352bf2015-03-25 18:17:31 -0700372 bool write(const void* buffer, size_t size) override;
373 void flush() override;
caryclark7471fa42015-12-16 13:41:23 -0800374 void fsync();
mtklein36352bf2015-03-25 18:17:31 -0700375 size_t bytesWritten() const override;
reed@google.com3b429982012-06-26 15:30:08 +0000376
reed@android.com8a1c16f2008-12-17 15:59:43 +0000377private:
halcanaryd76be9c2015-11-20 13:47:49 -0800378 FILE* fFILE;
reed@google.com3b429982012-06-26 15:30:08 +0000379
380 typedef SkWStream INHERITED;
reed@android.com8a1c16f2008-12-17 15:59:43 +0000381};
382
caryclark15e2a532016-03-16 06:51:55 -0700383class SK_API SkMemoryWStream : public SkWStream {
reed@android.com8a1c16f2008-12-17 15:59:43 +0000384public:
385 SkMemoryWStream(void* buffer, size_t size);
mtklein36352bf2015-03-25 18:17:31 -0700386 bool write(const void* buffer, size_t size) override;
387 size_t bytesWritten() const override { return fBytesWritten; }
junov@chromium.org1cc8f6f2012-02-22 21:00:42 +0000388
reed@android.com8a1c16f2008-12-17 15:59:43 +0000389private:
390 char* fBuffer;
391 size_t fMaxLength;
392 size_t fBytesWritten;
reed@google.com3b429982012-06-26 15:30:08 +0000393
394 typedef SkWStream INHERITED;
reed@android.com8a1c16f2008-12-17 15:59:43 +0000395};
396
ctguil@chromium.orgdfc5ffe2011-03-30 20:14:49 +0000397class SK_API SkDynamicMemoryWStream : public SkWStream {
reed@android.com8a1c16f2008-12-17 15:59:43 +0000398public:
399 SkDynamicMemoryWStream();
400 virtual ~SkDynamicMemoryWStream();
reed@google.com8a85d0c2011-06-24 19:12:12 +0000401
mtklein36352bf2015-03-25 18:17:31 -0700402 bool write(const void* buffer, size_t size) override;
403 size_t bytesWritten() const override { return fBytesWritten; }
reed@android.com8a1c16f2008-12-17 15:59:43 +0000404 // random access write
405 // modifies stream and returns true if offset + size is less than or equal to getOffset()
406 bool write(const void* buffer, size_t offset, size_t size);
407 bool read(void* buffer, size_t offset, size_t size);
vandebo@chromium.orga5180862010-10-26 19:48:49 +0000408 size_t getOffset() const { return fBytesWritten; }
reed@android.com8a1c16f2008-12-17 15:59:43 +0000409
410 // copy what has been written to the stream into dst
reed@google.com8a85d0c2011-06-24 19:12:12 +0000411 void copyTo(void* dst) const;
halcanary7af21502015-02-23 12:17:59 -0800412 void writeToStream(SkWStream* dst) const;
reed@google.com70442a62011-06-23 21:48:04 +0000413
reed42943c82016-09-12 12:01:44 -0700414 sk_sp<SkData> snapshotAsData() const;
415 // Return the contents as SkData, and then reset the stream.
416 sk_sp<SkData> detachAsData();
417#ifdef SK_SUPPORT_LEGACY_STREAM_DATA
reed@google.com70442a62011-06-23 21:48:04 +0000418 /**
reed@google.com8a85d0c2011-06-24 19:12:12 +0000419 * Return a copy of the data written so far. This call is responsible for
420 * calling unref() when they are finished with the data.
reed@google.com70442a62011-06-23 21:48:04 +0000421 */
reed42943c82016-09-12 12:01:44 -0700422 SkData* copyToData() const {
423 return snapshotAsData().release();
424 }
425#endif
reed@google.com70442a62011-06-23 21:48:04 +0000426
bungeman@google.com88682b72013-07-19 13:55:41 +0000427 /** Reset, returning a reader stream with the current content. */
bungeman@google.comc29f3d82013-07-19 22:32:11 +0000428 SkStreamAsset* detachAsStream();
bungeman@google.com88682b72013-07-19 13:55:41 +0000429
430 /** Reset the stream to its original, empty, state. */
reed@android.com8a1c16f2008-12-17 15:59:43 +0000431 void reset();
432 void padToAlign4();
433private:
434 struct Block;
435 Block* fHead;
436 Block* fTail;
437 size_t fBytesWritten;
reedfde05112016-03-11 13:02:28 -0800438 mutable sk_sp<SkData> fCopy; // is invalidated if we write after it is created
reed@google.com8a85d0c2011-06-24 19:12:12 +0000439
440 void invalidateCopy();
reed@google.com3b429982012-06-26 15:30:08 +0000441
bungeman@google.com88682b72013-07-19 13:55:41 +0000442 // For access to the Block type.
443 friend class SkBlockMemoryStream;
444 friend class SkBlockMemoryRefCnt;
445
reed@google.com3b429982012-06-26 15:30:08 +0000446 typedef SkWStream INHERITED;
reed@android.com8a1c16f2008-12-17 15:59:43 +0000447};
448
449
reed@google.coma718c5e2013-03-05 17:49:10 +0000450class SK_API SkDebugWStream : public SkWStream {
reed@android.com8a1c16f2008-12-17 15:59:43 +0000451public:
commit-bot@chromium.org490fb6b2014-03-06 17:16:26 +0000452 SkDebugWStream() : fBytesWritten(0) {}
reed@google.com3b429982012-06-26 15:30:08 +0000453
reed@android.com8a1c16f2008-12-17 15:59:43 +0000454 // overrides
mtklein36352bf2015-03-25 18:17:31 -0700455 bool write(const void* buffer, size_t size) override;
456 void newline() override;
457 size_t bytesWritten() const override { return fBytesWritten; }
reed@google.com3b429982012-06-26 15:30:08 +0000458
459private:
commit-bot@chromium.org490fb6b2014-03-06 17:16:26 +0000460 size_t fBytesWritten;
reed@google.com3b429982012-06-26 15:30:08 +0000461 typedef SkWStream INHERITED;
reed@android.com8a1c16f2008-12-17 15:59:43 +0000462};
463
464// for now
465typedef SkFILEStream SkURLStream;
466
467#endif