The Tor Browser: comparison gfx/skia/trunk/src/images/SkImageDecoder

--1:000000000000
+:31f97abd37c3
+/*
+* Copyright 2006 The Android Open Source Project
+*
+* Use of this source code is governed by a BSD-style license that can be
+* found in the LICENSE file.
+*/
+#include "SkColorPriv.h"
+#include "SkImageDecoder.h"
+#include "SkStream.h"
+#include "SkStreamHelpers.h"
+#include "SkTypes.h"
+class SkICOImageDecoder : public SkImageDecoder {
+public:
+SkICOImageDecoder();
+virtual Format getFormat() const SK_OVERRIDE {
+return kICO_Format;
+}
+protected:
+virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
+private:
+typedef SkImageDecoder INHERITED;
+};
+/////////////////////////////////////////////////////////////////////////////////////////
+//read bytes starting from the begin-th index in the buffer
+//read in Intel order, and return an integer
+#define readByte(buffer,begin) buffer[begin]
+#define read2Bytes(buffer,begin) buffer[begin]+(buffer[begin+1]<<8)
+#define read4Bytes(buffer,begin) buffer[begin]+(buffer[begin+1]<<8)+(buffer[begin+2]<<16)+(buffer[begin+3]<<24)
+/////////////////////////////////////////////////////////////////////////////////////////
+SkICOImageDecoder::SkICOImageDecoder()
+{
+}
+//helpers - my function pointer will call one of these, depending on the bitCount, each time through the inner loop
+static void editPixelBit1(const int pixelNo, const unsigned char* buf,
+const int xorOffset, int& x, int y, const int w,
+SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
+static void editPixelBit4(const int pixelNo, const unsigned char* buf,
+const int xorOffset, int& x, int y, const int w,
+SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
+static void editPixelBit8(const int pixelNo, const unsigned char* buf,
+const int xorOffset, int& x, int y, const int w,
+SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
+static void editPixelBit24(const int pixelNo, const unsigned char* buf,
+const int xorOffset, int& x, int y, const int w,
+SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
+static void editPixelBit32(const int pixelNo, const unsigned char* buf,
+const int xorOffset, int& x, int y, const int w,
+SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
+static int calculateRowBytesFor8888(int w, int bitCount)
+{
+//  Default rowBytes is w << 2 for kARGB_8888
+//  In the case of a 4 bit image with an odd width, we need to add some
+//  so we can go off the end of the drawn bitmap.
+//  Add 4 to ensure that it is still a multiple of 4.
+if (4 == bitCount && (w & 0x1)) {
+return (w + 1) << 2;
+}
+//  Otherwise return 0, which will allow it to be calculated automatically.
+return 0;
+}
+bool SkICOImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode)
+{
+SkAutoMalloc autoMal;
+const size_t length = CopyStreamToStorage(&autoMal, stream);
+if (0 == length) {
+return false;
+}
+unsigned char* buf = (unsigned char*)autoMal.get();
+//these should always be the same - should i use for error checking? - what about files that have some
+//incorrect values, but still decode properly?
+int reserved = read2Bytes(buf, 0);    // 0
+int type = read2Bytes(buf, 2);        // 1
+if (reserved != 0 || type != 1)
+return false;
+int count = read2Bytes(buf, 4);
+//need to at least have enough space to hold the initial table of info
+if (length < (size_t)(6 + count*16))
+return false;
+int choice;
+Chooser* chooser = this->getChooser();
+//FIXME:if no chooser, consider providing the largest color image
+//what are the odds that the largest image would be monochrome?
+if (NULL == chooser) {
+choice = 0;
+} else {
+chooser->begin(count);
+for (int i = 0; i < count; i++)
+{
+//need to find out the config, width, and height from the stream
+int width = readByte(buf, 6 + i*16);
+int height = readByte(buf, 7 + i*16);
+int offset = read4Bytes(buf, 18 + i*16);
+int bitCount = read2Bytes(buf, offset+14);
+SkBitmap::Config c;
+//currently only provide ARGB_8888_, but maybe we want kIndex8_Config for 1 and 4, and possibly 8?
+//or maybe we'll determine this based on the provided config
+switch (bitCount)
+{
+case 1:
+case 4:
+// In reality, at least for the moment, these will be decoded into kARGB_8888 bitmaps.
+// However, this will be used to distinguish between the lower quality 1bpp and 4 bpp
+// images and the higher quality images.
+c = SkBitmap::kIndex8_Config;
+break;
+case 8:
+case 24:
+case 32:
+c = SkBitmap::kARGB_8888_Config;
+break;
+default:
+SkDEBUGF(("Image with %ibpp not supported\n", bitCount));
+continue;
+}
+chooser->inspect(i, c, width, height);
+}
+choice = chooser->choose();
+}
+//you never know what the chooser is going to supply
+if (choice >= count || choice < 0)
+return false;
+//skip ahead to the correct header
+//commented out lines are not used, but if i switch to other read method, need to know how many to skip
+//otherwise, they could be used for error checking
+int w = readByte(buf, 6 + choice*16);
+int h = readByte(buf, 7 + choice*16);
+int colorCount = readByte(buf, 8 + choice*16);
+//int reservedToo = readByte(buf, 9 + choice*16);   //0
+//int planes = read2Bytes(buf, 10 + choice*16);       //1 - but often 0
+//int fakeBitCount = read2Bytes(buf, 12 + choice*16); //should be real - usually 0
+int size = read4Bytes(buf, 14 + choice*16);           //matters?
+int offset = read4Bytes(buf, 18 + choice*16);
+if ((size_t)(offset + size) > length)
+return false;
+// Check to see if this is a PNG image inside the ICO
+{
+SkMemoryStream subStream(buf + offset, size, false);
+SkAutoTDelete<SkImageDecoder> otherDecoder(SkImageDecoder::Factory(&subStream));
+if (otherDecoder.get() != NULL) {
+// Set fields on the other decoder to be the same as this one.
+this->copyFieldsToOther(otherDecoder.get());
+if(otherDecoder->decode(&subStream, bm, this->getDefaultPref(), mode)) {
+return true;
+}
+}
+}
+//int infoSize = read4Bytes(buf, offset);             //40
+//int width = read4Bytes(buf, offset+4);              //should == w
+//int height = read4Bytes(buf, offset+8);             //should == 2*h
+//int planesToo = read2Bytes(buf, offset+12);         //should == 1 (does it?)
+int bitCount = read2Bytes(buf, offset+14);
+void (*placePixel)(const int pixelNo, const unsigned char* buf,
+const int xorOffset, int& x, int y, const int w,
+SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors) = NULL;
+switch (bitCount)
+{
+case 1:
+placePixel = &editPixelBit1;
+colorCount = 2;
+break;
+case 4:
+placePixel = &editPixelBit4;
+colorCount = 16;
+break;
+case 8:
+placePixel = &editPixelBit8;
+colorCount = 256;
+break;
+case 24:
+placePixel = &editPixelBit24;
+colorCount = 0;
+break;
+case 32:
+placePixel = &editPixelBit32;
+colorCount = 0;
+break;
+default:
+SkDEBUGF(("Decoding %ibpp is unimplemented\n", bitCount));
+return false;
+}
+//these should all be zero, but perhaps are not - need to check
+//int compression = read4Bytes(buf, offset+16);       //0
+//int imageSize = read4Bytes(buf, offset+20);         //0 - sometimes has a value
+//int xPixels = read4Bytes(buf, offset+24);           //0
+//int yPixels = read4Bytes(buf, offset+28);           //0
+//int colorsUsed = read4Bytes(buf, offset+32)         //0 - might have an actual value though
+//int colorsImportant = read4Bytes(buf, offset+36);   //0
+int begin = offset + 40;
+//this array represents the colortable
+//if i allow other types of bitmaps, it may actually be used as a part of the bitmap
+SkPMColor* colors = NULL;
+int blue, green, red;
+if (colorCount)
+{
+colors = new SkPMColor[colorCount];
+for (int j = 0; j < colorCount; j++)
+{
+//should this be a function - maybe a #define?
+blue = readByte(buf, begin + 4*j);
+green = readByte(buf, begin + 4*j + 1);
+red = readByte(buf, begin + 4*j + 2);
+colors[j] = SkPackARGB32(0xFF, red & 0xFF, green & 0xFF, blue & 0xFF);
+}
+}
+int bitWidth = w*bitCount;
+int test = bitWidth & 0x1F;
+int mask = -(((test >> 4) | (test >> 3) | (test >> 2) | (test >> 1) | test) & 0x1);    //either 0xFFFFFFFF or 0
+int lineBitWidth = (bitWidth & 0xFFFFFFE0) + (0x20 & mask);
+int lineWidth = lineBitWidth/bitCount;
+int xorOffset = begin + colorCount*4;   //beginning of the color bitmap
+//other read method means we will just be here already
+int andOffset = xorOffset + ((lineWidth*h*bitCount) >> 3);
+/*int */test = w & 0x1F;   //the low 5 bits - we are rounding up to the next 32 (2^5)
+/*int */mask = -(((test >> 4) | (test >> 3) | (test >> 2) | (test >> 1) | test) & 0x1);    //either 0xFFFFFFFF or 0
+int andLineWidth = (w & 0xFFFFFFE0) + (0x20 & mask);
+//if we allow different Configs, everything is the same til here
+//change the config, and use different address getter, and place index vs color, and add the color table
+//FIXME: what is the tradeoff in size?
+//if the andbitmap (mask) is all zeroes, then we can easily do an index bitmap
+//however, with small images with large colortables, maybe it's better to still do argb_8888
+bm->setConfig(SkBitmap::kARGB_8888_Config, w, h, calculateRowBytesFor8888(w, bitCount));
+if (SkImageDecoder::kDecodeBounds_Mode == mode) {
+delete[] colors;
+return true;
+}
+if (!this->allocPixelRef(bm, NULL))
+{
+delete[] colors;
+return false;
+}
+SkAutoLockPixels alp(*bm);
+for (int y = 0; y < h; y++)
+{
+for (int x = 0; x < w; x++)
+{
+//U32* address = bm->getAddr32(x, y);
+//check the alpha bit first, but pass it along to the function to figure out how to deal with it
+int andPixelNo = andLineWidth*(h-y-1)+x;
+//only need to get a new alphaByte when x %8 == 0
+//but that introduces an if and a mod - probably much slower
+//that's ok, it's just a read of an array, not a stream
+int alphaByte = readByte(buf, andOffset + (andPixelNo >> 3));
+int shift = 7 - (andPixelNo & 0x7);
+int m = 1 << shift;
+int pixelNo = lineWidth*(h-y-1)+x;
+placePixel(pixelNo, buf, xorOffset, x, y, w, bm, alphaByte, m, shift, colors);
+}
+}
+delete [] colors;
+//ensure we haven't read off the end?
+//of course this doesn't help us if the andOffset was a lie...
+//return andOffset + (andLineWidth >> 3) <= length;
+return true;
+}   //onDecode
+//function to place the pixel, determined by the bitCount
+static void editPixelBit1(const int pixelNo, const unsigned char* buf,
+const int xorOffset, int& x, int y, const int w,
+SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
+{
+// note that this should be the same as/similar to the AND bitmap
+SkPMColor* address = bm->getAddr32(x,y);
+int byte = readByte(buf, xorOffset + (pixelNo >> 3));
+int colorBit;
+int alphaBit;
+// Read all of the bits in this byte.
+int i = x + 8;
+// Pin to the width so we do not write outside the bounds of
+// our color table.
+i = i > w ? w : i;
+// While loop to check all 8 bits individually.
+while (x < i)
+{
+colorBit = (byte & m) >> shift;
+alphaBit = (alphaByte & m) >> shift;
+*address = (alphaBit-1)&(colors[colorBit]);
+x++;
+// setup for the next pixel
+address = address + 1;
+m = m >> 1;
+shift -= 1;
+}
+x--;
+}
+static void editPixelBit4(const int pixelNo, const unsigned char* buf,
+const int xorOffset, int& x, int y, const int w,
+SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
+{
+SkPMColor* address = bm->getAddr32(x, y);
+int byte = readByte(buf, xorOffset + (pixelNo >> 1));
+int pixel = (byte >> 4) & 0xF;
+int alphaBit = (alphaByte & m) >> shift;
+*address = (alphaBit-1)&(colors[pixel]);
+x++;
+//if w is odd, x may be the same as w, which means we are writing to an unused portion of the bitmap
+//but that's okay, since i've added an extra rowByte for just this purpose
+address = address + 1;
+pixel = byte & 0xF;
+m = m >> 1;
+alphaBit = (alphaByte & m) >> (shift-1);
+//speed up trick here
+*address = (alphaBit-1)&(colors[pixel]);
+}
+static void editPixelBit8(const int pixelNo, const unsigned char* buf,
+const int xorOffset, int& x, int y, const int w,
+SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
+{
+SkPMColor* address = bm->getAddr32(x, y);
+int pixel = readByte(buf, xorOffset + pixelNo);
+int alphaBit = (alphaByte & m) >> shift;
+*address = (alphaBit-1)&(colors[pixel]);
+}
+static void editPixelBit24(const int pixelNo, const unsigned char* buf,
+const int xorOffset, int& x, int y, const int w,
+SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
+{
+SkPMColor* address = bm->getAddr32(x, y);
+int blue = readByte(buf, xorOffset + 3*pixelNo);
+int green = readByte(buf, xorOffset + 3*pixelNo + 1);
+int red = readByte(buf, xorOffset + 3*pixelNo + 2);
+int alphaBit = (alphaByte & m) >> shift;
+//alphaBit == 1 => alpha = 0
+int alpha = (alphaBit-1) & 0xFF;
+*address = SkPreMultiplyARGB(alpha, red, green, blue);
+}
+static void editPixelBit32(const int pixelNo, const unsigned char* buf,
+const int xorOffset, int& x, int y, const int w,
+SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
+{
+SkPMColor* address = bm->getAddr32(x, y);
+int blue = readByte(buf, xorOffset + 4*pixelNo);
+int green = readByte(buf, xorOffset + 4*pixelNo + 1);
+int red = readByte(buf, xorOffset + 4*pixelNo + 2);
+int alphaBit = (alphaByte & m) >> shift;
+#if 1 // don't trust the alphaBit for 32bit images <mrr>
+alphaBit = 0;
+#endif
+int alpha = readByte(buf, xorOffset + 4*pixelNo + 3) & ((alphaBit-1)&0xFF);
+*address = SkPreMultiplyARGB(alpha, red, green, blue);
+}
+///////////////////////////////////////////////////////////////////////////////
+DEFINE_DECODER_CREATOR(ICOImageDecoder);
+/////////////////////////////////////////////////////////////////////////////////////////
+static bool is_ico(SkStreamRewindable* stream) {
+// Check to see if the first four bytes are 0,0,1,0
+// FIXME: Is that required and sufficient?
+SkAutoMalloc autoMal(4);
+unsigned char* buf = (unsigned char*)autoMal.get();
+stream->read((void*)buf, 4);
+int reserved = read2Bytes(buf, 0);
+int type = read2Bytes(buf, 2);
+if (reserved != 0 || type != 1) {
+// This stream does not represent an ICO image.
+return false;
+}
+return true;
+}
+static SkImageDecoder* sk_libico_dfactory(SkStreamRewindable* stream) {
+if (is_ico(stream)) {
+return SkNEW(SkICOImageDecoder);
+}
+return NULL;
+}
+static SkImageDecoder_DecodeReg gReg(sk_libico_dfactory);
+static SkImageDecoder::Format get_format_ico(SkStreamRewindable* stream) {
+if (is_ico(stream)) {
+return SkImageDecoder::kICO_Format;
+}
+return SkImageDecoder::kUnknown_Format;
+}
+static SkImageDecoder_FormatReg gFormatReg(get_format_ico);

The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/images/SkImageDecoder_libico.cpp

gfx/skia/trunk/src/images/SkImageDecoder_libico.cpp