package cnslab.image;
import java.awt.*;
import java.io.*;
import java.awt.image.*;

public class BMPFile extends Component {

    //--- Private constants
    private final static int BITMAPFILEHEADER_SIZE = 14;
    private final static int BITMAPINFOHEADER_SIZE = 40;

    //--- Private variable declaration

    //--- Bitmap file header
    private byte bitmapFileHeader [] = new byte [14];
    private byte bfType [] = {(byte)'B', (byte)'M'};
    private int bfSize = 0;
    private int bfReserved1 = 0;
    private int bfReserved2 = 0;
    private int bfOffBits = BITMAPFILEHEADER_SIZE + BITMAPINFOHEADER_SIZE;

    //--- Bitmap info header
    private byte bitmapInfoHeader [] = new byte [40];
    private int biSize = BITMAPINFOHEADER_SIZE;
    private int biWidth = 0;
    private int biHeight = 0;
    private int biPlanes = 1;
    private int biBitCount = 24;
    private int biCompression = 0;
    private int biSizeImage = 0x030000;
    private int biXPelsPerMeter = 0x0;
    private int biYPelsPerMeter = 0x0;
    private int biClrUsed = 0;
    private int biClrImportant = 0;

    //--- Bitmap raw data
    private int bitmap [];

    //--- File section
    private FileOutputStream fo;

    //--- Default constructor
    public BMPFile() {

    }


    public void saveBitmap (String parFilename, int[] imagePix, int
                            parWidth, int parHeight) {

        try {
            fo = new FileOutputStream (parFilename);
            save (imagePix, parWidth, parHeight);
            fo.close ();
        }
        catch (Exception saveEx) {
            saveEx.printStackTrace ();
        }

    }


    /*
     * The saveMethod is the main method of the process. This method
     * will call the convertImage method to convert the memory image to
     * a byte array; method writeBitmapFileHeader creates and writes
     * the bitmap file header; writeBitmapInfoHeader creates the
     * information header; and writeBitmap writes the image.
     *
     */
    private void save (int[] imagePix, int parWidth, int parHeight) {

        try {
            convertImage (imagePix, parWidth, parHeight);
            writeBitmapFileHeader ();
            writeBitmapInfoHeader ();
            writeBitmap ();
        }
        catch (Exception saveEx) {
            saveEx.printStackTrace ();
        }
    }


    /*
     * convertImage converts the memory image to the bitmap format (BRG).
     * It also computes some information for the bitmap info header.
     *
     */
    private boolean convertImage (int[] imagePix, int parWidth, int parHeight) {

        int pad;
        bitmap = imagePix;

        //          //PixelGrabber pg = new PixelGrabber (parImage, 0, 0, parWidth, parHeight,
        //          //                            bitmap, 0, parWidth);

        //          try {
        //              pg.grabPixels ();
        //          }
        //          catch (InterruptedException e) {
        //              e.printStackTrace ();
        //              return (false);
        //          }

        pad = (4 - ((parWidth * 3) % 4)) * parHeight;

        if (4 - ((parWidth * 3) % 4) == 4) pad = 0 ;

        biSizeImage = ((parWidth * parHeight) * 3) + pad;
        bfSize = biSizeImage + BITMAPFILEHEADER_SIZE +
            BITMAPINFOHEADER_SIZE;
        biWidth = parWidth;
        biHeight = parHeight;

        return (true);
    }

