예제 #1
0
 public static IconHolder BitmapToIconHolder(Bitmap b)
 {
     var bmp = new BitmapHolder();
     using (var stream = new MemoryStream())
     {
         b.Save(stream, ImageFormat.Bmp);
         stream.Position = 0;
         bmp.Open(stream);
     }
     return BitmapToIconHolder(bmp);
 }
예제 #2
0
        public static IconHolder BitmapToIconHolder(BitmapHolder bmp)
        {
            var mapColors = (bmp.Info.InfoHeader.BiBitCount <= 24);
            //Hashtable uniqueColors = new Hashtable(maximumColors);
            // actual colors is probably nowhere near maximum, so dont try to initialize the hashtable
            var uniqueColors = new Hashtable();

            int sourcePosition = 0;
            int numPixels = bmp.Info.InfoHeader.BiHeight*bmp.Info.InfoHeader.BiWidth;
            var indexedImage = new byte[numPixels];
            byte colorIndex;

            if (mapColors)
            {
                for (var i = 0; i < indexedImage.Length; i++)
                {
                    //TODO: currently assumes source bitmap is 24bit color
                    //read 3 bytes, convert to color
                    var pixel = new byte[3];
                    Array.Copy(bmp.ImageData, sourcePosition, pixel, 0, 3);
                    sourcePosition += 3;

                    var color = new RGBQUAD(pixel);
                    if (uniqueColors.Contains(color))
                    {
                        colorIndex = Convert.ToByte(uniqueColors[color]);
                    }
                    else
                    {
                        if (uniqueColors.Count > byte.MaxValue)
                        {
                            throw new NotSupportedException(
                                String.Format("The source image contains more than {0} colors.", byte.MaxValue));
                        }
                        colorIndex = Convert.ToByte(uniqueColors.Count);
                        uniqueColors.Add(color, colorIndex);
                    }
                    // store pixel as an index into the color table
                    indexedImage[i] = colorIndex;
                }
            }
            else
            {
                // added by Pavel Janda on 14/11/2006
                if (bmp.Info.InfoHeader.BiBitCount == 32)
                {
                    for (var i = 0; i < indexedImage.Length; i++)
                    {
                        //TODO: currently assumes source bitmap is 32bit color with alpha set to zero
                        //ignore first byte, read another 3 bytes, convert to color
                        var pixel = new byte[4];
                        Array.Copy(bmp.ImageData, sourcePosition, pixel, 0, 4);
                        sourcePosition += 4;

                        var color = new RGBQUAD(pixel[0], pixel[1], pixel[2], pixel[3]);
                        if (uniqueColors.Contains(color))
                        {
                            colorIndex = Convert.ToByte(uniqueColors[color]);
                        }
                        else
                        {
                            if (uniqueColors.Count > byte.MaxValue)
                            {
                                throw new NotSupportedException(
                                    String.Format("The source image contains more than {0} colors.", byte.MaxValue));
                            }
                            colorIndex = Convert.ToByte(uniqueColors.Count);
                            uniqueColors.Add(color, colorIndex);
                        }
                        // store pixel as an index into the color table
                        indexedImage[i] = colorIndex;
                    }
                    // end of addition
                }
                else
                {
                    //TODO: implement converting an indexed bitmap
                    throw new NotImplementedException("Unable to convert indexed bitmaps.");
                }
            }

            ushort bitCount = GetBitCount(uniqueColors.Count);
            // *** Build Icon ***
            var ico = new IconHolder {IconDirectory = {Entries = new IconDirEntry[1]}};
            //TODO: is it really safe to assume the bitmap width/height are bytes?
            ico.IconDirectory.Entries[0].Width = (byte) bmp.Info.InfoHeader.BiWidth;
            ico.IconDirectory.Entries[0].Height = (byte) bmp.Info.InfoHeader.BiHeight;
            ico.IconDirectory.Entries[0].BitCount = bitCount; // maybe 0?
            ico.IconDirectory.Entries[0].ColorCount = (uniqueColors.Count > byte.MaxValue)
                                                          ? (byte) 0
                                                          : (byte) uniqueColors.Count;
            //HACK: safe to assume that the first imageoffset is always 22
            ico.IconDirectory.Entries[0].ImageOffset = 22;
            ico.IconDirectory.Entries[0].Planes = 0;
            ico.IconImages[0].Header.BiBitCount = bitCount;
            ico.IconImages[0].Header.BiWidth = ico.IconDirectory.Entries[0].Width;
            // height is doubled in header, to account for XOR and AND
            ico.IconImages[0].Header.BiHeight = ico.IconDirectory.Entries[0].Height << 1;
            ico.IconImages[0].XOR = new byte[ico.IconImages[0].NumBytesInXor()];
            ico.IconImages[0].AND = new byte[ico.IconImages[0].NumBytesInAnd()];
            ico.IconImages[0].Header.BiSize = 40; // always
            ico.IconImages[0].Header.BiSizeImage = (uint) ico.IconImages[0].XOR.Length;
            ico.IconImages[0].Header.BiPlanes = 1;
            ico.IconImages[0].Colors = BuildColorTable(uniqueColors, bitCount);
            //BytesInRes = biSize + colors * 4 + XOR + AND
            ico.IconDirectory.Entries[0].BytesInRes = (uint) (ico.IconImages[0].Header.BiSize
                                                              + (ico.IconImages[0].Colors.Length*4)
                                                              + ico.IconImages[0].XOR.Length
                                                              + ico.IconImages[0].AND.Length);

            // copy image data
            var bytePosXOR = 0;
            var bytePosAND = 0;
            byte transparentIndex = indexedImage[0];
            //initialize AND
            ico.IconImages[0].AND[0] = byte.MaxValue;

            int pixelsPerByte;
            int[] shiftCounts;

            switch (bitCount)
            {
                case 1:
                    pixelsPerByte = 8;
                    shiftCounts = new[] {7, 6, 5, 4, 3, 2, 1, 0};
                    break;
                case 4:
                    pixelsPerByte = 2;
                    shiftCounts = new[] {4, 0};
                    break;
                case 8:
                    pixelsPerByte = 1;
                    shiftCounts = new[] {0};
                    break;
                default:
                    throw new NotSupportedException("Bits per pixel must be 1, 4, or 8");
            }
            int bytesPerRow = ico.IconDirectory.Entries[0].Width/pixelsPerByte;
            int padBytes = bytesPerRow%4;
            if (padBytes > 0)
                padBytes = 4 - padBytes;

            sourcePosition = 0;
            for (var row = 0; row < ico.IconDirectory.Entries[0].Height; ++row)
            {
                for (var rowByte = 0; rowByte < bytesPerRow; ++rowByte)
                {
                    byte currentByte = 0;
                    for (var pixel = 0; pixel < pixelsPerByte; ++pixel)
                    {
                        byte index = indexedImage[sourcePosition++];
                        var shiftedIndex = (byte) (index << shiftCounts[pixel]);
                        currentByte |= shiftedIndex;
                    }
                    ico.IconImages[0].XOR[bytePosXOR] = currentByte;
                    ++bytePosXOR;
                }
                // make sure each scan line ends on a long boundary
                bytePosXOR += padBytes;
            }

            for (var i = 0; i < indexedImage.Length; i++)
            {
                var index = indexedImage[i];
                var bitPosAND = 128 >> (i%8);
                if (index != transparentIndex)
                    ico.IconImages[0].AND[bytePosAND] ^= (byte) bitPosAND;
                if (bitPosAND == 1)
                {
                    // need to start another byte for next pixel
                    if (bytePosAND%2 == 1)
                    {
                        //TODO: fix assumption that icon is 16px wide
                        //skip some bytes so that scanline ends on a long barrier
                        bytePosAND += 3;
                    }
                    else
                    {
                        bytePosAND += 1;
                    }
                    if (bytePosAND < ico.IconImages[0].AND.Length)
                        ico.IconImages[0].AND[bytePosAND] = byte.MaxValue;
                }
            }
            return ico;
        }