k++;
              }
              for (i=7; i>=0 ; i--) {
                 if ((i+x)< bmp_infoheader.biWidth) {
                     data[b+x+i] = (byte)((rawData[k] >>> (7-i)) & 1);
                 }
              }
            }
        } else if (bmp_infoheader.biBitCount == 4) {
            for (y=0; y < bmp_infoheader.biHeight; y++) {
              b=(bmp_infoheader.biHeight-1-y)*bmp_infoheader.biWidth;
              k=y*scanlineSize;
              for (x=0; x < (bmp_infoheader.biWidth-2); x+=2) {
                data[b+x]   = (byte)((rawData[k]>>4) & 0x0F);
                data[b+x+1] = (byte)((rawData[k] & 0x0F));
                k+=1;
              }
              for (i=1; i>=0 ; i--) {
                 if ((i+x)< bmp_infoheader.biWidth) {
                     data[b+x+i] = (byte)((rawData[k] >>> ((1-i)<<2)) & 0x0F);
                 }
              }              
            }
        } else {
            for (y=0; y < bmp_infoheader.biHeight; y++) {
              b=(bmp_infoheader.biHeight-1-y)*bmp_infoheader.biWidth;
              k=y*scanlineSize;
              for (x=0; x < bmp_infoheader.biWidth; x++) {
                data[x+b] = (byte)(rawData[k++] & 0xFF);
              }
            }
        }
        }catch (Exception e) {};

        ColorModel colourModel = new IndexColorModel(bmp_infoheader.biBitCount, bmp_palette.length, bmp_palette.r, bmp_palette.g, bmp_palette.b);
        return Toolkit.getDefaultToolkit().createImage(new MemoryImageSource(bmp_infoheader.biWidth, bmp_infoheader.biHeight, colourModel, data, 0, bmp_infoheader.biWidth));
    }

    /**
    * .BMP InfoHeader
    */

    class BmpInfoHeader {
        int   biSize = 40;                  /* InfoHeader Offset*/
        int   biWidth;                      /* Width */
        int   biHeight;                     /* Height */
        short biPlanes = 1;                 /* BitPlanes on Target Device */
        short biBitCount;                   /* Bits per Pixel */
        int   biCompression;                /* Bitmap Compression */
        int   biSizeImage;                  /* Bitmap Image Size */
        int   biXPelsPerMeter;              /* Horiz Pixels Per Meter */
        int   biYPelsPerMeter;              /* Vert Pixels Per Meter */
        int   biClrUsed;                    /* Number of ColorMap Entries */
        int   biClrImportant;               /* Number of important colours */
        
        int getSize() {
           return biSize;
        }

        void read(PCBinaryInputStream file) {
            try {
                biSize = file.readInt();
                if (biSize == 12) {
                    biWidth = file.readShort();
                    biHeight = file.readShort();
                    biPlanes = file.readShort();
                    biBitCount = file.readShort();
                }
                else
                {
                    biWidth = file.readInt();
                    biHeight = file.readInt();
                    biPlanes = file.readShort();
                    biBitCount = file.readShort();
                    biCompression = file.readInt();
                    biSizeImage = file.readInt();
                    biXPelsPerMeter = file.readInt();
                    biYPelsPerMeter = file.readInt();
                    biClrUsed = file.readInt();
                    biClrImportant = file.readInt();
                }
            } catch (IOException e) { System.err.println(e); }

            if (biSizeImage == 0)
                biSizeImage = (((biWidth*biBitCount+31)>>5)<<2)*biHeight;

            if (biClrUsed == 0 && biBitCount < 16)
                biClrUsed = 1 << biBitCount;
        }

        void write(PCBinaryOutputStream file) {
            try {
                file.writeInt(biSize);
                if (biSize == 12) {
                    file.writeShort((short)biWidth);
                    file.writeShort((short)biHeight);
                    file.writeShort(biPlanes);
                    file.writeShort(biBitCount);
                }
                else {
                    file.writeInt(biWidth);
                    file.writeInt(biHeight);
                    file.writeShort(biPlanes);
                    file.writeShort(biBitCount);
                    file.writeInt(biCompression);
                    file.writeInt(biSizeImage);
                    file.writeInt(biXPelsPerMeter);
                    file.writeInt(biYPelsPerMeter);
                    file.writeInt(biClrUsed);
                    file.writeInt(biClrImportant);
                }
            } catch (IOException e) {
                System.err.println(e);
            }
        }
    }

    /**
    * .BMP FileHeader
    */

    class BmpFileheader {
        byte    bfType[] = {'B','M'};       /* Type */
        int     bfSize;                     /* File Size */
        short   bfReserved1=0;              /* Reserved 1 */
        short   bfReserved2=0;              /* Reserved 2 */
        int     bfOffBits;                  /* Offset to Data */

        int getSize() {
           return 14;
        }

        void read(PCBinaryInputStream file) {
            try {
                bfType[0] = file.readByte();
                bfType[1] = file.readByte();
                if (bfType[0] != 'B' && bfType[1] != 'M')
                    throw new IOException("Invalid BMP 3.0 File.");
                bfSize = file.readInt();
                bfReserved1 = file.readShort();
                bfReserved2 = file.readShort();
                bfOffBits = file.readInt();
            } catch (IOException e) {
                System.err.println(e);
            }
        }

        void write(PCBinaryOutputStream file) {
            try {
            file.writeByte(bfType[0]);
            file.writeByte(bfType[1]);
            file.writeInt(bfSize);
            file.writeShort(bfReserved1);
            file.writeShort(bfReserved2);
            file.writeInt(bfOffBits);
            } catch (IOException e) {
                System.err.println(e);
            }
        }
    }

    /**
    * .BMP Palette
    */

    class BmpPalette {
        int length;
        byte r[];
        byte g[];
        byte b[];

        public BmpPalette(int length)
        {
            this.length = length;
            r = new byte[length];
            g = new byte[length];
            b = new byte[length];
        }

        int getSize() {
           return length*4;
        }

        public BmpPalette(ColorModel colourModel) {
            if (colourModel instanceof IndexColorModel) {
                IndexColorModel indexColourModel = (IndexColorModel)colourModel;
                this.length = indexColourModel.getMapSize();
                r = new byte[length];
                indexColourModel.getReds(r);
                g = new byte[length];
                indexColourModel.getGreens(g);
                b = new byte[length];
                indexColourModel.getBlues(b);
                bmp_infoheader.biBitCount = (short)indexColourModel.getPixelSize();
                bmp_infoheader.biClrUsed = length;
            }
        }

        void read(PCBinaryInputStream file) {
            if (length > 0) {
                try {
                    byte reserved;
                    for (int i=0; i < length; i++) {
                        b[i] = file.readByte();     // blue
                        g[i] = file.readByte();     // green
                        r[i] = file.readByte();     // red
                        reserved = file.readByte(); // reserved
                    }
                } catch (IOException e) {
                    System.err.println(e);
                }
            }
        }

        void write(PCBinaryOutputStream file) {
            if (length > 0) {
                try {
                    byte reserved = 0;
                    for (int i=0; i < length; i++) {
                        file.writeByte(b[i]);
                        file.writeByte(g[i]);
                        file.writeByte(r[i]);
                        file.writeByte(reserved);
                    }
                } catch (IOException e) {
                    System.err.println(e);
                }
            }
        }
    }

}