Java : know how much bytes were read by ImageIO.read() (and maybe other similar methods)

Question

i am making a java program that reads data from a binary stream (using a DataInputStream).

Sometimes during this process i need to read a data chunk, however the method (which i cannot modify) that reads it will stop before reaching the end of the chunk (it is the normal behavior, apparently it just doesn't need the last bytes, but i can't do anything about the fact that they are there). This is not a problem in itself because i know exactly how long the chunk is, i.e. i know how many bytes there are in the chunk so i can skip bytes (with the skipBytes(int) method) until the end of the chunk ; the problem is : i don't actually know how many bytes the method actually read (or left), so i don't know how many bytes i need to skip to reach the end of the chunk.
Is there any way to :

• know how many bytes were read in a stream since a certain point in time ?
• know how many bytes were read in a stream since it was ?
• any other way i could know how many bytes my data-chunk-reading method just read (since it won't directly tell me) ?

Just in case, i made a small diagram

Thanks in advance

Answer 1

ImageInputStream can do what you want. It implements DataInput and it has most of the methods of InputStream. And it has getStreamPosition, seek and skipBytes methods.

However, as you correctly point out, ImageIO.read(ImageInputStream) would close the stream, preventing you from reading more than one image.

The solution is to avoid using ImageIO.read, and instead obtain an ImageReader explicitly, using ImageIO.getImageReaders. Then you can invoke an ImageReader’s read method, which does not close the stream.

Here’s how I implemented it:

public void readImages(InputStream source,
                       Consumer<? super BufferedImage> imageHandler)
throws IOException {
    // Every image is at a byte index which is a multiple of this number.
    int boundary = 5000;

    try (ImageInputStream stream = ImageIO.createImageInputStream(source)) {
        while (true) {
            long pos = stream.getStreamPosition();

            Iterator<ImageReader> readers = ImageIO.getImageReaders(stream);
            if (!readers.hasNext()) {
                break;
            }

            ImageReader reader = readers.next();
            reader.setInput(stream);
            BufferedImage image = reader.read(0);

            imageHandler.accept(image);

            pos = stream.getStreamPosition();
            long bytesToSkip = boundary - (pos % boundary);
            if (bytesToSkip < boundary) {
                stream.skipBytes(bytesToSkip);
            }
        }
    }
}

And here’s how I tested it:

try (InputStream source = new BufferedInputStream(
        Files.newInputStream(Path.of(filename)))) {

    reader.readImages(source, img -> EventQueue.invokeLater(() -> {
        JOptionPane.showMessageDialog(null, new ImageIcon(img));
    }));
}

Answer 2

All the buffered read methods return the actual number of bytes read.

Quoting documentation for InputStream#read(byte[] b):

Returns: the total number of bytes read into the buffer, or -1 if there is no more data because the end of the stream has been reached.