2 * Copyright 2006 The Android Open Source Project
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
8 #include "SkColorPriv.h"
9 #include "SkImageDecoder.h"
11 #include "SkStreamPriv.h"
14 class SkICOImageDecoder : public SkImageDecoder {
18 virtual Format getFormat() const SK_OVERRIDE {
23 virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
26 typedef SkImageDecoder INHERITED;
29 /////////////////////////////////////////////////////////////////////////////////////////
31 //read bytes starting from the begin-th index in the buffer
32 //read in Intel order, and return an integer
34 #define readByte(buffer,begin) buffer[begin]
35 #define read2Bytes(buffer,begin) buffer[begin]+(buffer[begin+1]<<8)
36 #define read4Bytes(buffer,begin) buffer[begin]+(buffer[begin+1]<<8)+(buffer[begin+2]<<16)+(buffer[begin+3]<<24)
38 /////////////////////////////////////////////////////////////////////////////////////////
40 SkICOImageDecoder::SkICOImageDecoder()
44 //helpers - my function pointer will call one of these, depending on the bitCount, each time through the inner loop
45 static void editPixelBit1(const int pixelNo, const unsigned char* buf,
46 const int xorOffset, int& x, int y, const int w,
47 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
48 static void editPixelBit4(const int pixelNo, const unsigned char* buf,
49 const int xorOffset, int& x, int y, const int w,
50 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
51 static void editPixelBit8(const int pixelNo, const unsigned char* buf,
52 const int xorOffset, int& x, int y, const int w,
53 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
54 static void editPixelBit24(const int pixelNo, const unsigned char* buf,
55 const int xorOffset, int& x, int y, const int w,
56 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
57 static void editPixelBit32(const int pixelNo, const unsigned char* buf,
58 const int xorOffset, int& x, int y, const int w,
59 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
62 static int calculateRowBytesFor8888(int w, int bitCount)
64 // Default rowBytes is w << 2 for kARGB_8888
65 // In the case of a 4 bit image with an odd width, we need to add some
66 // so we can go off the end of the drawn bitmap.
67 // Add 4 to ensure that it is still a multiple of 4.
68 if (4 == bitCount && (w & 0x1)) {
71 // Otherwise return 0, which will allow it to be calculated automatically.
75 bool SkICOImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode)
78 const size_t length = SkCopyStreamToStorage(&autoMal, stream);
83 unsigned char* buf = (unsigned char*)autoMal.get();
85 //these should always be the same - should i use for error checking? - what about files that have some
86 //incorrect values, but still decode properly?
87 int reserved = read2Bytes(buf, 0); // 0
88 int type = read2Bytes(buf, 2); // 1
89 if (reserved != 0 || type != 1)
91 int count = read2Bytes(buf, 4);
93 //need to at least have enough space to hold the initial table of info
94 if (length < (size_t)(6 + count*16))
97 #ifdef SK_SUPPORT_LEGACY_IMAGEDECODER_CHOOSER
99 Chooser* chooser = this->getChooser();
100 //FIXME:if no chooser, consider providing the largest color image
101 //what are the odds that the largest image would be monochrome?
102 if (NULL == chooser) {
105 chooser->begin(count);
106 for (int i = 0; i < count; i++)
108 //need to find out the config, width, and height from the stream
109 int width = readByte(buf, 6 + i*16);
110 int height = readByte(buf, 7 + i*16);
111 int offset = read4Bytes(buf, 18 + i*16);
112 int bitCount = read2Bytes(buf, offset+14);
114 //currently only provide ARGB_8888_, but maybe we want kIndex8_Config for 1 and 4, and possibly 8?
115 //or maybe we'll determine this based on the provided config
120 // In reality, at least for the moment, these will be decoded into kARGB_8888 bitmaps.
121 // However, this will be used to distinguish between the lower quality 1bpp and 4 bpp
122 // images and the higher quality images.
123 c = SkBitmap::kIndex8_Config;
128 c = SkBitmap::kARGB_8888_Config;
131 SkDEBUGF(("Image with %ibpp not supported\n", bitCount));
134 chooser->inspect(i, c, width, height);
136 choice = chooser->choose();
139 //you never know what the chooser is going to supply
140 if (choice >= count || choice < 0)
143 const int choice = 0; // TODO: fold this value into the expressions below
146 //skip ahead to the correct header
147 //commented out lines are not used, but if i switch to other read method, need to know how many to skip
148 //otherwise, they could be used for error checking
149 int w = readByte(buf, 6 + choice*16);
150 int h = readByte(buf, 7 + choice*16);
151 int colorCount = readByte(buf, 8 + choice*16);
152 //int reservedToo = readByte(buf, 9 + choice*16); //0
153 //int planes = read2Bytes(buf, 10 + choice*16); //1 - but often 0
154 //int fakeBitCount = read2Bytes(buf, 12 + choice*16); //should be real - usually 0
155 const size_t size = read4Bytes(buf, 14 + choice*16); //matters?
156 const size_t offset = read4Bytes(buf, 18 + choice*16);
157 // promote the sum to 64-bits to avoid overflow
158 if (((uint64_t)offset + size) > length) {
162 // Check to see if this is a PNG image inside the ICO
164 SkMemoryStream subStream(buf + offset, size, false);
165 SkAutoTDelete<SkImageDecoder> otherDecoder(SkImageDecoder::Factory(&subStream));
166 if (otherDecoder.get() != NULL) {
167 // Disallow nesting ICO files within one another
168 if (otherDecoder->getFormat() == SkImageDecoder::kICO_Format) {
171 // Set fields on the other decoder to be the same as this one.
172 this->copyFieldsToOther(otherDecoder.get());
173 if(otherDecoder->decode(&subStream, bm, this->getDefaultPref(), mode)) {
179 //int infoSize = read4Bytes(buf, offset); //40
180 //int width = read4Bytes(buf, offset+4); //should == w
181 //int height = read4Bytes(buf, offset+8); //should == 2*h
182 //int planesToo = read2Bytes(buf, offset+12); //should == 1 (does it?)
183 int bitCount = read2Bytes(buf, offset+14);
185 void (*placePixel)(const int pixelNo, const unsigned char* buf,
186 const int xorOffset, int& x, int y, const int w,
187 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors) = NULL;
191 placePixel = &editPixelBit1;
195 placePixel = &editPixelBit4;
199 placePixel = &editPixelBit8;
203 placePixel = &editPixelBit24;
207 placePixel = &editPixelBit32;
211 SkDEBUGF(("Decoding %ibpp is unimplemented\n", bitCount));
215 //these should all be zero, but perhaps are not - need to check
216 //int compression = read4Bytes(buf, offset+16); //0
217 //int imageSize = read4Bytes(buf, offset+20); //0 - sometimes has a value
218 //int xPixels = read4Bytes(buf, offset+24); //0
219 //int yPixels = read4Bytes(buf, offset+28); //0
220 //int colorsUsed = read4Bytes(buf, offset+32) //0 - might have an actual value though
221 //int colorsImportant = read4Bytes(buf, offset+36); //0
223 int begin = offset + 40;
224 //this array represents the colortable
225 //if i allow other types of bitmaps, it may actually be used as a part of the bitmap
226 SkPMColor* colors = NULL;
227 int blue, green, red;
230 colors = new SkPMColor[colorCount];
231 for (int j = 0; j < colorCount; j++)
233 //should this be a function - maybe a #define?
234 blue = readByte(buf, begin + 4*j);
235 green = readByte(buf, begin + 4*j + 1);
236 red = readByte(buf, begin + 4*j + 2);
237 colors[j] = SkPackARGB32(0xFF, red & 0xFF, green & 0xFF, blue & 0xFF);
240 int bitWidth = w*bitCount;
241 int test = bitWidth & 0x1F;
242 int mask = -(((test >> 4) | (test >> 3) | (test >> 2) | (test >> 1) | test) & 0x1); //either 0xFFFFFFFF or 0
243 int lineBitWidth = (bitWidth & 0xFFFFFFE0) + (0x20 & mask);
244 int lineWidth = lineBitWidth/bitCount;
246 int xorOffset = begin + colorCount*4; //beginning of the color bitmap
247 //other read method means we will just be here already
248 int andOffset = xorOffset + ((lineWidth*h*bitCount) >> 3);
250 /*int */test = w & 0x1F; //the low 5 bits - we are rounding up to the next 32 (2^5)
251 /*int */mask = -(((test >> 4) | (test >> 3) | (test >> 2) | (test >> 1) | test) & 0x1); //either 0xFFFFFFFF or 0
252 int andLineWidth = (w & 0xFFFFFFE0) + (0x20 & mask);
253 //if we allow different Configs, everything is the same til here
254 //change the config, and use different address getter, and place index vs color, and add the color table
255 //FIXME: what is the tradeoff in size?
256 //if the andbitmap (mask) is all zeroes, then we can easily do an index bitmap
257 //however, with small images with large colortables, maybe it's better to still do argb_8888
259 bm->setInfo(SkImageInfo::MakeN32Premul(w, h), calculateRowBytesFor8888(w, bitCount));
261 if (SkImageDecoder::kDecodeBounds_Mode == mode) {
266 if (!this->allocPixelRef(bm, NULL))
272 SkAutoLockPixels alp(*bm);
274 for (int y = 0; y < h; y++)
276 for (int x = 0; x < w; x++)
278 //U32* address = bm->getAddr32(x, y);
280 //check the alpha bit first, but pass it along to the function to figure out how to deal with it
281 int andPixelNo = andLineWidth*(h-y-1)+x;
282 //only need to get a new alphaByte when x %8 == 0
283 //but that introduces an if and a mod - probably much slower
284 //that's ok, it's just a read of an array, not a stream
285 int alphaByte = readByte(buf, andOffset + (andPixelNo >> 3));
286 int shift = 7 - (andPixelNo & 0x7);
289 int pixelNo = lineWidth*(h-y-1)+x;
290 placePixel(pixelNo, buf, xorOffset, x, y, w, bm, alphaByte, m, shift, colors);
296 //ensure we haven't read off the end?
297 //of course this doesn't help us if the andOffset was a lie...
298 //return andOffset + (andLineWidth >> 3) <= length;
302 //function to place the pixel, determined by the bitCount
303 static void editPixelBit1(const int pixelNo, const unsigned char* buf,
304 const int xorOffset, int& x, int y, const int w,
305 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
307 // note that this should be the same as/similar to the AND bitmap
308 SkPMColor* address = bm->getAddr32(x,y);
309 int byte = readByte(buf, xorOffset + (pixelNo >> 3));
312 // Read all of the bits in this byte.
314 // Pin to the width so we do not write outside the bounds of
317 // While loop to check all 8 bits individually.
321 colorBit = (byte & m) >> shift;
322 alphaBit = (alphaByte & m) >> shift;
323 *address = (alphaBit-1)&(colors[colorBit]);
325 // setup for the next pixel
326 address = address + 1;
332 static void editPixelBit4(const int pixelNo, const unsigned char* buf,
333 const int xorOffset, int& x, int y, const int w,
334 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
336 SkPMColor* address = bm->getAddr32(x, y);
337 int byte = readByte(buf, xorOffset + (pixelNo >> 1));
338 int pixel = (byte >> 4) & 0xF;
339 int alphaBit = (alphaByte & m) >> shift;
340 *address = (alphaBit-1)&(colors[pixel]);
342 //if w is odd, x may be the same as w, which means we are writing to an unused portion of the bitmap
343 //but that's okay, since i've added an extra rowByte for just this purpose
344 address = address + 1;
347 alphaBit = (alphaByte & m) >> (shift-1);
348 //speed up trick here
349 *address = (alphaBit-1)&(colors[pixel]);
352 static void editPixelBit8(const int pixelNo, const unsigned char* buf,
353 const int xorOffset, int& x, int y, const int w,
354 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
356 SkPMColor* address = bm->getAddr32(x, y);
357 int pixel = readByte(buf, xorOffset + pixelNo);
358 int alphaBit = (alphaByte & m) >> shift;
359 *address = (alphaBit-1)&(colors[pixel]);
362 static void editPixelBit24(const int pixelNo, const unsigned char* buf,
363 const int xorOffset, int& x, int y, const int w,
364 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
366 SkPMColor* address = bm->getAddr32(x, y);
367 int blue = readByte(buf, xorOffset + 3*pixelNo);
368 int green = readByte(buf, xorOffset + 3*pixelNo + 1);
369 int red = readByte(buf, xorOffset + 3*pixelNo + 2);
370 int alphaBit = (alphaByte & m) >> shift;
371 //alphaBit == 1 => alpha = 0
372 int alpha = (alphaBit-1) & 0xFF;
373 *address = SkPreMultiplyARGB(alpha, red, green, blue);
376 static void editPixelBit32(const int pixelNo, const unsigned char* buf,
377 const int xorOffset, int& x, int y, const int w,
378 SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
380 SkPMColor* address = bm->getAddr32(x, y);
381 int blue = readByte(buf, xorOffset + 4*pixelNo);
382 int green = readByte(buf, xorOffset + 4*pixelNo + 1);
383 int red = readByte(buf, xorOffset + 4*pixelNo + 2);
384 int alphaBit = (alphaByte & m) >> shift;
385 #if 1 // don't trust the alphaBit for 32bit images <mrr>
388 int alpha = readByte(buf, xorOffset + 4*pixelNo + 3) & ((alphaBit-1)&0xFF);
389 *address = SkPreMultiplyARGB(alpha, red, green, blue);
392 ///////////////////////////////////////////////////////////////////////////////
393 DEFINE_DECODER_CREATOR(ICOImageDecoder);
394 /////////////////////////////////////////////////////////////////////////////////////////
396 static bool is_ico(SkStreamRewindable* stream) {
397 // Check to see if the first four bytes are 0,0,1,0
398 // FIXME: Is that required and sufficient?
399 SkAutoMalloc autoMal(4);
400 unsigned char* buf = (unsigned char*)autoMal.get();
401 stream->read((void*)buf, 4);
402 int reserved = read2Bytes(buf, 0);
403 int type = read2Bytes(buf, 2);
404 if (reserved != 0 || type != 1) {
405 // This stream does not represent an ICO image.
411 static SkImageDecoder* sk_libico_dfactory(SkStreamRewindable* stream) {
412 if (is_ico(stream)) {
413 return SkNEW(SkICOImageDecoder);
418 static SkImageDecoder_DecodeReg gReg(sk_libico_dfactory);
420 static SkImageDecoder::Format get_format_ico(SkStreamRewindable* stream) {
421 if (is_ico(stream)) {
422 return SkImageDecoder::kICO_Format;
424 return SkImageDecoder::kUnknown_Format;
427 static SkImageDecoder_FormatReg gFormatReg(get_format_ico);