X-Git-Url: http://source.jalview.org/gitweb/?p=jalviewjs.git;a=blobdiff_plain;f=src%2Fjavajs%2Fimg%2FJpgEncoder.java;fp=src%2Fjavajs%2Fimg%2FJpgEncoder.java;h=5c128d6ae6c598fc3b8145540772c9fd1c1b40a5;hp=684af37031f1170b4a0e5620b5ea6c7ab5223d5e;hb=b9b7a352eee79b7764c3b09c9d19663075061d8c;hpb=7301a2415adab88038b291fc54caeeb3a5a47a44 diff --git a/src/javajs/img/JpgEncoder.java b/src/javajs/img/JpgEncoder.java index 684af37..5c128d6 100644 --- a/src/javajs/img/JpgEncoder.java +++ b/src/javajs/img/JpgEncoder.java @@ -1,1208 +1,1208 @@ -// Version 1.0a -// Copyright (C) 1998, James R. Weeks and BioElectroMech. -// Visit BioElectroMech at www.obrador.com. Email James@obrador.com. - -// See license.txt for details about the allowed used of this software. -// This software is based in part on the work of the Independent JPEG Group. -// See IJGreadme.txt for details about the Independent JPEG Group's license. - -// This encoder is inspired by the Java Jpeg encoder by Florian Raemy, -// studwww.eurecom.fr/~raemy. -// It borrows a great deal of code and structure from the Independent -// Jpeg Group's Jpeg 6a library, Copyright Thomas G. Lane. -// See license.txt for details - -/* - * JpegEncoder and its associated classes are Copyright (c) 1998, James R. Weeks and BioElectroMech - * see(Jmol/src/com/obrador/license.txt) - * - * javjs.img.JpegEncoder.java was adapted by Bob Hanson - * - * for Jmol in the following ways: - * - * 1) minor coding efficiencies were made in some for() loops. - * 2) methods not used by Jmol were commented out - * 3) method and variable signatures were modified to provide - * more appropriate method privacy. - * 4) additions for Java2Script compatibility - * - * Original files are maintained in the Jmol.src.com.obrador package, but - * these original files are not distributed with Jmol. - * -*/ - -package javajs.img; - -import java.io.IOException; -import java.util.Map; - -import javajs.img.ImageEncoder; -import javajs.util.AU; -import javajs.util.OC; - -/** - * JpegEncoder - The JPEG main program which performs a jpeg compression of an - * image. - * - * A system to allow the full Jmol state -- regardless of length -- - * to be encoded in a set of APP1 (FFE1) tags. - * But we have to be careful about line ends for backward compatibility. - * This solution is not 100% effective, because some data lines may in principle be - * Very large and may not contain new lines for more than 65500 characters, - * But that would be very unusual. Perhaps a huge data set loaded from a - * string. Introduced in Jmol 12.1.36. Bob Hanson - * - * See org.com.obrador.license.txt - * - */ - -public class JpgEncoder extends ImageEncoder { - - // this string will GENERALLY appear at the end of lines and be escaped - private static final int CONTINUE_MAX = 65500; // some room to spare here. - private static final int CONTINUE_MAX_BUFFER = CONTINUE_MAX + 10; // never break up last 10 bytes - - private JpegObj jpegObj; - private Huffman huf; - private DCT dct; - protected int defaultQuality = 100; - private String applicationTag; - - public JpgEncoder() { - - } - - @Override - protected void setParams(Map params) { - if (quality <= 0) - quality = (params.containsKey("qualityJPG") ? ((Integer) params.get("qualityJPG")).intValue() : defaultQuality); - jpegObj = new JpegObj(); - jpegObj.comment = (String) params.get("comment"); - applicationTag = (String) params.get("jpgAppTag"); - } - - @Override - protected void generate() throws IOException { - jpegObj.imageWidth = width; - jpegObj.imageHeight = height; - dct = new DCT(quality); - huf = new Huffman(width, height); - if (jpegObj == null) - return; - jpegObj.getYCCArray(pixels); - String longState = writeHeaders(jpegObj, dct); - writeCompressedData(jpegObj, dct, huf); - writeMarker(eoi); - if (longState != null) { - byte[] b = longState.getBytes(); - out.write(b, 0, b.length); - } - } - - private void writeCompressedData(JpegObj jpegObj, DCT dct, Huffman huf) { - int i, j, r, c, a, b; - int comp, xpos, ypos, xblockoffset, yblockoffset; - float inputArray[][]; - float dctArray1[][] = new float[8][8]; - double dctArray2[][] = new double[8][8]; - int dctArray3[] = new int[8 * 8]; - - /* - * This method controls the compression of the image. - * Starting at the upper left of the image, it compresses 8x8 blocks - * of data until the entire image has been compressed. - */ - - int lastDCvalue[] = new int[jpegObj.numberOfComponents]; - //int zeroArray[] = new int[64]; // initialized to hold all zeros - //int Width = 0, Height = 0; - //int nothing = 0, not; - int minBlockWidth, minBlockHeight; - // This initial setting of MinBlockWidth and MinBlockHeight is done to - // ensure they start with values larger than will actually be the case. - minBlockWidth = ((huf.imageWidth % 8 != 0) ? (int) (Math - .floor(huf.imageWidth / 8.0) + 1) * 8 : huf.imageWidth); - minBlockHeight = ((huf.imageHeight % 8 != 0) ? (int) (Math - .floor(huf.imageHeight / 8.0) + 1) * 8 : huf.imageHeight); - for (comp = 0; comp < jpegObj.numberOfComponents; comp++) { - minBlockWidth = Math.min(minBlockWidth, jpegObj.blockWidth[comp]); - minBlockHeight = Math.min(minBlockHeight, jpegObj.blockHeight[comp]); - } - xpos = 0; - for (r = 0; r < minBlockHeight; r++) { - for (c = 0; c < minBlockWidth; c++) { - xpos = c * 8; - ypos = r * 8; - for (comp = 0; comp < jpegObj.numberOfComponents; comp++) { - //Width = JpegObj.BlockWidth[comp]; - //Height = JpegObj.BlockHeight[comp]; - inputArray = jpegObj.components[comp]; - int vsampF = jpegObj.vsampFactor[comp]; - int hsampF = jpegObj.hsampFactor[comp]; - int qNumber = jpegObj.qtableNumber[comp]; - int dcNumber = jpegObj.dctableNumber[comp]; - int acNumber = jpegObj.actableNumber[comp]; - - for (i = 0; i < vsampF; i++) { - for (j = 0; j < hsampF; j++) { - xblockoffset = j * 8; - yblockoffset = i * 8; - for (a = 0; a < 8; a++) { - for (b = 0; b < 8; b++) { - - // I believe this is where the dirty line at the bottom of - // the image is coming from. - // I need to do a check here to make sure I'm not reading past - // image data. - // This seems to not be a big issue right now. (04/04/98) - - dctArray1[a][b] = inputArray[ypos + yblockoffset + a][xpos - + xblockoffset + b]; - } - } - // The following code commented out because on some images this technique - // results in poor right and bottom borders. - // if ((!JpegObj.lastColumnIsDummy[comp] || c < Width - 1) && - // (!JpegObj.lastRowIsDummy[comp] || r < Height - 1)) { - dctArray2 = DCT.forwardDCT(dctArray1); - dctArray3 = DCT.quantizeBlock(dctArray2, dct.divisors[qNumber]); - // } - // else { - // zeroArray[0] = dctArray3[0]; - // zeroArray[0] = lastDCvalue[comp]; - // dctArray3 = zeroArray; - // } - huf.HuffmanBlockEncoder(out, dctArray3, lastDCvalue[comp], - dcNumber, acNumber); - lastDCvalue[comp] = dctArray3[0]; - } - } - } - } - } - huf.flushBuffer(out); - } - - private static byte[] eoi = { (byte) 0xFF, (byte) 0xD9 }; - - private static byte[] jfif = new byte[] { - /* JFIF[0] =*/(byte) 0xff, - /* JFIF[1] =*/(byte) 0xe0, - /* JFIF[2] =*/0, - /* JFIF[3] =*/16, - /* JFIF[4] =*/(byte) 0x4a, //'J' - /* JFIF[5] =*/(byte) 0x46, //'F' - /* JFIF[6] =*/(byte) 0x49, //'I' - /* JFIF[7] =*/(byte) 0x46, //'F' - /* JFIF[8] =*/0, - /* JFIF[9] =*/1, - /* JFIF[10] =*/0, - /* JFIF[11] =*/0, - /* JFIF[12] =*/0, - /* JFIF[13] =*/1, - /* JFIF[14] =*/0, - /* JFIF[15] =*/1, - /* JFIF[16] =*/0, - /* JFIF[17] =*/0 }; - - private static byte[] soi = { (byte) 0xFF, (byte) 0xD8 }; - - private String writeHeaders(JpegObj jpegObj, DCT dct) { - int i, j, index, offset; - int tempArray[]; - - // the SOI marker - writeMarker(soi); - - // The order of the following headers is quite inconsequential. - // the JFIF header - writeArray(jfif); - - // Comment Header - String comment = null; - if (jpegObj.comment.length() > 0) - writeString(jpegObj.comment, (byte) 0xE1); // App data 1 - writeString( - "JPEG Encoder Copyright 1998, James R. Weeks and BioElectroMech.\n\n", - (byte) 0xFE); - - // The DQT header - // 0 is the luminance index and 1 is the chrominance index - byte dqt[] = new byte[134]; - dqt[0] = (byte) 0xFF; - dqt[1] = (byte) 0xDB; - dqt[2] = 0; - dqt[3] = (byte) 132; - offset = 4; - for (i = 0; i < 2; i++) { - dqt[offset++] = (byte) ((0 << 4) + i); - tempArray = dct.quantum[i]; - for (j = 0; j < 64; j++) { - dqt[offset++] = (byte) tempArray[Huffman.jpegNaturalOrder[j]]; - } - } - writeArray(dqt); - - // Start of Frame Header - byte sof[] = new byte[19]; - sof[0] = (byte) 0xFF; - sof[1] = (byte) 0xC0; - sof[2] = 0; - sof[3] = 17; - sof[4] = (byte) jpegObj.precision; - sof[5] = (byte) ((jpegObj.imageHeight >> 8) & 0xFF); - sof[6] = (byte) ((jpegObj.imageHeight) & 0xFF); - sof[7] = (byte) ((jpegObj.imageWidth >> 8) & 0xFF); - sof[8] = (byte) ((jpegObj.imageWidth) & 0xFF); - sof[9] = (byte) jpegObj.numberOfComponents; - index = 10; - for (i = 0; i < sof[9]; i++) { - sof[index++] = (byte) jpegObj.compID[i]; - sof[index++] = (byte) ((jpegObj.hsampFactor[i] << 4) + jpegObj.vsampFactor[i]); - sof[index++] = (byte) jpegObj.qtableNumber[i]; - } - writeArray(sof); - - WriteDHTHeader(Huffman.bitsDCluminance, Huffman.valDCluminance); - WriteDHTHeader(Huffman.bitsACluminance, Huffman.valACluminance); - WriteDHTHeader(Huffman.bitsDCchrominance, Huffman.valDCchrominance); - WriteDHTHeader(Huffman.bitsACchrominance, Huffman.valACchrominance); - - // Start of Scan Header - byte sos[] = new byte[14]; - sos[0] = (byte) 0xFF; - sos[1] = (byte) 0xDA; - sos[2] = 0; - sos[3] = 12; - sos[4] = (byte) jpegObj.numberOfComponents; - index = 5; - for (i = 0; i < sos[4]; i++) { - sos[index++] = (byte) jpegObj.compID[i]; - sos[index++] = (byte) ((jpegObj.dctableNumber[i] << 4) + jpegObj.actableNumber[i]); - } - sos[index++] = (byte) jpegObj.ss; - sos[index++] = (byte) jpegObj.se; - sos[index++] = (byte) ((jpegObj.ah << 4) + jpegObj.al); - writeArray(sos); - return comment; - } - - private void writeString(String s, byte id) { - int len = s.length(); - int i0 = 0; - String suffix = applicationTag; - while (i0 < len) { - int nBytes = len - i0; - if (nBytes > CONTINUE_MAX_BUFFER) { - nBytes = CONTINUE_MAX; - // but break only at line breaks - int pt = s.lastIndexOf('\n', i0 + nBytes); - if (pt > i0 + 1) - nBytes = pt - i0; - } - if (i0 + nBytes == len) - suffix = ""; - writeTag(nBytes + suffix.length(), id); - writeArray(s.substring(i0, i0 + nBytes).getBytes()); - if (suffix.length() > 0) - writeArray(suffix.getBytes()); - i0 += nBytes; - } - } - - private void writeTag(int length, byte id) { - length += 2; - byte com[] = new byte[4]; - com[0] = (byte) 0xFF; - com[1] = id; - com[2] = (byte) ((length >> 8) & 0xFF); - com[3] = (byte) (length & 0xFF); - writeArray(com); - } - - void WriteDHTHeader(int[] bits, int[] val) { - // hansonr@stolaf.edu: simplified code. - byte[] dht; - int bytes = 0; - for (int j = 1; j < 17; j++) - bytes += bits[j]; - dht = new byte[21 + bytes]; - dht[0] = (byte) 0xFF; - dht[1] = (byte) 0xC4; - int index = 4; - for (int j = 0; j < 17; j++) - dht[index++] = (byte) bits[j]; - for (int j = 0; j < bytes; j++) - dht[index++] = (byte) val[j]; - dht[2] = (byte) (((index - 2) >> 8) & 0xFF); - dht[3] = (byte) ((index - 2) & 0xFF); - writeArray(dht); - } - - void writeMarker(byte[] data) { - out.write(data, 0, 2); - } - - void writeArray(byte[] data) { - out.write(data, 0, data.length); - } - -} - -// This class incorporates quality scaling as implemented in the JPEG-6a -// library. - -/* - * DCT - A Java implementation of the Discreet Cosine Transform - */ - -class DCT { - - /** - * DCT Block Size - default 8 - */ - private final static int N = 8; - private final static int NN = N * N; - - /** - * Image Quality (0-100) - default 80 (good image / good compression) - */ - //public int QUALITY = 80; - - int[][] quantum = AU.newInt2(2); - double[][] divisors = AU.newDouble2(2); - - /** - * Quantitization Matrix for luminace. - */ - private int quantum_luminance[] = new int[NN]; - private double DivisorsLuminance[] = new double[NN]; - - /** - * Quantitization Matrix for chrominance. - */ - private int quantum_chrominance[] = new int[NN]; - private double DivisorsChrominance[] = new double[NN]; - - /** - * Constructs a new DCT object. Initializes the cosine transform matrix these - * are used when computing the DCT and it's inverse. This also initializes the - * run length counters and the ZigZag sequence. Note that the image quality - * can be worse than 25 however the image will be extemely pixelated, usually - * to a block size of N. - * - * @param quality - * The quality of the image (0 worst - 100 best) - * - */ - DCT(int quality) { - initMatrix(quality); - } - - /* - * This method sets up the quantization matrix for luminance and - * chrominance using the Quality parameter. - */ - private void initMatrix(int quality) { - // converting quality setting to that specified in the jpeg_quality_scaling - // method in the IJG Jpeg-6a C libraries - - quality = (quality < 1 ? 1 : quality > 100 ? 100 : quality); - quality = (quality < 50 ? 5000 / quality : 200 - quality * 2); - - // Creating the luminance matrix - - quantum_luminance[0] = 16; - quantum_luminance[1] = 11; - quantum_luminance[2] = 10; - quantum_luminance[3] = 16; - quantum_luminance[4] = 24; - quantum_luminance[5] = 40; - quantum_luminance[6] = 51; - quantum_luminance[7] = 61; - quantum_luminance[8] = 12; - quantum_luminance[9] = 12; - quantum_luminance[10] = 14; - quantum_luminance[11] = 19; - quantum_luminance[12] = 26; - quantum_luminance[13] = 58; - quantum_luminance[14] = 60; - quantum_luminance[15] = 55; - quantum_luminance[16] = 14; - quantum_luminance[17] = 13; - quantum_luminance[18] = 16; - quantum_luminance[19] = 24; - quantum_luminance[20] = 40; - quantum_luminance[21] = 57; - quantum_luminance[22] = 69; - quantum_luminance[23] = 56; - quantum_luminance[24] = 14; - quantum_luminance[25] = 17; - quantum_luminance[26] = 22; - quantum_luminance[27] = 29; - quantum_luminance[28] = 51; - quantum_luminance[29] = 87; - quantum_luminance[30] = 80; - quantum_luminance[31] = 62; - quantum_luminance[32] = 18; - quantum_luminance[33] = 22; - quantum_luminance[34] = 37; - quantum_luminance[35] = 56; - quantum_luminance[36] = 68; - quantum_luminance[37] = 109; - quantum_luminance[38] = 103; - quantum_luminance[39] = 77; - quantum_luminance[40] = 24; - quantum_luminance[41] = 35; - quantum_luminance[42] = 55; - quantum_luminance[43] = 64; - quantum_luminance[44] = 81; - quantum_luminance[45] = 104; - quantum_luminance[46] = 113; - quantum_luminance[47] = 92; - quantum_luminance[48] = 49; - quantum_luminance[49] = 64; - quantum_luminance[50] = 78; - quantum_luminance[51] = 87; - quantum_luminance[52] = 103; - quantum_luminance[53] = 121; - quantum_luminance[54] = 120; - quantum_luminance[55] = 101; - quantum_luminance[56] = 72; - quantum_luminance[57] = 92; - quantum_luminance[58] = 95; - quantum_luminance[59] = 98; - quantum_luminance[60] = 112; - quantum_luminance[61] = 100; - quantum_luminance[62] = 103; - quantum_luminance[63] = 99; - - AANscale(DivisorsLuminance, quantum_luminance, quality); - - // Creating the chrominance matrix - - for (int i = 4; i < 64; i++) - quantum_chrominance[i] = 99; - - quantum_chrominance[0] = 17; - quantum_chrominance[1] = 18; - quantum_chrominance[2] = 24; - quantum_chrominance[3] = 47; - - quantum_chrominance[8] = 18; - quantum_chrominance[9] = 21; - quantum_chrominance[10] = 26; - quantum_chrominance[11] = 66; - - quantum_chrominance[16] = 24; - quantum_chrominance[17] = 26; - quantum_chrominance[18] = 56; - - quantum_chrominance[24] = 47; - quantum_chrominance[25] = 66; - - AANscale(DivisorsChrominance, quantum_chrominance, quality); - - // quantum and Divisors are objects used to hold the appropriate matices - - quantum[0] = quantum_luminance; - quantum[1] = quantum_chrominance; - - divisors[0] = DivisorsLuminance; - divisors[1] = DivisorsChrominance; - - } - - private final static double[] AANscaleFactor = { 1.0, 1.387039845, - 1.306562965, 1.175875602, 1.0, 0.785694958, 0.541196100, 0.275899379 }; - - static private void AANscale(double[] divisors, int[] values, int quality) { - - for (int j = 0; j < 64; j++) { - int temp = (values[j] * quality + 50) / 100; - values[j] = (temp < 1 ? 1 : temp > 255 ? 255 : temp); - } - - for (int i = 0, index = 0; i < 8; i++) - for (int j = 0; j < 8; j++, index++) - // The divisors for the LL&M method (the slow integer method used in - // jpeg 6a library). This method is currently (04/04/98) incompletely - // implemented. - // DivisorsLuminance[index] = ((double) quantum_luminance[index]) << 3; - // The divisors for the AAN method (the float method used in jpeg 6a library. - divisors[index] = (0.125 / (values[index] * AANscaleFactor[i] * AANscaleFactor[j])); - } - - /* - * This method preforms forward DCT on a block of image data using - * the literal method specified for a 2-D Discrete Cosine Transform. - * It is included as a curiosity and can give you an idea of the - * difference in the compression result (the resulting image quality) - * by comparing its output to the output of the AAN method below. - * It is ridiculously inefficient. - */ - - // For now the final output is unusable. The associated quantization step - // needs some tweaking. If you get this part working, please let me know. - /* - public double[][] forwardDCTExtreme(float input[][]) - { - double output[][] = new double[N][N]; - int v, u, x, y; - for (v = 0; v < 8; v++) { - for (u = 0; u < 8; u++) { - for (x = 0; x < 8; x++) { - for (y = 0; y < 8; y++) { - output[v][u] += input[x][y] * - Math.cos(((double)(2*x + 1)*(double)u*Math.PI)/16)* - Math.cos(((double)(2*y + 1)*(double)v*Math.PI)/16); - } - } - output[v][u] *= (0.25)*((u == 0) ? (1.0/Math.sqrt(2)) : (double) 1.0)*((v == 0) ? (1.0/Math.sqrt(2)) : (double) 1.0); - } - } - return output; - } - - */ - /* - * This method preforms a DCT on a block of image data using the AAN - * method as implemented in the IJG Jpeg-6a library. - */ - static double[][] forwardDCT(float input[][]) { - double output[][] = new double[N][N]; - double tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; - double tmp10, tmp11, tmp12, tmp13; - double z1, z2, z3, z4, z5, z11, z13; - // Subtracts 128 from the input values - for (int i = 0; i < 8; i++) - for (int j = 0; j < 8; j++) - output[i][j] = (input[i][j] - 128.0); - // input[i][j] -= 128; - - for (int i = 0; i < 8; i++) { - tmp0 = output[i][0] + output[i][7]; - tmp7 = output[i][0] - output[i][7]; - tmp1 = output[i][1] + output[i][6]; - tmp6 = output[i][1] - output[i][6]; - tmp2 = output[i][2] + output[i][5]; - tmp5 = output[i][2] - output[i][5]; - tmp3 = output[i][3] + output[i][4]; - tmp4 = output[i][3] - output[i][4]; - - tmp10 = tmp0 + tmp3; - tmp13 = tmp0 - tmp3; - tmp11 = tmp1 + tmp2; - tmp12 = tmp1 - tmp2; - - output[i][0] = tmp10 + tmp11; - output[i][4] = tmp10 - tmp11; - - z1 = (tmp12 + tmp13) * 0.707106781; - output[i][2] = tmp13 + z1; - output[i][6] = tmp13 - z1; - - tmp10 = tmp4 + tmp5; - tmp11 = tmp5 + tmp6; - tmp12 = tmp6 + tmp7; - - z5 = (tmp10 - tmp12) * 0.382683433; - z2 = 0.541196100 * tmp10 + z5; - z4 = 1.306562965 * tmp12 + z5; - z3 = tmp11 * 0.707106781; - - z11 = tmp7 + z3; - z13 = tmp7 - z3; - - output[i][5] = z13 + z2; - output[i][3] = z13 - z2; - output[i][1] = z11 + z4; - output[i][7] = z11 - z4; - } - - for (int i = 0; i < 8; i++) { - tmp0 = output[0][i] + output[7][i]; - tmp7 = output[0][i] - output[7][i]; - tmp1 = output[1][i] + output[6][i]; - tmp6 = output[1][i] - output[6][i]; - tmp2 = output[2][i] + output[5][i]; - tmp5 = output[2][i] - output[5][i]; - tmp3 = output[3][i] + output[4][i]; - tmp4 = output[3][i] - output[4][i]; - - tmp10 = tmp0 + tmp3; - tmp13 = tmp0 - tmp3; - tmp11 = tmp1 + tmp2; - tmp12 = tmp1 - tmp2; - - output[0][i] = tmp10 + tmp11; - output[4][i] = tmp10 - tmp11; - - z1 = (tmp12 + tmp13) * 0.707106781; - output[2][i] = tmp13 + z1; - output[6][i] = tmp13 - z1; - - tmp10 = tmp4 + tmp5; - tmp11 = tmp5 + tmp6; - tmp12 = tmp6 + tmp7; - - z5 = (tmp10 - tmp12) * 0.382683433; - z2 = 0.541196100 * tmp10 + z5; - z4 = 1.306562965 * tmp12 + z5; - z3 = tmp11 * 0.707106781; - - z11 = tmp7 + z3; - z13 = tmp7 - z3; - - output[5][i] = z13 + z2; - output[3][i] = z13 - z2; - output[1][i] = z11 + z4; - output[7][i] = z11 - z4; - } - - return output; - } - - /* - * This method quantitizes data and rounds it to the nearest integer. - */ - static int[] quantizeBlock(double inputData[][], double[] divisorsCode) { - int outputData[] = new int[NN]; - for (int i = 0, index = 0; i < 8; i++) - for (int j = 0; j < 8; j++, index++) - // The second line results in significantly better compression. - outputData[index] = (int) (Math.round(inputData[i][j] - * divisorsCode[index])); - // outputData[index] = (int)(((inputData[i][j] * (((double[]) (Divisors[code]))[index])) + 16384.5) -16384); - return outputData; - } - - /* - * This is the method for quantizing a block DCT'ed with forwardDCTExtreme - * This method quantitizes data and rounds it to the nearest integer. - */ - - /* - - public double[][] forwardDCTExtreme(float input[][]) - { - double output[][] = new double[N][N]; - int v, u, x, y; - for (v = 0; v < 8; v++) { - for (u = 0; u < 8; u++) { - for (x = 0; x < 8; x++) { - for (y = 0; y < 8; y++) { - output[v][u] += input[x][y] * - Math.cos(((double)(2*x + 1)*(double)u*Math.PI)/16)* - Math.cos(((double)(2*y + 1)*(double)v*Math.PI)/16); - } - } - output[v][u] *= (0.25)*((u == 0) ? (1.0/Math.sqrt(2)) : (double) 1.0)*((v == 0) ? (1.0/Math.sqrt(2)) : (double) 1.0); - } - } - return output; - } - - */ - /* - public int[] quantizeBlockExtreme(double inputData[][], int code) - { - int outputData[] = new int[NN]; - int i, j; - int index; - index = 0; - for (i = 0; i < 8; i++) { - for (j = 0; j < 8; j++) { - outputData[index] = (int)(Math.round(inputData[i][j] / (((int[]) (quantum[code]))[index]))); - index++; - } - } - - return outputData; - } - */ -} - -// This class was modified by James R. Weeks on 3/27/98. -// It now incorporates Huffman table derivation as in the C jpeg library -// from the IJG, Jpeg-6a. - -class Huffman { - private int bufferPutBits, bufferPutBuffer; - int imageHeight; - int imageWidth; - private int dc_matrix0[][]; - private int ac_matrix0[][]; - private int dc_matrix1[][]; - private int ac_matrix1[][]; - private int[][][] dc_matrix; - private int[][][] ac_matrix; - //private int code; - int numOfDCTables; - int numOfACTables; - final static int[] bitsDCluminance = { 0x00, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, - 0, 0, 0, 0, 0 }; - final static int[] valDCluminance = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; - final static int[] bitsDCchrominance = { 0x01, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 0, 0, 0, 0, 0 }; - final static int[] valDCchrominance = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; - final static int[] bitsACluminance = { 0x10, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, - 4, 0, 0, 1, 0x7d }; - final static int[] valACluminance = { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, - 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, - 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, - 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, - 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, - 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, - 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, - 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, - 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, - 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, - 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, - 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, - 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, - 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa }; - final static int[] bitsACchrominance = { 0x11, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, - 4, 4, 0, 1, 2, 0x77 }; - final static int[] valACchrominance = { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, - 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, - 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, - 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, - 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, - 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, - 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, - 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, - 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, - 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, - 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, - 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, - 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, - 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa }; - - /* - * jpegNaturalOrder[i] is the natural-order position of the i'th element - * of zigzag order. - */ - final static int[] jpegNaturalOrder = { 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, - 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, - 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, - 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63, }; - - Huffman(int width, int height) { - initHuf(); - imageWidth = width; - imageHeight = height; - - } - - /** - * HuffmanBlockEncoder run length encodes and Huffman encodes the quantized - * data. - * - * @param out - * @param zigzag - * @param prec - * @param dcCode - * @param acCode - **/ - - void HuffmanBlockEncoder(OC out, int zigzag[], int prec, - int dcCode, int acCode) { - int temp, temp2, nbits, k, r, i; - - numOfDCTables = 2; - numOfACTables = 2; - - int[][] matrixDC = dc_matrix[dcCode]; - int[][] matrixAC = ac_matrix[acCode]; - - // The DC portion - - temp = temp2 = zigzag[0] - prec; - if (temp < 0) { - temp = -temp; - temp2--; - } - nbits = 0; - while (temp != 0) { - nbits++; - temp >>= 1; - } - // if (nbits > 11) nbits = 11; - bufferIt(out, matrixDC[nbits][0], matrixDC[nbits][1]); - // The arguments in bufferIt are code and size. - if (nbits != 0) { - bufferIt(out, temp2, nbits); - } - - // The AC portion - - r = 0; - - for (k = 1; k < 64; k++) { - if ((temp = zigzag[jpegNaturalOrder[k]]) == 0) { - r++; - } else { - while (r > 15) { - bufferIt(out, matrixAC[0xF0][0], matrixAC[0xF0][1]); - r -= 16; - } - temp2 = temp; - if (temp < 0) { - temp = -temp; - temp2--; - } - nbits = 1; - while ((temp >>= 1) != 0) { - nbits++; - } - i = (r << 4) + nbits; - bufferIt(out, matrixAC[i][0], matrixAC[i][1]); - bufferIt(out, temp2, nbits); - - r = 0; - } - } - - if (r > 0) { - bufferIt(out, matrixAC[0][0], matrixAC[0][1]); - } - - } - - // Uses an integer long (32 bits) buffer to store the Huffman encoded bits - // and sends them to out by the byte. - - void bufferIt(OC out, int code, int size) { - int putBuffer = code; - int putBits = bufferPutBits; - - putBuffer &= (1 << size) - 1; - putBits += size; - putBuffer <<= 24 - putBits; - putBuffer |= bufferPutBuffer; - - while (putBits >= 8) { - int c = ((putBuffer >> 16) & 0xFF); - out.writeByteAsInt(c); - if (c == 0xFF) { - out.writeByteAsInt(0); - } - putBuffer <<= 8; - putBits -= 8; - } - bufferPutBuffer = putBuffer; - bufferPutBits = putBits; - - } - - void flushBuffer(OC out) { - int putBuffer = bufferPutBuffer; - int putBits = bufferPutBits; - while (putBits >= 8) { - int c = ((putBuffer >> 16) & 0xFF); - out.writeByteAsInt(c); - if (c == 0xFF) { - out.writeByteAsInt(0); - } - putBuffer <<= 8; - putBits -= 8; - } - if (putBits > 0) { - int c = ((putBuffer >> 16) & 0xFF); - out.writeByteAsInt(c); - } - } - - /* - * Initialisation of the Huffman codes for Luminance and Chrominance. - * This code results in the same tables created in the IJG Jpeg-6a - * library. - */ - - private 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 = AU.newInt3(2, -1); - ac_matrix = AU.newInt3(2, -1); - int p, l, i, lastp, si, 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++) - for (i = bitsDCchrominance[l]; --i >= 0;) { - huffsize[p++] = l; //that's an "el", not a "one" - } - } - 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 huffman 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 = bitsACchrominance[l]; --i >= 0;) - // 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++) - for (i = bitsDCluminance[l]; --i >= 0;) { - 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 huffman 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++) - for (i = bitsACluminance[l]; --i >= 0;) { - 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 JpegObj { - String comment; - int imageHeight; - int imageWidth; - int blockWidth[]; - int blockHeight[]; - - int precision = 8; - int numberOfComponents = 3; - float[][][] components; - int[] compID = { 1, 2, 3 }; - int[] hsampFactor = { 1, 1, 1 }; - int[] vsampFactor = { 1, 1, 1 }; - int[] qtableNumber = { 0, 1, 1 }; - int[] dctableNumber = { 0, 1, 1 }; - int[] actableNumber = { 0, 1, 1 }; - private boolean[] lastColumnIsDummy = { false, false, false }; - private boolean[] lastRowIsDummy = { false, false, false }; - int ss = 0; - int se = 63; - int ah = 0; - int al = 0; - private int compWidth[]; - private int compHeight[]; - private int maxHsampFactor; - private int maxVsampFactor; - - public JpegObj() { - components = AU.newFloat3(numberOfComponents, -1); - compWidth = new int[numberOfComponents]; - compHeight = new int[numberOfComponents]; - blockWidth = new int[numberOfComponents]; - blockHeight = new int[numberOfComponents]; - } - - /* - * This method creates and fills three arrays, Y, Cb, and Cr using the - * input image. - */ - - void getYCCArray(int[] pixels) { - // 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. - maxHsampFactor = 1; - maxVsampFactor = 1; - for (int y = 0; y < numberOfComponents; y++) { - maxHsampFactor = Math.max(maxHsampFactor, hsampFactor[y]); - maxVsampFactor = Math.max(maxVsampFactor, vsampFactor[y]); - } - for (int y = 0; y < numberOfComponents; y++) { - compWidth[y] = (((imageWidth % 8 != 0) ? ((int) Math - .ceil(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(compWidth[y] / 8.0); - compHeight[y] = (((imageHeight % 8 != 0) ? ((int) Math - .ceil(imageHeight / 8.0)) * 8 : imageHeight) / maxVsampFactor) - * vsampFactor[y]; - if (compHeight[y] != ((imageHeight / maxVsampFactor) * vsampFactor[y])) { - lastRowIsDummy[y] = true; - } - blockHeight[y] = (int) Math.ceil(compHeight[y] / 8.0); - } - 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]]; - for (int pt = 0, y = 0; y < imageHeight; ++y) { - for (int x = 0; x < imageWidth; ++x, pt++) { - int p = pixels[pt]; - int r = ((p >> 16) & 0xff); - int g = ((p >> 8) & 0xff); - int b = (p & 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 * r + 0.587 * g + 0.114 * b)); - Cb1[y][x] = 128 + (float) ((-0.16874 * r - 0.33126 * g + 0.5 * b)); - Cr1[y][x] = 128 + (float) ((0.5 * r - 0.41869 * g - 0.08131 * b)); - } - } - - // 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, incol; - int outrow, outcol; - float output[][]; - int bias; - inrow = 0; - incol = 0; - int cHeight = compHeight[comp]; - int cWidth = compWidth[comp]; - output = new float[cHeight][cWidth]; - - for (outrow = 0; outrow < cHeight; outrow++) { - bias = 1; - for (outcol = 0; outcol < cWidth; outcol++) { - output[outrow][outcol] = (C[inrow][incol++] + C[inrow++][incol--] - + C[inrow][incol++] + C[inrow--][incol++] + bias)/(float)4.0; - bias ^= 3; - } - inrow += 2; - incol = 0; - } - return output; - } - */ - -} +// Version 1.0a +// Copyright (C) 1998, James R. Weeks and BioElectroMech. +// Visit BioElectroMech at www.obrador.com. Email James@obrador.com. + +// See license.txt for details about the allowed used of this software. +// This software is based in part on the work of the Independent JPEG Group. +// See IJGreadme.txt for details about the Independent JPEG Group's license. + +// This encoder is inspired by the Java Jpeg encoder by Florian Raemy, +// studwww.eurecom.fr/~raemy. +// It borrows a great deal of code and structure from the Independent +// Jpeg Group's Jpeg 6a library, Copyright Thomas G. Lane. +// See license.txt for details + +/* + * JpegEncoder and its associated classes are Copyright (c) 1998, James R. Weeks and BioElectroMech + * see(Jmol/src/com/obrador/license.txt) + * + * javjs.img.JpegEncoder.java was adapted by Bob Hanson + * + * for Jmol in the following ways: + * + * 1) minor coding efficiencies were made in some for() loops. + * 2) methods not used by Jmol were commented out + * 3) method and variable signatures were modified to provide + * more appropriate method privacy. + * 4) additions for Java2Script compatibility + * + * Original files are maintained in the Jmol.src.com.obrador package, but + * these original files are not distributed with Jmol. + * +*/ + +package javajs.img; + +import java.io.IOException; +import java.util.Map; + +import javajs.img.ImageEncoder; +import javajs.util.AU; +import javajs.util.OC; + +/** + * JpegEncoder - The JPEG main program which performs a jpeg compression of an + * image. + * + * A system to allow the full Jmol state -- regardless of length -- + * to be encoded in a set of APP1 (FFE1) tags. + * But we have to be careful about line ends for backward compatibility. + * This solution is not 100% effective, because some data lines may in principle be + * Very large and may not contain new lines for more than 65500 characters, + * But that would be very unusual. Perhaps a huge data set loaded from a + * string. Introduced in Jmol 12.1.36. Bob Hanson + * + * See org.com.obrador.license.txt + * + */ + +public class JpgEncoder extends ImageEncoder { + + // this string will GENERALLY appear at the end of lines and be escaped + private static final int CONTINUE_MAX = 65500; // some room to spare here. + private static final int CONTINUE_MAX_BUFFER = CONTINUE_MAX + 10; // never break up last 10 bytes + + private JpegObj jpegObj; + private Huffman huf; + private DCT dct; + protected int defaultQuality = 100; + private String applicationTag; + + public JpgEncoder() { + + } + + @Override + protected void setParams(Map params) { + if (quality <= 0) + quality = (params.containsKey("qualityJPG") ? ((Integer) params.get("qualityJPG")).intValue() : defaultQuality); + jpegObj = new JpegObj(); + jpegObj.comment = (String) params.get("comment"); + applicationTag = (String) params.get("jpgAppTag"); + } + + @Override + protected void generate() throws IOException { + jpegObj.imageWidth = width; + jpegObj.imageHeight = height; + dct = new DCT(quality); + huf = new Huffman(width, height); + if (jpegObj == null) + return; + jpegObj.getYCCArray(pixels); + String longState = writeHeaders(jpegObj, dct); + writeCompressedData(jpegObj, dct, huf); + writeMarker(eoi); + if (longState != null) { + byte[] b = longState.getBytes(); + out.write(b, 0, b.length); + } + } + + private void writeCompressedData(JpegObj jpegObj, DCT dct, Huffman huf) { + int i, j, r, c, a, b; + int comp, xpos, ypos, xblockoffset, yblockoffset; + float inputArray[][]; + float dctArray1[][] = new float[8][8]; + double dctArray2[][] = new double[8][8]; + int dctArray3[] = new int[8 * 8]; + + /* + * This method controls the compression of the image. + * Starting at the upper left of the image, it compresses 8x8 blocks + * of data until the entire image has been compressed. + */ + + int lastDCvalue[] = new int[jpegObj.numberOfComponents]; + //int zeroArray[] = new int[64]; // initialized to hold all zeros + //int Width = 0, Height = 0; + //int nothing = 0, not; + int minBlockWidth, minBlockHeight; + // This initial setting of MinBlockWidth and MinBlockHeight is done to + // ensure they start with values larger than will actually be the case. + minBlockWidth = ((huf.imageWidth % 8 != 0) ? (int) (Math + .floor(huf.imageWidth / 8.0) + 1) * 8 : huf.imageWidth); + minBlockHeight = ((huf.imageHeight % 8 != 0) ? (int) (Math + .floor(huf.imageHeight / 8.0) + 1) * 8 : huf.imageHeight); + for (comp = 0; comp < jpegObj.numberOfComponents; comp++) { + minBlockWidth = Math.min(minBlockWidth, jpegObj.blockWidth[comp]); + minBlockHeight = Math.min(minBlockHeight, jpegObj.blockHeight[comp]); + } + xpos = 0; + for (r = 0; r < minBlockHeight; r++) { + for (c = 0; c < minBlockWidth; c++) { + xpos = c * 8; + ypos = r * 8; + for (comp = 0; comp < jpegObj.numberOfComponents; comp++) { + //Width = JpegObj.BlockWidth[comp]; + //Height = JpegObj.BlockHeight[comp]; + inputArray = jpegObj.components[comp]; + int vsampF = jpegObj.vsampFactor[comp]; + int hsampF = jpegObj.hsampFactor[comp]; + int qNumber = jpegObj.qtableNumber[comp]; + int dcNumber = jpegObj.dctableNumber[comp]; + int acNumber = jpegObj.actableNumber[comp]; + + for (i = 0; i < vsampF; i++) { + for (j = 0; j < hsampF; j++) { + xblockoffset = j * 8; + yblockoffset = i * 8; + for (a = 0; a < 8; a++) { + for (b = 0; b < 8; b++) { + + // I believe this is where the dirty line at the bottom of + // the image is coming from. + // I need to do a check here to make sure I'm not reading past + // image data. + // This seems to not be a big issue right now. (04/04/98) + + dctArray1[a][b] = inputArray[ypos + yblockoffset + a][xpos + + xblockoffset + b]; + } + } + // The following code commented out because on some images this technique + // results in poor right and bottom borders. + // if ((!JpegObj.lastColumnIsDummy[comp] || c < Width - 1) && + // (!JpegObj.lastRowIsDummy[comp] || r < Height - 1)) { + dctArray2 = DCT.forwardDCT(dctArray1); + dctArray3 = DCT.quantizeBlock(dctArray2, dct.divisors[qNumber]); + // } + // else { + // zeroArray[0] = dctArray3[0]; + // zeroArray[0] = lastDCvalue[comp]; + // dctArray3 = zeroArray; + // } + huf.HuffmanBlockEncoder(out, dctArray3, lastDCvalue[comp], + dcNumber, acNumber); + lastDCvalue[comp] = dctArray3[0]; + } + } + } + } + } + huf.flushBuffer(out); + } + + private static byte[] eoi = { (byte) 0xFF, (byte) 0xD9 }; + + private static byte[] jfif = new byte[] { + /* JFIF[0] =*/(byte) 0xff, + /* JFIF[1] =*/(byte) 0xe0, + /* JFIF[2] =*/0, + /* JFIF[3] =*/16, + /* JFIF[4] =*/(byte) 0x4a, //'J' + /* JFIF[5] =*/(byte) 0x46, //'F' + /* JFIF[6] =*/(byte) 0x49, //'I' + /* JFIF[7] =*/(byte) 0x46, //'F' + /* JFIF[8] =*/0, + /* JFIF[9] =*/1, + /* JFIF[10] =*/0, + /* JFIF[11] =*/0, + /* JFIF[12] =*/0, + /* JFIF[13] =*/1, + /* JFIF[14] =*/0, + /* JFIF[15] =*/1, + /* JFIF[16] =*/0, + /* JFIF[17] =*/0 }; + + private static byte[] soi = { (byte) 0xFF, (byte) 0xD8 }; + + private String writeHeaders(JpegObj jpegObj, DCT dct) { + int i, j, index, offset; + int tempArray[]; + + // the SOI marker + writeMarker(soi); + + // The order of the following headers is quite inconsequential. + // the JFIF header + writeArray(jfif); + + // Comment Header + String comment = null; + if (jpegObj.comment.length() > 0) + writeString(jpegObj.comment, (byte) 0xE1); // App data 1 + writeString( + "JPEG Encoder Copyright 1998, James R. Weeks and BioElectroMech.\n\n", + (byte) 0xFE); + + // The DQT header + // 0 is the luminance index and 1 is the chrominance index + byte dqt[] = new byte[134]; + dqt[0] = (byte) 0xFF; + dqt[1] = (byte) 0xDB; + dqt[2] = 0; + dqt[3] = (byte) 132; + offset = 4; + for (i = 0; i < 2; i++) { + dqt[offset++] = (byte) ((0 << 4) + i); + tempArray = dct.quantum[i]; + for (j = 0; j < 64; j++) { + dqt[offset++] = (byte) tempArray[Huffman.jpegNaturalOrder[j]]; + } + } + writeArray(dqt); + + // Start of Frame Header + byte sof[] = new byte[19]; + sof[0] = (byte) 0xFF; + sof[1] = (byte) 0xC0; + sof[2] = 0; + sof[3] = 17; + sof[4] = (byte) jpegObj.precision; + sof[5] = (byte) ((jpegObj.imageHeight >> 8) & 0xFF); + sof[6] = (byte) ((jpegObj.imageHeight) & 0xFF); + sof[7] = (byte) ((jpegObj.imageWidth >> 8) & 0xFF); + sof[8] = (byte) ((jpegObj.imageWidth) & 0xFF); + sof[9] = (byte) jpegObj.numberOfComponents; + index = 10; + for (i = 0; i < sof[9]; i++) { + sof[index++] = (byte) jpegObj.compID[i]; + sof[index++] = (byte) ((jpegObj.hsampFactor[i] << 4) + jpegObj.vsampFactor[i]); + sof[index++] = (byte) jpegObj.qtableNumber[i]; + } + writeArray(sof); + + WriteDHTHeader(Huffman.bitsDCluminance, Huffman.valDCluminance); + WriteDHTHeader(Huffman.bitsACluminance, Huffman.valACluminance); + WriteDHTHeader(Huffman.bitsDCchrominance, Huffman.valDCchrominance); + WriteDHTHeader(Huffman.bitsACchrominance, Huffman.valACchrominance); + + // Start of Scan Header + byte sos[] = new byte[14]; + sos[0] = (byte) 0xFF; + sos[1] = (byte) 0xDA; + sos[2] = 0; + sos[3] = 12; + sos[4] = (byte) jpegObj.numberOfComponents; + index = 5; + for (i = 0; i < sos[4]; i++) { + sos[index++] = (byte) jpegObj.compID[i]; + sos[index++] = (byte) ((jpegObj.dctableNumber[i] << 4) + jpegObj.actableNumber[i]); + } + sos[index++] = (byte) jpegObj.ss; + sos[index++] = (byte) jpegObj.se; + sos[index++] = (byte) ((jpegObj.ah << 4) + jpegObj.al); + writeArray(sos); + return comment; + } + + private void writeString(String s, byte id) { + int len = s.length(); + int i0 = 0; + String suffix = applicationTag; + while (i0 < len) { + int nBytes = len - i0; + if (nBytes > CONTINUE_MAX_BUFFER) { + nBytes = CONTINUE_MAX; + // but break only at line breaks + int pt = s.lastIndexOf('\n', i0 + nBytes); + if (pt > i0 + 1) + nBytes = pt - i0; + } + if (i0 + nBytes == len) + suffix = ""; + writeTag(nBytes + suffix.length(), id); + writeArray(s.substring(i0, i0 + nBytes).getBytes()); + if (suffix.length() > 0) + writeArray(suffix.getBytes()); + i0 += nBytes; + } + } + + private void writeTag(int length, byte id) { + length += 2; + byte com[] = new byte[4]; + com[0] = (byte) 0xFF; + com[1] = id; + com[2] = (byte) ((length >> 8) & 0xFF); + com[3] = (byte) (length & 0xFF); + writeArray(com); + } + + void WriteDHTHeader(int[] bits, int[] val) { + // hansonr@stolaf.edu: simplified code. + byte[] dht; + int bytes = 0; + for (int j = 1; j < 17; j++) + bytes += bits[j]; + dht = new byte[21 + bytes]; + dht[0] = (byte) 0xFF; + dht[1] = (byte) 0xC4; + int index = 4; + for (int j = 0; j < 17; j++) + dht[index++] = (byte) bits[j]; + for (int j = 0; j < bytes; j++) + dht[index++] = (byte) val[j]; + dht[2] = (byte) (((index - 2) >> 8) & 0xFF); + dht[3] = (byte) ((index - 2) & 0xFF); + writeArray(dht); + } + + void writeMarker(byte[] data) { + out.write(data, 0, 2); + } + + void writeArray(byte[] data) { + out.write(data, 0, data.length); + } + +} + +// This class incorporates quality scaling as implemented in the JPEG-6a +// library. + +/* + * DCT - A Java implementation of the Discreet Cosine Transform + */ + +class DCT { + + /** + * DCT Block Size - default 8 + */ + private final static int N = 8; + private final static int NN = N * N; + + /** + * Image Quality (0-100) - default 80 (good image / good compression) + */ + //public int QUALITY = 80; + + int[][] quantum = AU.newInt2(2); + double[][] divisors = AU.newDouble2(2); + + /** + * Quantitization Matrix for luminace. + */ + private int quantum_luminance[] = new int[NN]; + private double DivisorsLuminance[] = new double[NN]; + + /** + * Quantitization Matrix for chrominance. + */ + private int quantum_chrominance[] = new int[NN]; + private double DivisorsChrominance[] = new double[NN]; + + /** + * Constructs a new DCT object. Initializes the cosine transform matrix these + * are used when computing the DCT and it's inverse. This also initializes the + * run length counters and the ZigZag sequence. Note that the image quality + * can be worse than 25 however the image will be extemely pixelated, usually + * to a block size of N. + * + * @param quality + * The quality of the image (0 worst - 100 best) + * + */ + DCT(int quality) { + initMatrix(quality); + } + + /* + * This method sets up the quantization matrix for luminance and + * chrominance using the Quality parameter. + */ + private void initMatrix(int quality) { + // converting quality setting to that specified in the jpeg_quality_scaling + // method in the IJG Jpeg-6a C libraries + + quality = (quality < 1 ? 1 : quality > 100 ? 100 : quality); + quality = (quality < 50 ? 5000 / quality : 200 - quality * 2); + + // Creating the luminance matrix + + quantum_luminance[0] = 16; + quantum_luminance[1] = 11; + quantum_luminance[2] = 10; + quantum_luminance[3] = 16; + quantum_luminance[4] = 24; + quantum_luminance[5] = 40; + quantum_luminance[6] = 51; + quantum_luminance[7] = 61; + quantum_luminance[8] = 12; + quantum_luminance[9] = 12; + quantum_luminance[10] = 14; + quantum_luminance[11] = 19; + quantum_luminance[12] = 26; + quantum_luminance[13] = 58; + quantum_luminance[14] = 60; + quantum_luminance[15] = 55; + quantum_luminance[16] = 14; + quantum_luminance[17] = 13; + quantum_luminance[18] = 16; + quantum_luminance[19] = 24; + quantum_luminance[20] = 40; + quantum_luminance[21] = 57; + quantum_luminance[22] = 69; + quantum_luminance[23] = 56; + quantum_luminance[24] = 14; + quantum_luminance[25] = 17; + quantum_luminance[26] = 22; + quantum_luminance[27] = 29; + quantum_luminance[28] = 51; + quantum_luminance[29] = 87; + quantum_luminance[30] = 80; + quantum_luminance[31] = 62; + quantum_luminance[32] = 18; + quantum_luminance[33] = 22; + quantum_luminance[34] = 37; + quantum_luminance[35] = 56; + quantum_luminance[36] = 68; + quantum_luminance[37] = 109; + quantum_luminance[38] = 103; + quantum_luminance[39] = 77; + quantum_luminance[40] = 24; + quantum_luminance[41] = 35; + quantum_luminance[42] = 55; + quantum_luminance[43] = 64; + quantum_luminance[44] = 81; + quantum_luminance[45] = 104; + quantum_luminance[46] = 113; + quantum_luminance[47] = 92; + quantum_luminance[48] = 49; + quantum_luminance[49] = 64; + quantum_luminance[50] = 78; + quantum_luminance[51] = 87; + quantum_luminance[52] = 103; + quantum_luminance[53] = 121; + quantum_luminance[54] = 120; + quantum_luminance[55] = 101; + quantum_luminance[56] = 72; + quantum_luminance[57] = 92; + quantum_luminance[58] = 95; + quantum_luminance[59] = 98; + quantum_luminance[60] = 112; + quantum_luminance[61] = 100; + quantum_luminance[62] = 103; + quantum_luminance[63] = 99; + + AANscale(DivisorsLuminance, quantum_luminance, quality); + + // Creating the chrominance matrix + + for (int i = 4; i < 64; i++) + quantum_chrominance[i] = 99; + + quantum_chrominance[0] = 17; + quantum_chrominance[1] = 18; + quantum_chrominance[2] = 24; + quantum_chrominance[3] = 47; + + quantum_chrominance[8] = 18; + quantum_chrominance[9] = 21; + quantum_chrominance[10] = 26; + quantum_chrominance[11] = 66; + + quantum_chrominance[16] = 24; + quantum_chrominance[17] = 26; + quantum_chrominance[18] = 56; + + quantum_chrominance[24] = 47; + quantum_chrominance[25] = 66; + + AANscale(DivisorsChrominance, quantum_chrominance, quality); + + // quantum and Divisors are objects used to hold the appropriate matices + + quantum[0] = quantum_luminance; + quantum[1] = quantum_chrominance; + + divisors[0] = DivisorsLuminance; + divisors[1] = DivisorsChrominance; + + } + + private final static double[] AANscaleFactor = { 1.0, 1.387039845, + 1.306562965, 1.175875602, 1.0, 0.785694958, 0.541196100, 0.275899379 }; + + static private void AANscale(double[] divisors, int[] values, int quality) { + + for (int j = 0; j < 64; j++) { + int temp = (values[j] * quality + 50) / 100; + values[j] = (temp < 1 ? 1 : temp > 255 ? 255 : temp); + } + + for (int i = 0, index = 0; i < 8; i++) + for (int j = 0; j < 8; j++, index++) + // The divisors for the LL&M method (the slow integer method used in + // jpeg 6a library). This method is currently (04/04/98) incompletely + // implemented. + // DivisorsLuminance[index] = ((double) quantum_luminance[index]) << 3; + // The divisors for the AAN method (the float method used in jpeg 6a library. + divisors[index] = (0.125 / (values[index] * AANscaleFactor[i] * AANscaleFactor[j])); + } + + /* + * This method preforms forward DCT on a block of image data using + * the literal method specified for a 2-D Discrete Cosine Transform. + * It is included as a curiosity and can give you an idea of the + * difference in the compression result (the resulting image quality) + * by comparing its output to the output of the AAN method below. + * It is ridiculously inefficient. + */ + + // For now the final output is unusable. The associated quantization step + // needs some tweaking. If you get this part working, please let me know. + /* + public double[][] forwardDCTExtreme(float input[][]) + { + double output[][] = new double[N][N]; + int v, u, x, y; + for (v = 0; v < 8; v++) { + for (u = 0; u < 8; u++) { + for (x = 0; x < 8; x++) { + for (y = 0; y < 8; y++) { + output[v][u] += input[x][y] * + Math.cos(((double)(2*x + 1)*(double)u*Math.PI)/16)* + Math.cos(((double)(2*y + 1)*(double)v*Math.PI)/16); + } + } + output[v][u] *= (0.25)*((u == 0) ? (1.0/Math.sqrt(2)) : (double) 1.0)*((v == 0) ? (1.0/Math.sqrt(2)) : (double) 1.0); + } + } + return output; + } + + */ + /* + * This method preforms a DCT on a block of image data using the AAN + * method as implemented in the IJG Jpeg-6a library. + */ + static double[][] forwardDCT(float input[][]) { + double output[][] = new double[N][N]; + double tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; + double tmp10, tmp11, tmp12, tmp13; + double z1, z2, z3, z4, z5, z11, z13; + // Subtracts 128 from the input values + for (int i = 0; i < 8; i++) + for (int j = 0; j < 8; j++) + output[i][j] = (input[i][j] - 128.0); + // input[i][j] -= 128; + + for (int i = 0; i < 8; i++) { + tmp0 = output[i][0] + output[i][7]; + tmp7 = output[i][0] - output[i][7]; + tmp1 = output[i][1] + output[i][6]; + tmp6 = output[i][1] - output[i][6]; + tmp2 = output[i][2] + output[i][5]; + tmp5 = output[i][2] - output[i][5]; + tmp3 = output[i][3] + output[i][4]; + tmp4 = output[i][3] - output[i][4]; + + tmp10 = tmp0 + tmp3; + tmp13 = tmp0 - tmp3; + tmp11 = tmp1 + tmp2; + tmp12 = tmp1 - tmp2; + + output[i][0] = tmp10 + tmp11; + output[i][4] = tmp10 - tmp11; + + z1 = (tmp12 + tmp13) * 0.707106781; + output[i][2] = tmp13 + z1; + output[i][6] = tmp13 - z1; + + tmp10 = tmp4 + tmp5; + tmp11 = tmp5 + tmp6; + tmp12 = tmp6 + tmp7; + + z5 = (tmp10 - tmp12) * 0.382683433; + z2 = 0.541196100 * tmp10 + z5; + z4 = 1.306562965 * tmp12 + z5; + z3 = tmp11 * 0.707106781; + + z11 = tmp7 + z3; + z13 = tmp7 - z3; + + output[i][5] = z13 + z2; + output[i][3] = z13 - z2; + output[i][1] = z11 + z4; + output[i][7] = z11 - z4; + } + + for (int i = 0; i < 8; i++) { + tmp0 = output[0][i] + output[7][i]; + tmp7 = output[0][i] - output[7][i]; + tmp1 = output[1][i] + output[6][i]; + tmp6 = output[1][i] - output[6][i]; + tmp2 = output[2][i] + output[5][i]; + tmp5 = output[2][i] - output[5][i]; + tmp3 = output[3][i] + output[4][i]; + tmp4 = output[3][i] - output[4][i]; + + tmp10 = tmp0 + tmp3; + tmp13 = tmp0 - tmp3; + tmp11 = tmp1 + tmp2; + tmp12 = tmp1 - tmp2; + + output[0][i] = tmp10 + tmp11; + output[4][i] = tmp10 - tmp11; + + z1 = (tmp12 + tmp13) * 0.707106781; + output[2][i] = tmp13 + z1; + output[6][i] = tmp13 - z1; + + tmp10 = tmp4 + tmp5; + tmp11 = tmp5 + tmp6; + tmp12 = tmp6 + tmp7; + + z5 = (tmp10 - tmp12) * 0.382683433; + z2 = 0.541196100 * tmp10 + z5; + z4 = 1.306562965 * tmp12 + z5; + z3 = tmp11 * 0.707106781; + + z11 = tmp7 + z3; + z13 = tmp7 - z3; + + output[5][i] = z13 + z2; + output[3][i] = z13 - z2; + output[1][i] = z11 + z4; + output[7][i] = z11 - z4; + } + + return output; + } + + /* + * This method quantitizes data and rounds it to the nearest integer. + */ + static int[] quantizeBlock(double inputData[][], double[] divisorsCode) { + int outputData[] = new int[NN]; + for (int i = 0, index = 0; i < 8; i++) + for (int j = 0; j < 8; j++, index++) + // The second line results in significantly better compression. + outputData[index] = (int) (Math.round(inputData[i][j] + * divisorsCode[index])); + // outputData[index] = (int)(((inputData[i][j] * (((double[]) (Divisors[code]))[index])) + 16384.5) -16384); + return outputData; + } + + /* + * This is the method for quantizing a block DCT'ed with forwardDCTExtreme + * This method quantitizes data and rounds it to the nearest integer. + */ + + /* + + public double[][] forwardDCTExtreme(float input[][]) + { + double output[][] = new double[N][N]; + int v, u, x, y; + for (v = 0; v < 8; v++) { + for (u = 0; u < 8; u++) { + for (x = 0; x < 8; x++) { + for (y = 0; y < 8; y++) { + output[v][u] += input[x][y] * + Math.cos(((double)(2*x + 1)*(double)u*Math.PI)/16)* + Math.cos(((double)(2*y + 1)*(double)v*Math.PI)/16); + } + } + output[v][u] *= (0.25)*((u == 0) ? (1.0/Math.sqrt(2)) : (double) 1.0)*((v == 0) ? (1.0/Math.sqrt(2)) : (double) 1.0); + } + } + return output; + } + + */ + /* + public int[] quantizeBlockExtreme(double inputData[][], int code) + { + int outputData[] = new int[NN]; + int i, j; + int index; + index = 0; + for (i = 0; i < 8; i++) { + for (j = 0; j < 8; j++) { + outputData[index] = (int)(Math.round(inputData[i][j] / (((int[]) (quantum[code]))[index]))); + index++; + } + } + + return outputData; + } + */ +} + +// This class was modified by James R. Weeks on 3/27/98. +// It now incorporates Huffman table derivation as in the C jpeg library +// from the IJG, Jpeg-6a. + +class Huffman { + private int bufferPutBits, bufferPutBuffer; + int imageHeight; + int imageWidth; + private int dc_matrix0[][]; + private int ac_matrix0[][]; + private int dc_matrix1[][]; + private int ac_matrix1[][]; + private int[][][] dc_matrix; + private int[][][] ac_matrix; + //private int code; + int numOfDCTables; + int numOfACTables; + final static int[] bitsDCluminance = { 0x00, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, + 0, 0, 0, 0, 0 }; + final static int[] valDCluminance = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; + final static int[] bitsDCchrominance = { 0x01, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 0, 0, 0, 0, 0 }; + final static int[] valDCchrominance = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; + final static int[] bitsACluminance = { 0x10, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, + 4, 0, 0, 1, 0x7d }; + final static int[] valACluminance = { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, + 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, + 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, + 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, + 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, + 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, + 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, + 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, + 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, + 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, + 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, + 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, + 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, + 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa }; + final static int[] bitsACchrominance = { 0x11, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, + 4, 4, 0, 1, 2, 0x77 }; + final static int[] valACchrominance = { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, + 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, + 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, + 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, + 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, + 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, + 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, + 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, + 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, + 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, + 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, + 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, + 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, + 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa }; + + /* + * jpegNaturalOrder[i] is the natural-order position of the i'th element + * of zigzag order. + */ + final static int[] jpegNaturalOrder = { 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, + 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, + 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63, }; + + Huffman(int width, int height) { + initHuf(); + imageWidth = width; + imageHeight = height; + + } + + /** + * HuffmanBlockEncoder run length encodes and Huffman encodes the quantized + * data. + * + * @param out + * @param zigzag + * @param prec + * @param dcCode + * @param acCode + **/ + + void HuffmanBlockEncoder(OC out, int zigzag[], int prec, + int dcCode, int acCode) { + int temp, temp2, nbits, k, r, i; + + numOfDCTables = 2; + numOfACTables = 2; + + int[][] matrixDC = dc_matrix[dcCode]; + int[][] matrixAC = ac_matrix[acCode]; + + // The DC portion + + temp = temp2 = zigzag[0] - prec; + if (temp < 0) { + temp = -temp; + temp2--; + } + nbits = 0; + while (temp != 0) { + nbits++; + temp >>= 1; + } + // if (nbits > 11) nbits = 11; + bufferIt(out, matrixDC[nbits][0], matrixDC[nbits][1]); + // The arguments in bufferIt are code and size. + if (nbits != 0) { + bufferIt(out, temp2, nbits); + } + + // The AC portion + + r = 0; + + for (k = 1; k < 64; k++) { + if ((temp = zigzag[jpegNaturalOrder[k]]) == 0) { + r++; + } else { + while (r > 15) { + bufferIt(out, matrixAC[0xF0][0], matrixAC[0xF0][1]); + r -= 16; + } + temp2 = temp; + if (temp < 0) { + temp = -temp; + temp2--; + } + nbits = 1; + while ((temp >>= 1) != 0) { + nbits++; + } + i = (r << 4) + nbits; + bufferIt(out, matrixAC[i][0], matrixAC[i][1]); + bufferIt(out, temp2, nbits); + + r = 0; + } + } + + if (r > 0) { + bufferIt(out, matrixAC[0][0], matrixAC[0][1]); + } + + } + + // Uses an integer long (32 bits) buffer to store the Huffman encoded bits + // and sends them to out by the byte. + + void bufferIt(OC out, int code, int size) { + int putBuffer = code; + int putBits = bufferPutBits; + + putBuffer &= (1 << size) - 1; + putBits += size; + putBuffer <<= 24 - putBits; + putBuffer |= bufferPutBuffer; + + while (putBits >= 8) { + int c = ((putBuffer >> 16) & 0xFF); + out.writeByteAsInt(c); + if (c == 0xFF) { + out.writeByteAsInt(0); + } + putBuffer <<= 8; + putBits -= 8; + } + bufferPutBuffer = putBuffer; + bufferPutBits = putBits; + + } + + void flushBuffer(OC out) { + int putBuffer = bufferPutBuffer; + int putBits = bufferPutBits; + while (putBits >= 8) { + int c = ((putBuffer >> 16) & 0xFF); + out.writeByteAsInt(c); + if (c == 0xFF) { + out.writeByteAsInt(0); + } + putBuffer <<= 8; + putBits -= 8; + } + if (putBits > 0) { + int c = ((putBuffer >> 16) & 0xFF); + out.writeByteAsInt(c); + } + } + + /* + * Initialisation of the Huffman codes for Luminance and Chrominance. + * This code results in the same tables created in the IJG Jpeg-6a + * library. + */ + + private 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 = AU.newInt3(2, -1); + ac_matrix = AU.newInt3(2, -1); + int p, l, i, lastp, si, 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++) + for (i = bitsDCchrominance[l]; --i >= 0;) { + huffsize[p++] = l; //that's an "el", not a "one" + } + } + 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 huffman 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 = bitsACchrominance[l]; --i >= 0;) + // 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++) + for (i = bitsDCluminance[l]; --i >= 0;) { + 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 huffman 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++) + for (i = bitsACluminance[l]; --i >= 0;) { + 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 JpegObj { + String comment; + int imageHeight; + int imageWidth; + int blockWidth[]; + int blockHeight[]; + + int precision = 8; + int numberOfComponents = 3; + float[][][] components; + int[] compID = { 1, 2, 3 }; + int[] hsampFactor = { 1, 1, 1 }; + int[] vsampFactor = { 1, 1, 1 }; + int[] qtableNumber = { 0, 1, 1 }; + int[] dctableNumber = { 0, 1, 1 }; + int[] actableNumber = { 0, 1, 1 }; + private boolean[] lastColumnIsDummy = { false, false, false }; + private boolean[] lastRowIsDummy = { false, false, false }; + int ss = 0; + int se = 63; + int ah = 0; + int al = 0; + private int compWidth[]; + private int compHeight[]; + private int maxHsampFactor; + private int maxVsampFactor; + + public JpegObj() { + components = AU.newFloat3(numberOfComponents, -1); + compWidth = new int[numberOfComponents]; + compHeight = new int[numberOfComponents]; + blockWidth = new int[numberOfComponents]; + blockHeight = new int[numberOfComponents]; + } + + /* + * This method creates and fills three arrays, Y, Cb, and Cr using the + * input image. + */ + + void getYCCArray(int[] pixels) { + // 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. + maxHsampFactor = 1; + maxVsampFactor = 1; + for (int y = 0; y < numberOfComponents; y++) { + maxHsampFactor = Math.max(maxHsampFactor, hsampFactor[y]); + maxVsampFactor = Math.max(maxVsampFactor, vsampFactor[y]); + } + for (int y = 0; y < numberOfComponents; y++) { + compWidth[y] = (((imageWidth % 8 != 0) ? ((int) Math + .ceil(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(compWidth[y] / 8.0); + compHeight[y] = (((imageHeight % 8 != 0) ? ((int) Math + .ceil(imageHeight / 8.0)) * 8 : imageHeight) / maxVsampFactor) + * vsampFactor[y]; + if (compHeight[y] != ((imageHeight / maxVsampFactor) * vsampFactor[y])) { + lastRowIsDummy[y] = true; + } + blockHeight[y] = (int) Math.ceil(compHeight[y] / 8.0); + } + 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]]; + for (int pt = 0, y = 0; y < imageHeight; ++y) { + for (int x = 0; x < imageWidth; ++x, pt++) { + int p = pixels[pt]; + int r = ((p >> 16) & 0xff); + int g = ((p >> 8) & 0xff); + int b = (p & 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 * r + 0.587 * g + 0.114 * b)); + Cb1[y][x] = 128 + (float) ((-0.16874 * r - 0.33126 * g + 0.5 * b)); + Cr1[y][x] = 128 + (float) ((0.5 * r - 0.41869 * g - 0.08131 * b)); + } + } + + // 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, incol; + int outrow, outcol; + float output[][]; + int bias; + inrow = 0; + incol = 0; + int cHeight = compHeight[comp]; + int cWidth = compWidth[comp]; + output = new float[cHeight][cWidth]; + + for (outrow = 0; outrow < cHeight; outrow++) { + bias = 1; + for (outcol = 0; outcol < cWidth; outcol++) { + output[outrow][outcol] = (C[inrow][incol++] + C[inrow++][incol--] + + C[inrow][incol++] + C[inrow--][incol++] + bias)/(float)4.0; + bias ^= 3; + } + inrow += 2; + incol = 0; + } + return output; + } + */ + +}