OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2013 Google Inc. | 2 * Copyright 2013 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkFrontBufferedStream.h" | 8 #include "SkFrontBufferedStream.h" |
| 9 #include "SkStream.h" |
| 10 #include "SkTemplates.h" |
| 11 |
| 12 class FrontBufferedStream : public SkStreamRewindable { |
| 13 public: |
| 14 // Called by Create. |
| 15 FrontBufferedStream(SkStream*, size_t bufferSize); |
| 16 |
| 17 virtual size_t read(void* buffer, size_t size) SK_OVERRIDE; |
| 18 |
| 19 virtual bool isAtEnd() const SK_OVERRIDE; |
| 20 |
| 21 virtual bool rewind() SK_OVERRIDE; |
| 22 |
| 23 virtual bool hasPosition() const SK_OVERRIDE { return true; } |
| 24 |
| 25 virtual size_t getPosition() const SK_OVERRIDE { return fOffset; } |
| 26 |
| 27 virtual bool hasLength() const SK_OVERRIDE; |
| 28 |
| 29 virtual size_t getLength() const SK_OVERRIDE; |
| 30 |
| 31 virtual SkStreamRewindable* duplicate() const SK_OVERRIDE { return NULL; } |
| 32 |
| 33 private: |
| 34 SkAutoTUnref<SkStream> fStream; |
| 35 // Current offset into the stream. Always >= 0. |
| 36 size_t fOffset; |
| 37 // Amount that has been buffered by calls to read. Will always be less than |
| 38 // fBufferSize. |
| 39 size_t fBufferedSoFar; |
| 40 // Total size of the buffer. |
| 41 const size_t fBufferSize; |
| 42 SkAutoTMalloc<char> fBuffer; |
| 43 |
| 44 // Read up to size bytes from already buffered data, and copy to |
| 45 // dst, if non-NULL. Updates fOffset. Assumes that fOffset is less |
| 46 // than fBufferedSoFar. |
| 47 size_t readFromBuffer(char* dst, size_t size); |
| 48 |
| 49 // Buffer up to size bytes from the stream, and copy to dst if non- |
| 50 // NULL. Updates fOffset and fBufferedSoFar. Assumes that fOffset is |
| 51 // less than fBufferedSoFar, and size is greater than 0. |
| 52 size_t bufferAndWriteTo(char* dst, size_t size); |
| 53 |
| 54 // Read up to size bytes directly from the stream and into dst if non- |
| 55 // NULL. Updates fOffset. Assumes fOffset is at or beyond the buffered |
| 56 // data, and size is greater than 0. |
| 57 size_t readDirectlyFromStream(char* dst, size_t size); |
| 58 |
| 59 typedef SkStream INHERITED; |
| 60 }; |
9 | 61 |
10 SkStreamRewindable* SkFrontBufferedStream::Create(SkStream* stream, size_t buffe
rSize) { | 62 SkStreamRewindable* SkFrontBufferedStream::Create(SkStream* stream, size_t buffe
rSize) { |
11 if (NULL == stream) { | 63 if (NULL == stream) { |
12 return NULL; | 64 return NULL; |
13 } | 65 } |
14 return SkNEW_ARGS(SkFrontBufferedStream, (stream, bufferSize)); | 66 return SkNEW_ARGS(FrontBufferedStream, (stream, bufferSize)); |
15 } | 67 } |
16 | 68 |
17 SkFrontBufferedStream::SkFrontBufferedStream(SkStream* stream, size_t bufferSize
) | 69 FrontBufferedStream::FrontBufferedStream(SkStream* stream, size_t bufferSize) |
18 : fStream(SkRef(stream)) | 70 : fStream(SkRef(stream)) |
19 , fOffset(0) | 71 , fOffset(0) |
20 , fBufferedSoFar(0) | 72 , fBufferedSoFar(0) |
21 , fBufferSize(bufferSize) | 73 , fBufferSize(bufferSize) |
22 , fBuffer(bufferSize) {} | 74 , fBuffer(bufferSize) {} |
23 | 75 |
24 bool SkFrontBufferedStream::isAtEnd() const { | 76 bool FrontBufferedStream::isAtEnd() const { |
25 if (fOffset < fBufferedSoFar) { | 77 if (fOffset < fBufferedSoFar) { |
26 // Even if the underlying stream is at the end, this stream has been | 78 // Even if the underlying stream is at the end, this stream has been |
27 // rewound after buffering, so it is not at the end. | 79 // rewound after buffering, so it is not at the end. |
28 return false; | 80 return false; |
29 } | 81 } |
30 | 82 |
31 return fStream->isAtEnd(); | 83 return fStream->isAtEnd(); |
32 } | 84 } |
33 | 85 |
34 bool SkFrontBufferedStream::rewind() { | 86 bool FrontBufferedStream::rewind() { |
35 // Only allow a rewind if we have not exceeded the buffer. | 87 // Only allow a rewind if we have not exceeded the buffer. |
36 if (fOffset <= fBufferSize) { | 88 if (fOffset <= fBufferSize) { |
37 fOffset = 0; | 89 fOffset = 0; |
38 return true; | 90 return true; |
39 } | 91 } |
40 return false; | 92 return false; |
41 } | 93 } |
42 | 94 |
43 bool SkFrontBufferedStream::hasLength() const { | 95 bool FrontBufferedStream::hasLength() const { |
44 return fStream->hasLength(); | 96 return fStream->hasLength(); |
45 } | 97 } |
46 | 98 |
47 size_t SkFrontBufferedStream::getLength() const { | 99 size_t FrontBufferedStream::getLength() const { |
48 return fStream->getLength(); | 100 return fStream->getLength(); |
49 } | 101 } |
50 | 102 |
51 size_t SkFrontBufferedStream::readFromBuffer(char* dst, size_t size) { | 103 size_t FrontBufferedStream::readFromBuffer(char* dst, size_t size) { |
52 SkASSERT(fOffset < fBufferedSoFar); | 104 SkASSERT(fOffset < fBufferedSoFar); |
53 // Some data has already been copied to fBuffer. Read up to the | 105 // Some data has already been copied to fBuffer. Read up to the |
54 // lesser of the size requested and the remainder of the buffered | 106 // lesser of the size requested and the remainder of the buffered |
55 // data. | 107 // data. |
56 const size_t bytesToCopy = SkTMin(size, fBufferedSoFar - fOffset); | 108 const size_t bytesToCopy = SkTMin(size, fBufferedSoFar - fOffset); |
57 if (dst != NULL) { | 109 if (dst != NULL) { |
58 memcpy(dst, fBuffer + fOffset, bytesToCopy); | 110 memcpy(dst, fBuffer + fOffset, bytesToCopy); |
59 } | 111 } |
60 | 112 |
61 // Update fOffset to the new position. It is guaranteed to be | 113 // Update fOffset to the new position. It is guaranteed to be |
62 // within the buffered data. | 114 // within the buffered data. |
63 fOffset += bytesToCopy; | 115 fOffset += bytesToCopy; |
64 SkASSERT(fOffset <= fBufferedSoFar); | 116 SkASSERT(fOffset <= fBufferedSoFar); |
65 | 117 |
66 return bytesToCopy; | 118 return bytesToCopy; |
67 } | 119 } |
68 | 120 |
69 size_t SkFrontBufferedStream::bufferAndWriteTo(char* dst, size_t size) { | 121 size_t FrontBufferedStream::bufferAndWriteTo(char* dst, size_t size) { |
70 SkASSERT(size > 0); | 122 SkASSERT(size > 0); |
71 SkASSERT(fOffset >= fBufferedSoFar); | 123 SkASSERT(fOffset >= fBufferedSoFar); |
72 // Data needs to be buffered. Buffer up to the lesser of the size requested | 124 // Data needs to be buffered. Buffer up to the lesser of the size requested |
73 // and the remainder of the max buffer size. | 125 // and the remainder of the max buffer size. |
74 const size_t bytesToBuffer = SkTMin(size, fBufferSize - fBufferedSoFar); | 126 const size_t bytesToBuffer = SkTMin(size, fBufferSize - fBufferedSoFar); |
75 char* buffer = fBuffer + fOffset; | 127 char* buffer = fBuffer + fOffset; |
76 const size_t buffered = fStream->read(buffer, bytesToBuffer); | 128 const size_t buffered = fStream->read(buffer, bytesToBuffer); |
77 | 129 |
78 fBufferedSoFar += buffered; | 130 fBufferedSoFar += buffered; |
79 fOffset = fBufferedSoFar; | 131 fOffset = fBufferedSoFar; |
80 SkASSERT(fBufferedSoFar <= fBufferSize); | 132 SkASSERT(fBufferedSoFar <= fBufferSize); |
81 | 133 |
82 // Copy the buffer to the destination buffer and update the amount read. | 134 // Copy the buffer to the destination buffer and update the amount read. |
83 if (dst != NULL) { | 135 if (dst != NULL) { |
84 memcpy(dst, buffer, buffered); | 136 memcpy(dst, buffer, buffered); |
85 } | 137 } |
86 | 138 |
87 return buffered; | 139 return buffered; |
88 } | 140 } |
89 | 141 |
90 size_t SkFrontBufferedStream::readDirectlyFromStream(char* dst, size_t size) { | 142 size_t FrontBufferedStream::readDirectlyFromStream(char* dst, size_t size) { |
91 SkASSERT(size > 0); | 143 SkASSERT(size > 0); |
92 // If we get here, we have buffered all that can be buffered. | 144 // If we get here, we have buffered all that can be buffered. |
93 SkASSERT(fBufferSize == fBufferedSoFar && fOffset >= fBufferSize); | 145 SkASSERT(fBufferSize == fBufferedSoFar && fOffset >= fBufferSize); |
94 | 146 |
95 const size_t bytesReadDirectly = fStream->read(dst, size); | 147 const size_t bytesReadDirectly = fStream->read(dst, size); |
96 fOffset += bytesReadDirectly; | 148 fOffset += bytesReadDirectly; |
97 | 149 |
98 // If we have read past the end of the buffer, rewinding is no longer | 150 // If we have read past the end of the buffer, rewinding is no longer |
99 // supported, so we can go ahead and free the memory. | 151 // supported, so we can go ahead and free the memory. |
100 if (bytesReadDirectly > 0) { | 152 if (bytesReadDirectly > 0) { |
101 fBuffer.reset(0); | 153 fBuffer.reset(0); |
102 } | 154 } |
103 | 155 |
104 return bytesReadDirectly; | 156 return bytesReadDirectly; |
105 } | 157 } |
106 | 158 |
107 size_t SkFrontBufferedStream::read(void* voidDst, size_t size) { | 159 size_t FrontBufferedStream::read(void* voidDst, size_t size) { |
108 // Cast voidDst to a char* for easy addition. | 160 // Cast voidDst to a char* for easy addition. |
109 char* dst = reinterpret_cast<char*>(voidDst); | 161 char* dst = reinterpret_cast<char*>(voidDst); |
110 SkDEBUGCODE(const size_t totalSize = size;) | 162 SkDEBUGCODE(const size_t totalSize = size;) |
111 const size_t start = fOffset; | 163 const size_t start = fOffset; |
112 | 164 |
113 // First, read any data that was previously buffered. | 165 // First, read any data that was previously buffered. |
114 if (fOffset < fBufferedSoFar) { | 166 if (fOffset < fBufferedSoFar) { |
115 const size_t bytesCopied = this->readFromBuffer(dst, size); | 167 const size_t bytesCopied = this->readFromBuffer(dst, size); |
116 | 168 |
117 // Update the remaining number of bytes needed to read | 169 // Update the remaining number of bytes needed to read |
(...skipping 20 matching lines...) Expand all Loading... |
138 } | 190 } |
139 | 191 |
140 if (size > 0 && !fStream->isAtEnd()) { | 192 if (size > 0 && !fStream->isAtEnd()) { |
141 SkDEBUGCODE(const size_t bytesReadDirectly =) this->readDirectlyFromStre
am(dst, size); | 193 SkDEBUGCODE(const size_t bytesReadDirectly =) this->readDirectlyFromStre
am(dst, size); |
142 SkDEBUGCODE(size -= bytesReadDirectly;) | 194 SkDEBUGCODE(size -= bytesReadDirectly;) |
143 SkASSERT(size + (fOffset - start) == totalSize); | 195 SkASSERT(size + (fOffset - start) == totalSize); |
144 } | 196 } |
145 | 197 |
146 return fOffset - start; | 198 return fOffset - start; |
147 } | 199 } |
OLD | NEW |