1/*
2 * Copyright 2015 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "include/core/SkData.h"
9#include "include/core/SkStream.h"
10#include "include/private/SkColorData.h"
11#include "include/private/SkTDArray.h"
12#include "src/codec/SkBmpCodec.h"
13#include "src/codec/SkCodecPriv.h"
14#include "src/codec/SkIcoCodec.h"
15#include "src/codec/SkPngCodec.h"
16#include "src/core/SkTSort.h"
17
18/*
19 * Checks the start of the stream to see if the image is an Ico or Cur
20 */
21bool SkIcoCodec::IsIco(const void* buffer, size_t bytesRead) {
22 const char icoSig[] = { '\x00', '\x00', '\x01', '\x00' };
23 const char curSig[] = { '\x00', '\x00', '\x02', '\x00' };
24 return bytesRead >= sizeof(icoSig) &&
25 (!memcmp(buffer, icoSig, sizeof(icoSig)) ||
26 !memcmp(buffer, curSig, sizeof(curSig)));
27}
28
29std::unique_ptr<SkCodec> SkIcoCodec::MakeFromStream(std::unique_ptr<SkStream> stream,
30 Result* result) {
31 // Header size constants
32 constexpr uint32_t kIcoDirectoryBytes = 6;
33 constexpr uint32_t kIcoDirEntryBytes = 16;
34
35 // Read the directory header
36 std::unique_ptr<uint8_t[]> dirBuffer(new uint8_t[kIcoDirectoryBytes]);
37 if (stream->read(dirBuffer.get(), kIcoDirectoryBytes) != kIcoDirectoryBytes) {
38 SkCodecPrintf("Error: unable to read ico directory header.\n");
39 *result = kIncompleteInput;
40 return nullptr;
41 }
42
43 // Process the directory header
44 const uint16_t numImages = get_short(dirBuffer.get(), 4);
45 if (0 == numImages) {
46 SkCodecPrintf("Error: No images embedded in ico.\n");
47 *result = kInvalidInput;
48 return nullptr;
49 }
50
51 // This structure is used to represent the vital information about entries
52 // in the directory header. We will obtain this information for each
53 // directory entry.
54 struct Entry {
55 uint32_t offset;
56 uint32_t size;
57 };
58 SkAutoFree dirEntryBuffer(sk_malloc_canfail(sizeof(Entry) * numImages));
59 if (!dirEntryBuffer) {
60 SkCodecPrintf("Error: OOM allocating ICO directory for %i images.\n",
61 numImages);
62 *result = kInternalError;
63 return nullptr;
64 }
65 auto* directoryEntries = reinterpret_cast<Entry*>(dirEntryBuffer.get());
66
67 // Iterate over directory entries
68 for (uint32_t i = 0; i < numImages; i++) {
69 uint8_t entryBuffer[kIcoDirEntryBytes];
70 if (stream->read(entryBuffer, kIcoDirEntryBytes) != kIcoDirEntryBytes) {
71 SkCodecPrintf("Error: Dir entries truncated in ico.\n");
72 *result = kIncompleteInput;
73 return nullptr;
74 }
75
76 // The directory entry contains information such as width, height,
77 // bits per pixel, and number of colors in the color palette. We will
78 // ignore these fields since they are repeated in the header of the
79 // embedded image. In the event of an inconsistency, we would always
80 // defer to the value in the embedded header anyway.
81
82 // Specifies the size of the embedded image, including the header
83 uint32_t size = get_int(entryBuffer, 8);
84
85 // Specifies the offset of the embedded image from the start of file.
86 // It does not indicate the start of the pixel data, but rather the
87 // start of the embedded image header.
88 uint32_t offset = get_int(entryBuffer, 12);
89
90 // Save the vital fields
91 directoryEntries[i].offset = offset;
92 directoryEntries[i].size = size;
93 }
94
95 // Default Result, if no valid embedded codecs are found.
96 *result = kInvalidInput;
97
98 // It is "customary" that the embedded images will be stored in order of
99 // increasing offset. However, the specification does not indicate that
100 // they must be stored in this order, so we will not trust that this is the
101 // case. Here we sort the embedded images by increasing offset.
102 struct EntryLessThan {
103 bool operator() (Entry a, Entry b) const {
104 return a.offset < b.offset;
105 }
106 };
107 EntryLessThan lessThan;
108 SkTQSort(directoryEntries, &directoryEntries[numImages - 1], lessThan);
109
110 // Now will construct a candidate codec for each of the embedded images
111 uint32_t bytesRead = kIcoDirectoryBytes + numImages * kIcoDirEntryBytes;
112 std::unique_ptr<SkTArray<std::unique_ptr<SkCodec>, true>> codecs(
113 new SkTArray<std::unique_ptr<SkCodec>, true>(numImages));
114 for (uint32_t i = 0; i < numImages; i++) {
115 uint32_t offset = directoryEntries[i].offset;
116 uint32_t size = directoryEntries[i].size;
117
118 // Ensure that the offset is valid
119 if (offset < bytesRead) {
120 SkCodecPrintf("Warning: invalid ico offset.\n");
121 continue;
122 }
123
124 // If we cannot skip, assume we have reached the end of the stream and
125 // stop trying to make codecs
126 if (stream->skip(offset - bytesRead) != offset - bytesRead) {
127 SkCodecPrintf("Warning: could not skip to ico offset.\n");
128 break;
129 }
130 bytesRead = offset;
131
132 // Create a new stream for the embedded codec
133 SkAutoFree buffer(sk_malloc_canfail(size));
134 if (!buffer) {
135 SkCodecPrintf("Warning: OOM trying to create embedded stream.\n");
136 break;
137 }
138
139 if (stream->read(buffer.get(), size) != size) {
140 SkCodecPrintf("Warning: could not create embedded stream.\n");
141 *result = kIncompleteInput;
142 break;
143 }
144
145 sk_sp<SkData> data(SkData::MakeFromMalloc(buffer.release(), size));
146 auto embeddedStream = SkMemoryStream::Make(data);
147 bytesRead += size;
148
149 // Check if the embedded codec is bmp or png and create the codec
150 std::unique_ptr<SkCodec> codec;
151 Result dummyResult;
152 if (SkPngCodec::IsPng((const char*) data->bytes(), data->size())) {
153 codec = SkPngCodec::MakeFromStream(std::move(embeddedStream), &dummyResult);
154 } else {
155 codec = SkBmpCodec::MakeFromIco(std::move(embeddedStream), &dummyResult);
156 }
157
158 // Save a valid codec
159 if (nullptr != codec) {
160 codecs->push_back().reset(codec.release());
161 }
162 }
163
164 // Recognize if there are no valid codecs
165 if (0 == codecs->count()) {
166 SkCodecPrintf("Error: could not find any valid embedded ico codecs.\n");
167 return nullptr;
168 }
169
170 // Use the largest codec as a "suggestion" for image info
171 size_t maxSize = 0;
172 int maxIndex = 0;
173 for (int i = 0; i < codecs->count(); i++) {
174 SkImageInfo info = codecs->operator[](i)->getInfo();
175 size_t size = info.computeMinByteSize();
176
177 if (size > maxSize) {
178 maxSize = size;
179 maxIndex = i;
180 }
181 }
182
183 auto maxInfo = codecs->operator[](maxIndex)->getEncodedInfo().copy();
184
185 *result = kSuccess;
186 // The original stream is no longer needed, because the embedded codecs own their
187 // own streams.
188 return std::unique_ptr<SkCodec>(new SkIcoCodec(std::move(maxInfo), codecs.release()));
189}
190
191SkIcoCodec::SkIcoCodec(SkEncodedInfo&& info, SkTArray<std::unique_ptr<SkCodec>, true>* codecs)
192 // The source skcms_PixelFormat will not be used. The embedded
193 // codec's will be used instead.
194 : INHERITED(std::move(info), skcms_PixelFormat(), nullptr)
195 , fEmbeddedCodecs(codecs)
196 , fCurrCodec(nullptr)
197{}
198
199/*
200 * Chooses the best dimensions given the desired scale
201 */
202SkISize SkIcoCodec::onGetScaledDimensions(float desiredScale) const {
203 // We set the dimensions to the largest candidate image by default.
204 // Regardless of the scale request, this is the largest image that we
205 // will decode.
206 int origWidth = this->dimensions().width();
207 int origHeight = this->dimensions().height();
208 float desiredSize = desiredScale * origWidth * origHeight;
209 // At least one image will have smaller error than this initial value
210 float minError = ((float) (origWidth * origHeight)) - desiredSize + 1.0f;
211 int32_t minIndex = -1;
212 for (int32_t i = 0; i < fEmbeddedCodecs->count(); i++) {
213 auto dimensions = fEmbeddedCodecs->operator[](i)->dimensions();
214 int width = dimensions.width();
215 int height = dimensions.height();
216 float error = SkTAbs(((float) (width * height)) - desiredSize);
217 if (error < minError) {
218 minError = error;
219 minIndex = i;
220 }
221 }
222 SkASSERT(minIndex >= 0);
223
224 return fEmbeddedCodecs->operator[](minIndex)->dimensions();
225}
226
227int SkIcoCodec::chooseCodec(const SkISize& requestedSize, int startIndex) {
228 SkASSERT(startIndex >= 0);
229
230 // FIXME: Cache the index from onGetScaledDimensions?
231 for (int i = startIndex; i < fEmbeddedCodecs->count(); i++) {
232 if (fEmbeddedCodecs->operator[](i)->dimensions() == requestedSize) {
233 return i;
234 }
235 }
236
237 return -1;
238}
239
240bool SkIcoCodec::onDimensionsSupported(const SkISize& dim) {
241 return this->chooseCodec(dim, 0) >= 0;
242}
243
244/*
245 * Initiates the Ico decode
246 */
247SkCodec::Result SkIcoCodec::onGetPixels(const SkImageInfo& dstInfo,
248 void* dst, size_t dstRowBytes,
249 const Options& opts,
250 int* rowsDecoded) {
251 if (opts.fSubset) {
252 // Subsets are not supported.
253 return kUnimplemented;
254 }
255
256 int index = 0;
257 SkCodec::Result result = kInvalidScale;
258 while (true) {
259 index = this->chooseCodec(dstInfo.dimensions(), index);
260 if (index < 0) {
261 break;
262 }
263
264 SkCodec* embeddedCodec = fEmbeddedCodecs->operator[](index).get();
265 result = embeddedCodec->getPixels(dstInfo, dst, dstRowBytes, &opts);
266 switch (result) {
267 case kSuccess:
268 case kIncompleteInput:
269 // The embedded codec will handle filling incomplete images, so we will indicate
270 // that all of the rows are initialized.
271 *rowsDecoded = dstInfo.height();
272 return result;
273 default:
274 // Continue trying to find a valid embedded codec on a failed decode.
275 break;
276 }
277
278 index++;
279 }
280
281 SkCodecPrintf("Error: No matching candidate image in ico.\n");
282 return result;
283}
284
285SkCodec::Result SkIcoCodec::onStartScanlineDecode(const SkImageInfo& dstInfo,
286 const SkCodec::Options& options) {
287 int index = 0;
288 SkCodec::Result result = kInvalidScale;
289 while (true) {
290 index = this->chooseCodec(dstInfo.dimensions(), index);
291 if (index < 0) {
292 break;
293 }
294
295 SkCodec* embeddedCodec = fEmbeddedCodecs->operator[](index).get();
296 result = embeddedCodec->startScanlineDecode(dstInfo, &options);
297 if (kSuccess == result) {
298 fCurrCodec = embeddedCodec;
299 return result;
300 }
301
302 index++;
303 }
304
305 SkCodecPrintf("Error: No matching candidate image in ico.\n");
306 return result;
307}
308
309int SkIcoCodec::onGetScanlines(void* dst, int count, size_t rowBytes) {
310 SkASSERT(fCurrCodec);
311 return fCurrCodec->getScanlines(dst, count, rowBytes);
312}
313
314bool SkIcoCodec::onSkipScanlines(int count) {
315 SkASSERT(fCurrCodec);
316 return fCurrCodec->skipScanlines(count);
317}
318
319SkCodec::Result SkIcoCodec::onStartIncrementalDecode(const SkImageInfo& dstInfo,
320 void* pixels, size_t rowBytes, const SkCodec::Options& options) {
321 int index = 0;
322 while (true) {
323 index = this->chooseCodec(dstInfo.dimensions(), index);
324 if (index < 0) {
325 break;
326 }
327
328 SkCodec* embeddedCodec = fEmbeddedCodecs->operator[](index).get();
329 switch (embeddedCodec->startIncrementalDecode(dstInfo,
330 pixels, rowBytes, &options)) {
331 case kSuccess:
332 fCurrCodec = embeddedCodec;
333 return kSuccess;
334 case kUnimplemented:
335 // FIXME: embeddedCodec is a BMP. If scanline decoding would work,
336 // return kUnimplemented so that SkSampledCodec will fall through
337 // to use the scanline decoder.
338 // Note that calling startScanlineDecode will require an extra
339 // rewind. The embedded codec has an SkMemoryStream, which is
340 // cheap to rewind, though it will do extra work re-reading the
341 // header.
342 // Also note that we pass nullptr for Options. This is because
343 // Options that are valid for incremental decoding may not be
344 // valid for scanline decoding.
345 // Once BMP supports incremental decoding this workaround can go
346 // away.
347 if (embeddedCodec->startScanlineDecode(dstInfo) == kSuccess) {
348 return kUnimplemented;
349 }
350 // Move on to the next embedded codec.
351 break;
352 default:
353 break;
354 }
355
356 index++;
357 }
358
359 SkCodecPrintf("Error: No matching candidate image in ico.\n");
360 return kInvalidScale;
361}
362
363SkCodec::Result SkIcoCodec::onIncrementalDecode(int* rowsDecoded) {
364 SkASSERT(fCurrCodec);
365 return fCurrCodec->incrementalDecode(rowsDecoded);
366}
367
368SkCodec::SkScanlineOrder SkIcoCodec::onGetScanlineOrder() const {
369 // FIXME: This function will possibly return the wrong value if it is called
370 // before startScanlineDecode()/startIncrementalDecode().
371 if (fCurrCodec) {
372 return fCurrCodec->getScanlineOrder();
373 }
374
375 return INHERITED::onGetScanlineOrder();
376}
377
378SkSampler* SkIcoCodec::getSampler(bool createIfNecessary) {
379 if (fCurrCodec) {
380 return fCurrCodec->getSampler(createIfNecessary);
381 }
382
383 return nullptr;
384}
385