    /*
     * writeBitmap converts the image returned from the pixel grabber to
     * the format required. Remember: scan lines are inverted in
     * a bitmap file!
     *
     * Each scan line must be padded to an even 4-byte boundary.
     */
    private void writeBitmap () {

        int size;
        int value;
        int j;
        int i;
        int rowCount;
        int rowIndex;
        int lastRowIndex;
        int pad;
        int padCount;
        byte rgb [] = new byte [3];


        size = (biWidth * biHeight) - 1;
        pad = 4 - ((biWidth * 3) % 4);

        //The following bug correction will cause the bitmap to be unreadable by
        //GIMP.  It must be there for the bitmap to be readable by most other
        //graphics packages.
        if (pad == 4){ // <==== Bug correction
            pad = 0;
        }// <==== Bug correction


        rowCount = 1;
        padCount = 0;
        rowIndex = size - biWidth;
        lastRowIndex = rowIndex;

        try {
            // The following three lines of code are a correction supplied
            // by Alin Arsu, Feb 2003.  The original code set the top-right
            // pixel in the image to black, and also shifted the bottom row
            // of the image by one pixel.
            // The original code was the following two lines:
            // for (j = 0; j < size; j++) {
            //     value = bitmap [rowIndex];
            // This is replaced by the three lines that appear next.
            for (j = 0; j < size+1; j++) {
                if (j<biWidth) { value = bitmap [rowIndex+1]; }
                else { value = bitmap [rowIndex]; }

                rgb [0] = (byte) (value & 0xFF);
                rgb [1] = (byte) ((value >> 8) & 0xFF);
                rgb [2] = (byte) ((value >> 16) & 0xFF);
                fo.write (rgb);
                if (rowCount == biWidth) {
                    padCount += pad;
                    for (i = 1; i <= pad; i++) {
                        fo.write (0x00);
                    }
                    rowCount = 1;
                    rowIndex = lastRowIndex - biWidth;
                    lastRowIndex = rowIndex;
                }
                else
                    rowCount++;
                rowIndex++;
            }

            //--- Update the size of the file
            bfSize += padCount - pad;
            biSizeImage += padCount - pad;
        }
        catch (Exception wb) {
            wb.printStackTrace ();
        }

    }

    /*
     * writeBitmapFileHeader writes the bitmap file header to the file.
     *
     */
    private void writeBitmapFileHeader () {

        try {
            fo.write (bfType);
            fo.write (intToDWord (bfSize));
            fo.write (intToWord (bfReserved1));
            fo.write (intToWord (bfReserved2));
            fo.write (intToDWord (bfOffBits));

        }
        catch (Exception wbfh) {
            wbfh.printStackTrace ();
        }

    }

    /*
     *
     * writeBitmapInfoHeader writes the bitmap information header
     * to the file.
     *
     */

    private void writeBitmapInfoHeader () {

        try {
            fo.write (intToDWord (biSize));
            fo.write (intToDWord (biWidth));
            fo.write (intToDWord (biHeight));
            fo.write (intToWord (biPlanes));
            fo.write (intToWord (biBitCount));
            fo.write (intToDWord (biCompression));
            fo.write (intToDWord (biSizeImage));
            fo.write (intToDWord (biXPelsPerMeter));
            fo.write (intToDWord (biYPelsPerMeter));
            fo.write (intToDWord (biClrUsed));
            fo.write (intToDWord (biClrImportant));
        }
        catch (Exception wbih) {
            wbih.printStackTrace ();
        }

    }


    /*
     *
     * intToWord converts an int to a word, where the return
     * value is stored in a 2-byte array.
     *
     */
    private byte [] intToWord (int parValue) {

        byte retValue [] = new byte [2];

        retValue [0] = (byte) (parValue & 0x00FF);
        retValue [1] = (byte) ((parValue >> 8) & 0x00FF);

        return (retValue);

    }

    /*
     *
     * intToDWord converts an int to a double word, where the return
     * value is stored in a 4-byte array.
     *
     */
    private byte [] intToDWord (int parValue) {

        byte retValue [] = new byte [4];
        retValue [0] = (byte) (parValue & 0x00FF);
        retValue [1] = (byte) ((parValue >> 8) & 0x000000FF);
        retValue [2] = (byte) ((parValue >> 16) & 0x000000FF);
        retValue [3] = (byte) ((parValue >> 24) & 0x000000FF);

        return (retValue);

    }

}