@cogeotiff/core 7.2.0 → 8.0.1

package/src/cog.tiff.ts

@@ -1,165 +1,162 @@
-import { ChunkSource } from '@chunkd/core';
 import { CogTiffImage } from './cog.tiff.image.js';
 import { TiffEndian } from './const/tiff.endian.js';
-import { TiffTag } from './const/tiff.tag.id.js';
+import { TagId } from './const/tiff.tag.id.js';
 import { TiffVersion } from './const/tiff.version.js';
-import { CogTiffTagBase } from './read/tag/tiff.tag.base.js';
+import { TiffTag } from './index.js';
+import { DataViewOffset, hasBytes } from './read/data.view.offset.js';
 import { CogTifGhostOptions } from './read/tiff.gdal.js';
 import { TagTiffBigConfig, TagTiffConfig, TiffIfdConfig } from './read/tiff.ifd.config.js';
-import { CogTiffTag } from './read/tiff.tag.js';
-import { CogSourceCursor } from './source/cog.source.view.js';
-import { toHexString } from './util/util.hex.js';
+import { createTag } from './read/tiff.tag.factory.js';
+import { Source } from './source.js';
+import { getUint } from './util/bytes.js';
+import { toHex } from './util/util.hex.js';
 
 export class CogTiff {
-    source: ChunkSource;
-    version = TiffVersion.Tiff;
-    images: CogTiffImage[] = [];
-    options = new CogTifGhostOptions();
-
-    private cursor: CogSourceCursor;
-    ifdConfig: TiffIfdConfig = TagTiffConfig;
-
-    constructor(source: ChunkSource) {
-        this.source = source;
-        this.cursor = new CogSourceCursor(this);
-    }
-
-    /** Create and initialize a CogTiff */
-    static create(source: ChunkSource): Promise<CogTiff> {
-        return new CogTiff(source).init();
-    }
-
-    /** Has init() been called */
-    isInitialized = false;
-
-    _initPromise?: Promise<CogTiff>;
-    /**
-     * Initialize the COG loading in the header and all image headers
-     *
-     * @param loadGeoKeys Whether to also initialize the GeoKeyDirectory
-     */
-    init(loadGeoKeys = false): Promise<CogTiff> {
-        if (this._initPromise) return this._initPromise;
-        this._initPromise = this.doInit(loadGeoKeys);
-        return this._initPromise;
-    }
-
-    private async doInit(loadGeoKeys = false): Promise<CogTiff> {
-        if (this.isInitialized) return this;
-        // Load the first few KB in, more loads will run as more data is required
-        await this.source.loadBytes(0, this.source.chunkSize);
-        await this.fetchIfd();
-        await Promise.all(this.images.map((c) => c.init(loadGeoKeys)));
-
-        this.isInitialized = true;
-        return this;
+  /** Read 16KB blocks at a time */
+  defaultReadSize = 16 * 1024;
+  /** Where this cog is fetching its data from */
+  source: Source;
+  /** Big or small Tiff */
+  version = TiffVersion.Tiff;
+  /** List of images, o is the base image */
+  images: CogTiffImage[] = [];
+  /** Ghost header options */
+  options?: CogTifGhostOptions;
+  /** Configuration for the size of the IFD */
+  ifdConfig: TiffIfdConfig = TagTiffConfig;
+  /** Is the tiff being read is little Endian */
+  isLittleEndian = false;
+  /** Has init() been called */
+  isInitialized = false;
+
+  private _initPromise?: Promise<CogTiff>;
+  constructor(source: Source) {
+    this.source = source;
+  }
+
+  /** Create a COG and initialize it by reading the COG headers */
+  static create(source: Source): Promise<CogTiff> {
+    return new CogTiff(source).init();
+  }
+
+  /**
+   * Initialize the COG loading in the header and all image headers
+   */
+  init(): Promise<CogTiff> {
+    if (this._initPromise) return this._initPromise;
+    this._initPromise = this.readHeader();
+    return this._initPromise;
+  }
+
+  /**
+   * Find a image which has a resolution similar to the provided resolution
+   *
+   * @param resolution resolution to find
+   */
+  getImageByResolution(resolution: number): CogTiffImage {
+    const firstImage = this.images[0];
+    const firstImageSize = firstImage.size;
+    const [refX] = firstImage.resolution;
+
+    const resolutionBaseX = refX * firstImageSize.width;
+    // const resolutionBaseY = refY * firstImageSize.height;
+    for (let i = this.images.length - 1; i > 0; i--) {
+      const img = this.images[i];
+      const imgSize = img.size;
+
+      const imgResolutionX = resolutionBaseX / imgSize.width;
+      // TODO do we care about y resolution
+      // const imgResolutionY = resolutionBaseY / imgSize.height;
+
+      if (imgResolutionX - resolution <= 0.01) return img;
     }
-
-    private async fetchIfd(): Promise<void> {
-        const view = this.cursor.seekTo(0);
-        const endian = view.uint16();
-        this.source.isLittleEndian = endian === TiffEndian.Little;
-        if (!this.source.isLittleEndian) throw new Error('Only little endian is supported');
-        this.version = view.uint16();
-
-        let nextOffsetIfd: number;
-        if (this.version === TiffVersion.BigTiff) {
-            this.ifdConfig = TagTiffBigConfig;
-            const pointerSize = view.uint16();
-            if (pointerSize !== 8) throw new Error('Only 8byte pointers are supported');
-            const zeros = view.uint16();
-            if (zeros !== 0) throw new Error('Invalid big tiff header');
-            nextOffsetIfd = view.pointer();
-        } else if (this.version === TiffVersion.Tiff) {
-            nextOffsetIfd = view.pointer();
-        } else {
-            throw new Error(`Only tiff supported version:${this.version}`);
-        }
-
-        const ghostSize = nextOffsetIfd - this.cursor.currentOffset;
-        // GDAL now stores metadata between the IFD inside a ghost storage area
-        if (ghostSize > 0 && ghostSize < 16 * 1024) this.options.process(view.bytes(ghostSize));
-
-        return this.processIfd(nextOffsetIfd);
+    return firstImage;
+  }
+
+  /** Read the Starting header and all Image headers from the source */
+  private async readHeader(): Promise<CogTiff> {
+    if (this.isInitialized) return this;
+    const bytes = new DataView(await this.source.fetch(0, this.defaultReadSize)) as DataViewOffset;
+    bytes.sourceOffset = 0;
+
+    let offset = 0;
+    const endian = bytes.getUint16(offset, this.isLittleEndian);
+    offset += 2;
+
+    this.isLittleEndian = endian === TiffEndian.Little;
+    if (!this.isLittleEndian) throw new Error('Only little endian is supported');
+    this.version = bytes.getUint16(offset, this.isLittleEndian);
+    offset += 2;
+
+    let nextOffsetIfd: number;
+    if (this.version === TiffVersion.BigTiff) {
+      this.ifdConfig = TagTiffBigConfig;
+      const pointerSize = bytes.getUint16(offset, this.isLittleEndian);
+      offset += 2;
+      if (pointerSize !== 8) throw new Error('Only 8byte pointers are supported');
+      const zeros = bytes.getUint16(offset, this.isLittleEndian);
+      offset += 2;
+      if (zeros !== 0) throw new Error('Invalid big tiff header');
+      nextOffsetIfd = getUint(bytes, offset, this.ifdConfig.pointer, this.isLittleEndian);
+      offset += this.ifdConfig.pointer;
+    } else if (this.version === TiffVersion.Tiff) {
+      nextOffsetIfd = getUint(bytes, offset, this.ifdConfig.pointer, this.isLittleEndian);
+      offset += this.ifdConfig.pointer;
+    } else {
+      throw new Error(`Only tiff supported version:${this.version}`);
     }
 
-    getImage(z: number): CogTiffImage {
-        return this.images[z];
+    const ghostSize = nextOffsetIfd - offset;
+    // GDAL now stores metadata between the IFD inside a ghost storage area
+    if (ghostSize > 0 && ghostSize < 16 * 1024) {
+      this.options = new CogTifGhostOptions();
+      this.options.process(bytes, offset, ghostSize);
     }
 
-    /**
-     * Find a image which has a resolution similar to the provided resolution
-     *
-     * @param resolution resolution to find
-     */
-    getImageByResolution(resolution: number): CogTiffImage {
-        const firstImage = this.images[0];
-        const firstImageSize = firstImage.size;
-        const [refX] = firstImage.resolution;
-
-        const resolutionBaseX = refX * firstImageSize.width;
-        // const resolutionBaseY = refY * firstImageSize.height;
-        for (let i = this.images.length - 1; i > 0; i--) {
-            const img = this.images[i];
-            const imgSize = img.size;
-
-            const imgResolutionX = resolutionBaseX / imgSize.width;
-            // TODO do we care about y resolution
-            // const imgResolutionY = resolutionBaseY / imgSize.height;
-
-            if (imgResolutionX - resolution <= 0.01) return img;
-        }
-        return firstImage;
+    while (nextOffsetIfd !== 0) {
+      let lastView = bytes;
+
+      // Ensure at least 1KB near at the IFD offset is ready for reading
+      // TODO is 1KB enough, most IFD entries are in the order of 100-300 bytes
+      if (!hasBytes(lastView, nextOffsetIfd, 1024)) {
+        const bytes = await this.source.fetch(nextOffsetIfd, this.defaultReadSize);
+        lastView = new DataView(bytes) as DataViewOffset;
+        lastView.sourceOffset = nextOffsetIfd;
+      }
+      nextOffsetIfd = await this.readIfd(nextOffsetIfd, lastView);
     }
 
-    /**
-     * Get the raw bytes for a tile at a given x,y, index.
-     *
-     * This may return null if the tile does not exist eg Sparse cogs,
-     *
-     * @param x tile x index
-     * @param y tile y index
-     * @param index image index
-     */
-    async getTile(x: number, y: number, index: number): Promise<{ mimeType: string; bytes: Uint8Array } | null> {
-        const image = this.getImage(index);
-        if (image == null) throw new Error(`Missing z: ${index}`);
-        if (!image.isTiled()) throw new Error('Tif is not tiled');
-
-        return image.getTile(x, y);
+    await Promise.all(this.images.map((i) => i.init()));
+    this.isInitialized = true;
+    return this;
+  }
+
+  /**
+   * Read a IFD at a the provided offset
+   *
+   * @param offset file offset to read the header from
+   * @param view offset that contains the bytes for the header
+   */
+  private async readIfd(offset: number, view: DataViewOffset): Promise<number> {
+    const viewOffset = offset - view.sourceOffset;
+    const tagCount = getUint(view, viewOffset, this.ifdConfig.offset, this.isLittleEndian);
+
+    const tags: Map<TagId, TiffTag> = new Map();
+
+    // We now know how many bytes we need so ensure the ifd bytes are all read
+    const ifdBytes = tagCount * this.ifdConfig.ifd;
+    if (!hasBytes(view, offset, ifdBytes)) {
+      throw new Error('IFD out of range @ ' + toHex(offset) + ' IFD' + this.images.length);
     }
 
-    private async processIfd(offset: number): Promise<void> {
-        const { image, nextOffset } = await this.readIfd(offset);
-        this.images.push(image);
-
-        if (nextOffset) await this.processIfd(nextOffset);
+    const ifdSize = this.ifdConfig.ifd;
+    const startOffset = viewOffset + this.ifdConfig.offset;
+    for (let i = 0; i < tagCount; i++) {
+      const tag = createTag(this, view, startOffset + i * ifdSize);
+      tags.set(tag.id, tag);
     }
 
-    private async readIfd(offset: number): Promise<{ nextOffset: number; image: CogTiffImage }> {
-        if (!this.source.hasBytes(offset, 4096)) await this.source.loadBytes(offset, 4096);
-
-        const view = this.cursor.seekTo(offset);
-        const tagCount = view.offset();
-        const byteStart = offset + this.ifdConfig.offset;
-        const tags: Map<TiffTag, CogTiffTagBase> = new Map();
-
-        let pos = byteStart;
-        for (let i = 0; i < tagCount; i++) {
-            const tag = CogTiffTag.create(this, pos);
-            pos += tag.size;
-
-            if (tag.name == null) throw new Error('Unknown IFD Tag: ' + toHexString(tag.id));
-            tags.set(tag.id, tag);
-        }
-
-        const image = new CogTiffImage(this, this.images.length, tags);
-        const nextOffset = this.source.getUint(pos, this.ifdConfig.pointer);
-        return { nextOffset, image };
-    }
-
-    /** Close the file source if it needs closing */
-    async close(): Promise<void> {
-        await this.source?.close?.();
-    }
+    this.images.push(new CogTiffImage(this, this.images.length, tags));
+    return getUint(view, startOffset + tagCount * ifdSize, this.ifdConfig.pointer, this.isLittleEndian);
+  }
 }

package/src/const/index.ts

@@ -1,5 +1,5 @@
 export { TiffEndian } from './tiff.endian.js';
 export { TiffCompression, TiffMimeType } from './tiff.mime.js';
-export { TiffTag, TiffTagGeo } from './tiff.tag.id.js';
+export { TagId as TiffTag, TagGeoId as TiffTagGeo } from './tiff.tag.id.js';
 export { TiffTagValueType } from './tiff.tag.value.js';
 export { TiffVersion } from './tiff.version.js';

package/src/const/tiff.endian.ts

@@ -3,6 +3,6 @@
  * The header of a tif file contains the endianness of the file
  */
 export enum TiffEndian {
-    Big = 0x4d4d,
-    Little = 0x4949,
+  Big = 0x4d4d,
+  Little = 0x4949,
 }

package/src/const/tiff.mime.ts

@@ -2,28 +2,28 @@
  * MimeType conversion for common tif image types
  */
 export enum TiffMimeType {
-    NONE = 'application/octet-stream',
-    JPEG = 'image/jpeg',
-    JP2 = 'image/jp2',
-    JPEGXL = 'image/jpegxl',
-    WEBP = 'image/webp',
-    ZSTD = 'application/zstd',
-    LZW = 'application/lzw',
-    DEFLATE = 'application/deflate',
-    LZERC = 'application/lerc',
-    LZMA = 'application/x-lzma',
+  None = 'application/octet-stream',
+  Jpeg = 'image/jpeg',
+  Jp2 = 'image/jp2',
+  JpegXl = 'image/jpegxl',
+  Webp = 'image/webp',
+  Zstd = 'application/zstd',
+  Lzw = 'application/lzw',
+  Deflate = 'application/deflate',
+  Lerc = 'application/lerc',
+  Lzma = 'application/x-lzma',
 }
 
 export const TiffCompression: { [key: number]: TiffMimeType } = {
-    1: TiffMimeType.NONE,
-    5: TiffMimeType.LZW,
-    6: TiffMimeType.JPEG,
-    7: TiffMimeType.JPEG,
-    8: TiffMimeType.DEFLATE,
-    34887: TiffMimeType.LZERC,
-    34925: TiffMimeType.LZMA,
-    34712: TiffMimeType.JP2,
-    50000: TiffMimeType.ZSTD,
-    50001: TiffMimeType.WEBP,
-    50002: TiffMimeType.JPEGXL,
+  1: TiffMimeType.None,
+  5: TiffMimeType.Lzw,
+  6: TiffMimeType.Jpeg,
+  7: TiffMimeType.Jpeg,
+  8: TiffMimeType.Deflate,
+  34887: TiffMimeType.Lerc,
+  34925: TiffMimeType.Lzma,
+  34712: TiffMimeType.Jp2,
+  50000: TiffMimeType.Zstd,
+  50001: TiffMimeType.Webp,
+  50002: TiffMimeType.JpegXl,
 };