dequantize.java

用java写的jt-jpeg。jt表示java time package

package jpeg;
import java.util.*;
import jcp.*;

/**
 *  Dequantize.java
 *  A component that dequantizes an image block.
 *
 *  Input(s):
 *      in - Takes an 8x8 matrix of integers as input.
 *      quality - An Integer that specifies the quantization factor that the image was
 *                originally quantized with.
 *  Ouput(s):
 *      out - Outputs an 8x8 matrix of integers representing the dequantized image block.
 *
 *  @see IntMatrix
 */

public class Dequantize extends SynchComponent
{
    // Block size
    private final static int N = 8;

    // Quantization matrix
    private int[][] quantum = new int[N][N];

    // Quality
    private int quality = 10;

    private Port in_p, out_p;
    private Port quality_p;

    public Dequantize() {
        setName("Dequantize");
        in_p = addPort(true,"in");
        out_p = addPort(false,"out");
        quality_p = addPort(true,"quality");

        // Temp values to set the types of ports
        IntMatrix t0 = new IntMatrix();
        Integer t1 = new Integer(0);

        in_p.setType(t0.getClass());
        quality_p.setType(t1.getClass());

        initMatrix(quality);
    }

    public void go(Port port) {
        if (port == in_p) {
            IntMatrix s = (IntMatrix)in_p.signal();
            int[][] matrix = s.get_matrix();
            emit(new IntMatrix(dequantize(matrix)),out_p);
        } else if (port == quality_p) {
            int qual = ((Integer)quality_p.signal()).intValue();
            initMatrix(qual);
        }
    }

    private int outputData[][] = new int[N][N];
    public int[][] dequantize(int inputData[][]) {

        for (int i=0; i<N; i++) {
            for (int j=0; j<N; j++) {

                double result = inputData[i][j] * quantum[i][j];
                outputData[i][j] = (int)(Math.round(result));
            }
        }

        return outputData;
    }

    private void initMatrix(int quality)
    {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                quantum[i][j] = (1 + ((1 + i + j) * quality));
            }
        }
    }
}