src/images/SkImageDecoder_libico.cpp - platform/external/skia - Gitiles

 /*
  * 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 "SkData.h"
 #include "SkImageDecoder.h"
 #include "SkStream.h"
 #include "SkStreamPriv.h"
 #include "SkTypes.h"

 class SkICOImageDecoder : public SkImageDecoder {
 public:
     SkICOImageDecoder();

     Format getFormat() const override {
         return kICO_Format;
     }

 protected:
     Result onDecode(SkStream* stream, SkBitmap* bm, Mode) 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]+SkLeftShift(buffer[begin+1],8)
 #define read4Bytes(buffer,begin) buffer[begin]+SkLeftShift(buffer[begin+1],8)+SkLeftShift(buffer[begin+2],16)+SkLeftShift(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;
 }

 SkImageDecoder::Result SkICOImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode)
 {
     SkAutoTUnref<SkData> data(SkCopyStreamToData(stream));
     if (!data) {
         return kFailure;
     }

     const size_t length = data->size();
     // Check that the buffer is large enough to read the directory header
     if (length < 6) {
         return kFailure;
     }

     unsigned char* buf = (unsigned char*) data->data();

     //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 kFailure;
     }

     int count = read2Bytes(buf, 4);
     // Check that there are directory entries
     if (count < 1) {
         return kFailure;
     }

     // Check that buffer is large enough to read directory entries.
     // We are guaranteed that count is at least 1.  We might as well assume
     // count is 1 because this deprecated decoder only looks at the first
     // directory entry.
     if (length < (size_t)(6 + count*16)) {
         return kFailure;
     }

     //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);
     int h = readByte(buf, 7);
     SkASSERT(w >= 0 && h >= 0);
     int colorCount = readByte(buf, 8);
     //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
     const size_t size = read4Bytes(buf, 14);           //matters?
     const size_t offset = read4Bytes(buf, 18);
     // promote the sum to 64-bits to avoid overflow
     // Check that buffer is large enough to read image data
     if (offset > length || size > length || ((uint64_t)offset + size) > length) {
         return kFailure;
     }

     // 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() != nullptr) {
             // Disallow nesting ICO files within one another
             // FIXME: Can ICO files contain other formats besides PNG?
             if (otherDecoder->getFormat() == SkImageDecoder::kICO_Format) {
                 return kFailure;
             }
             // Set fields on the other decoder to be the same as this one.
             this->copyFieldsToOther(otherDecoder.get());
             const Result result = otherDecoder->decode(&subStream, bm, this->getDefaultPref(),
                                                        mode);
             // FIXME: Should we just return result here? Is it possible that data that looked like
             // a subimage was not, but was actually a valid ICO?
             if (result != kFailure) {
                 return result;
             }
         }
     }

     //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?)

     // For ico images, only a byte is used to store each dimension
     // 0 is used to represent 256
     if (w == 0) {
         w = 256;
     }
     if (h == 0) {
         h = 256;
     }

     // Check that buffer is large enough to read the bit depth
     if (length < offset + 16) {
         return kFailure;
     }
     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) = nullptr;
     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 kFailure;
     }

     //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 = SkToInt(offset + 40);
     // Check that the buffer is large enough to read the color table
     // For bmp-in-icos, there should be 4 bytes per color
     if (length < (size_t) (begin + 4*colorCount)) {
         return kFailure;
     }

     //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 = nullptr;
     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->setInfo(SkImageInfo::MakeN32Premul(w, h), calculateRowBytesFor8888(w, bitCount));

     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         delete[] colors;
         return kSuccess;
     }

     if (!this->allocPixelRef(bm, nullptr))
     {
         delete[] colors;
         return kFailure;
     }

     // The AND mask is a 1-bit alpha mask for each pixel that comes after the
     // XOR mask in the bmp.  If we check that the largest AND offset is safe,
     // it should mean all other buffer accesses will be at smaller indices and
     // will therefore be safe.
     size_t maxAndOffset = andOffset + ((andLineWidth*(h-1)+(w-1)) >> 3);
     if (length <= maxAndOffset) {
         return kFailure;
     }

     // Here we assert that all reads from the buffer using the XOR offset are
     // less than the AND offset.  This should be guaranteed based on the above
     // calculations.
 #ifdef SK_DEBUG
     int maxPixelNum = lineWidth*(h-1)+w-1;
     int maxByte;
     switch (bitCount) {
         case 1:
             maxByte = maxPixelNum >> 3;
             break;
         case 4:
             maxByte = maxPixelNum >> 1;
             break;
         case 8:
             maxByte = maxPixelNum;
             break;
         case 24:
             maxByte = maxPixelNum * 3 + 2;
             break;
         case 32:
             maxByte = maxPixelNum * 4 + 3;
             break;
         default:
             SkASSERT(false);
             return kFailure;
     }
     int maxXOROffset = xorOffset + maxByte;
     SkASSERT(maxXOROffset < andOffset);
 #endif

     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 kSuccess;
 }   //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?
     char buf[4];
     if (stream->read((void*)buf, 4) != 4) {
         return false;
     }
     int reserved = read2Bytes(buf, 0);
     int type = read2Bytes(buf, 2);
     return 0 == reserved && 1 == type;
 }

 static SkImageDecoder* sk_libico_dfactory(SkStreamRewindable* stream) {
     if (is_ico(stream)) {
         return new SkICOImageDecoder;
     }
     return nullptr;
 }

 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);
	/*
	* 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 "SkData.h"
	#include "SkImageDecoder.h"
	#include "SkStream.h"
	#include "SkStreamPriv.h"
	#include "SkTypes.h"

	class SkICOImageDecoder : public SkImageDecoder {
	public:
	SkICOImageDecoder();

	Format getFormat() const override {
	return kICO_Format;
	}

	protected:
	Result onDecode(SkStream* stream, SkBitmap* bm, Mode) 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]+SkLeftShift(buffer[begin+1],8)
	#define read4Bytes(buffer,begin) buffer[begin]+SkLeftShift(buffer[begin+1],8)+SkLeftShift(buffer[begin+2],16)+SkLeftShift(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;
	}

	SkImageDecoder::Result SkICOImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode)
	{
	SkAutoTUnref<SkData> data(SkCopyStreamToData(stream));
	if (!data) {
	return kFailure;
	}

	const size_t length = data->size();
	// Check that the buffer is large enough to read the directory header
	if (length < 6) {
	return kFailure;
	}

	unsigned char* buf = (unsigned char*) data->data();

	//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 kFailure;
	}

	int count = read2Bytes(buf, 4);
	// Check that there are directory entries
	if (count < 1) {
	return kFailure;
	}

	// Check that buffer is large enough to read directory entries.
	// We are guaranteed that count is at least 1. We might as well assume
	// count is 1 because this deprecated decoder only looks at the first
	// directory entry.
	if (length < (size_t)(6 + count*16)) {
	return kFailure;
	}

	//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);
	int h = readByte(buf, 7);
	SkASSERT(w >= 0 && h >= 0);
	int colorCount = readByte(buf, 8);
	//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
	const size_t size = read4Bytes(buf, 14); //matters?
	const size_t offset = read4Bytes(buf, 18);
	// promote the sum to 64-bits to avoid overflow
	// Check that buffer is large enough to read image data
	if (offset > length \|\| size > length \|\| ((uint64_t)offset + size) > length) {
	return kFailure;
	}

	// 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() != nullptr) {
	// Disallow nesting ICO files within one another
	// FIXME: Can ICO files contain other formats besides PNG?
	if (otherDecoder->getFormat() == SkImageDecoder::kICO_Format) {
	return kFailure;
	}
	// Set fields on the other decoder to be the same as this one.
	this->copyFieldsToOther(otherDecoder.get());
	const Result result = otherDecoder->decode(&subStream, bm, this->getDefaultPref(),
	mode);
	// FIXME: Should we just return result here? Is it possible that data that looked like
	// a subimage was not, but was actually a valid ICO?
	if (result != kFailure) {
	return result;
	}
	}
	}

	//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?)

	// For ico images, only a byte is used to store each dimension
	// 0 is used to represent 256
	if (w == 0) {
	w = 256;
	}
	if (h == 0) {
	h = 256;
	}

	// Check that buffer is large enough to read the bit depth
	if (length < offset + 16) {
	return kFailure;
	}
	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) = nullptr;
	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 kFailure;
	}

	//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 = SkToInt(offset + 40);
	// Check that the buffer is large enough to read the color table
	// For bmp-in-icos, there should be 4 bytes per color
	if (length < (size_t) (begin + 4*colorCount)) {
	return kFailure;
	}

	//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 = nullptr;
	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 + ((lineWidthhbitCount) >> 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->setInfo(SkImageInfo::MakeN32Premul(w, h), calculateRowBytesFor8888(w, bitCount));

	if (SkImageDecoder::kDecodeBounds_Mode == mode) {
	delete[] colors;
	return kSuccess;
	}

	if (!this->allocPixelRef(bm, nullptr))
	{
	delete[] colors;
	return kFailure;
	}

	// The AND mask is a 1-bit alpha mask for each pixel that comes after the
	// XOR mask in the bmp. If we check that the largest AND offset is safe,
	// it should mean all other buffer accesses will be at smaller indices and
	// will therefore be safe.
	size_t maxAndOffset = andOffset + ((andLineWidth*(h-1)+(w-1)) >> 3);
	if (length <= maxAndOffset) {
	return kFailure;
	}

	// Here we assert that all reads from the buffer using the XOR offset are
	// less than the AND offset. This should be guaranteed based on the above
	// calculations.
	#ifdef SK_DEBUG
	int maxPixelNum = lineWidth*(h-1)+w-1;
	int maxByte;
	switch (bitCount) {
	case 1:
	maxByte = maxPixelNum >> 3;
	break;
	case 4:
	maxByte = maxPixelNum >> 1;
	break;
	case 8:
	maxByte = maxPixelNum;
	break;
	case 24:
	maxByte = maxPixelNum * 3 + 2;
	break;
	case 32:
	maxByte = maxPixelNum * 4 + 3;
	break;
	default:
	SkASSERT(false);
	return kFailure;
	}
	int maxXOROffset = xorOffset + maxByte;
	SkASSERT(maxXOROffset < andOffset);
	#endif

	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 kSuccess;
	} //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?
	char buf[4];
	if (stream->read((void*)buf, 4) != 4) {
	return false;
	}
	int reserved = read2Bytes(buf, 0);
	int type = read2Bytes(buf, 2);
	return 0 == reserved && 1 == type;
	}

	static SkImageDecoder* sk_libico_dfactory(SkStreamRewindable* stream) {
	if (is_ico(stream)) {
	return new SkICOImageDecoder;
	}
	return nullptr;
	}

	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);