OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright 2006 The Android Open Source Project | |
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 "SkColorPriv.h" | |
9 #include "SkData.h" | |
10 #include "SkImageDecoder.h" | |
11 #include "SkStream.h" | |
12 #include "SkStreamPriv.h" | |
13 #include "SkTypes.h" | |
14 | |
15 class SkICOImageDecoder : public SkImageDecoder { | |
16 public: | |
17 SkICOImageDecoder(); | |
18 | |
19 Format getFormat() const override { | |
20 return kICO_Format; | |
21 } | |
22 | |
23 protected: | |
24 Result onDecode(SkStream* stream, SkBitmap* bm, Mode) override; | |
25 | |
26 private: | |
27 typedef SkImageDecoder INHERITED; | |
28 }; | |
29 | |
30 ////////////////////////////////////////////////////////////////////////////////
///////// | |
31 | |
32 //read bytes starting from the begin-th index in the buffer | |
33 //read in Intel order, and return an integer | |
34 | |
35 #define readByte(buffer,begin) buffer[begin] | |
36 #define read2Bytes(buffer,begin) buffer[begin]+SkLeftShift(buffer[begin+1],8) | |
37 #define read4Bytes(buffer,begin) buffer[begin]+SkLeftShift(buffer[begin+1],8)+Sk
LeftShift(buffer[begin+2],16)+SkLeftShift(buffer[begin+3],24) | |
38 | |
39 ////////////////////////////////////////////////////////////////////////////////
///////// | |
40 | |
41 SkICOImageDecoder::SkICOImageDecoder() | |
42 { | |
43 } | |
44 | |
45 //helpers - my function pointer will call one of these, depending on the bitCoun
t, each time through the inner loop | |
46 static void editPixelBit1(const int pixelNo, const unsigned char* buf, | |
47 const int xorOffset, int& x, int y, const int w, | |
48 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors); | |
49 static void editPixelBit4(const int pixelNo, const unsigned char* buf, | |
50 const int xorOffset, int& x, int y, const int w, | |
51 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors); | |
52 static void editPixelBit8(const int pixelNo, const unsigned char* buf, | |
53 const int xorOffset, int& x, int y, const int w, | |
54 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors); | |
55 static void editPixelBit24(const int pixelNo, const unsigned char* buf, | |
56 const int xorOffset, int& x, int y, const int w, | |
57 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors); | |
58 static void editPixelBit32(const int pixelNo, const unsigned char* buf, | |
59 const int xorOffset, int& x, int y, const int w, | |
60 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors); | |
61 | |
62 | |
63 static int calculateRowBytesFor8888(int w, int bitCount) | |
64 { | |
65 // Default rowBytes is w << 2 for kARGB_8888 | |
66 // In the case of a 4 bit image with an odd width, we need to add some | |
67 // so we can go off the end of the drawn bitmap. | |
68 // Add 4 to ensure that it is still a multiple of 4. | |
69 if (4 == bitCount && (w & 0x1)) { | |
70 return (w + 1) << 2; | |
71 } | |
72 // Otherwise return 0, which will allow it to be calculated automatically. | |
73 return 0; | |
74 } | |
75 | |
76 SkImageDecoder::Result SkICOImageDecoder::onDecode(SkStream* stream, SkBitmap* b
m, Mode mode) { | |
77 auto data = SkCopyStreamToData(stream); | |
78 if (!data) { | |
79 return kFailure; | |
80 } | |
81 | |
82 const size_t length = data->size(); | |
83 // Check that the buffer is large enough to read the directory header | |
84 if (length < 6) { | |
85 return kFailure; | |
86 } | |
87 | |
88 unsigned char* buf = (unsigned char*) data->data(); | |
89 | |
90 //these should always be the same - should i use for error checking? - what
about files that have some | |
91 //incorrect values, but still decode properly? | |
92 int reserved = read2Bytes(buf, 0); // 0 | |
93 int type = read2Bytes(buf, 2); // 1 | |
94 if (reserved != 0 || type != 1) { | |
95 return kFailure; | |
96 } | |
97 | |
98 int count = read2Bytes(buf, 4); | |
99 // Check that there are directory entries | |
100 if (count < 1) { | |
101 return kFailure; | |
102 } | |
103 | |
104 // Check that buffer is large enough to read directory entries. | |
105 // We are guaranteed that count is at least 1. We might as well assume | |
106 // count is 1 because this deprecated decoder only looks at the first | |
107 // directory entry. | |
108 if (length < (size_t)(6 + count*16)) { | |
109 return kFailure; | |
110 } | |
111 | |
112 //skip ahead to the correct header | |
113 //commented out lines are not used, but if i switch to other read method, ne
ed to know how many to skip | |
114 //otherwise, they could be used for error checking | |
115 int w = readByte(buf, 6); | |
116 int h = readByte(buf, 7); | |
117 SkASSERT(w >= 0 && h >= 0); | |
118 int colorCount = readByte(buf, 8); | |
119 //int reservedToo = readByte(buf, 9 + choice*16); //0 | |
120 //int planes = read2Bytes(buf, 10 + choice*16); //1 - but often 0 | |
121 //int fakeBitCount = read2Bytes(buf, 12 + choice*16); //should be real - usu
ally 0 | |
122 const size_t size = read4Bytes(buf, 14); //matters? | |
123 const size_t offset = read4Bytes(buf, 18); | |
124 // promote the sum to 64-bits to avoid overflow | |
125 // Check that buffer is large enough to read image data | |
126 if (offset > length || size > length || ((uint64_t)offset + size) > length)
{ | |
127 return kFailure; | |
128 } | |
129 | |
130 // Check to see if this is a PNG image inside the ICO | |
131 { | |
132 SkMemoryStream subStream(buf + offset, size, false); | |
133 SkAutoTDelete<SkImageDecoder> otherDecoder(SkImageDecoder::Factory(&subS
tream)); | |
134 if (otherDecoder.get() != nullptr) { | |
135 // Disallow nesting ICO files within one another | |
136 // FIXME: Can ICO files contain other formats besides PNG? | |
137 if (otherDecoder->getFormat() == SkImageDecoder::kICO_Format) { | |
138 return kFailure; | |
139 } | |
140 // Set fields on the other decoder to be the same as this one. | |
141 this->copyFieldsToOther(otherDecoder.get()); | |
142 const Result result = otherDecoder->decode(&subStream, bm, this->get
DefaultPref(), | |
143 mode); | |
144 // FIXME: Should we just return result here? Is it possible that dat
a that looked like | |
145 // a subimage was not, but was actually a valid ICO? | |
146 if (result != kFailure) { | |
147 return result; | |
148 } | |
149 } | |
150 } | |
151 | |
152 //int infoSize = read4Bytes(buf, offset); //40 | |
153 //int width = read4Bytes(buf, offset+4); //should == w | |
154 //int height = read4Bytes(buf, offset+8); //should == 2*h | |
155 //int planesToo = read2Bytes(buf, offset+12); //should == 1 (does it
?) | |
156 | |
157 // For ico images, only a byte is used to store each dimension | |
158 // 0 is used to represent 256 | |
159 if (w == 0) { | |
160 w = 256; | |
161 } | |
162 if (h == 0) { | |
163 h = 256; | |
164 } | |
165 | |
166 // Check that buffer is large enough to read the bit depth | |
167 if (length < offset + 16) { | |
168 return kFailure; | |
169 } | |
170 int bitCount = read2Bytes(buf, offset+14); | |
171 | |
172 void (*placePixel)(const int pixelNo, const unsigned char* buf, | |
173 const int xorOffset, int& x, int y, const int w, | |
174 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors) = null
ptr; | |
175 switch (bitCount) | |
176 { | |
177 case 1: | |
178 placePixel = &editPixelBit1; | |
179 colorCount = 2; | |
180 break; | |
181 case 4: | |
182 placePixel = &editPixelBit4; | |
183 colorCount = 16; | |
184 break; | |
185 case 8: | |
186 placePixel = &editPixelBit8; | |
187 colorCount = 256; | |
188 break; | |
189 case 24: | |
190 placePixel = &editPixelBit24; | |
191 colorCount = 0; | |
192 break; | |
193 case 32: | |
194 placePixel = &editPixelBit32; | |
195 colorCount = 0; | |
196 break; | |
197 default: | |
198 SkDEBUGF(("Decoding %ibpp is unimplemented\n", bitCount)); | |
199 return kFailure; | |
200 } | |
201 | |
202 //these should all be zero, but perhaps are not - need to check | |
203 //int compression = read4Bytes(buf, offset+16); //0 | |
204 //int imageSize = read4Bytes(buf, offset+20); //0 - sometimes has a
value | |
205 //int xPixels = read4Bytes(buf, offset+24); //0 | |
206 //int yPixels = read4Bytes(buf, offset+28); //0 | |
207 //int colorsUsed = read4Bytes(buf, offset+32) //0 - might have an ac
tual value though | |
208 //int colorsImportant = read4Bytes(buf, offset+36); //0 | |
209 | |
210 int begin = SkToInt(offset + 40); | |
211 // Check that the buffer is large enough to read the color table | |
212 // For bmp-in-icos, there should be 4 bytes per color | |
213 if (length < (size_t) (begin + 4*colorCount)) { | |
214 return kFailure; | |
215 } | |
216 | |
217 //this array represents the colortable | |
218 //if i allow other types of bitmaps, it may actually be used as a part of th
e bitmap | |
219 SkPMColor* colors = nullptr; | |
220 int blue, green, red; | |
221 if (colorCount) | |
222 { | |
223 colors = new SkPMColor[colorCount]; | |
224 for (int j = 0; j < colorCount; j++) | |
225 { | |
226 //should this be a function - maybe a #define? | |
227 blue = readByte(buf, begin + 4*j); | |
228 green = readByte(buf, begin + 4*j + 1); | |
229 red = readByte(buf, begin + 4*j + 2); | |
230 colors[j] = SkPackARGB32(0xFF, red & 0xFF, green & 0xFF, blue & 0xFF
); | |
231 } | |
232 } | |
233 int bitWidth = w*bitCount; | |
234 int test = bitWidth & 0x1F; | |
235 int mask = -(((test >> 4) | (test >> 3) | (test >> 2) | (test >> 1) | test)
& 0x1); //either 0xFFFFFFFF or 0 | |
236 int lineBitWidth = (bitWidth & 0xFFFFFFE0) + (0x20 & mask); | |
237 int lineWidth = lineBitWidth/bitCount; | |
238 | |
239 int xorOffset = begin + colorCount*4; //beginning of the color bitmap | |
240 //other read method means we will ju
st be here already | |
241 int andOffset = xorOffset + ((lineWidth*h*bitCount) >> 3); | |
242 | |
243 /*int */test = w & 0x1F; //the low 5 bits - we are rounding up to the next
32 (2^5) | |
244 /*int */mask = -(((test >> 4) | (test >> 3) | (test >> 2) | (test >> 1) | te
st) & 0x1); //either 0xFFFFFFFF or 0 | |
245 int andLineWidth = (w & 0xFFFFFFE0) + (0x20 & mask); | |
246 //if we allow different Configs, everything is the same til here | |
247 //change the config, and use different address getter, and place index vs co
lor, and add the color table | |
248 //FIXME: what is the tradeoff in size? | |
249 //if the andbitmap (mask) is all zeroes, then we can easily do an index bitm
ap | |
250 //however, with small images with large colortables, maybe it's better to st
ill do argb_8888 | |
251 | |
252 bm->setInfo(SkImageInfo::MakeN32Premul(w, h), calculateRowBytesFor8888(w, bi
tCount)); | |
253 | |
254 if (SkImageDecoder::kDecodeBounds_Mode == mode) { | |
255 delete[] colors; | |
256 return kSuccess; | |
257 } | |
258 | |
259 if (!this->allocPixelRef(bm, nullptr)) | |
260 { | |
261 delete[] colors; | |
262 return kFailure; | |
263 } | |
264 | |
265 // The AND mask is a 1-bit alpha mask for each pixel that comes after the | |
266 // XOR mask in the bmp. If we check that the largest AND offset is safe, | |
267 // it should mean all other buffer accesses will be at smaller indices and | |
268 // will therefore be safe. | |
269 size_t maxAndOffset = andOffset + ((andLineWidth*(h-1)+(w-1)) >> 3); | |
270 if (length <= maxAndOffset) { | |
271 return kFailure; | |
272 } | |
273 | |
274 // Here we assert that all reads from the buffer using the XOR offset are | |
275 // less than the AND offset. This should be guaranteed based on the above | |
276 // calculations. | |
277 #ifdef SK_DEBUG | |
278 int maxPixelNum = lineWidth*(h-1)+w-1; | |
279 int maxByte; | |
280 switch (bitCount) { | |
281 case 1: | |
282 maxByte = maxPixelNum >> 3; | |
283 break; | |
284 case 4: | |
285 maxByte = maxPixelNum >> 1; | |
286 break; | |
287 case 8: | |
288 maxByte = maxPixelNum; | |
289 break; | |
290 case 24: | |
291 maxByte = maxPixelNum * 3 + 2; | |
292 break; | |
293 case 32: | |
294 maxByte = maxPixelNum * 4 + 3; | |
295 break; | |
296 default: | |
297 SkASSERT(false); | |
298 return kFailure; | |
299 } | |
300 int maxXOROffset = xorOffset + maxByte; | |
301 SkASSERT(maxXOROffset < andOffset); | |
302 #endif | |
303 | |
304 SkAutoLockPixels alp(*bm); | |
305 | |
306 for (int y = 0; y < h; y++) | |
307 { | |
308 for (int x = 0; x < w; x++) | |
309 { | |
310 //U32* address = bm->getAddr32(x, y); | |
311 | |
312 //check the alpha bit first, but pass it along to the function to fi
gure out how to deal with it | |
313 int andPixelNo = andLineWidth*(h-y-1)+x; | |
314 //only need to get a new alphaByte when x %8 == 0 | |
315 //but that introduces an if and a mod - probably much slower | |
316 //that's ok, it's just a read of an array, not a stream | |
317 int alphaByte = readByte(buf, andOffset + (andPixelNo >> 3)); | |
318 int shift = 7 - (andPixelNo & 0x7); | |
319 int m = 1 << shift; | |
320 | |
321 int pixelNo = lineWidth*(h-y-1)+x; | |
322 placePixel(pixelNo, buf, xorOffset, x, y, w, bm, alphaByte, m, shift
, colors); | |
323 | |
324 } | |
325 } | |
326 | |
327 delete [] colors; | |
328 //ensure we haven't read off the end? | |
329 //of course this doesn't help us if the andOffset was a lie... | |
330 //return andOffset + (andLineWidth >> 3) <= length; | |
331 return kSuccess; | |
332 } //onDecode | |
333 | |
334 //function to place the pixel, determined by the bitCount | |
335 static void editPixelBit1(const int pixelNo, const unsigned char* buf, | |
336 const int xorOffset, int& x, int y, const int w, | |
337 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors) | |
338 { | |
339 // note that this should be the same as/similar to the AND bitmap | |
340 SkPMColor* address = bm->getAddr32(x,y); | |
341 int byte = readByte(buf, xorOffset + (pixelNo >> 3)); | |
342 int colorBit; | |
343 int alphaBit; | |
344 // Read all of the bits in this byte. | |
345 int i = x + 8; | |
346 // Pin to the width so we do not write outside the bounds of | |
347 // our color table. | |
348 i = i > w ? w : i; | |
349 // While loop to check all 8 bits individually. | |
350 while (x < i) | |
351 { | |
352 | |
353 colorBit = (byte & m) >> shift; | |
354 alphaBit = (alphaByte & m) >> shift; | |
355 *address = (alphaBit-1)&(colors[colorBit]); | |
356 x++; | |
357 // setup for the next pixel | |
358 address = address + 1; | |
359 m = m >> 1; | |
360 shift -= 1; | |
361 } | |
362 x--; | |
363 } | |
364 static void editPixelBit4(const int pixelNo, const unsigned char* buf, | |
365 const int xorOffset, int& x, int y, const int w, | |
366 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors) | |
367 { | |
368 SkPMColor* address = bm->getAddr32(x, y); | |
369 int byte = readByte(buf, xorOffset + (pixelNo >> 1)); | |
370 int pixel = (byte >> 4) & 0xF; | |
371 int alphaBit = (alphaByte & m) >> shift; | |
372 *address = (alphaBit-1)&(colors[pixel]); | |
373 x++; | |
374 //if w is odd, x may be the same as w, which means we are writing to an unus
ed portion of the bitmap | |
375 //but that's okay, since i've added an extra rowByte for just this purpose | |
376 address = address + 1; | |
377 pixel = byte & 0xF; | |
378 m = m >> 1; | |
379 alphaBit = (alphaByte & m) >> (shift-1); | |
380 //speed up trick here | |
381 *address = (alphaBit-1)&(colors[pixel]); | |
382 } | |
383 | |
384 static void editPixelBit8(const int pixelNo, const unsigned char* buf, | |
385 const int xorOffset, int& x, int y, const int w, | |
386 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors) | |
387 { | |
388 SkPMColor* address = bm->getAddr32(x, y); | |
389 int pixel = readByte(buf, xorOffset + pixelNo); | |
390 int alphaBit = (alphaByte & m) >> shift; | |
391 *address = (alphaBit-1)&(colors[pixel]); | |
392 } | |
393 | |
394 static void editPixelBit24(const int pixelNo, const unsigned char* buf, | |
395 const int xorOffset, int& x, int y, const int w, | |
396 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors) | |
397 { | |
398 SkPMColor* address = bm->getAddr32(x, y); | |
399 int blue = readByte(buf, xorOffset + 3*pixelNo); | |
400 int green = readByte(buf, xorOffset + 3*pixelNo + 1); | |
401 int red = readByte(buf, xorOffset + 3*pixelNo + 2); | |
402 int alphaBit = (alphaByte & m) >> shift; | |
403 //alphaBit == 1 => alpha = 0 | |
404 int alpha = (alphaBit-1) & 0xFF; | |
405 *address = SkPreMultiplyARGB(alpha, red, green, blue); | |
406 } | |
407 | |
408 static void editPixelBit32(const int pixelNo, const unsigned char* buf, | |
409 const int xorOffset, int& x, int y, const int w, | |
410 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors) | |
411 { | |
412 SkPMColor* address = bm->getAddr32(x, y); | |
413 int blue = readByte(buf, xorOffset + 4*pixelNo); | |
414 int green = readByte(buf, xorOffset + 4*pixelNo + 1); | |
415 int red = readByte(buf, xorOffset + 4*pixelNo + 2); | |
416 int alphaBit = (alphaByte & m) >> shift; | |
417 #if 1 // don't trust the alphaBit for 32bit images <mrr> | |
418 alphaBit = 0; | |
419 #endif | |
420 int alpha = readByte(buf, xorOffset + 4*pixelNo + 3) & ((alphaBit-1)&0xFF); | |
421 *address = SkPreMultiplyARGB(alpha, red, green, blue); | |
422 } | |
423 | |
424 /////////////////////////////////////////////////////////////////////////////// | |
425 DEFINE_DECODER_CREATOR(ICOImageDecoder); | |
426 ////////////////////////////////////////////////////////////////////////////////
///////// | |
427 | |
428 static bool is_ico(SkStreamRewindable* stream) { | |
429 // Check to see if the first four bytes are 0,0,1,0 | |
430 // FIXME: Is that required and sufficient? | |
431 char buf[4]; | |
432 if (stream->read((void*)buf, 4) != 4) { | |
433 return false; | |
434 } | |
435 int reserved = read2Bytes(buf, 0); | |
436 int type = read2Bytes(buf, 2); | |
437 return 0 == reserved && 1 == type; | |
438 } | |
439 | |
440 static SkImageDecoder* sk_libico_dfactory(SkStreamRewindable* stream) { | |
441 if (is_ico(stream)) { | |
442 return new SkICOImageDecoder; | |
443 } | |
444 return nullptr; | |
445 } | |
446 | |
447 static SkImageDecoder_DecodeReg gReg(sk_libico_dfactory); | |
448 | |
449 static SkImageDecoder::Format get_format_ico(SkStreamRewindable* stream) { | |
450 if (is_ico(stream)) { | |
451 return SkImageDecoder::kICO_Format; | |
452 } | |
453 return SkImageDecoder::kUnknown_Format; | |
454 } | |
455 | |
456 static SkImageDecoder_FormatReg gFormatReg(get_format_ico); | |
OLD | NEW |