jpegencoder.java

JavaExplorer是一个独立于平台的浏览器

            PutBits -= 8;
        }

        if (PutBits > 0) {
            int c = ((PutBuffer >> 16) & 0xFF);

            try {
                outStream.write(c);
            } catch (IOException e) {
                System.out.println("IO Error: " + e.getMessage());
            }
        }
    }

    /*
    * Initialisation of the Huffman codes for Luminance and Chrominance.
    * This code results in the same tables created in the IJG Jpeg-6a
    * library.
    */
    public void initHuf() {
        DC_matrix0 = new int[12][2];
        DC_matrix1 = new int[12][2];
        AC_matrix0 = new int[255][2];
        AC_matrix1 = new int[255][2];
        DC_matrix = new Object[2];
        AC_matrix = new Object[2];

        int p;
        int l;
        int i;
        int lastp;
        int si;
        int code;
        int[] huffsize = new int[257];
        int[] huffcode = new int[257];

        /*
        * init of the DC values for the chrominance
        * [][0] is the code   [][1] is the number of bit
        */
        p = 0;

        for (l = 1; l <= 16; l++) {
            for (i = 1; i <= bitsDCchrominance[l]; i++) {
                huffsize[p++] = l;
            }
        }

        huffsize[p] = 0;
        lastp = p;

        code = 0;
        si = huffsize[0];
        p = 0;

        while (huffsize[p] != 0) {
            while (huffsize[p] == si) {
                huffcode[p++] = code;
                code++;
            }

            code <<= 1;
            si++;
        }

        for (p = 0; p < lastp; p++) {
            DC_matrix1[valDCchrominance[p]][0] = huffcode[p];
            DC_matrix1[valDCchrominance[p]][1] = huffsize[p];
        }

        /*
        * Init of the AC hufmann code for the chrominance
        * matrix [][][0] is the code & matrix[][][1] is the number of bit needed
        */
        p = 0;

        for (l = 1; l <= 16; l++) {
            for (i = 1; i <= bitsACchrominance[l]; i++) {
                huffsize[p++] = l;
            }
        }

        huffsize[p] = 0;
        lastp = p;

        code = 0;
        si = huffsize[0];
        p = 0;

        while (huffsize[p] != 0) {
            while (huffsize[p] == si) {
                huffcode[p++] = code;
                code++;
            }

            code <<= 1;
            si++;
        }

        for (p = 0; p < lastp; p++) {
            AC_matrix1[valACchrominance[p]][0] = huffcode[p];
            AC_matrix1[valACchrominance[p]][1] = huffsize[p];
        }

        /*
        * init of the DC values for the luminance
        * [][0] is the code   [][1] is the number of bit
        */
        p = 0;

        for (l = 1; l <= 16; l++) {
            for (i = 1; i <= bitsDCluminance[l]; i++) {
                huffsize[p++] = l;
            }
        }

        huffsize[p] = 0;
        lastp = p;

        code = 0;
        si = huffsize[0];
        p = 0;

        while (huffsize[p] != 0) {
            while (huffsize[p] == si) {
                huffcode[p++] = code;
                code++;
            }

            code <<= 1;
            si++;
        }

        for (p = 0; p < lastp; p++) {
            DC_matrix0[valDCluminance[p]][0] = huffcode[p];
            DC_matrix0[valDCluminance[p]][1] = huffsize[p];
        }

        /*
        * Init of the AC hufmann code for luminance
        * matrix [][][0] is the code & matrix[][][1] is the number of bit
        */
        p = 0;

        for (l = 1; l <= 16; l++) {
            for (i = 1; i <= bitsACluminance[l]; i++) {
                huffsize[p++] = l;
            }
        }

        huffsize[p] = 0;
        lastp = p;

        code = 0;
        si = huffsize[0];
        p = 0;

        while (huffsize[p] != 0) {
            while (huffsize[p] == si) {
                huffcode[p++] = code;
                code++;
            }

            code <<= 1;
            si++;
        }

        for (int q = 0; q < lastp; q++) {
            AC_matrix0[valACluminance[q]][0] = huffcode[q];
            AC_matrix0[valACluminance[q]][1] = huffsize[q];
        }

        DC_matrix[0] = DC_matrix0;
        DC_matrix[1] = DC_matrix1;
        AC_matrix[0] = AC_matrix0;
        AC_matrix[1] = AC_matrix1;
    }
}


/*
 * JpegInfo - Given an image, sets default information about it and divides
 * it into its constituant components, downsizing those that need to be.
 */
class JpegInfo {
    String Comment;
    public Image imageobj;
    public int imageHeight;
    public int imageWidth;
    public int[] BlockWidth;
    public int[] BlockHeight;

    // the following are set as the default
    public int Precision = 8;
    public int NumberOfComponents = 3;
    public Object[] Components;
    public int[] CompID = { 1, 2, 3 };
    public int[] HsampFactor = { 1, 1, 1 };
    public int[] VsampFactor = { 1, 1, 1 };
    public int[] QtableNumber = { 0, 1, 1 };
    public int[] DCtableNumber = { 0, 1, 1 };
    public int[] ACtableNumber = { 0, 1, 1 };
    public boolean[] lastColumnIsDummy = { false, false, false };
    public boolean[] lastRowIsDummy = { false, false, false };
    public int Ss = 0;
    public int Se = 63;
    public int Ah = 0;
    public int Al = 0;
    public int[] compWidth;
    public int[] compHeight;
    public int MaxHsampFactor;
    public int MaxVsampFactor;

