开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图片显示 > 查看源码
JpegEncoder.java
资源名称：picweb.zip　[点击查看]
上传用户：shengda799
上传日期：2007-01-10
资源大小：68k
文件大小：50k
源码类别：

图片显示

开发平台：

Java

JpegEncoder.java：源码内容
  1. // Version 1.0a
  2. // Copyright (C) 1998, James R. Weeks and BioElectroMech.
  3. // Visit BioElectroMech at www.obrador.com.  Email James@obrador.com.
  5. // See license.txt for details about the allowed used of this software.
  6. // This software is based in part on the work of the Independent JPEG Group.
  7. // See IJGreadme.txt for details about the Independent JPEG Group's license.
  9. // This encoder is inspired by the Java Jpeg encoder by Florian Raemy,
  10. // studwww.eurecom.fr/~raemy.
  11. // It borrows a great deal of code and structure from the Independent
  12. // Jpeg Group's Jpeg 6a library, Copyright Thomas G. Lane.
  13. // See license.txt for details.
  15. // Note from Mark Watson, author of PicWeb Open SOurce utility:
  16. //   Thanks to James Weeks, Florian Raemy, and the programmers
  17. //   at the JPEG Group who did the original C implementation!
  18. //   I include James Weeks's license.txt file here for reference:
  20. /*
  22. The JpegEncoder and its associated classes are Copyright (c) 1998, James R. Weeks and BioElectroMech.  This software is based in part on the work of the Independent JPEG Group.
  24. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
  26. 1. Redistributions of source code must retain the above copyright notice, this list of conditions, all files included with the source code, and the following disclaimer.
  27. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
  29. THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31. */
  32. import java.applet.Applet;
  33. import java.awt.*;
  34. import java.awt.image.*;
  35. import java.io.*;
  36. import java.util.*;
  37. import java.lang.*;
  39. /*
  40. * JpegEncoder - The JPEG main program which performs a jpeg compression of
  41. * an image.
  42. */
  44. public class JpegEncoder extends Frame
  45. {
  46.     Thread runner;
  47.     BufferedOutputStream outStream;
  48.     Image image;
  49.     JpegInfo JpegObj;
  50.     Huffman Huf;
  51.     DCT dct;
  52.     int imageHeight, imageWidth;
  53.     int Quality;
  54.     int code;
  55.     public static int[] jpegNaturalOrder = {
  56.           0,  1,  8, 16,  9,  2,  3, 10,
  57.          17, 24, 32, 25, 18, 11,  4,  5,
  58.          12, 19, 26, 33, 40, 48, 41, 34,
  59.          27, 20, 13,  6,  7, 14, 21, 28,
  60.          35, 42, 49, 56, 57, 50, 43, 36,
  61.          29, 22, 15, 23, 30, 37, 44, 51,
  62.          58, 59, 52, 45, 38, 31, 39, 46,
  63.          53, 60, 61, 54, 47, 55, 62, 63,
  64.         };
  66.     public JpegEncoder(Image image, int quality, OutputStream out)
  67.     {
  68.                 MediaTracker tracker = new MediaTracker(this);
  69.                 tracker.addImage(image, 0);
  70.                 try {
  71.                         tracker.waitForID(0);
  72.                 }
  73.                 catch (InterruptedException e) {
  74. // Got to do something?
  75.                 }
  76.         /*
  77.         * Quality of the image.
  78.         * 0 to 100 and from bad image quality, high compression to good
  79.         * image quality low compression
  80.         */
  81.         Quality=quality;
  83.         /*
  84.         * Getting picture information
  85.         * It takes the Width, Height and RGB scans of the image. 
  86.         */
  87.         JpegObj = new JpegInfo(image);
  89.         imageHeight=JpegObj.imageHeight;
  90.         imageWidth=JpegObj.imageWidth;
  91.         outStream = new BufferedOutputStream(out);
  92.         dct = new DCT(Quality);
  93.         Huf=new Huffman(imageWidth,imageHeight);
  94.     }
  96.     public void setQuality(int quality) {
  97.         dct = new DCT(quality);
  98.     }
  100.     public int getQuality() {
  101.         return Quality;
  102.     }
  104.     public void Compress() {
  105.         WriteHeaders(outStream);
  106.         WriteCompressedData(outStream);
  107.         WriteEOI(outStream);
  108.         try {
  109.                 outStream.flush();
  110.         } catch (IOException e) {
  111.                 System.out.println("IO Error: " + e.getMessage());
  112.         }
  113.     }
  115.     public void WriteCompressedData(BufferedOutputStream outStream) {
  116.         int offset, i, j, r, c,a ,b, temp = 0;
  117.         int comp, xpos, ypos, xblockoffset, yblockoffset;
  118.         float inputArray[][];
  119.         float dctArray1[][] = new float[8][8];
  120.         double dctArray2[][] = new double[8][8];
  121.         int dctArray3[] = new int[8*8];
  123.         /*
  124.          * This method controls the compression of the image.
  125.          * Starting at the upper left of the image, it compresses 8x8 blocks
  126.          * of data until the entire image has been compressed.
  127.          */
  129.         int lastDCvalue[] = new int[JpegObj.NumberOfComponents];
  130.         int zeroArray[] = new int[64]; // initialized to hold all zeros
  131.         int Width = 0, Height = 0;
  132.         int nothing = 0, not;
  133.         int MinBlockWidth, MinBlockHeight;
  134. // This initial setting of MinBlockWidth and MinBlockHeight is done to
  135. // ensure they start with values larger than will actually be the case.
  136.         MinBlockWidth = ((imageWidth%8 != 0) ? (int) (Math.floor((double) imageWidth/8.0) + 1)*8 : imageWidth);
  137.         MinBlockHeight = ((imageHeight%8 != 0) ? (int) (Math.floor((double) imageHeight/8.0) + 1)*8: imageHeight);
  138.         for (comp = 0; comp < JpegObj.NumberOfComponents; comp++) {
  139.                 MinBlockWidth = Math.min(MinBlockWidth, JpegObj.BlockWidth[comp]);
  140.                 MinBlockHeight = Math.min(MinBlockHeight, JpegObj.BlockHeight[comp]);
  141.         }
  142.         xpos = 0;
  143.         for (r = 0; r < MinBlockHeight; r++) {
  144.            for (c = 0; c < MinBlockWidth; c++) {
  145.                xpos = c*8;
  146.                ypos = r*8;
  147.                for (comp = 0; comp < JpegObj.NumberOfComponents; comp++) {
  148.                   Width = JpegObj.BlockWidth[comp];
  149.                   Height = JpegObj.BlockHeight[comp];
  150.                   inputArray = (float[][]) JpegObj.Components[comp];
  152.                   for(i = 0; i < JpegObj.VsampFactor[comp]; i++) {
  153.                      for(j = 0; j < JpegObj.HsampFactor[comp]; j++) {
  154.                         xblockoffset = j * 8;
  155.                         yblockoffset = i * 8;
  156.                         for (a = 0; a < 8; a++) {
  157.                            for (b = 0; b < 8; b++) {
  159. // I believe this is where the dirty line at the bottom of the image is
  160. // coming from.  I need to do a check here to make sure I'm not reading past
  161. // image data.
  162. // This seems to not be a big issue right now. (04/04/98)
  164.                               dctArray1[a][b] = inputArray[ypos + yblockoffset + a][xpos + xblockoffset + b];
  165.                            }
  166.                         }
  167. // The following code commented out because on some images this technique
  168. // results in poor right and bottom borders.
  169. //                        if ((!JpegObj.lastColumnIsDummy[comp] || c < Width - 1) && (!JpegObj.lastRowIsDummy[comp] || r < Height - 1)) {
  170.                            dctArray2 = dct.forwardDCT(dctArray1);
  171.                            dctArray3 = dct.quantizeBlock(dctArray2, JpegObj.QtableNumber[comp]);
  172. //                        }
  173. //                        else {
  174. //                           zeroArray[0] = dctArray3[0];
  175. //                           zeroArray[0] = lastDCvalue[comp];
  176. //                           dctArray3 = zeroArray;
  177. //                        }
  178.                         Huf.HuffmanBlockEncoder(outStream, dctArray3, lastDCvalue[comp], JpegObj.DCtableNumber[comp], JpegObj.ACtableNumber[comp]);
  179.                         lastDCvalue[comp] = dctArray3[0];
  180.                      }
  181.                   }
  182.                }
  183.             }
  184.         }
  185.         Huf.flushBuffer(outStream);
  186.     }
  188.     public void WriteEOI(BufferedOutputStream out) {
  189.         byte[] EOI = {(byte) 0xFF, (byte) 0xD9};
  190.         WriteMarker(EOI, out);
  191.     }
  193.     public void WriteHeaders(BufferedOutputStream out) {
  194.         int i, j, index, offset, length;
  195.         int tempArray[];
  197. // the SOI marker
  198.         byte[] SOI = {(byte) 0xFF, (byte) 0xD8};
  199.         WriteMarker(SOI, out);
  201. // The order of the following headers is quiet inconsequential.
  202. // the JFIF header
  203.         byte JFIF[] = new byte[18];
  204.         JFIF[0] = (byte) 0xff;
  205.         JFIF[1] = (byte) 0xe0;
  206.         JFIF[2] = (byte) 0x00;
  207.         JFIF[3] = (byte) 0x10;
  208.         JFIF[4] = (byte) 0x4a;
  209.         JFIF[5] = (byte) 0x46;
  210.         JFIF[6] = (byte) 0x49;
  211.         JFIF[7] = (byte) 0x46;
  212.         JFIF[8] = (byte) 0x00;
  213.         JFIF[9] = (byte) 0x01;
  214.         JFIF[10] = (byte) 0x00;
  215.         JFIF[11] = (byte) 0x00;
  216.         JFIF[12] = (byte) 0x00;
  217.         JFIF[13] = (byte) 0x01;
  218.         JFIF[14] = (byte) 0x00;
  219.         JFIF[15] = (byte) 0x01;
  220.         JFIF[16] = (byte) 0x00;
  221.         JFIF[17] = (byte) 0x00;
  222.         WriteArray(JFIF, out);
  224. // Comment Header
  225.         String comment = new String();
  226.         comment = JpegObj.getComment();
  227.         length = comment.length();
  228.         byte COM[] = new byte[length + 4];
  229.         COM[0] = (byte) 0xFF;
  230.         COM[1] = (byte) 0xFE;
  231.         COM[2] = (byte) ((length >> 8) & 0xFF);
  232.         COM[3] = (byte) (length & 0xFF);
  233.         java.lang.System.arraycopy(JpegObj.Comment.getBytes(), 0, COM, 4, JpegObj.Comment.length());
  234.         WriteArray(COM, out);
  236. // The DQT header
  237. // 0 is the luminance index and 1 is the chrominance index
  238.         byte DQT[] = new byte[134];
  239.         DQT[0] = (byte) 0xFF;
  240.         DQT[1] = (byte) 0xDB;
  241.         DQT[2] = (byte) 0x00;
  242.         DQT[3] = (byte) 0x84;
  243.         offset = 4;
  244.         for (i = 0; i < 2; i++) {
  245.                 DQT[offset++] = (byte) ((0 << 4) + i);
  246.                 tempArray = (int[]) dct.quantum[i];
  247.                 for (j = 0; j < 64; j++) {
  248.                         DQT[offset++] = (byte) tempArray[jpegNaturalOrder[j]];
  249.                 }
  250.         }
  251.         WriteArray(DQT, out);
  253. // Start of Frame Header
  254.         byte SOF[] = new byte[19];
  255.         SOF[0] = (byte) 0xFF;
  256.         SOF[1] = (byte) 0xC0;
  257.         SOF[2] = (byte) 0x00;
  258.         SOF[3] = (byte) 17;
  259.         SOF[4] = (byte) JpegObj.Precision;
  260.         SOF[5] = (byte) ((JpegObj.imageHeight >> 8) & 0xFF);
  261.         SOF[6] = (byte) ((JpegObj.imageHeight) & 0xFF);
  262.         SOF[7] = (byte) ((JpegObj.imageWidth >> 8) & 0xFF);
  263.         SOF[8] = (byte) ((JpegObj.imageWidth) & 0xFF);
  264.         SOF[9] = (byte) JpegObj.NumberOfComponents;
  265.         index = 10;
  266.         for (i = 0; i < SOF[9]; i++) {
  267.                 SOF[index++] = (byte) JpegObj.CompID[i];
  268.                 SOF[index++] = (byte) ((JpegObj.HsampFactor[i] << 4) + JpegObj.VsampFactor[i]);
  269.                 SOF[index++] = (byte) JpegObj.QtableNumber[i];
  270.         }
  271.         WriteArray(SOF, out);
  273. // The DHT Header
  274.         byte DHT1[], DHT2[], DHT3[], DHT4[];
  275.         int bytes, temp, oldindex, intermediateindex;
  276.         length = 2;
  277.         index = 4;
  278.         oldindex = 4;
  279.         DHT1 = new byte[17];
  280.         DHT4 = new byte[4];
  281.         DHT4[0] = (byte) 0xFF;
  282.         DHT4[1] = (byte) 0xC4;
  283.         for (i = 0; i < 4; i++ ) {
  284.                 bytes = 0;
  285.                 DHT1[index++ - oldindex] = (byte) ((int[]) Huf.bits.elementAt(i))[0];
  286.                 for (j = 1; j < 17; j++) {
  287.                         temp = ((int[]) Huf.bits.elementAt(i))[j];
  288.                         DHT1[index++ - oldindex] =(byte) temp;
  289.                         bytes += temp;
  290.                 }
  291.                 intermediateindex = index;
  292.                 DHT2 = new byte[bytes];
  293.                 for (j = 0; j < bytes; j++) {
  294.                         DHT2[index++ - intermediateindex] = (byte) ((int[]) Huf.val.elementAt(i))[j];
  295.                 }
  296.                 DHT3 = new byte[index];
  297.                 java.lang.System.arraycopy(DHT4, 0, DHT3, 0, oldindex);
  298.                 java.lang.System.arraycopy(DHT1, 0, DHT3, oldindex, 17);
  299.                 java.lang.System.arraycopy(DHT2, 0, DHT3, oldindex + 17, bytes);
  300.                 DHT4 = DHT3;
  301.                 oldindex = index;
  302.         }
  303.         DHT4[2] = (byte) (((index - 2) >> 8)& 0xFF);
  304.         DHT4[3] = (byte) ((index -2) & 0xFF);
  305.         WriteArray(DHT4, out);
  308. // Start of Scan Header
  309.         byte SOS[] = new byte[14];
  310.         SOS[0] = (byte) 0xFF;
  311.         SOS[1] = (byte) 0xDA;
  312.         SOS[2] = (byte) 0x00;
  313.         SOS[3] = (byte) 12;
  314.         SOS[4] = (byte) JpegObj.NumberOfComponents;
  315.         index = 5;
  316.         for (i = 0; i < SOS[4]; i++) {
  317.                 SOS[index++] = (byte) JpegObj.CompID[i];
  318.                 SOS[index++] = (byte) ((JpegObj.DCtableNumber[i] << 4) + JpegObj.ACtableNumber[i]);
  319.         }
  320.         SOS[index++] = (byte) JpegObj.Ss;
  321.         SOS[index++] = (byte) JpegObj.Se;
  322.         SOS[index++] = (byte) ((JpegObj.Ah << 4) + JpegObj.Al);
  323.         WriteArray(SOS, out);
  325.     }
  327.     void WriteMarker(byte[] data, BufferedOutputStream out) {
  328.         try {
  329.                 out.write(data, 0, 2);
  330.         } catch (IOException e) {
  331.                 System.out.println("IO Error: " + e.getMessage());
  332.         }
  333.     }
  334.         
  335.     void WriteArray(byte[] data, BufferedOutputStream out) {
  336.         int i, length;
  337.         try {
  338.                 length = (((int) (data[2] & 0xFF)) << 8) + (int) (data[3] & 0xFF) + 2;
  339.                 out.write(data, 0, length);
  340.         } catch (IOException e) {
  341.                 System.out.println("IO Error: " + e.getMessage());
  342.         }
  343.     }
  344. }
  346. // This class incorporates quality scaling as implemented in the JPEG-6a
  347. // library.
  349.  /*
  350.  * DCT - A Java implementation of the Discreet Cosine Transform
  351.  */
  353. class DCT
  354. {
  355.     /**
  356.      * DCT Block Size - default 8
  357.      */
  358.     public int N        = 8;
  360.     /**
  361.      * Image Quality (0-100) - default 80 (good image / good compression)
  362.      */
  363.     public int QUALITY = 80;
  365.     public Object quantum[] = new Object[2];
  366.     public Object Divisors[] = new Object[2];
  368.     /**
  369.      * Quantitization Matrix for luminace.
  370.      */
  371.     public int quantum_luminance[]     = new int[N*N];
  372.     public double DivisorsLuminance[] = new double[N*N];
  374.     /**
  375.      * Quantitization Matrix for chrominance.
  376.      */
  377.     public int quantum_chrominance[]     = new int[N*N];
  378.     public double DivisorsChrominance[] = new double[N*N];
  380.     /**
  381.      * Constructs a new DCT object. Initializes the cosine transform matrix
  382.      * these are used when computing the DCT and it's inverse. This also
  383.      * initializes the run length counters and the ZigZag sequence. Note that
  384.      * the image quality can be worse than 25 however the image will be
  385.      * extemely pixelated, usually to a block size of N.
  386.      *
  387.      * @param QUALITY The quality of the image (0 worst - 100 best)
  388.      *
  389.      */
  390.     public DCT(int QUALITY)
  391.     {
  392.         initMatrix(QUALITY);
  393.     }
  394.                         
  396.     /*
  397.      * This method sets up the quantization matrix for luminance and
  398.      * chrominance using the Quality parameter.
  399.      */
  400.     private void initMatrix(int quality)
  401.     {
  402.         double[] AANscaleFactor = { 1.0, 1.387039845, 1.306562965, 1.175875602,
  403.                                     1.0, 0.785694958, 0.541196100, 0.275899379};
  404.         int i;
  405.         int j;
  406.         int index;
  407.         int Quality;
  408.         int temp;
  410. // converting quality setting to that specified in the jpeg_quality_scaling
  411. // method in the IJG Jpeg-6a C libraries
  413.         Quality = quality;
  414.         if (Quality <= 0)
  415.                 Quality = 1;
  416.         if (Quality > 100)
  417.                 Quality = 100;
  418.         if (Quality < 50)
  419.                 Quality = 5000 / Quality;
  420.         else
  421.                 Quality = 200 - Quality * 2;
  423. // Creating the luminance matrix
  425.         quantum_luminance[0]=16;
  426.         quantum_luminance[1]=11;
  427.         quantum_luminance[2]=10;
  428.         quantum_luminance[3]=16;
  429.         quantum_luminance[4]=24;
  430.         quantum_luminance[5]=40;
  431.         quantum_luminance[6]=51;
  432.         quantum_luminance[7]=61;
  433.         quantum_luminance[8]=12;
  434.         quantum_luminance[9]=12;
  435.         quantum_luminance[10]=14;
  436.         quantum_luminance[11]=19;
  437.         quantum_luminance[12]=26;
  438.         quantum_luminance[13]=58;
  439.         quantum_luminance[14]=60;
  440.         quantum_luminance[15]=55;
  441.         quantum_luminance[16]=14;
  442.         quantum_luminance[17]=13;
  443.         quantum_luminance[18]=16;
  444.         quantum_luminance[19]=24;
  445.         quantum_luminance[20]=40;
  446.         quantum_luminance[21]=57;
  447.         quantum_luminance[22]=69;
  448.         quantum_luminance[23]=56;
  449.         quantum_luminance[24]=14;
  450.         quantum_luminance[25]=17;
  451.         quantum_luminance[26]=22;
  452.         quantum_luminance[27]=29;
  453.         quantum_luminance[28]=51;
  454.         quantum_luminance[29]=87;
  455.         quantum_luminance[30]=80;
  456.         quantum_luminance[31]=62;
  457.         quantum_luminance[32]=18;
  458.         quantum_luminance[33]=22;
  459.         quantum_luminance[34]=37;
  460.         quantum_luminance[35]=56;
  461.         quantum_luminance[36]=68;
  462.         quantum_luminance[37]=109;
  463.         quantum_luminance[38]=103;
  464.         quantum_luminance[39]=77;
  465.         quantum_luminance[40]=24;
  466.         quantum_luminance[41]=35;
  467.         quantum_luminance[42]=55;
  468.         quantum_luminance[43]=64;
  469.         quantum_luminance[44]=81;
  470.         quantum_luminance[45]=104;
  471.         quantum_luminance[46]=113;
  472.         quantum_luminance[47]=92;
  473.         quantum_luminance[48]=49;
  474.         quantum_luminance[49]=64;
  475.         quantum_luminance[50]=78;
  476.         quantum_luminance[51]=87;
  477.         quantum_luminance[52]=103;
  478.         quantum_luminance[53]=121;
  479.         quantum_luminance[54]=120;
  480.         quantum_luminance[55]=101;
  481.         quantum_luminance[56]=72;
  482.         quantum_luminance[57]=92;
  483.         quantum_luminance[58]=95;
  484.         quantum_luminance[59]=98;
  485.         quantum_luminance[60]=112;
  486.         quantum_luminance[61]=100;
  487.         quantum_luminance[62]=103;
  488.         quantum_luminance[63]=99;
  490.         for (j = 0; j < 64; j++)
  491.         {
  492.                 temp = (quantum_luminance[j] * Quality + 50) / 100;
  493.                 if ( temp <= 0) temp = 1;
  494.                 if (temp > 255) temp = 255;
  495.                 quantum_luminance[j] = temp;
  496.         }
  497.         index = 0;
  498.         for (i = 0; i < 8; i++) {
  499.                 for (j = 0; j < 8; j++) {
  500. // The divisors for the LL&M method (the slow integer method used in
  501. // jpeg 6a library).  This method is currently (04/04/98) incompletely
  502. // implemented.
  503. //                        DivisorsLuminance[index] = ((double) quantum_luminance[index]) << 3;
  504. // The divisors for the AAN method (the float method used in jpeg 6a library.
  505.                         DivisorsLuminance[index] = (double) ((double)1.0/((double) quantum_luminance[index] * AANscaleFactor[i] * AANscaleFactor[j] * (double) 8.0));
  506.                         index++;
  507.                 }
  508.         }
  511. // Creating the chrominance matrix
  513.         quantum_chrominance[0]=17;
  514.         quantum_chrominance[1]=18;
  515.         quantum_chrominance[2]=24;
  516.         quantum_chrominance[3]=47;
  517.         quantum_chrominance[4]=99;
  518.         quantum_chrominance[5]=99;
  519.         quantum_chrominance[6]=99;
  520.         quantum_chrominance[7]=99;
  521.         quantum_chrominance[8]=18;
  522.         quantum_chrominance[9]=21;
  523.         quantum_chrominance[10]=26;
  524.         quantum_chrominance[11]=66;
  525.         quantum_chrominance[12]=99;
  526.         quantum_chrominance[13]=99;
  527.         quantum_chrominance[14]=99;
  528.         quantum_chrominance[15]=99;
  529.         quantum_chrominance[16]=24;
  530.         quantum_chrominance[17]=26;
  531.         quantum_chrominance[18]=56;
  532.         quantum_chrominance[19]=99;
  533.         quantum_chrominance[20]=99;
  534.         quantum_chrominance[21]=99;
  535.         quantum_chrominance[22]=99;
  536.         quantum_chrominance[23]=99;
  537.         quantum_chrominance[24]=47;
  538.         quantum_chrominance[25]=66;
  539.         quantum_chrominance[26]=99;
  540.         quantum_chrominance[27]=99;
  541.         quantum_chrominance[28]=99;
  542.         quantum_chrominance[29]=99;
  543.         quantum_chrominance[30]=99;
  544.         quantum_chrominance[31]=99;
  545.         quantum_chrominance[32]=99;
  546.         quantum_chrominance[33]=99;
  547.         quantum_chrominance[34]=99;
  548.         quantum_chrominance[35]=99;
  549.         quantum_chrominance[36]=99;
  550.         quantum_chrominance[37]=99;
  551.         quantum_chrominance[38]=99;
  552.         quantum_chrominance[39]=99;
  553.         quantum_chrominance[40]=99;
  554.         quantum_chrominance[41]=99;
  555.         quantum_chrominance[42]=99;
  556.         quantum_chrominance[43]=99;
  557.         quantum_chrominance[44]=99;
  558.         quantum_chrominance[45]=99;
  559.         quantum_chrominance[46]=99;
  560.         quantum_chrominance[47]=99;
  561.         quantum_chrominance[48]=99;
  562.         quantum_chrominance[49]=99;
  563.         quantum_chrominance[50]=99;
  564.         quantum_chrominance[51]=99;
  565.         quantum_chrominance[52]=99;
  566.         quantum_chrominance[53]=99;
  567.         quantum_chrominance[54]=99;
  568.         quantum_chrominance[55]=99;
  569.         quantum_chrominance[56]=99;
  570.         quantum_chrominance[57]=99;
  571.         quantum_chrominance[58]=99;
  572.         quantum_chrominance[59]=99;
  573.         quantum_chrominance[60]=99;
  574.         quantum_chrominance[61]=99;
  575.         quantum_chrominance[62]=99;
  576.         quantum_chrominance[63]=99;
  578.         for (j = 0; j < 64; j++)
  579.         {
  580.                 temp = (quantum_chrominance[j] * Quality + 50) / 100;
  581.                 if ( temp <= 0) temp = 1;
  582.                 if (temp >= 255) temp = 255;
  583.                 quantum_chrominance[j] = temp;
  584.         }
  585.         index = 0;
  586.         for (i = 0; i < 8; i++) {
  587.                 for (j = 0; j < 8; j++) {
  588. // The divisors for the LL&M method (the slow integer method used in
  589. // jpeg 6a library).  This method is currently (04/04/98) incompletely
  590. // implemented.
  591. //                        DivisorsChrominance[index] = ((double) quantum_chrominance[index]) << 3;
  592. // The divisors for the AAN method (the float method used in jpeg 6a library.
  593.                         DivisorsChrominance[index] = (double) ((double)1.0/((double) quantum_chrominance[index] * AANscaleFactor[i] * AANscaleFactor[j] * (double)8.0));
  594.                         index++;
  595.                 }
  596.         }
  598. // quantum and Divisors are objects used to hold the appropriate matices
  600.         quantum[0] = quantum_luminance;
  601.         Divisors[0] = DivisorsLuminance;
  602.         quantum[1] = quantum_chrominance;
  603.         Divisors[1] = DivisorsChrominance;
  606.     }
  608.     /*
  609.      * This method preforms forward DCT on a block of image data using
  610.      * the literal method specified for a 2-D Discrete Cosine Transform.
  611.      * It is included as a curiosity and can give you an idea of the
  612.      * difference in the compression result (the resulting image quality)
  613.      * by comparing its output to the output of the AAN method below.
  614.      * It is ridiculously inefficient.
  615.      */
  617. // For now the final output is unusable.  The associated quantization step
  618. // needs some tweaking.  If you get this part working, please let me know.
  620.     public double[][] forwardDCTExtreme(float input[][])
  621.     {
  622.         double output[][] = new double[N][N];
  623.         double tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
  624.         double tmp10, tmp11, tmp12, tmp13;
  625.         double z1, z2, z3, z4, z5, z11, z13;
  626.         int i;
  627.         int j;
  628.         int v, u, x, y;
  629.         for (v = 0; v < 8; v++) {
  630.                 for (u = 0; u < 8; u++) {
  631.                         for (x = 0; x < 8; x++) {
  632.                                 for (y = 0; y < 8; y++) {
  633.                                         output[v][u] += ((double)input[x][y])*Math.cos(((double)(2*x + 1)*(double)u*Math.PI)/(double)16)*Math.cos(((double)(2*y + 1)*(double)v*Math.PI)/(double)16);
  634.                                 }
  635.                         }
  636.                         output[v][u] *= (double)(0.25)*((u == 0) ? ((double)1.0/Math.sqrt(2)) : (double) 1.0)*((v == 0) ? ((double)1.0/Math.sqrt(2)) : (double) 1.0);
  637.                 }
  638.         }
  639.         return output;
  640.     }
  641.                                                                 
  643.     /*
  644.      * This method preforms a DCT on a block of image data using the AAN
  645.      * method as implemented in the IJG Jpeg-6a library.
  646.      */
  647.     public double[][] forwardDCT(float input[][])
  648.     {
  649.         double output[][] = new double[N][N];
  650.         double tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
  651.         double tmp10, tmp11, tmp12, tmp13;
  652.         double z1, z2, z3, z4, z5, z11, z13;
  653.         int i;
  654.         int j;
  656. // Subtracts 128 from the input values
  657.         for (i = 0; i < 8; i++) {
  658.                 for(j = 0; j < 8; j++) {
  659.                         output[i][j] = ((double)input[i][j] - (double)128.0);
  660. //                        input[i][j] -= 128;
  662.                 }
  663.         }
  665.         for (i = 0; i < 8; i++) {
  666.                 tmp0 = output[i][0] + output[i][7];
  667.                 tmp7 = output[i][0] - output[i][7];
  668.                 tmp1 = output[i][1] + output[i][6];
  669.                 tmp6 = output[i][1] - output[i][6];
  670.                 tmp2 = output[i][2] + output[i][5];
  671.                 tmp5 = output[i][2] - output[i][5];
  672.                 tmp3 = output[i][3] + output[i][4];
  673.                 tmp4 = output[i][3] - output[i][4];
  675.                 tmp10 = tmp0 + tmp3;
  676.                 tmp13 = tmp0 - tmp3;
  677.                 tmp11 = tmp1 + tmp2;
  678.                 tmp12 = tmp1 - tmp2;
  680.                 output[i][0] = tmp10 + tmp11;
  681.                 output[i][4] = tmp10 - tmp11;
  683.                 z1 = (tmp12 + tmp13) * (double) 0.707106781;
  684.                 output[i][2] = tmp13 + z1;
  685.                 output[i][6] = tmp13 - z1;
  687.                 tmp10 = tmp4 + tmp5;
  688.                 tmp11 = tmp5 + tmp6;
  689.                 tmp12 = tmp6 + tmp7;
  691.                 z5 = (tmp10 - tmp12) * (double) 0.382683433;
  692.                 z2 = ((double) 0.541196100) * tmp10 + z5;
  693.                 z4 = ((double) 1.306562965) * tmp12 + z5;
  694.                 z3 = tmp11 * ((double) 0.707106781);
  696.                 z11 = tmp7 + z3;
  697.                 z13 = tmp7 - z3;
  699.                 output[i][5] = z13 + z2;
  700.                 output[i][3] = z13 - z2;
  701.                 output[i][1] = z11 + z4;
  702.                 output[i][7] = z11 - z4;
  703.         }
  705.         for (i = 0; i < 8; i++) {
  706.                 tmp0 = output[0][i] + output[7][i];
  707.                 tmp7 = output[0][i] - output[7][i];
  708.                 tmp1 = output[1][i] + output[6][i];
  709.                 tmp6 = output[1][i] - output[6][i];
  710.                 tmp2 = output[2][i] + output[5][i];
  711.                 tmp5 = output[2][i] - output[5][i];
  712.                 tmp3 = output[3][i] + output[4][i];
  713.                 tmp4 = output[3][i] - output[4][i];
  715.                 tmp10 = tmp0 + tmp3;
  716.                 tmp13 = tmp0 - tmp3;
  717.                 tmp11 = tmp1 + tmp2;
  718.                 tmp12 = tmp1 - tmp2;
  720.                 output[0][i] = tmp10 + tmp11;
  721.                 output[4][i] = tmp10 - tmp11;
  723.                 z1 = (tmp12 + tmp13) * (double) 0.707106781;
  724.                 output[2][i] = tmp13 + z1;
  725.                 output[6][i] = tmp13 - z1;
  727.                 tmp10 = tmp4 + tmp5;
  728.                 tmp11 = tmp5 + tmp6;
  729.                 tmp12 = tmp6 + tmp7;
  731.                 z5 = (tmp10 - tmp12) * (double) 0.382683433;
  732.                 z2 = ((double) 0.541196100) * tmp10 + z5;
  733.                 z4 = ((double) 1.306562965) * tmp12 + z5;
  734.                 z3 = tmp11 * ((double) 0.707106781);
  736.                 z11 = tmp7 + z3;
  737.                 z13 = tmp7 - z3;
  739.                 output[5][i] = z13 + z2;
  740.                 output[3][i] = z13 - z2;
  741.                 output[1][i] = z11 + z4;
  742.                 output[7][i] = z11 - z4;
  743.         }
  745.         return output;
  746.     }
  748.     /*
  749.     * This method quantitizes data and rounds it to the nearest integer.
  750.     */
  751.     public int[] quantizeBlock(double inputData[][], int code)
  752.     {
  753.         int outputData[] = new int[N*N];
  754.         int i, j;
  755.         int index;
  756.         index = 0;
  757.         for (i = 0; i < 8; i++) {
  758.                 for (j = 0; j < 8; j++) {
  759. // The second line results in significantly better compression.
  760.                         outputData[index] = (int)(Math.round(inputData[i][j] * (((double[]) (Divisors[code]))[index])));
  761. //                        outputData[index] = (int)(((inputData[i][j] * (((double[]) (Divisors[code]))[index])) + 16384.5) -16384);
  762.                         index++;
  763.                 }
  764.         }
  766.         return outputData;
  767.     }
  769.     /*
  770.     * This is the method for quantizing a block DCT'ed with forwardDCTExtreme
  771.     * This method quantitizes data and rounds it to the nearest integer.
  772.     */
  773.     public int[] quantizeBlockExtreme(double inputData[][], int code)
  774.     {
  775.         int outputData[] = new int[N*N];
  776.         int i, j;
  777.         int index;
  778.         index = 0;
  779.         for (i = 0; i < 8; i++) {
  780.                 for (j = 0; j < 8; j++) {
  781.                         outputData[index] = (int)(Math.round(inputData[i][j] / (double)(((int[]) (quantum[code]))[index])));
  782.                         index++;
  783.                 }
  784.         }
  786.         return outputData;
  787.     }
  788. }
  790. // This class was modified by James R. Weeks on 3/27/98.
  791. // It now incorporates Huffman table derivation as in the C jpeg library
  792. // from the IJG, Jpeg-6a.
  794. class Huffman
  795. {
  796.     int bufferPutBits, bufferPutBuffer;    
  797.     public int ImageHeight;
  798.     public int ImageWidth;
  799.     public int DC_matrix0[][];
  800.     public int AC_matrix0[][];
  801.     public int DC_matrix1[][];
  802.     public int AC_matrix1[][];
  803.     public Object DC_matrix[];
  804.     public Object AC_matrix[];
  805.     public int code;
  806.     public int NumOfDCTables;
  807.     public int NumOfACTables;
  808.     public int[] bitsDCluminance = { 0x00, 0, 1, 5, 1, 1,1,1,1,1,0,0,0,0,0,0,0};
  809.     public int[] valDCluminance = { 0,1,2,3,4,5,6,7,8,9,10,11 };
  810.     public int[] bitsDCchrominance = { 0x01,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0 };
  811.     public int[] valDCchrominance = { 0,1,2,3,4,5,6,7,8,9,10,11 };
  812.     public int[] bitsACluminance = {0x10,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d };
  813.     public int[] valACluminance =
  814.         { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
  815.           0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
  816.           0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
  817.           0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
  818.           0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
  819.           0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
  820.           0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
  821.           0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
  822.           0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
  823.           0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
  824.           0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
  825.           0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
  826.           0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
  827.           0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
  828.           0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
  829.           0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
  830.           0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
  831.           0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
  832.           0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
  833.           0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
  834.           0xf9, 0xfa };
  835.     public int[] bitsACchrominance = { 0x11,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77 };;
  836.     public int[] valACchrominance = 
  837.         { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
  838.           0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
  839.           0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
  840.           0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
  841.           0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
  842.           0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
  843.           0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 
  844.           0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 
  845.           0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 
  846.           0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 
  847.           0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 
  848.           0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 
  849.           0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 
  850.           0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 
  851.           0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 
  852.           0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 
  853.           0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 
  854.           0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 
  855.           0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 
  856.           0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
  857.           0xf9, 0xfa };
  858.     public Vector bits;
  859.     public Vector val;
  861.     /*
  862.      * jpegNaturalOrder[i] is the natural-order position of the i'th element
  863.      * of zigzag order.
  864.      */
  865.     public static int[] jpegNaturalOrder = {
  866.           0,  1,  8, 16,  9,  2,  3, 10,
  867.          17, 24, 32, 25, 18, 11,  4,  5,
  868.          12, 19, 26, 33, 40, 48, 41, 34,
  869.          27, 20, 13,  6,  7, 14, 21, 28,
  870.          35, 42, 49, 56, 57, 50, 43, 36,
  871.          29, 22, 15, 23, 30, 37, 44, 51,
  872.          58, 59, 52, 45, 38, 31, 39, 46,
  873.          53, 60, 61, 54, 47, 55, 62, 63,
  874.         };
  875.     /*
  876.     * The Huffman class constructor
  877.     */
  878.         public Huffman(int Width,int Height)
  879. {
  881.             bits = new Vector();
  882.             bits.addElement(bitsDCluminance);
  883.             bits.addElement(bitsACluminance);
  884.             bits.addElement(bitsDCchrominance);
  885.             bits.addElement(bitsACchrominance);
  886.             val = new Vector();
  887.             val.addElement(valDCluminance);
  888.             val.addElement(valACluminance);
  889.             val.addElement(valDCchrominance);
  890.             val.addElement(valACchrominance);
  891.             initHuf();
  892.     code=code;
  893.             ImageWidth=Width;
  894.             ImageHeight=Height;
  896. }
  898.    /**
  899.    * HuffmanBlockEncoder run length encodes and Huffman encodes the quantized
  900.    * data.
  901.    **/
  903.         public void HuffmanBlockEncoder(BufferedOutputStream outStream, int zigzag[], int prec, int DCcode, int ACcode)
  904. {
  905.         int temp, temp2, nbits, k, r, i;
  907.         NumOfDCTables = 2;
  908.         NumOfACTables = 2;
  910. // The DC portion
  912.         temp = temp2 = zigzag[0] - prec;
  913.         if(temp < 0) {
  914.                 temp = -temp;
  915.                 temp2--;
  916.         }
  917.         nbits = 0;
  918.         while (temp != 0) {
  919.                 nbits++;
  920.                 temp >>= 1;
  921.         }
  922. //        if (nbits > 11) nbits = 11;
  923.         bufferIt(outStream, ((int[][])DC_matrix[DCcode])[nbits][0], ((int[][])DC_matrix[DCcode])[nbits][1]);
  924.         // The arguments in bufferIt are code and size.
  925.         if (nbits != 0) {
  926.                 bufferIt(outStream, temp2, nbits);
  927.         }
  929. // The AC portion
  931.         r = 0;
  933.         for (k = 1; k < 64; k++) {
  934.                 if ((temp = zigzag[jpegNaturalOrder[k]]) == 0) {
  935.                         r++;
  936.                 }
  937.                 else {
  938.                         while (r > 15) {
  939.                                 bufferIt(outStream, ((int[][])AC_matrix[ACcode])[0xF0][0], ((int[][])AC_matrix[ACcode])[0xF0][1]);
  940.                                 r -= 16;
  941.                         }
  942.                         temp2 = temp;
  943.                         if (temp < 0) {
  944.                                 temp = -temp;
  945.                                 temp2--;
  946.                         }
  947.                         nbits = 1;
  948.                         while ((temp >>= 1) != 0) {
  949.                                 nbits++;
  950.                         }
  951.                         i = (r << 4) + nbits;
  952.                         bufferIt(outStream, ((int[][])AC_matrix[ACcode])[i][0], ((int[][])AC_matrix[ACcode])[i][1]);
  953.                         bufferIt(outStream, temp2, nbits);
  955.                         r = 0;
  956.                 }
  957.         }
  959.         if (r > 0) {
  960.                 bufferIt(outStream, ((int[][])AC_matrix[ACcode])[0][0], ((int[][])AC_matrix[ACcode])[0][1]);
  961.         }
  963. }
  965. // Uses an integer long (32 bits) buffer to store the Huffman encoded bits
  966. // and sends them to outStream by the byte.
  968.         void bufferIt(BufferedOutputStream outStream, int code,int size)
  969. {
  970.         int PutBuffer = code;
  971.         int PutBits = bufferPutBits;
  973.         PutBuffer &= (1 << size) - 1;
  974.         PutBits += size;
  975.         PutBuffer <<= 24 - PutBits;
  976.         PutBuffer |= bufferPutBuffer;
  978.         while(PutBits >= 8) {
  979.                 int c = ((PutBuffer >> 16) & 0xFF);
  980.                 try
  981.                 {
  982.                         outStream.write(c);
  983.                 }
  984.                 catch (IOException e) {
  985.                         System.out.println("IO Error: " + e.getMessage());
  986.                 }
  987.                 if (c == 0xFF) {
  988.                         try
  989.                         {
  990.                                 outStream.write(0);
  991.                         }
  992.                         catch (IOException e) {
  993.                                 System.out.println("IO Error: " + e.getMessage());
  994.                         }
  995.                 }
  996.                 PutBuffer <<= 8;
  997.                 PutBits -= 8;
  998.         }
  999.         bufferPutBuffer = PutBuffer;
  1000.         bufferPutBits = PutBits;
  1002.         }
  1004.         void flushBuffer(BufferedOutputStream outStream) {
  1005.                 int PutBuffer = bufferPutBuffer;
  1006.                 int PutBits = bufferPutBits;
  1007.                 while (PutBits >= 8) {
  1008.                         int c = ((PutBuffer >> 16) & 0xFF);
  1009.                         try
  1010.                         {
  1011.                                 outStream.write(c);
  1012.                         }
  1013.                         catch (IOException e) {
  1014.                                 System.out.println("IO Error: " + e.getMessage());
  1015.                         }
  1016.                         if (c == 0xFF) {
  1017.                                 try {
  1018.                                         outStream.write(0);
  1019.                                 }
  1020.                                 catch (IOException e) {
  1021.                                         System.out.println("IO Error: " + e.getMessage());
  1022.                                 }
  1023.                         }
  1024.                         PutBuffer <<= 8;
  1025.                         PutBits -= 8;
  1026.                 }
  1027.                 if (PutBits > 0) {
  1028.                         int c = ((PutBuffer >> 16) & 0xFF);
  1029.                         try
  1030.                         {
  1031.                                 outStream.write(c);
  1032.                         }
  1033.                         catch (IOException e) {
  1034.                                 System.out.println("IO Error: " + e.getMessage());
  1035.                         }
  1036.                 }
  1037.         }
  1039.     /*
  1040.     * Initialisation of the Huffman codes for Luminance and Chrominance.
  1041.     * This code results in the same tables created in the IJG Jpeg-6a
  1042.     * library.
  1043.     */
  1045.     public void initHuf()
  1046.     {
  1047.         DC_matrix0=new int[12][2];
  1048.         DC_matrix1=new int[12][2];
  1049.         AC_matrix0=new int[255][2];
  1050.         AC_matrix1=new int[255][2];
  1051.         DC_matrix = new Object[2];
  1052.         AC_matrix = new Object[2];
  1053.         int p, l, i, lastp, si, code;
  1054.         int[] huffsize = new int[257];
  1055.         int[] huffcode= new int[257];
  1057.         /*
  1058.         * init of the DC values for the chrominance
  1059.         * [][0] is the code   [][1] is the number of bit
  1060.         */
  1062.         p = 0;
  1063.         for (l = 1; l <= 16; l++)
  1064.         {
  1065.                 for (i = 1; i <= bitsDCchrominance[l]; i++)
  1066.                 {
  1067.                         huffsize[p++] = l;
  1068.                 }
  1069.         }
  1070.         huffsize[p] = 0;
  1071.         lastp = p;
  1073.         code = 0;
  1074.         si = huffsize[0];
  1075.         p = 0;
  1076.         while(huffsize[p] != 0)
  1077.         {
  1078.                 while(huffsize[p] == si)
  1079.                 {
  1080.                         huffcode[p++] = code;
  1081.                         code++;
  1082.                 }
  1083.                 code <<= 1;
  1084.                 si++;
  1085.         }
  1087.         for (p = 0; p < lastp; p++)
  1088.         {
  1089.                 DC_matrix1[valDCchrominance[p]][0] = huffcode[p];
  1090.                 DC_matrix1[valDCchrominance[p]][1] = huffsize[p];
  1091.         }
  1093.         /*
  1094.         * Init of the AC hufmann code for the chrominance
  1095.         * matrix [][][0] is the code & matrix[][][1] is the number of bit needed
  1096.         */
  1098.         p = 0;
  1099.         for (l = 1; l <= 16; l++)
  1100.         {
  1101.                 for (i = 1; i <= bitsACchrominance[l]; i++)
  1102.                 {
  1103.                         huffsize[p++] = l;
  1104.                 }
  1105.         }
  1106.         huffsize[p] = 0;
  1107.         lastp = p;
  1109.         code = 0;
  1110.         si = huffsize[0];
  1111.         p = 0;
  1112.         while(huffsize[p] != 0)
  1113.         {
  1114.                 while(huffsize[p] == si)
  1115.                 {
  1116.                         huffcode[p++] = code;
  1117.                         code++;
  1118.                 }
  1119.                 code <<= 1;
  1120.                 si++;
  1121.         }
  1123.         for (p = 0; p < lastp; p++)
  1124.         {
  1125.                 AC_matrix1[valACchrominance[p]][0] = huffcode[p];
  1126.                 AC_matrix1[valACchrominance[p]][1] = huffsize[p];
  1127.         }
  1129.         /*
  1130.         * init of the DC values for the luminance
  1131.         * [][0] is the code   [][1] is the number of bit
  1132.         */
  1133.         p = 0;
  1134.         for (l = 1; l <= 16; l++)
  1135.         {
  1136.                 for (i = 1; i <= bitsDCluminance[l]; i++)
  1137.                 {
  1138.                         huffsize[p++] = l;
  1139.                 }
  1140.         }
  1141.         huffsize[p] = 0;
  1142.         lastp = p;
  1144.         code = 0;
  1145.         si = huffsize[0];
  1146.         p = 0;
  1147.         while(huffsize[p] != 0)
  1148.         {
  1149.                 while(huffsize[p] == si)
  1150.                 {
  1151.                         huffcode[p++] = code;
  1152.                         code++;
  1153.                 }
  1154.                 code <<= 1;
  1155.                 si++;
  1156.         }
  1158.         for (p = 0; p < lastp; p++)
  1159.         {
  1160.                 DC_matrix0[valDCluminance[p]][0] = huffcode[p];
  1161.                 DC_matrix0[valDCluminance[p]][1] = huffsize[p];
  1162.         }
  1164.         /*
  1165.         * Init of the AC hufmann code for luminance
  1166.         * matrix [][][0] is the code & matrix[][][1] is the number of bit
  1167.         */
  1169.         p = 0;
  1170.         for (l = 1; l <= 16; l++)
  1171.         {
  1172.                 for (i = 1; i <= bitsACluminance[l]; i++)
  1173.                 {
  1174.                         huffsize[p++] = l;
  1175.                 }
  1176.         }
  1177.         huffsize[p] = 0;
  1178.         lastp = p;
  1180.         code = 0;
  1181.         si = huffsize[0];
  1182.         p = 0;
  1183.         while(huffsize[p] != 0)
  1184.         {
  1185.                 while(huffsize[p] == si)
  1186.                 {
  1187.                         huffcode[p++] = code;
  1188.                         code++;
  1189.                 }
  1190.                 code <<= 1;
  1191.                 si++;
  1192.         }
  1193.         for (int q = 0; q < lastp; q++)
  1194.         {
  1195.                 AC_matrix0[valACluminance[q]][0] = huffcode[q];
  1196.                 AC_matrix0[valACluminance[q]][1] = huffsize[q];
  1197.         } 
  1199.         DC_matrix[0] = DC_matrix0;
  1200.         DC_matrix[1] = DC_matrix1;
  1201.         AC_matrix[0] = AC_matrix0;
  1202.         AC_matrix[1] = AC_matrix1;
  1203.     }
  1205. }
  1207. /*
  1208.  * JpegInfo - Given an image, sets default information about it and divides
  1209.  * it into its constituant components, downsizing those that need to be.
  1210.  */
  1212. class JpegInfo
  1213. {
  1214.     String Comment;
  1215.     public Image imageobj;
  1216.     public int imageHeight;
  1217.     public int imageWidth;
  1218.     public int BlockWidth[];
  1219.     public int BlockHeight[];
  1221. // the following are set as the default
  1222.     public int Precision = 8;
  1223.     public int NumberOfComponents = 3;
  1224.     public Object Components[];
  1225.     public int[] CompID = {1, 2, 3};
  1226.     public int[] HsampFactor = {1, 1, 1};
  1227.     public int[] VsampFactor = {1, 1, 1};
  1228.     public int[] QtableNumber = {0, 1, 1};
  1229.     public int[] DCtableNumber = {0, 1, 1};
  1230.     public int[] ACtableNumber = {0, 1, 1};
  1231.     public boolean[] lastColumnIsDummy = {false, false, false};
  1232.     public boolean[] lastRowIsDummy = {false, false, false};
  1233.     public int Ss = 0;
  1234.     public int Se = 63;
  1235.     public int Ah = 0;
  1236.     public int Al = 0;
  1237.     public int compWidth[], compHeight[];
  1238.     public int MaxHsampFactor;
  1239.     public int MaxVsampFactor;
  1242.     public JpegInfo(Image image)
  1243.     {
  1244.         Components = new Object[NumberOfComponents];
  1245.         compWidth = new int[NumberOfComponents];
  1246.         compHeight = new int[NumberOfComponents];
  1247.         BlockWidth = new int[NumberOfComponents];
  1248.         BlockHeight = new int[NumberOfComponents];
  1249.         imageobj = image;
  1250.         imageWidth = image.getWidth(null);
  1251.         imageHeight = image.getHeight(null);
  1252.         Comment = "JPEG Encoder Copyright 1998, James R. Weeks and BioElectroMech.  ";
  1253.         getYCCArray();
  1254.     }
  1256.     public void setComment(String comment) {
  1257.         Comment.concat(comment);
  1258.     }
  1260.     public String getComment() {
  1261.         return Comment;
  1262.     }
  1264.     /*
  1265.      * This method creates and fills three arrays, Y, Cb, and Cr using the
  1266.      * input image.
  1267.      */
  1269.     private void getYCCArray()
  1270.     {
  1271.         int values[] = new int[imageWidth * imageHeight];
  1272.         int r, g, b, y, x;
  1273. // In order to minimize the chance that grabPixels will throw an exception
  1274. // it may be necessary to grab some pixels every few scanlines and process
  1275. // those before going for more.  The time expense may be prohibitive.
  1276. // However, for a situation where memory overhead is a concern, this may be
  1277. // the only choice.
  1278.      PixelGrabber grabber = new PixelGrabber(imageobj.getSource(), 0, 0, imageWidth, imageHeight, values, 0, imageWidth);
  1279.         MaxHsampFactor = 1;
  1280.         MaxVsampFactor = 1;
  1281.         for (y = 0; y < NumberOfComponents; y++) {
  1282.                 MaxHsampFactor = Math.max(MaxHsampFactor, HsampFactor[y]);
  1283.                 MaxVsampFactor = Math.max(MaxVsampFactor, VsampFactor[y]);
  1284.         }
  1285.         for (y = 0; y < NumberOfComponents; y++) {
  1286.                 compWidth[y] = (((imageWidth%8 != 0) ? ((int) Math.ceil((double) imageWidth/8.0))*8 : imageWidth)/MaxHsampFactor)*HsampFactor[y];
  1287.                 if (compWidth[y] != ((imageWidth/MaxHsampFactor)*HsampFactor[y])) {
  1288.                         lastColumnIsDummy[y] = true;
  1289.                 }
  1290.                 // results in a multiple of 8 for compWidth
  1291.                 // this will make the rest of the program fail for the unlikely
  1292.                 // event that someone tries to compress an 16 x 16 pixel image
  1293.                 // which would of course be worse than pointless
  1294.                 BlockWidth[y] = (int) Math.ceil((double) compWidth[y]/8.0);
  1295.                 compHeight[y] = (((imageHeight%8 != 0) ? ((int) Math.ceil((double) imageHeight/8.0))*8: imageHeight)/MaxVsampFactor)*VsampFactor[y];
  1296.                 if (compHeight[y] != ((imageHeight/MaxVsampFactor)*VsampFactor[y])) {
  1297.                         lastRowIsDummy[y] = true;
  1298.                 }
  1299.                 BlockHeight[y] = (int) Math.ceil((double) compHeight[y]/8.0);
  1300.         }
  1301.         try
  1302.      {
  1303.          if(grabber.grabPixels() != true)
  1304.          {
  1305.          try
  1306.          {
  1307.              throw new AWTException("Grabber returned false: " + grabber.status());
  1308.          }
  1309.          catch (Exception e) {};
  1310.             }
  1311.      }
  1312.      catch (InterruptedException e) {};
  1313.         float Y[][] = new float[compHeight[0]][compWidth[0]];
  1314.         float Cr1[][] = new float[compHeight[0]][compWidth[0]];
  1315.         float Cb1[][] = new float[compHeight[0]][compWidth[0]];
  1316.         float Cb2[][] = new float[compHeight[1]][compWidth[1]];
  1317.         float Cr2[][] = new float[compHeight[2]][compWidth[2]];
  1318.         int index = 0;
  1319.         for (y = 0; y < imageHeight; ++y)
  1320.      {
  1321.             for (x = 0; x < imageWidth; ++x)
  1322.          {
  1323.                 r = ((values[index] >> 16) & 0xff);
  1324.                 g = ((values[index] >> 8) & 0xff);
  1325.                 b = (values[index] & 0xff);
  1327. // The following three lines are a more correct color conversion but
  1328. // the current conversion technique is sufficient and results in a higher
  1329. // compression rate.
  1330. //                Y[y][x] = 16 + (float)(0.8588*(0.299 * (float)r + 0.587 * (float)g + 0.114 * (float)b ));
  1331. //                Cb1[y][x] = 128 + (float)(0.8784*(-0.16874 * (float)r - 0.33126 * (float)g + 0.5 * (float)b));
  1332. //                Cr1[y][x] = 128 + (float)(0.8784*(0.5 * (float)r - 0.41869 * (float)g - 0.08131 * (float)b));
  1333.                 Y[y][x] = (float)((0.299 * (float)r + 0.587 * (float)g + 0.114 * (float)b));
  1334.                 Cb1[y][x] = 128 + (float)((-0.16874 * (float)r - 0.33126 * (float)g + 0.5 * (float)b));
  1335.                 Cr1[y][x] = 128 + (float)((0.5 * (float)r - 0.41869 * (float)g - 0.08131 * (float)b));
  1336.                 index++;
  1337.          }
  1338.      }
  1340. // Need a way to set the H and V sample factors before allowing downsampling.
  1341. // For now (04/04/98) downsampling must be hard coded.
  1342. // Until a better downsampler is implemented, this will not be done.
  1343. // Downsampling is currently supported.  The downsampling method here
  1344. // is a simple box filter.
  1346.         Components[0] = Y;
  1347. //        Cb2 = DownSample(Cb1, 1);
  1348.         Components[1] = Cb1;
  1349. //        Cr2 = DownSample(Cr1, 2);
  1350.         Components[2] = Cr1;
  1351.     }
  1353.     float[][] DownSample(float[][] C, int comp)
  1354.     {
  1355.         int inrow, incol;
  1356.         int outrow, outcol;
  1357.         float output[][];
  1358.         int temp;
  1359.         int bias;
  1360.         inrow = 0;
  1361.         incol = 0;
  1362.         output = new float[compHeight[comp]][compWidth[comp]];
  1363.         for (outrow = 0; outrow < compHeight[comp]; outrow++) {
  1364.                 bias = 1;
  1365.                 for (outcol = 0; outcol < compWidth[comp]; outcol++) {
  1366.                         output[outrow][outcol] = (C[inrow][incol++] + C[inrow++][incol--] + C[inrow][incol++] + C[inrow--][incol++] + (float)bias)/(float)4.0;
  1367.                         bias ^= 3;
  1368.                 }
  1369.                 inrow += 2;
  1370.                 incol = 0;
  1371.         }
  1372.         return output;
  1373.     }
  1374. }