javax.imageio.stream.MemoryCacheImageInputStream Java Examples

/** Reads the image header.
 * Does nothing if the header has already been loaded.
 */
private void readHeader() throws IOException {
    if (image == null) {
        ImageReader r = new JPEGImageReader(getOriginatingProvider());
        Object in = getInput();
        /*if (in instanceof Buffer) {
            Buffer buffer = (Buffer) in;
            in=buffer.getData();
        }*/
        if (in instanceof byte[]) {
            r.setInput(new MemoryCacheImageInputStream(AVIBMPDIB.prependDHTSeg((byte[]) in)));
        } else if (in instanceof ImageInputStream) {
            r.setInput(AVIBMPDIB.prependDHTSeg((ImageInputStream) in));
        } else {
            r.setInput(AVIBMPDIB.prependDHTSeg((InputStream) in));
        }
        image = r.read(0);
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public static void main(String[] args) throws IOException {
    // Generate some trivial image and save it to a temporary array
    ByteArrayOutputStream tmp = new ByteArrayOutputStream();
    ImageIO.write(new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB),
            "gif", tmp);

    // Read the stream
    ImageInputStream in = new MemoryCacheImageInputStream(
            new ByteArrayInputStream(tmp.toByteArray()));
    ImageReader reader = ImageIO.getImageReaders(in).next();
    reader.setInput(in);

    // Retrieve standard image metadata tree
    IIOMetadata meta = reader.getImageMetadata(0);
    if (meta == null || !meta.isStandardMetadataFormatSupported()) {
        throw new Error("Test failure: Missing metadata");
    }
    Element root = (Element) meta.
            getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName);

    // Test getElementsByTagName("*")
    if (root.getElementsByTagName("*").getLength() == 0) {
        throw new RuntimeException("getElementsByTagName(\"*\") returns"
                + " nothing");
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

public ImageInputStream createInputStreamInstance(Object input,
                                                  boolean useCache,
                                                  File cacheDir)
    throws IOException {
    if (input instanceof InputStream) {
        InputStream is = (InputStream)input;

        if (useCache) {
            return new FileCacheImageInputStream(is, cacheDir);
        } else {
            return new MemoryCacheImageInputStream(is);
        }
    } else {
        throw new IllegalArgumentException();
    }
}
 

/**
 * Reformats bit-discontiguous data into the {@code DataBuffer}
 * of the supplied {@code WritableRaster}.
 */
private static void reformatDiscontiguousData(byte[] buf,
                                              int[] bitsPerSample,
                                              int stride,
                                              int w,
                                              int h,
                                              WritableRaster raster)
    throws IOException {

    // Get SampleModel info.
    SampleModel sm = raster.getSampleModel();
    int numBands = sm.getNumBands();

    // Initialize input stream.
    ByteArrayInputStream is = new ByteArrayInputStream(buf);
    ImageInputStream iis = new MemoryCacheImageInputStream(is);

    // Reformat.
    long iisPosition = 0L;
    int y = raster.getMinY();
    for(int j = 0; j < h; j++, y++) {
        iis.seek(iisPosition);
        int x = raster.getMinX();
        for(int i = 0; i < w; i++, x++) {
            for(int b = 0; b < numBands; b++) {
                long bits = iis.readBits(bitsPerSample[b]);
                raster.setSample(x, y, b, (int)bits);
            }
        }
        iisPosition += stride;
    }
}
 

@Override
public BufferedImage readImage(final InputStream in,
	final JPEG2000CodecOptions options) throws IOException, ServiceException
{
	final J2KImageReader reader = getReader();
	final MemoryCacheImageInputStream mciis = new MemoryCacheImageInputStream(
		in);
	reader.setInput(mciis, false, true);
	final J2KImageReadParam param = (J2KImageReadParam) reader
		.getDefaultReadParam();
	if (options.resolution != null) {
		param.setResolution(options.resolution.intValue());
	}
	return reader.read(0, param);
}
 

public static void main(String[] args) throws IOException {
    // Generate some trivial image and save it to a temporary array
    ByteArrayOutputStream tmp = new ByteArrayOutputStream();
    ImageIO.write(new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB),
            "gif", tmp);

    // Read it back in
    ImageInputStream in = new MemoryCacheImageInputStream(
            new ByteArrayInputStream(tmp.toByteArray()));
    ImageReader reader = ImageIO.getImageReaders(in).next();
    reader.setInput(in);

    // Retrieve standard image metadata tree
    IIOMetadata meta = reader.getImageMetadata(0);
    if (meta == null || !meta.isStandardMetadataFormatSupported()) {
        throw new Error("Test failure: Missing metadata");
    }
    Element root = (Element) meta.
            getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName);

    NodeList nodeList = root.
            getElementsByTagName(root.getFirstChild().getNodeName());
    /*
     * Accessing the nth node should return null and not throw
     * IndexOutOfBoundsException.
     */
    Node n = (nodeList.item(nodeList.getLength()));
}
 

public static void main(String args[]) throws Exception {
    Iterator<ImageReader> readers = ImageIO.getImageReadersBySuffix("simp");
    ImageReader simpReader = null;
    if (readers.hasNext()) {
        simpReader = readers.next();
        System.out.println("reader="+simpReader);
    }
    if (simpReader == null) {
        throw new RuntimeException("Reader not found.");
    }

    ImageReaderSpi spi = simpReader.getOriginatingProvider();
    IIOMetadataFormat spiFmt =
        spi.getImageMetadataFormat("simp_metadata_1.0");
    System.out.println("fmt from SPI=" + spiFmt);

    ByteArrayInputStream bais = new ByteArrayInputStream(simpData);
    ImageInputStream iis = new MemoryCacheImageInputStream(bais);
    simpReader.setInput(iis);
    BufferedImage bi = simpReader.read(0);
    System.out.println(bi);
    IIOMetadata metadata = simpReader.getImageMetadata(0);
    System.out.println("Image metadata="+metadata);
    IIOMetadataFormat format =
        metadata.getMetadataFormat("simp_metadata_1.0");
    System.out.println("Image metadata format="+format);
    if (format == null) {
        throw new RuntimeException("MetadataFormat not found.");
    }
}
 

