openjpeg/wrapping/java/openjp2/java-sources/org/openJpeg/OpenJPEGJavaDecoder.java

251 lines
8.9 KiB
Java

/*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2002-2007, Patrick Piscaglia, Telemis s.a.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.
*/
package org.openJpeg;
import java.util.Vector;
/** This class decodes one J2K codestream into an image (width + height + depth + pixels[],
* using the OpenJPEG.org library.
* To be able to log messages, the called must register a IJavaJ2KDecoderLogger object.
*/
public class OpenJPEGJavaDecoder {
public interface IJavaJ2KDecoderLogger {
public void logDecoderMessage(String message);
public void logDecoderError(String message);
}
private static boolean isInitialized = false;
// ===== decompression parameters =============>
// These value may be changed for each image
private String[] decoder_arguments = null;
/** number of resolutions decompositions */
private int nbResolutions = -1;
/** the quality layers */
private int[] layers = null;
/** Contains the 8 bpp version of the image. May NOT be filled together with image16 or image24.<P>
* We store in Java the 8 or 16 bpp version of the image while the decoder uses a 32 bpp version, because <UL>
* <LI> the storage capacity required is smaller
* <LI> the transfer Java <-- C will be faster
* <LI> the conversion byte/short ==> int will be done faster by the C
* </UL>*/
private byte[] image8 = null;
/** Contains the 16 bpp version of the image. May NOT be filled together with image8 or image24*/
private short[] image16 = null;
/** Contains the 24 bpp version of the image. May NOT be filled together with image8 or image16 */
private int[] image24 = null;
/** Holds the J2K compressed bytecode to decode */
private byte compressedStream[] = null;
/** Holds the compressed version of the index file, to be used by the decoder */
private byte compressedIndex[] = null;
/** Width and Height of the image */
private int width = -1;
private int height = -1;
private int depth = -1;
/** This parameter is never used in Java but is read by the C library to know the number of resolutions to skip when decoding,
* i.e. if there are 5 resolutions and skipped=1 ==> decode until resolution 4. */
private int skippedResolutions = 0;
private Vector<IJavaJ2KDecoderLogger> loggers = new Vector();
public OpenJPEGJavaDecoder(String openJPEGlibraryFullPathAndName, IJavaJ2KDecoderLogger messagesAndErrorsLogger) throws ExceptionInInitializerError
{
this(openJPEGlibraryFullPathAndName);
loggers.addElement(messagesAndErrorsLogger);
}
public OpenJPEGJavaDecoder(String openJPEGlibraryFullPathAndName) throws ExceptionInInitializerError
{
if (!isInitialized) {
try {
System.load(openJPEGlibraryFullPathAndName);
isInitialized = true;
} catch (Throwable t) {
throw new ExceptionInInitializerError("OpenJPEG Java Decoder: probably impossible to find the C library");
}
}
}
public void addLogger(IJavaJ2KDecoderLogger messagesAndErrorsLogger) {
loggers.addElement(messagesAndErrorsLogger);
}
public void removeLogger(IJavaJ2KDecoderLogger messagesAndErrorsLogger) {
loggers.removeElement(messagesAndErrorsLogger);
}
public int decodeJ2KtoImage() {
if ((image16 == null || (image16 != null && image16.length != width*height)) && (depth==-1 || depth==16)) {
image16 = new short[width*height];
logMessage("OpenJPEGJavaDecoder.decompressImage: image16 length = " + image16.length + " (" + width + " x " + height + ") ");
}
if ((image8 == null || (image8 != null && image8.length != width*height)) && (depth==-1 || depth==8)) {
image8 = new byte[width*height];
logMessage("OpenJPEGJavaDecoder.decompressImage: image8 length = " + image8.length + " (" + width + " x " + height + ") ");
}
if ((image24 == null || (image24 != null && image24.length != width*height)) && (depth==-1 || depth==24)) {
image24 = new int[width*height];
logMessage("OpenJPEGJavaDecoder.decompressImage: image24 length = " + image24.length + " (" + width + " x " + height + ") ");
}
String[] arguments = new String[0 + (decoder_arguments != null ? decoder_arguments.length : 0)];
int offset = 0;
if (decoder_arguments != null) {
for (int i=0; i<decoder_arguments.length; i++) {
arguments[i+offset] = decoder_arguments[i];
}
}
return internalDecodeJ2KtoImage(arguments);
}
/**
* Decode the j2k stream given in the codestream byte[] and fills the image8, image16 or image24 array, according to the bit depth.
*/
private native int internalDecodeJ2KtoImage(String[] parameters);
/** Image depth in bpp */
public int getDepth() {
return depth;
}
/** Image depth in bpp */
public void setDepth(int depth) {
this.depth = depth;
}
/** Image height in pixels */
public int getHeight() {
return height;
}
/** Image height in pixels */
public void setHeight(int height) {
this.height = height;
}
/** Number of resolutions contained in the image */
public int getNbResolutions() {
return nbResolutions;
}
/** Number of resolutions contained in the image */
public void setNbResolutions(int nbResolutions) {
this.nbResolutions = nbResolutions;
}
/** Width of the image in pixels */
public int getWidth() {
return width;
}
/** Width of the image in pixels */
public void setWidth(int width) {
this.width = width;
}
/** Contains the decompressed version of the image, if the depth in is [9,16] bpp.
* Returns NULL otherwise.
*/
public short[] getImage16() {
return image16;
}
/** Contains the decompressed version of the image, if the depth in is [17,24] bpp and the image is in color.
* Returns NULL otherwise.
*/
public int[] getImage24() {
return image24;
}
/** Contains the decompressed version of the image, if the depth in is [1,8] bpp.
* Returns NULL otherwise.
*/
public byte[] getImage8() {
return image8;
}
/** Sets the compressed version of the index file for this image.
* This index file is used by the decompressor
*/
public void setCompressedIndex(byte[] compressedIndex) {
this.compressedIndex = compressedIndex;
}
/** Sets the codestream to be decoded */
public void setCompressedStream(byte[] compressedStream) {
this.compressedStream = compressedStream;
}
/** @return the compressed code stream length, or -1 if not defined */
public long getCodestreamLength() {
if (compressedStream == null)
return -1;
else return compressedStream.length;
}
/** This method is called either directly or by the C methods */
public void logMessage(String message) {
for (IJavaJ2KDecoderLogger logger:loggers)
logger.logDecoderMessage(message);
}
/** This method is called either directly or by the C methods */
public void logError(String error) {
for (IJavaJ2KDecoderLogger logger:loggers)
logger.logDecoderError(error);
}
public void reset() {
nbResolutions = -1;
layers = null;
image8 = null;
image16 = null;
image24 = null;
compressedStream = null;
compressedIndex = null;
width = -1;
height = -1;
depth = -1;
}
public void setSkippedResolutions(int numberOfSkippedResolutions) {
skippedResolutions = numberOfSkippedResolutions;
}
/** Contains all the decoding arguments other than the input/output file */
public void setDecoderArguments(String[] argumentsForTheDecoder) {
decoder_arguments = argumentsForTheDecoder;
}
}