    public JpegInfo(Image image) {
        Components = new Object[NumberOfComponents];
        compWidth = new int[NumberOfComponents];
        compHeight = new int[NumberOfComponents];
        BlockWidth = new int[NumberOfComponents];
        BlockHeight = new int[NumberOfComponents];
        imageobj = image;
        imageWidth = image.getWidth(null);
        imageHeight = image.getHeight(null);
        Comment = "JPEG Encoder Copyright 1998, James R. Weeks and BioElectroMech.  ";
        getYCCArray();
    }

    public void setComment(String comment) {
        Comment.concat(comment);
    }

    public String getComment() {
        return Comment;
    }

    /*
     * This method creates and fills three arrays, Y, Cb, and Cr using the
     * input image.
     */
    private void getYCCArray() {
        int[] values = new int[imageWidth * imageHeight];
        int r;
        int g;
        int b;
        int y;
        int x;

        // In order to minimize the chance that grabPixels will throw an exception
        // it may be necessary to grab some pixels every few scanlines and process
        // those before going for more.  The time expense may be prohibitive.
        // However, for a situation where memory overhead is a concern, this may be
        // the only choice.
        PixelGrabber grabber = new PixelGrabber(imageobj.getSource(), 0, 0,
                imageWidth, imageHeight, values, 0, imageWidth);
        MaxHsampFactor = 1;
        MaxVsampFactor = 1;

        for (y = 0; y < NumberOfComponents; y++) {
            MaxHsampFactor = Math.max(MaxHsampFactor, HsampFactor[y]);
            MaxVsampFactor = Math.max(MaxVsampFactor, VsampFactor[y]);
        }

        for (y = 0; y < NumberOfComponents; y++) {
            compWidth[y] = ((((imageWidth % 8) != 0)
                ? (((int) Math.ceil((double) imageWidth / 8.0)) * 8) : imageWidth) / MaxHsampFactor) * HsampFactor[y];

            if (compWidth[y] != ((imageWidth / MaxHsampFactor) * HsampFactor[y])) {
                lastColumnIsDummy[y] = true;
            }

            // results in a multiple of 8 for compWidth
            // this will make the rest of the program fail for the unlikely
            // event that someone tries to compress an 16 x 16 pixel image
            // which would of course be worse than pointless
            BlockWidth[y] = (int) Math.ceil((double) compWidth[y] / 8.0);
            compHeight[y] = ((((imageHeight % 8) != 0)
                ? (((int) Math.ceil((double) imageHeight / 8.0)) * 8)
                : imageHeight) / MaxVsampFactor) * VsampFactor[y];

            if (compHeight[y] != ((imageHeight / MaxVsampFactor) * VsampFactor[y])) {
                lastRowIsDummy[y] = true;
            }

            BlockHeight[y] = (int) Math.ceil((double) compHeight[y] / 8.0);
        }

        try {
            if (grabber.grabPixels() != true) {
                try {
                    throw new AWTException("Grabber returned false: " +
                        grabber.status());
                } catch (Exception e) {
                }

                ;
            }
        } catch (InterruptedException e) {
        }

        ;

        float[][] Y = new float[compHeight[0]][compWidth[0]];
        float[][] Cr1 = new float[compHeight[0]][compWidth[0]];
        float[][] Cb1 = new float[compHeight[0]][compWidth[0]];
        float[][] Cb2 = new float[compHeight[1]][compWidth[1]];
        float[][] Cr2 = new float[compHeight[2]][compWidth[2]];
        int index = 0;

        for (y = 0; y < imageHeight; ++y) {
            for (x = 0; x < imageWidth; ++x) {
                r = ((values[index] >> 16) & 0xff);
                g = ((values[index] >> 8) & 0xff);
                b = (values[index] & 0xff);

                // The following three lines are a more correct color conversion but
                // the current conversion technique is sufficient and results in a higher
                // compression rate.
                //                Y[y][x] = 16 + (float)(0.8588*(0.299 * (float)r + 0.587 * (float)g + 0.114 * (float)b ));
                //                Cb1[y][x] = 128 + (float)(0.8784*(-0.16874 * (float)r - 0.33126 * (float)g + 0.5 * (float)b));
                //                Cr1[y][x] = 128 + (float)(0.8784*(0.5 * (float)r - 0.41869 * (float)g - 0.08131 * (float)b));
                Y[y][x] = (float) (((0.299 * (float) r) + (0.587 * (float) g) +
                    (0.114 * (float) b)));
                Cb1[y][x] = 128 +
                    (float) (((-0.16874 * (float) r) - (0.33126 * (float) g) +
                    (0.5 * (float) b)));
                Cr1[y][x] = 128 +
                    (float) (((0.5 * (float) r) - (0.41869 * (float) g) -
                    (0.08131 * (float) b)));
                index++;
            }
        }

        // Need a way to set the H and V sample factors before allowing downsampling.
        // For now (04/04/98) downsampling must be hard coded.
        // Until a better downsampler is implemented, this will not be done.
        // Downsampling is currently supported.  The downsampling method here
        // is a simple box filter.
        Components[0] = Y;

        //        Cb2 = DownSample(Cb1, 1);
        Components[1] = Cb1;

        //        Cr2 = DownSample(Cr1, 2);
        Components[2] = Cr1;
    }

    float[][] DownSample(float[][] C, int comp) {
        int inrow;
        int incol;
        int outrow;
        int outcol;
        float[][] output;
        int temp;
        int bias;
        inrow = 0;
        incol = 0;
        output = new float[compHeight[comp]][compWidth[comp]];

        for (outrow = 0; outrow < compHeight[comp]; outrow++) {
            bias = 1;

            for (outcol = 0; outcol < compWidth[comp]; outcol++) {
                output[outrow][outcol] = (C[inrow][incol++] +
                    C[inrow++][incol--] + C[inrow][incol++] +
                    C[inrow--][incol++] + (float) bias) / (float) 4.0;
                bias ^= 3;
            }

            inrow += 2;
            incol = 0;
        }

        return output;
    }
}