public static String getImageType(byte[] mapObj) throws IOException {
    String type = "";
    try (ByteArrayInputStream bais = new ByteArrayInputStream(mapObj);
         MemoryCacheImageInputStream mcis = new MemoryCacheImageInputStream(bais)) {
        Iterator<ImageReader> itr = ImageIO.getImageReaders(mcis);
        while (itr.hasNext()) {
            ImageReader reader = itr.next();
            String imageName = reader.getClass().getSimpleName();
            if (imageName != null) {
                if ("GIFImageReader".equals(imageName)) {
                    type = "gif";
                } else if ("JPEGImageReader".equals(imageName)) {
                    type = "jpg";
                } else if ("PNGImageReader".equals(imageName)) {
                    type = "png";
                } else if ("BMPImageReader".equals(imageName)) {
                    type = "bmp";
                } else {
                    type = "noPic";
                }
            }
        }
    } catch (Exception e) {
        type = "noPic";
    }
    return type;
}
 

private static void checkIndexBounds(List<byte[]> codeTable, long index,
        MemoryCacheImageInputStream in) throws IOException
{
    if (index < 0)
    {
        throw new IOException(
                "negative array index: " + index + " near offset " + in.getStreamPosition());
    }
    if (index >= codeTable.size())
    {
        throw new IOException("array index overflow: " + index + " >= " + codeTable.size()
                + " near offset " + in.getStreamPosition());
    }
}
 

/**
 * Get all sample values of this function.
 *
 * @return an array with all samples.
 */
private int[][] getSamples()
{
    if (samples == null)
    {
        int arraySize = 1;
        int nIn = getNumberOfInputParameters();
        int nOut = getNumberOfOutputParameters();
        COSArray sizes = getSize();
        for (int i = 0; i < nIn; i++)
        {
            arraySize *= sizes.getInt(i);
        }
        samples = new int[arraySize][nOut];
        int bitsPerSample = getBitsPerSample();
        int index = 0;
        try
        {
            // PDF spec 1.7 p.171:
            // Each sample value is represented as a sequence of BitsPerSample bits. 
            // Successive values are adjacent in the bit stream; there is no padding at byte boundaries.
            ImageInputStream mciis = new MemoryCacheImageInputStream(getPDStream().createInputStream());
            for (int i = 0; i < arraySize; i++)
            {
                for (int k = 0; k < nOut; k++)
                {
                    // TODO will this cast work properly for 32 bitsPerSample or should we use long[]?
                    samples[index][k] = (int) mciis.readBits(bitsPerSample);
                }
                index++;
            }
            mciis.close();
        }
        catch (IOException exception)
        {
            LOG.error("IOException while reading the sample values of this function.", exception);
        }
    }
    return samples;
}
 

/**
 * Get all sample values of this function.
 *
 * @return an array with all samples.
 */
private int[][] getSamples()
{
    if (samples == null)
    {
        int arraySize = 1;
        int nIn = getNumberOfInputParameters();
        int nOut = getNumberOfOutputParameters();
        COSArray sizes = getSize();
        for (int i = 0; i < nIn; i++)
        {
            arraySize *= sizes.getInt(i);
        }
        samples = new int[arraySize][nOut];
        int bitsPerSample = getBitsPerSample();
        int index = 0;
        try
        {
            // PDF spec 1.7 p.171:
            // Each sample value is represented as a sequence of BitsPerSample bits. 
            // Successive values are adjacent in the bit stream; there is no padding at byte boundaries.
            ImageInputStream mciis = new MemoryCacheImageInputStream(getPDStream().createInputStream());
            for (int i = 0; i < arraySize; i++)
            {
                for (int k = 0; k < nOut; k++)
                {
                    // TODO will this cast work properly for 32 bitsPerSample or should we use long[]?
                    samples[index][k] = (int) mciis.readBits(bitsPerSample);
                }
                index++;
            }
            mciis.close();
        }
        catch (IOException exception)
        {
            LOG.error("IOException while reading the sample values of this function.", exception);
        }
    }
    return samples;
}
 

private void checkIndexBounds(List<byte[]> codeTable, long index, MemoryCacheImageInputStream in)
        throws IOException
{
    if (index < 0)
    {
        throw new IOException("negative array index: " + index + " near offset "
                + in.getStreamPosition());
    }
    if (index >= codeTable.size())
    {
        throw new IOException("array index overflow: " + index +
                " >= " + codeTable.size() + " near offset "
                + in.getStreamPosition());
    }
}
 

private ImageInputStream createImageInputStream(InputStream is) throws IOException {
	if (this.cacheDir != null) {
		return new FileCacheImageInputStream(is, this.cacheDir);
	}
	else {
		return new MemoryCacheImageInputStream(is);
	}
}
 

private ImageInputStream createImageInputStream(InputStream is) throws IOException {
	if (this.cacheDir != null) {
		return new FileCacheImageInputStream(is, cacheDir);
	}
	else {
		return new MemoryCacheImageInputStream(is);
	}
}
 

private ImageInputStream createImageInputStream(InputStream is) throws IOException {
	if (this.cacheDir != null) {
		return new FileCacheImageInputStream(is, cacheDir);
	}
	else {
		return new MemoryCacheImageInputStream(is);
	}
}