/*
 * @(#)JPEGQTable.java	1.14 05/11/17
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

/**********************************************************************
 **********************************************************************
 **********************************************************************
 *** COPYRIGHT (c) 1997-1998 Eastman Kodak Company.                 ***
 *** As  an unpublished  work pursuant to Title 17 of the United    ***
 *** States Code.  All rights reserved.                             ***
 **********************************************************************
 **********************************************************************
 **********************************************************************/

package javax.imageio.plugins.jpeg;

/**
 * A class encapsulating a single JPEG quantization table.  The
 * elements appear in natural order (as opposed to zig-zag order).
 * Static variables are provided for the "standard" tables taken from
 * Annex K of the JPEG spec, as well as the default tables
 * conventionally used for visually lossless encoding.
 *
 * <p>
 * For more information about the operation of the built-in JPEG plug-ins,
 * see the <A HREF="../../metadata/doc-files/jpeg_metadata.html">JPEG
 * metadata format specification and usage notes</A>.
 *
 * @version 0.5
 */
public class JPEGQTable {

    /** Table */
    private int[] table;

    /** The number of coefficients in a quantization table. */
    private static final byte QTABLESIZE = 64;
	
    /** 
     * The sample luminance quantization table given in the JPEG
     * specification, table K.1.  According to the specification,
     * these values produce "good" quality output.
     *
     * @see #K1Div2Luminance
     */
    public static final JPEGQTable K1Luminance = new JPEGQTable();
    static {
        int [] lumVals = {
            16,  11,  10,  16,  24,  40,  51,  61,
            12,  12,  14,  19,  26,  58,  60,  55,
            14,  13,  16,  24,  40,  57,  69,  56,
            14,  17,  22,  29,  51,  87,  80,  62,
            18,  22,  37,  56,  68, 109, 103,  77,
            24,  35,  55,  64,  81, 104, 113,  92,
            49,  64,  78,  87, 103, 121, 120, 101,
            72,  92,  95,  98, 112, 100, 103,  99
        };
        
        K1Luminance.table = lumVals;
    }

    /**
     * The sample luminance quantization table given in the JPEG
     * specification, table K.1, with all elements divided by 2.
     * According to the specification, these values produce "very
     * good" quality output.  This is the table usually used for
     * "visually lossless" encoding, and is the default luminance
     * table used if the default tables and quality settings are used.
     *
     * @see #K1Luminance
     */
    public static final JPEGQTable K1Div2Luminance = 
        K1Luminance.getScaledInstance(0.5f, true);

    /** 
     * The sample chrominance quantization table given in the JPEG
     * specification, table K.2.  According to the specification,
     * these values produce "good" quality output.
     *
     * @see #K2Div2Chrominance
     */
    public static final JPEGQTable K2Chrominance = new JPEGQTable();
    static {
        int [] chromVals = {
            17,  18,  24,  47,  99,  99,  99,  99,
            18,  21,  26,  66,  99,  99,  99,  99,
            24,  26,  56,  99,  99,  99,  99,  99,
            47,  66,  99,  99,  99,  99,  99,  99,
            99,  99,  99,  99,  99,  99,  99,  99,
            99,  99,  99,  99,  99,  99,  99,  99,
            99,  99,  99,  99,  99,  99,  99,  99,
            99,  99,  99,  99,  99,  99,  99,  99
        };
        K2Chrominance.table = chromVals;
    }
    
    /**
     * The sample chrominance quantization table given in the JPEG
     * specification, table K.2, with all elements divided by 2.
     * According to the specification, these values produce "very
     * good" quality output.  This is the table usually used for
     * "visually lossless" encoding, and is the default chrominance
     * table used if the default tables and quality settings are used.
     *
     * @see #K2Chrominance
     */
    public static final JPEGQTable K2Div2Chrominance = 
        K2Chrominance.getScaledInstance(0.5f, true);
    
    /** 
     * Constructs an empty quantization table. This is used to create
     * the standard tables.
     */
    private JPEGQTable() {}
		
    /** 
     * Constructs a quantization table from the argument, which must
     * contain 64 elements in natural order (not zig-zag order).
     * A copy is made of the the input array.
     *
     * @param table the quantization table, as an <code>int</code>
     * array.
     *
     * @exception IllegalArgumentException if <code>table</code> is
     * <code>null</code> or <code>table.length</code> is not equal to
     * 64.
     */
    public JPEGQTable(int[] table) {
        if (table == null) {
            throw new IllegalArgumentException("table == null!");
        }
        if (table.length != QTABLESIZE) {
            throw new IllegalArgumentException
                ("Quantization table is the wrong size.");
        }

        this.table = (int[])table.clone();
    }
    
    /** 
     * Returns a copy of the current quantization table as an array of
     * ints in natural (not zig-zag) order.
     *
     * @return A copy of the current quantization table.
     */
    public int[] getTable() { 
        return (int[])table.clone();
    }

    /** 
     * Returns a new quantization table where the values are
     * multiplied by <code>scaleFactor</code> and then clamped to the
     * range 1..32767 (or to 1..255 if <code>forceBaseline</code> is
     * <code>true</code>).
     *
     * <p> Values of <code>scaleFactorless</code> than 1 tend to
     * improve the quality level of the table, and values greater than
     * <code>1.0</code> degrade the quality level of the table.
     
     * @param scaleFactor the multiplicative factor for the table.
     * @param forceBaseline if <code>true</code>, the values will be
     * clamped to the range 1..255.
     *
     * @return a new quantization table that is a linear multiple of
     * the current table.
     */
    public JPEGQTable getScaledInstance(float scaleFactor, 
                                        boolean forceBaseline) {
        int max = (forceBaseline) ? 255 : 32767;
        int[] ret = new int[QTABLESIZE];

        for (int i = 0; i < QTABLESIZE; i++) {
            float scaledValue = (float)Math.round(table[i]*scaleFactor);
            int holder;
            
            // limit to valid range
            if (scaledValue <= 1.0F) {
                holder = 1;
            } else if (scaledValue >= max) {
                holder = max;
            } else {
                holder = (int)scaledValue;
            }
            ret[i] = holder;
        }

        return new JPEGQTable(ret);
    }

    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append("JPEGQTable:\n");
        for (int i = 0; i< 8; i++) {
            sb.append('\t');
            for (int j = 0; j < 8; j++) {
                sb.append(table[(i*8)+j]).append(" ");
            }
            sb.append('\n');
        }
        return sb.toString();
    }
}