This is an automated email from the ASF dual-hosted git repository.
desruisseaux pushed a commit to branch geoapi-4.0
in repository https://gitbox.apache.org/repos/asf/sis.git
commit ec8d89adde13533ad3dd197a7cd7244a7dab48fc
Author: Martin Desruisseaux <martin.desruisse...@geomatys.com>
AuthorDate: Thu Apr 10 16:40:32 2025 +0200
Allow to read tiles through HTTP using HTTP range requests.
It requires some reorganization for allowing to know the ranges in advance.
---
.../org/apache/sis/io/stream/ChannelDataInput.java | 15 ++
.../sis/storage/base/TiledDeferredImage.java | 1 +
.../apache/sis/storage/base/TiledGridCoverage.java | 19 ++-
.../apache/sis/storage/geoheif/FromImageIO.java | 65 ++++----
.../main/org/apache/sis/storage/geoheif/Image.java | 43 ++++--
.../apache/sis/storage/geoheif/ImageResource.java | 152 +++++++++++++------
.../sis/storage/geoheif/ResourceBuilder.java | 6 +-
.../sis/storage/geoheif/UncompressedImage.java | 69 ++++-----
.../org/apache/sis/storage/isobmff/ByteRanges.java | 163 +++++++++++++++++++++
.../org/apache/sis/storage/isobmff/ByteReader.java | 92 ------------
.../org/apache/sis/storage/isobmff/Reader.java | 14 +-
.../apache/sis/storage/isobmff/base/ItemData.java | 32 ++--
.../sis/storage/isobmff/base/ItemLocation.java | 96 +++++++-----
13 files changed, 481 insertions(+), 286 deletions(-)
diff --git
a/endorsed/src/org.apache.sis.storage/main/org/apache/sis/io/stream/ChannelDataInput.java
b/endorsed/src/org.apache.sis.storage/main/org/apache/sis/io/stream/ChannelDataInput.java
index 8616626267..2abd181a59 100644
---
a/endorsed/src/org.apache.sis.storage/main/org/apache/sis/io/stream/ChannelDataInput.java
+++
b/endorsed/src/org.apache.sis.storage/main/org/apache/sis/io/stream/ChannelDataInput.java
@@ -1221,6 +1221,8 @@ loop: while (hasRemaining()) {
*
* @param lower position (inclusive) of the first byte to be requested.
* @param upper position (exclusive) of the last byte to be requested.
+ *
+ * @see #useRangeOfInterest()
*/
public final void rangeOfInterest(long lower, long upper) {
if (channel instanceof ByteRangeChannel) {
@@ -1230,6 +1232,19 @@ loop: while (hasRemaining()) {
}
}
+ /**
+ * Returns whether calls to {@code rangeOfInterest(…)} has any effect.
+ * This method is useful when {@code rangeOfInterest(…)} is invoked in a
loop.
+ * If this method returns {@code false}, then the loop can be omitted
completly.
+ *
+ * @return whether calls to {@code rangeOfInterest(…)} has any effect.
+ *
+ * @see #rangeOfInterest(long, long)
+ */
+ public final boolean useRangeOfInterest() {
+ return (channel instanceof ByteRangeChannel);
+ }
+
/**
* Forgets the given number of bytes in the buffer.
* This is invoked for making room for more bytes.
diff --git
a/endorsed/src/org.apache.sis.storage/main/org/apache/sis/storage/base/TiledDeferredImage.java
b/endorsed/src/org.apache.sis.storage/main/org/apache/sis/storage/base/TiledDeferredImage.java
index 1e6a7f10b9..eb4b50d2c3 100644
---
a/endorsed/src/org.apache.sis.storage/main/org/apache/sis/storage/base/TiledDeferredImage.java
+++
b/endorsed/src/org.apache.sis.storage/main/org/apache/sis/storage/base/TiledDeferredImage.java
@@ -97,6 +97,7 @@ final class TiledDeferredImage extends BatchComputedImage {
*
* @param tiles range of tile indices for which to load tiles.
* @return loaded tiles for the given indices, in row-major fashion.
+ * @throws Exception if an error occurred while loading a tile.
*/
@Override
protected Raster[] computeTiles(final Rectangle tiles) throws Exception {
diff --git
a/endorsed/src/org.apache.sis.storage/main/org/apache/sis/storage/base/TiledGridCoverage.java
b/endorsed/src/org.apache.sis.storage/main/org/apache/sis/storage/base/TiledGridCoverage.java
index f5604cfb34..cada7ef2ac 100644
---
a/endorsed/src/org.apache.sis.storage/main/org/apache/sis/storage/base/TiledGridCoverage.java
+++
b/endorsed/src/org.apache.sis.storage/main/org/apache/sis/storage/base/TiledGridCoverage.java
@@ -19,7 +19,6 @@ package org.apache.sis.storage.base;
import java.util.Map;
import java.util.Locale;
import java.util.Optional;
-import java.io.IOException;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.image.DataBuffer;
@@ -43,7 +42,6 @@ import org.apache.sis.coverage.grid.GridExtent;
import org.apache.sis.coverage.grid.DisjointExtentException;
import org.apache.sis.image.privy.DeferredProperty;
import org.apache.sis.image.privy.TiledImage;
-import org.apache.sis.storage.DataStoreException;
import org.apache.sis.storage.tiling.TileMatrixSet;
import org.apache.sis.storage.internal.Resources;
import org.apache.sis.util.collection.WeakValueHashMap;
@@ -1329,17 +1327,22 @@ public abstract class TiledGridCoverage extends
GridCoverage {
* corner of the image in the {@link TiledGridResource}).
*
* The {@link Raster#getMinX()} and {@code getMinY()} coordinates of
returned rasters
- * shall start at the given {@code iterator.offsetAOI} values.
+ * shall start at the values given by {@link
TileIterator#getTileOrigin(int)}.
+ * Each tile in the returned array shall be stored at the index given by
+ * {@link TileIterator#getTileIndexInResultArray()}.
*
* <p>This method must be thread-safe. It is implementer responsibility to
ensure synchronization,
* for example using {@link
TiledGridResource#getSynchronizationLock()}.</p>
*
* @param iterator an iterator over the tiles that intersect the Area Of
Interest specified by user.
* @return tiles decoded from the {@link TiledGridResource}.
- * @throws IOException if an I/O error occurred.
- * @throws DataStoreException if a logical error occurred.
- * @throws RuntimeException if the Java2D image cannot be created for
another reason
- * (too many exception types to list them all).
+ * @throws Exception if the tile cannot be created. There is too many
possible exceptions for listing all types,
+ * but the main ones are {@link java.io.IOException} for I/O
errors and various {@link RuntimeException}
+ * subtypes for Java2D errors.
+ *
+ * @see TileIterator#createRaster()
+ * @see TileIterator#getTileOrigin(int)
+ * @see TileIterator#getTileIndexInResultArray()
*/
- protected abstract Raster[] readTiles(TileIterator iterator) throws
IOException, DataStoreException;
+ protected abstract Raster[] readTiles(TileIterator iterator) throws
Exception;
}
diff --git
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/FromImageIO.java
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/FromImageIO.java
index d8e55e8e93..2db0d56ebb 100644
---
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/FromImageIO.java
+++
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/FromImageIO.java
@@ -17,7 +17,6 @@
package org.apache.sis.storage.geoheif;
import java.io.IOException;
-import java.awt.image.Raster;
import java.awt.image.SampleModel;
import java.awt.image.BufferedImage;
import java.awt.image.RasterFormatException;
@@ -25,11 +24,12 @@ import javax.imageio.ImageReader;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.spi.IIORegistry;
import javax.imageio.spi.ImageReaderSpi;
+import org.apache.sis.io.stream.ChannelDataInput;
import org.apache.sis.storage.DataStoreException;
import org.apache.sis.storage.DataStoreContentException;
import org.apache.sis.storage.IllegalOpenParameterException;
import org.apache.sis.storage.UnsupportedEncodingException;
-import org.apache.sis.storage.isobmff.ByteReader;
+import org.apache.sis.storage.isobmff.ByteRanges;
import org.apache.sis.util.ArraysExt;
@@ -60,7 +60,7 @@ final class FromImageIO extends Image {
* @param name a name that identifies this image, for debugging
purpose.
* @throws RasterFormatException if the sample model cannot be created.
*/
- FromImageIO(final CoverageBuilder builder, final ByteReader locator, final
ImageReaderSpi provider, final String name) {
+ FromImageIO(final CoverageBuilder builder, final ByteRanges.Reader
locator, final ImageReaderSpi provider, final String name) {
super(builder, locator, name);
this.provider = provider;
}
@@ -86,22 +86,21 @@ final class FromImageIO extends Image {
}
/**
- * Sets the input of the given reader to an input stream positioned to the
beginning of the image.
+ * Sets the input of the given reader to an input stream positioned at the
beginning of the image.
*
- * @param store the store that opened the <abbr>HEIF</abbr> file.
* @param reader the image reader for which to set the input.
+ * @param input the input from which to read bytes.
+ * @param ranges the ranges of bytes to read.
* @throws DataStoreException if the input cannot be set because of its
type.
* @throws IOException if an I/O error occurred while setting the input.
*/
- private void setReaderInput(final GeoHeifStore store, final ImageReader
reader) throws DataStoreException, IOException {
- final var request = new ByteReader.FileRegion();
- request.input = store.ensureOpen();
- request.length = -1;
- locator.resolve(request);
- request.input.seek(request.offset);
- request.input.buffer.order(byteOrder);
+ private void setReaderInput(final ImageReader reader, final
ChannelDataInput input, final ByteRanges ranges)
+ throws DataStoreException, IOException
+ {
+ input.seek(ranges.offset());
+ input.buffer.order(byteOrder);
try {
- reader.setInput(request.input, true, true);
+ reader.setInput(input, true, true);
} catch (IllegalArgumentException e) {
throw new IllegalOpenParameterException("Not an image input
stream.", e);
}
@@ -119,7 +118,9 @@ final class FromImageIO extends Image {
@Override
protected ImageTypeSpecifier getImageType(final GeoHeifStore store) throws
DataStoreException, IOException {
final ImageReader reader = provider.createReaderInstance();
- setReaderInput(store, reader);
+ final var ranges = new ByteRanges();
+ locator.resolve(0, -1, ranges);
+ setReaderInput(reader,
ranges.viewAsConsecutiveBytes(store.ensureOpen()), ranges);
final var it = reader.getImageTypes(IMAGE_INDEX);
ImageTypeSpecifier specifier;
if (it.hasNext()) {
@@ -139,26 +140,26 @@ final class FromImageIO extends Image {
}
/**
- * Reads a single tile.
+ * Computes the range of bytes that will be needed for reading a single
tile of this image.
*
- * @param store the data store reading a tile.
- * @param tileX 0-based column index of the tile to read, starting
from image left.
- * @param tileY 0-based column index of the tile to read, starting
from image top.
- * @param context contains the target raster or the image reader to use.
- * @return tile filled with the pixel values read by this method.
+ * @param context where to store the ranges of bytes.
+ * @throws DataStoreException if an error occurred while computing the
range of bytes.
*/
@Override
- protected Raster readTile(final GeoHeifStore store, final long tileX,
final long tileY,
- final ImageResource.Coverage.ReadContext context) throws
IOException, DataStoreException
- {
- final ImageReader reader = context.getReader(provider);
- setReaderInput(store, reader);
- final BufferedImage image;
- try {
- image = reader.readTile(IMAGE_INDEX, Math.toIntExact(tileX),
Math.toIntExact(tileY));
- } finally {
- reader.setInput(null);
- }
- return image.getRaster();
+ protected Reader computeByteRanges(final
ImageResource.Coverage.ReadContext context) throws DataStoreException {
+ locator.resolve(0, -1, context);
+ return (final ChannelDataInput input) -> {
+ final ImageReader reader = context.getReader(provider);
+ setReaderInput(reader, input, context);
+ final BufferedImage image;
+ try {
+ image = reader.readTile(IMAGE_INDEX,
+ Math.toIntExact(context.subTileX),
+ Math.toIntExact(context.subTileY));
+ } finally {
+ reader.setInput(null);
+ }
+ return image.getRaster();
+ };
}
}
diff --git
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/Image.java
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/Image.java
index 75742b29f3..b04b221e54 100644
---
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/Image.java
+++
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/Image.java
@@ -24,7 +24,7 @@ import javax.imageio.ImageTypeSpecifier;
import org.apache.sis.io.stream.ChannelDataInput;
import org.apache.sis.storage.DataStoreException;
import org.apache.sis.storage.DataStoreContentException;
-import org.apache.sis.storage.isobmff.ByteReader;
+import org.apache.sis.storage.isobmff.ByteRanges;
/**
@@ -51,7 +51,7 @@ abstract class Image {
* The provider of bytes to read from the <abbr>ISOBMFF</abbr> box.
* The bytes are read from the {@link ChannelDataInput} at a position
specified by the box.
*/
- protected final ByteReader locator;
+ protected final ByteRanges.Reader locator;
/**
* The byte order to use for reading the sample values of the image.
@@ -66,7 +66,7 @@ abstract class Image {
* @param name a name that identifies this image, for debugging
purpose.
* @throws RasterFormatException if the sample model cannot be created.
*/
- protected Image(final CoverageBuilder builder, final ByteReader locator,
final String name) {
+ protected Image(final CoverageBuilder builder, final ByteRanges.Reader
locator, final String name) {
this.locator = locator;
this.name = name;
byteOrder = builder.byteOrder();
@@ -99,16 +99,37 @@ abstract class Image {
}
/**
- * Reads a single tile.
+ * Computes the range of bytes that will be needed for reading a single
tile of this image.
+ * There will be usually a single range of bytes per tile, but this method
allows the bytes
+ * to be spread over more than one extent.
*
- * @param store the data store reading a tile.
- * @param tileX 0-based column index of the tile to read, starting
from image left.
- * @param tileY 0-based column index of the tile to read, starting
from image top.
- * @param context contains the target raster or the image reader to use.
- * @return tile filled with the pixel values read by this method.
+ * <p>This method does not read the bytes immediately.
+ * Instead, it returns a function which will be executed later for
finishing the read operation.</p>
+ *
+ * @param context where to store the ranges of bytes.
+ * @return the function to invoke later for reading the tile.
+ * @throws DataStoreException if an error occurred while computing the
range of bytes.
+ */
+ protected abstract Reader
computeByteRanges(ImageResource.Coverage.ReadContext context) throws
DataStoreException;
+
+ /**
+ * Reads a single tile from a sequence of bytes.
+ * Instances are prepared and returned by {@link #computeByteRanges
computeByteRanges(…)}.
*/
- protected abstract Raster readTile(final GeoHeifStore store, final long
tileX, final long tileY,
- final ImageResource.Coverage.ReadContext context) throws
IOException, DataStoreException;
+ @FunctionalInterface
+ protected interface Reader {
+ /**
+ * Reads a single tile from a sequence of bytes in the given input.
+ * The implementation is responsible for setting the stream position
before to start reading bytes.
+ * The given {@code input} will view all bytes after the initial
position as if they were stored in
+ * one single large extent.
+ * Implementations should ignore the fact that the sequence of bytes
may be spread in many extents.
+ *
+ * @param input a view of the byte sequences as if they were stored
in one single large extent.
+ * @return tile filled with the pixel values read by this method.
+ */
+ Raster readTile(ChannelDataInput input) throws Exception;
+ }
/**
* Returns the name of this image, for debugging purposes.
diff --git
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/ImageResource.java
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/ImageResource.java
index d5f35f50a0..32439c4d07 100644
---
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/ImageResource.java
+++
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/ImageResource.java
@@ -16,11 +16,13 @@
*/
package org.apache.sis.storage.geoheif;
+import java.util.Arrays;
import java.util.List;
import java.util.Map;
+import java.util.HashMap;
import java.util.Optional;
-import java.util.IdentityHashMap;
import java.io.IOException;
+import java.io.UncheckedIOException;
import static java.lang.Math.addExact;
import static java.lang.Math.multiplyExact;
import java.awt.image.ColorModel;
@@ -41,6 +43,8 @@ import org.apache.sis.storage.DataStoreException;
import org.apache.sis.storage.base.StoreResource;
import org.apache.sis.storage.base.TiledGridCoverage;
import org.apache.sis.storage.base.TiledGridResource;
+import org.apache.sis.storage.isobmff.ByteRanges;
+import org.apache.sis.io.stream.ChannelDataInput;
/**
@@ -109,18 +113,19 @@ final class ImageResource extends TiledGridResource
implements StoreResource {
private final ColorModel colorModel;
/**
- * The images that constitute the tiles of this grid. Shall contain at
least 1 element.
+ * Information about the images that constitute the tiles of this grid.
Shall contain at least 1 element.
+ * The {@link Image} elements contain only metadata such as position in
the file, not actual pixel values.
* All tiles shall have the same size.
*/
private final Image[] tiles;
/**
* Creates a new grid coverage resource for an image.
- * Exactly one of {@code tiles} and {@code reader} argument shall be
non-null.
+ * Exactly one of {@code tiles} and {@code image} arguments shall be
non-null.
*
* @param builder helper class for building the grid geometry and sample
dimensions.
* @param tiles the images that constitute the tiles, or {@code null}
if {@code reader} is provided.
- * @param image the single tile for the wole image, or {@code null} if
{@code tiles} is provided.
+ * @param image the single tile for the whole image, or {@code null}
if {@code tiles} is provided.
* @throws RasterFormatException if the sample dimensions or sample model
cannot be created.
* @throws DataStoreException if the "grid to <abbr>CRS</abbr>" transform
cannot be created.
*/
@@ -299,19 +304,36 @@ final class ImageResource extends TiledGridResource
implements StoreResource {
* @return tiles decoded from the enclosing resource.
*/
@Override
- protected Raster[] readTiles(final TileIterator iterator) throws
IOException, DataStoreException {
- final Raster[] result = new Raster[iterator.tileCountInQuery];
- try (final var context = new ReadContext(iterator)) {
- synchronized (getSynchronizationLock()) {
+ protected Raster[] readTiles(final TileIterator iterator) throws
Exception {
+ final var result = new Raster[iterator.tileCountInQuery];
+ final var requests = new ReadContext[result.length];
+ int count = 0;
+ synchronized (getSynchronizationLock()) {
+ try (final var context = new ReadContext(iterator)) {
do {
- Raster tile = iterator.getCachedTile();
- if (tile == null) {
- long[] tileCoord =
iterator.getTileCoordinatesInResource();
- tile = readTile(tileCoord[0], tileCoord[1],
context);
- tile = iterator.cache(iterator.moveRaster(tile));
+ Raster raster = iterator.getCachedTile();
+ if (raster != null) {
+ result[iterator.getTileIndexInResultArray()] =
raster;
+ } else {
+ requests[count++] = new ReadContext(context,
ImageResource.this);
}
- result[iterator.getTileIndexInResultArray()] = tile;
} while (iterator.next());
+ /*
+ * For any tile that was not in the cache, read them in
the order they appear in the file.
+ * The ranges of bytes of all tiles should be declared
before to start the reading process,
+ * for giving a chance to emit a single "HTTP range"
request. Then, for each tile, `input`
+ * may be replaced by a view hiding the fact that byte may
be spread in more than one extent.
+ */
+ Arrays.sort(requests, 0, count);
+ final ChannelDataInput input = store.ensureOpen();
+ if (input.useRangeOfInterest()) {
+ for (int i=0; i<count; i++) {
+ requests[i].notify(input); // Implementation
should take care of merging the ranges.
+ }
+ }
+ for (int i=0; i<count; i++) {
+ requests[i].readTile(input, result); //
Implementation may create an `input` view.
+ }
}
}
return result;
@@ -321,17 +343,27 @@ final class ImageResource extends TiledGridResource
implements StoreResource {
* Context about a {@code readTile(…)} operation. Contains the tile to
create, or
* the image reader to use in the case of read operations delegated to
Image I/O.
*/
- static final class ReadContext implements AutoCloseable {
+ static final class ReadContext extends ByteRanges implements
AutoCloseable {
/**
* Iterator over the tiles to read.
*/
private final AOI iterator;
/**
- * The image reader created for reading the tiles,
- * or {@code null} if image readers are not used.
+ * The image readers created for reading the tiles.
+ */
+ private final Map<ImageReaderSpi, ImageReader> readers;
+
+ /**
+ * The function to execute for reading the image as a tile.
*/
- private Map<ImageReaderSpi, ImageReader> readers;
+ private final Image.Reader reader;
+
+ /**
+ * 0-based index (column and row) of the tile to read inside the
image to read.
+ * This is a tile inside the {@linkplain #tile}, i.e. a second
level of tiling.
+ */
+ final long subTileX, subTileY;
/**
* Creates a new read context.
@@ -340,6 +372,42 @@ final class ImageResource extends TiledGridResource
implements StoreResource {
*/
private ReadContext(final AOI iterator) {
this.iterator = iterator;
+ this.readers = new HashMap<>();
+ this.reader = null;
+ this.subTileX = 0;
+ this.subTileY = 0;
+ }
+
+ /**
+ * Creates a context which is a snapshot of the given context at
the current iterator position.
+ *
+ * @param parent the parent from which to create a snapshot.
+ * @param tileX 0-based column index of the tile to read,
starting from image left.
+ * @param tileY 0-based row index of the tile to read, starting
from image top.
+ */
+ private ReadContext(final ReadContext parent, final ImageResource
owner) throws DataStoreException {
+ this.iterator = new Snapshot(parent.iterator);
+ this.readers = parent.readers;
+ final long[] tileCoord =
iterator.getTileCoordinatesInResource();
+ final Image tile = owner.getTile(tileCoord[0], tileCoord[1]);
+ subTileX = tileCoord[0] % tile.numXTiles;
+ subTileY = tileCoord[1] % tile.numYTiles;
+ reader = tile.computeByteRanges(this);
+ }
+
+ /**
+ * Reads the tile and store the result in the given array.
+ * The given input is the stream over the <abbr>HEIF</abbr> file
+ * (not yet the view showing all bytes as if they were stored in a
single extent).
+ *
+ * @param input the input from which to read bytes.
+ * @param result where to store the result.
+ */
+ final void readTile(ChannelDataInput input, final Raster[] result)
throws Exception {
+ input = viewAsConsecutiveBytes(input);
+ Raster raster = reader.readTile(input);
+ raster = iterator.cache(iterator.moveRaster(raster));
+ result[iterator.getTileIndexInResultArray()] = raster;
}
/**
@@ -363,15 +431,17 @@ final class ImageResource extends TiledGridResource
implements StoreResource {
* @throws IOException if an error occurred while creating the
image reader.
*/
public ImageReader getReader(final ImageReaderSpi spi) throws
IOException {
- if (readers == null) {
- readers = new IdentityHashMap<>();
- }
- ImageReader reader = readers.get(spi);
- if (reader == null) {
- reader = spi.createReaderInstance();
- readers.put(spi, reader);
+ try {
+ return readers.computeIfAbsent(spi, (factory) -> {
+ try {
+ return factory.createReaderInstance();
+ } catch (IOException e) {
+ throw new UncheckedIOException(e);
+ }
+ });
+ } catch (UncheckedIOException e) {
+ throw e.getCause();
}
- return reader;
}
/**
@@ -380,30 +450,24 @@ final class ImageResource extends TiledGridResource
implements StoreResource {
*/
@Override
public void close() {
- if (readers != null) {
- readers.values().forEach(ImageReader::dispose);
- }
+ readers.values().forEach(ImageReader::dispose);
}
}
}
/**
- * Reads a single tile.
+ * Returns information (not pixel values) about the tile at the given tile
coordinates.
+ * The tile coordinates are in the tile matrix including the sub-divisions
in each tile.
+ * This method returns the image which contains the requested tile.
*
- * @param tileX 0-based column index of the tile to read, starting
from image left.
- * @param tileY 0-based column index of the tile to read, starting
from image top.
- * @param context contains the target raster or the image reader to use.
- * @return tile filled with the pixel values read by this method.
+ * @param tileX 0-based column index of the tile to read, starting from
image left.
+ * @param tileY 0-based row index of the tile to read, starting from
image top.
+ * @return information about the tile at the specified tile coordinates.
*/
- private Raster readTile(long tileX, long tileY, final Coverage.ReadContext
context)
- throws IOException, DataStoreException
- {
- Image tile = tiles[0];
- final long tx = tileX / tile.numXTiles;
- final long ty = tileY / tile.numYTiles;
- tile = tiles[Math.toIntExact(addExact(tx, multiplyExact(ty,
tileMatrixRowStride)))];
- tileX %= tile.numXTiles;
- tileY %= tile.numYTiles;
- return tile.readTile(store, tileX, tileY, context);
+ final Image getTile(long tileX, long tileY) {
+ Image template = tiles[0]; // First tile taken as a template for
all tiles.
+ tileX /= template.numXTiles;
+ tileY /= template.numYTiles;
+ return tiles[Math.toIntExact(addExact(tileX, multiplyExact(tileY,
tileMatrixRowStride)))];
}
}
diff --git
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/ResourceBuilder.java
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/ResourceBuilder.java
index e3bc44b1d1..087cabb903 100644
---
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/ResourceBuilder.java
+++
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/ResourceBuilder.java
@@ -36,7 +36,7 @@ import org.apache.sis.storage.DataStoreException;
import org.apache.sis.storage.DataStoreContentException;
import org.apache.sis.storage.UnsupportedEncodingException;
import org.apache.sis.storage.isobmff.Box;
-import org.apache.sis.storage.isobmff.ByteReader;
+import org.apache.sis.storage.isobmff.ByteRanges;
import org.apache.sis.storage.isobmff.Root;
import org.apache.sis.storage.isobmff.base.EntityToGroup;
import org.apache.sis.storage.isobmff.base.GroupList;
@@ -257,7 +257,7 @@ final class ResourceBuilder {
* @return the item for locating the identified data, or {@code null} if
none.
* @throws DataStoreContentException if there is two ore more items for
the same identifier.
*/
- private ByteReader getLocationByIdentifier(final int itemID) throws
DataStoreContentException {
+ private ByteRanges.Reader getLocationByIdentifier(final int itemID) throws
DataStoreContentException {
final Object item = itemLocations.get(itemID);
if (item == null) {
return data; // May be null.
@@ -335,7 +335,7 @@ final class ResourceBuilder {
if (firstBuilder == null) {
firstBuilder = coverage;
}
- final ByteReader locator;
+ final ByteRanges.Reader locator;
final Image.Supplier image;
switch (entry.itemType) {
default: {
diff --git
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/UncompressedImage.java
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/UncompressedImage.java
index 945520ff7e..2e9a05c964 100644
---
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/UncompressedImage.java
+++
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/geoheif/UncompressedImage.java
@@ -16,10 +16,8 @@
*/
package org.apache.sis.storage.geoheif;
-import java.io.IOException;
import static java.lang.Math.addExact;
import static java.lang.Math.multiplyExact;
-import java.awt.image.Raster;
import java.awt.image.DataBuffer;
import java.awt.image.SampleModel;
import java.awt.image.WritableRaster;
@@ -27,10 +25,11 @@ import java.awt.image.RasterFormatException;
import org.apache.sis.image.DataType;
import org.apache.sis.image.privy.ImageUtilities;
import org.apache.sis.image.privy.RasterFactory;
+import org.apache.sis.io.stream.ChannelDataInput;
import org.apache.sis.io.stream.HyperRectangleReader;
import org.apache.sis.io.stream.Region;
import org.apache.sis.storage.DataStoreException;
-import org.apache.sis.storage.isobmff.ByteReader;
+import org.apache.sis.storage.isobmff.ByteRanges;
/**
@@ -66,25 +65,22 @@ final class UncompressedImage extends Image {
* @param name a name that identifies this image, for debugging
purpose.
* @throws RasterFormatException if the sample model cannot be created.
*/
- UncompressedImage(final CoverageBuilder builder, final ByteReader locator,
final String name) throws DataStoreException {
+ UncompressedImage(final CoverageBuilder builder, final ByteRanges.Reader
locator, final String name)
+ throws DataStoreException
+ {
super(builder, locator, name);
sampleModel = builder.sampleModel();
dataType = builder.dataType(); // Shall be after
`sampleModel()`.
}
/**
- * Reads a single tile. The default implementation assumes an uncompressed
tile.
+ * Computes the range of bytes that will be needed for reading a single
tile of this image.
*
- * @param store the data store reading a tile.
- * @param tileX 0-based column index of the tile to read, starting
from image left.
- * @param tileY 0-based column index of the tile to read, starting
from image top.
- * @param context contains the target raster or the image reader to use.
- * @return tile filled with the pixel values read by this method.
+ * @param context where to store the ranges of bytes.
+ * @throws DataStoreException if an error occurred while computing the
range of bytes.
*/
@Override
- protected Raster readTile(final GeoHeifStore store, final long tileX,
final long tileY,
- final ImageResource.Coverage.ReadContext context) throws
IOException, DataStoreException
- {
+ protected Reader computeByteRanges(final
ImageResource.Coverage.ReadContext context) throws DataStoreException {
final long[] sourceSize = {
// Note: the following ignores `MultiPixelPackedSampleModel`, but
that model does not seem used by HEIF.
sampleModel.getWidth() * (long) sampleModel.getNumDataElements(),
@@ -99,30 +95,29 @@ final class UncompressedImage extends Image {
final int dataSize = dataType.bytes();
final long tileSize = multiplyExact(region.length, dataSize);
final long skipBytes = region.getStartByteOffset(dataSize);
- final var request = new ByteReader.FileRegion();
- request.input = store.ensureOpen();
- request.offset = multiplyExact(addExact(multiplyExact(tileY,
numXTiles), tileX), tileSize);
- request.length = tileSize;
- request.skip(skipBytes);
- locator.resolve(request);
- /*
- * Now read all banks and store the values in the image buffer.
- * If there is many banks (`InterleavingMode.COMPONENT`), these
- * banks are assumed consecutive.
- */
- request.input.buffer.order(byteOrder);
- final var hr = new
HyperRectangleReader(ImageUtilities.toNumberEnum(dataType), request.input);
- hr.setOrigin(request.offset - skipBytes);
- final WritableRaster raster = context.createRaster();
- final DataBuffer data = raster.getDataBuffer();
- final int numBanks = data.getNumBanks();
- for (int b=0; b<numBanks; b++) {
- if (b != 0) {
- hr.setOrigin(addExact(hr.getOrigin(), tileSize));
+ final long tileIndex = addExact(multiplyExact(context.subTileY,
numXTiles), context.subTileX);
+ final long offset = addExact(multiplyExact(tileIndex, tileSize),
skipBytes);
+ locator.resolve(offset, tileSize - skipBytes, context);
+ return (final ChannelDataInput input) -> {
+ /*
+ * Now read all banks and store the values in the image buffer.
+ * If there is many banks (`InterleavingMode.COMPONENT`), these
+ * banks are assumed consecutive.
+ */
+ input.buffer.order(byteOrder);
+ final var hr = new
HyperRectangleReader(ImageUtilities.toNumberEnum(dataType), input);
+ hr.setOrigin(context.offset() - skipBytes);
+ final WritableRaster raster = context.createRaster();
+ final DataBuffer data = raster.getDataBuffer();
+ final int numBanks = data.getNumBanks();
+ for (int b=0; b<numBanks; b++) {
+ if (b != 0) {
+ hr.setOrigin(addExact(hr.getOrigin(), tileSize));
+ }
+ hr.setDestination(RasterFactory.wrapAsBuffer(data, b));
+ hr.readAsBuffer(region, 0);
}
- hr.setDestination(RasterFactory.wrapAsBuffer(data, b));
- hr.readAsBuffer(region, 0);
- }
- return raster;
+ return raster;
+ };
}
}
diff --git
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/ByteRanges.java
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/ByteRanges.java
new file mode 100644
index 0000000000..2d2df96047
--- /dev/null
+++
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/ByteRanges.java
@@ -0,0 +1,163 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.sis.storage.isobmff;
+
+import java.util.Arrays;
+import org.apache.sis.io.stream.ChannelDataInput;
+import org.apache.sis.storage.DataStoreException;
+import org.apache.sis.storage.DataStoreContentException;
+import org.apache.sis.storage.UnsupportedEncodingException;
+
+
+/**
+ * Ranges of bytes to read from a <abbr>HEIF</abbr> file.
+ * Instances are given to {@link Reader#resolve(long, long, ByteRanges)} for
+ * converting values relative to a box item to values relative to the stream.
+ *
+ * @author Martin Desruisseaux (Geomatys)
+ */
+public class ByteRanges implements Comparable<ByteRanges> {
+ /**
+ * Interface implemented by the {@link TreeNode} subclasses which read
bytes only when requested.
+ * Contrarily to the constructors of {@link Box} subclasses which read all
the payload immediately,
+ * the method provided by this interface allow access to a subset of a
potentially large sequence of bytes.
+ *
+ * @author Martin Desruisseaux (Geomatys)
+ */
+ public interface Reader {
+ /**
+ * Converts an offset relative to the data of this item to offsets
relative to the origin of the input stream.
+ * The subset is specified by the {@code offset} and {@code length}
arguments, where an {@code offset} of zero
+ * is for the first byte stored by this item. Implementation will
typically add to {@code offset} the position
+ * in the file of the first byte.
+ *
+ * @param offset offset of the first byte to read relative to the
data stored is this item.
+ * @param length maximum number of bytes to read, starting at the
offset, or a negative value for reading all.
+ * @param addTo where to add the ranges of bytes to read as offsets
relatives to the beginning of the file.
+ * @throws UnsupportedEncodingException if this item uses an
unsupported construction method.
+ * @throws DataStoreContentException if the <abbr>HEIF</abbr> file is
malformed.
+ * @throws DataStoreException if another logical error occurred.
+ * @throws ArithmeticException if an integer overflow occurred.
+ *
+ * @see #addRange(long, long)
+ */
+ void resolve(long offset, long length, ByteRanges addTo) throws
DataStoreException;
+ }
+
+ /**
+ * Ranges of bytes to read, relative to the file and in the order they
were added.
+ * Consecutive ranges are merged in a single range, but no other
simplification is performed.
+ * Offsets at even indexes are starting point (inclusive) and offsets at
odd indexes are end point (exclusive).
+ */
+ private long[] offsets;
+
+ /**
+ * Creates an initially empty set of byte ranges.
+ */
+ public ByteRanges() {
+ }
+
+ /**
+ * Adds a range of byte offsets relative to the beginning of the
<abbr>HEIF</abbr> file.
+ * this method is invoked by {@link Reader#resolve(long, long,
ByteRanges)} implementations
+ * for specifying all range of bytes to read. This method is usually
invoked exactly once.
+ * It may be invoked more often if the bytes are spread over many regions
of the file.
+ *
+ * @param start offset of the first byte to read, inclusive.
+ * @param end offset after the last byte to read.
+ */
+ public void addRange(final long start, final long end) {
+ if (start < end) {
+ if (offsets == null) {
+ offsets = new long[] {start, end};
+ } else {
+ int i = offsets.length - 1;
+ if (offsets[i] == start) {
+ offsets[i] = end;
+ } else {
+ offsets = Arrays.copyOf(offsets, ++i + 2);
+ offsets[i] = start;
+ offsets[i+1] = end;
+ }
+ }
+ }
+ }
+
+ /**
+ * Returns the offset of the first byte to read, or 0 if unknown.
+ * Note that this is not necessarily the smallest offset, because nothing
prevent the
+ * ranges to be declared out-of-order. However, out-of-order ranges are
assumed rare.
+ */
+ public final long offset() {
+ return (offsets != null) ? offsets[0] : 0; // A non-null array
should be non-empty.
+ }
+
+ /**
+ * Compares this set of ranges with the given ranges for the order in
which they appear in the file.
+ * In the current implementation, the ordering is based on the offset of
the first byte to read.
+ * It may be revised in a future version if useful.
+ *
+ * @param other the other range of bytes to compare with this instance.
+ * @return negative is this range of bytes is before {@code other},
positive if after, 0 if same offset.
+ */
+ @Override
+ public final int compareTo(final ByteRanges other) {
+ return Long.compare(offset(), other.offset());
+ }
+
+ /**
+ * Notifies the given input about the range of bytes which will be
requested. This method should be
+ * invoked for the {@code ByteRanges} associated to all tiles to read
before the actual reading starts.
+ * This notification is only a hint. It can be used for preparing a
<abbr>HTTP</abbr> range request.
+ *
+ * @param input the input stream to notify about the ranges of bytes
that will be requested.
+ */
+ public final void notify(final ChannelDataInput input) {
+ @SuppressWarnings("LocalVariableHidesMemberVariable")
+ final long[] offsets = this.offsets;
+ if (offsets != null) {
+ for (int i=0; i < offsets.length;) {
+ // Note: FileCacheByteChannel uses a RangeSet for merging
efficiently those ranges.
+ input.rangeOfInterest(offsets[i++], offsets[i++]);
+ }
+ }
+ }
+
+ /**
+ * Returns a stream of bytes for the given request as if all bytes were
stored in one sequence.
+ * If all data are stored in the same extent, then this method returns
{@code input} directly.
+ * Otherwise, this method returns a view over the given input as if all
extents were consecutive.
+ *
+ * @todo The view is not yet implemented.
+ *
+ * @param input the channel opened on the <abbr>HEIF</abbr> file.
+ * @param request the region to read, as adjusted by {@link
#resolve(long, long, ByteRanges)}.
+ * @return the input to use. By default, this is {@code input} directly.
+ * @throws DataStoreException if the input cannot be created.
+ */
+ public final ChannelDataInput viewAsConsecutiveBytes(ChannelDataInput
input) throws DataStoreException {
+ if (offsets != null && offsets.length == 2) {
+ return input;
+ }
+ /*
+ * There is at least two extents to read. Create a channel
+ * which will read each extent as if they were consecutive.
+ * TODO: not yet implemented.
+ */
+ throw new UnsupportedEncodingException("Not supported yet");
+ }
+}
diff --git
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/ByteReader.java
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/ByteReader.java
deleted file mode 100644
index d32e68297f..0000000000
---
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/ByteReader.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.sis.storage.isobmff;
-
-import org.apache.sis.io.stream.ChannelDataInput;
-import org.apache.sis.storage.DataStoreException;
-import org.apache.sis.storage.DataStoreContentException;
-import org.apache.sis.storage.UnsupportedEncodingException;
-
-
-/**
- * Interface implemented by {@link TreeNode} which read bytes only when
requested.
- * Contrarily to {@link Box} constructors which are read all the payload
immediately,
- * the method provided by this interface reads only a subset of a potentially
large
- * array of bytes.
- *
- * @author Martin Desruisseaux (Geomatys)
- */
-public interface ByteReader {
- /**
- * Converts an offset relative to the data of this item to an offset
relative to the origin of the input stream.
- * This method updates the {@link FileRegion#offset} value in-place,
typically by adding the stream position of
- * the first byte of the data stored in this item. The {@link
FileRegion#input} is usually unmodified, but this
- * method may also replace it by a temporary instance if the bytes to read
are spread in different regions of the file.
- *
- * @param request the input stream, offset and length of the region to
read. Modified in-place by this method.
- * @throws UnsupportedEncodingException if this item uses an unsupported
construction method.
- * @throws DataStoreContentException if the <abbr>HEIF</abbr> file is
malformed.
- * @throws DataStoreException if another logical error occurred.
- * @throws ArithmeticException if an integer overflow occurred.
- */
- void resolve(FileRegion request) throws DataStoreException;
-
- /**
- * A sub-region of the item to read. Instances of this class are given to
{@link #resolve(FileRegion)}
- * and modified in-place for converting values relative to the item to
values relative to the stream.
- */
- static final class FileRegion {
- /**
- * The input stream from which to read the bytes. After the call to
{@link #resolve(FileRegion)},
- * it may be a temporary instance providing a view of distinct extents
as if they were a single
- * stream of consecutive bytes.
- */
- public ChannelDataInput input;
-
- /**
- * Offset of the first byte to read. Before the call to {@link
#resolve(FileRegion)},
- * this offset is relative to the data stored by the item (i.e.,
offset zero is the
- * first byte stored by the item). After the call to {@code
resolve(FileRegion)},
- * the offset is relative to the origin of {@link #input}.
- */
- public long offset;
-
- /**
- * Maximum number of bytes to read, starting at the offset, or a
negative value for reading all.
- * After the call to {@link #resolve(FileRegion)}, should be updated
to a value not greater than
- * the number of bytes actually available.
- */
- public long length;
-
- /**
- * Creates an initially empty file region.
- */
- public FileRegion() {
- }
-
- /**
- * Skips the given number of bytes at the beginning.
- * This method increments {@link #offset} and decrements {@link
#length} by the given amount.
- *
- * @param bytes the number of bytes to skip at the beginning.
- */
- public void skip(final long bytes) {
- offset = Math.addExact(offset, bytes);
- length -= bytes;
- }
- }
-}
diff --git
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/Reader.java
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/Reader.java
index ee7389b883..b37bf0b435 100644
---
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/Reader.java
+++
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/Reader.java
@@ -22,6 +22,7 @@ import java.util.List;
import java.util.HashMap;
import java.util.HashSet;
import java.util.ArrayList;
+import java.util.OptionalLong;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.net.URI;
@@ -253,7 +254,10 @@ public final class Reader implements Cloneable {
* @throws IOException if an error occurred while reading the integers.
*/
public final int[] readRemainingInts() throws IOException {
- int n = Math.toIntExact((endOfCurrentBox() -
input.getStreamPosition()) / Integer.BYTES);
+ if (endOfCurrentBox < 0) {
+ throw new IOException("Stream of unknown length.");
+ }
+ int n = Math.toIntExact((endOfCurrentBox - input.getStreamPosition())
/ Integer.BYTES);
return (n != 0) ? input.readInts(n) : ArraysExt.EMPTY_INT;
}
@@ -309,13 +313,9 @@ public final class Reader implements Cloneable {
* Returns the stream position after the last byte of the current box.
*
* @return stream position after the last byte of the current box.
- * @throws IOException if the box size is unknown.
*/
- public final long endOfCurrentBox() throws IOException {
- if (endOfCurrentBox >= 0) {
- return endOfCurrentBox;
- }
- throw new IOException("Stream of unknown length.");
+ public final OptionalLong endOfCurrentBox() {
+ return (endOfCurrentBox >= 0) ? OptionalLong.of(endOfCurrentBox) :
OptionalLong.empty();
}
/**
diff --git
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/base/ItemData.java
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/base/ItemData.java
index bd2a2c4433..c044b827f8 100644
---
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/base/ItemData.java
+++
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/base/ItemData.java
@@ -18,7 +18,8 @@ package org.apache.sis.storage.isobmff.base;
import java.io.IOException;
import org.apache.sis.util.ArgumentChecks;
-import org.apache.sis.storage.isobmff.ByteReader;
+import org.apache.sis.storage.DataStoreException;
+import org.apache.sis.storage.isobmff.ByteRanges;
import org.apache.sis.storage.isobmff.Reader;
import org.apache.sis.storage.isobmff.Box;
@@ -34,7 +35,7 @@ import org.apache.sis.storage.isobmff.Box;
* @author Johann Sorel (Geomatys)
* @author Martin Desruisseaux (Geomatys)
*/
-public class ItemData extends Box implements ByteReader {
+public class ItemData extends Box implements ByteRanges.Reader {
/**
* Numerical representation of the {@code "idat"} box type.
*/
@@ -56,7 +57,8 @@ public class ItemData extends Box implements ByteReader {
public final long payloadOffset;
/**
- * Number of bytes to read.
+ * Number of bytes to read, or -1 for reading until the end of file.
+ * Note that -1 is also the maximal unsigned value.
*/
@Interpretation(Type.UNSIGNED)
public final long size;
@@ -70,23 +72,29 @@ public class ItemData extends Box implements ByteReader {
*/
public ItemData(final Reader reader) throws IOException {
payloadOffset = reader.input.getStreamPosition();
- size = reader.endOfCurrentBox() - payloadOffset;
+ size = reader.endOfCurrentBox().orElse(payloadOffset - 1) -
payloadOffset;
}
/**
* Converts an offset relative to the data of this item to an offset
relative to the origin of the input stream.
- * This method updates the {@link FileRegion#offset} value in-place by
adding the stream position of the first
- * byte of the data stored in this item.
+ * This method adds the stream position of the first byte of the data
stored in this item.
*
- * @param request the input stream, offset and length of the region to
read. Modified in-place by this method.
+ * @param offset offset of the first byte to read relative to the data
stored in this item.
+ * @param length maximum number of bytes to read, starting at the
offset, or a negative value for reading all.
+ * @param addTo where to add the range of bytes to read as offsets
relatives to the beginning of the file.
* @throws ArithmeticException if an integer overflow occurred.
*/
@Override
- public void resolve(final FileRegion request) {
- ArgumentChecks.ensureBetween("offset", 0, size - Math.max(0,
request.length), request.offset);
- if (request.length > size || request.length < 0) {
- request.length = size;
+ public void resolve(long offset, long length, ByteRanges addTo) throws
DataStoreException {
+ if (size >= 0) {
+ ArgumentChecks.ensureBetween("offset", 0, size - Math.max(0,
length), offset);
+ if (length > size || length < 0) {
+ length = size;
+ }
+ } else if (length < 0) {
+ throw new DataStoreException("Stream of unknown length.");
}
- request.offset = Math.addExact(payloadOffset, request.offset);
+ offset = Math.addExact(payloadOffset, offset);
+ addTo.addRange(offset, Math.addExact(offset, length));
}
}
diff --git
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/base/ItemLocation.java
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/base/ItemLocation.java
index 879bb652a8..e2fd25011b 100644
---
a/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/base/ItemLocation.java
+++
b/incubator/src/org.apache.sis.storage.geoheif/main/org/apache/sis/storage/isobmff/base/ItemLocation.java
@@ -24,7 +24,7 @@ import org.apache.sis.storage.DataStoreContentException;
import org.apache.sis.storage.UnsupportedEncodingException;
import org.apache.sis.storage.isobmff.UnsupportedVersionException;
import org.apache.sis.storage.isobmff.VectorReader;
-import org.apache.sis.storage.isobmff.ByteReader;
+import org.apache.sis.storage.isobmff.ByteRanges;
import org.apache.sis.storage.isobmff.TreeNode;
import org.apache.sis.storage.isobmff.FullBox;
import org.apache.sis.storage.isobmff.Reader;
@@ -89,7 +89,7 @@ public final class ItemLocation extends FullBox {
}
items = new Item[count];
for (int i=0; i<count; i++) {
- items[i] = new Item(input, version, sizes);
+ items[i] = new Item(reader, input, version, sizes);
}
}
@@ -98,7 +98,7 @@ public final class ItemLocation extends FullBox {
* An extent is a continuous subset of the bytes of the resource. The full
resource is formed by the
* concatenation of the extents in the order specified in this {@code
Item} object.
*/
- public static final class Item extends TreeNode implements ByteReader {
+ public static final class Item extends TreeNode implements
ByteRanges.Reader {
/**
* Identifier of this item, as an unsigned integer.
*/
@@ -180,13 +180,16 @@ public final class ItemLocation extends FullBox {
/**
* Decodes a single item.
*
+ * @param reader the reader from which to read the payload.
* @param input the input stream from which to read the item.
* @param version version of the enclosing {@link ItemLocation}.
* @param sizes sizes of (offset, length, base, index) in that
order on 4 bits each.
* @throws IOException if an error occurred while reading the payload.
* @throws DataStoreContentException if the <abbr>HEIF</abbr> file is
malformed.
*/
- Item(final ChannelDataInput input, final int version, int sizes)
throws IOException, DataStoreContentException {
+ Item(final Reader reader, final ChannelDataInput input, final int
version, int sizes)
+ throws IOException, DataStoreContentException
+ {
itemID = (version < 2) ? input.readUnsignedShort() :
input.readInt();
constructionMethod = (version == 0) ? 0 : (byte)
(input.readShort() & 0x0F);
dataReferenceIndex = input.readShort();
@@ -200,9 +203,18 @@ public final class ItemLocation extends FullBox {
if (offsetReader != null) offsetReader.read(input, i);
if (lengthReader != null) lengthReader.read(input, i);
}
+ @SuppressWarnings("LocalVariableHidesMemberVariable")
+ Vector extentLength;
itemReferenceIndex = result( indexReader);
extentOffset = result(offsetReader);
extentLength = result(lengthReader);
+ if (extentLength == null) {
+ final var endOfCurrentBox = reader.endOfCurrentBox();
+ if (endOfCurrentBox.isPresent()) {
+ extentLength = Vector.create(new long[]
{endOfCurrentBox.getAsLong() - baseOffset}, true);
+ }
+ }
+ this.extentLength = extentLength;
}
/**
@@ -224,57 +236,61 @@ public final class ItemLocation extends FullBox {
}
/**
- * Converts an offset relative to the data of this item to an offset
relative to the origin of the input stream.
- * This method updates the {@link FileRegion#offset} value in-place.
It may also replace {@link FileRegion#input}
- * if the bytes to read are spread in different regions of the item.
+ * Converts an offset relative to the data of this item to offsets
relative to the origin of the input stream.
*
- * @param request the input stream, offset and length of the region
to read. Modified in-place by this method.
+ * @param offset offset of the first byte to read relative to the
data stored in this item.
+ * @param length maximum number of bytes to read, starting at the
offset, or a negative value for reading all.
+ * @param addTo where to add the range of bytes to read as offsets
relatives to the beginning of the file.
* @throws UnsupportedEncodingException if this item uses an
unsupported construction method.
* @throws DataStoreContentException if the <abbr>HEIF</abbr> file is
malformed.
* @throws ArithmeticException if an integer overflow occurred.
*/
@Override
- public void resolve(final FileRegion request) throws
DataStoreException {
+ public void resolve(long offset, long length, ByteRanges addTo) throws
DataStoreException {
switch (constructionMethod) {
- default: throw new DataStoreContentException("Unexpected
construction method.");
+ default: {
+ throw new DataStoreContentException("Unexpected
construction method.");
+ }
case IDAT_OFFSET:
- case ITEM_OFFSET: throw new UnsupportedEncodingException("Not
supported yet");
+ case ITEM_OFFSET: {
+ throw new UnsupportedEncodingException("Not supported
yet");
+ }
case FILE_OFFSET: {
if (dataReferenceIndex != 0) {
throw new UnsupportedEncodingException("Not supported
yet");
}
- long start = 0;
- if (extentLength != null) {
- final int n = extentLength.size();
- for (int i=0; i<n; i++) {
- long available = extentLength.longValue(i);
- if (request.offset >= available) {
- request.offset -= available;
- continue; // Extent is before
requested data.
- }
- available -= request.offset;
- if (request.length > available && i < n-1) {
- /*
- * There is at least two extents to read.
Create a channel
- * which will read each extent as if they were
consecutive.
- * TODO: assign a temporary instance to
`request.input`.
- */
- throw new UnsupportedEncodingException("Not
supported yet");
- }
- if (extentOffset != null && i <
extentOffset.size()) {
- start = extentOffset.longValue(i);
- }
- if (request.length > available || request.length <
0) {
- request.length = available;
+ final int offsetCount = (extentOffset != null) ?
extentOffset.size() : 0;
+ final int lengthCount = (extentLength != null) ?
extentLength.size() : 0;
+ final int n = Math.max(1, Math.min(offsetCount,
lengthCount));
+ for (int i=0; i<n; i++) {
+ long available;
+ if (i < lengthCount) {
+ available = extentLength.longValue(i);
+ } else if (length >= 0) {
+ available = length;
+ } else {
+ throw new DataStoreException("Stream of unknown
length.");
+ }
+ if (available < offset) {
+ offset -= available; // Make offset relative to
the next extent.
+ continue; // Skip all extents before
the first byte.
+ }
+ long position = Math.addExact(baseOffset, offset);
+ if (i < offsetCount) {
+ position = Math.addExact(position,
extentOffset.longValue(i));
+ }
+ offset = 0; // Next extents will start
from the first byte.
+ if (length >= 0) {
+ if (length < available) {
+ available = length;
+ length = 0;
+ } else {
+ length -= available;
}
- break;
}
+ addTo.addRange(position, Math.addExact(position,
available));
+ if (length == 0) break; // Short circuit if not
reading everything.
}
- /*
- * All the bytes to read are in a single extent. We can
- * use the existing channel directly, without wrapping.
- */
- request.offset = Math.addExact(request.offset,
Math.addExact(baseOffset, start));
}
}
}
