unbikit 0.7.0 → 0.9.0

package/README.md

@@ -3,13 +3,10 @@
 [![minzipped bundle size](https://img.shields.io/bundlephobia/minzip/unbikit?style=flat-square)](https://bundlephobia.com/package/unbikit)
 [![types included](https://img.shields.io/npm/types/unbikit?style=flat-square)](https://www.npmjs.com/package/unbikit)
 
-> ⚠️
-> This package is at an early development stage. Expect API changes!
-
 <img src="/app/src/images/unbikit-logo.svg" alt="logo of unbikit" width="24" height="24"> unbikit
 (_un-bik-ɪt_) is a decoder for `.bik` ([Bink Video](https://en.wikipedia.org/wiki/Bink_Video))
-files that can be used to play or transcode videos using the Web Streams API.
-The format was first released in 1999 and has since been used in many classic computer games.
+files that can be used to play or transcode videos. The format was first released in 1999 and has
+since been used in many classic computer games.
 
 ⭐ [Documentation](https://blennies.github.io/unbikit/) and a
 ⭐ [video player demo](https://blennies.github.io/unbikit/demo/)
@@ -20,9 +17,10 @@ are available, as well as a
 
 - Supports Bink 1, revisions `c` to `i` inclusive
 - Handles demuxing and decompression of audio and video streams
-- TypeScript/JavaScript only (no WASM or native code)
+- TypeScript/JavaScript (no WASM or native code)
 - No dependencies
-- Uses Web Streams API for efficient reading of video data
+- Straightforward API: supply a video via `Blob`, `File`, `Request` or `URL`
+  - the Web Streams API will be used where possible for efficient reading of video data
 - Isomorphic
   - runs on client/server runtimes that support at least ES2022
   - can be run with older runtimes by using the syntax lowering feature of some bundlers

package/dist/unbikit.d.ts

@@ -4,31 +4,48 @@
 * not used by the decoder for any subsequent processing, so can be used by an application freely.
 */
 interface BikVideoFrame {
+  /**
+  * Coded width of the video frame (in pixels).
+  */
   width: number;
+  /**
+  * Coded height of the video frame (in pixels).
+  */
   height: number;
+  /**
+  * Pixel data for the video frame, encoded in Planar YUV 4:2:0 format with an optional alpha
+  * channel. The planes are stored in the order: Y, U, V, alpha. Each of the Y and alpha planes
+  * occupy 4 times as much space in the buffer as either the U or V plane (as would be expected
+  * given the encoding format), and the total buffer size is set to be just enough to hold all
+  * of the planes.
+  */
   yuv: Uint8Array<ArrayBuffer>;
+  /**
+  * The number of pixels per line of the video frame, stored as an array of per-plane values in
+  * the order: Y, U, V, alpha.
+  */
   lineSize: number[];
 }
 //#endregion
 //#region src/bik-decoder.d.ts
 /**
-* Decoded header of a BIK file.
+* Decoded header of a BIK data source.
 */
 interface BikHeader {
   /**
-  * Version of the encoded file format.
+  * Version of the encoding format.
   */
   version: 1 | 2;
   /**
-  * Sub-version of the encoded file format.
+  * Sub-version of the encoding format.
   */
   subVersion: number;
   /**
-  * Total size of the encoded file (in bytes).
+  * Total size of the encoded video data (in bytes).
   */
-  fileSize: number;
+  totalSize: number;
   /**
-  * Number of (video) frames stored in the file.
+  * Number of frames in the video.
   *
   * Note that audio is stored with each frame but doesn't necessarily correspond to the audio
   * that should be played when the video frame is shown.
@@ -48,20 +65,20 @@ interface BikHeader {
   */
   height: number;
   /**
-  * Number of frames per second that the video in the file should be played at.
+  * Number of frames per second that the video should be played at.
   */
   fps: number;
   /**
-  * Flags providing additional information about the encoded file.
+  * Flags providing additional information about the encoded video.
   */
   videoFlags: {
     /**
-    * When `true`, the encoded file contains an alpha plane for each frame. Otherwise the file
+    * When `true`, the encoded video contains an alpha plane for each frame. Otherwise the video
     * contains no alpha information.
     */
     hasAlpha: boolean;
     /**
-    * When `true`, the U and V planes in the encoded file should be swapped during the decoding
+    * When `true`, the U and V planes in the encoded video should be swapped during the decoding
     * process.
     *
     * This is a value intended for internal use by the decoder and should not be needed by
@@ -69,7 +86,7 @@ interface BikHeader {
     */
     hasSwappedUVPlanes: boolean;
     /**
-    * When `true`, the encoded file doesn't contain U or V planes. Otherwise the file contains
+    * When `true`, the encoded video doesn't contain U or V planes. Otherwise the video contains
     * both U and V planes.
     */
     isGrayscale: boolean;
@@ -87,55 +104,84 @@ interface BikHeader {
     scaling: number;
   };
   /**
-  * Total number of audio tracks stored in the encoded file.
+  * Total number of audio tracks stored in the encoded video.
   *
   * Each track can have one or more channels (e.g. for stereo or surround sound).
   */
   numAudioTracks: number;
   /**
   * Array containing decoded header information for each individual audio track stored in the
-  * encoded file.
+  * encoded video.
   */
   audioTracks: BikAudioTrackHeader[];
   /**
   * Array containing decoded header information for each individual video frame stored in the
-  * encoded file.
+  * encoded video.
   */
   frames: BikFrameHeader[];
 }
 /**
-* Decoded header of an audio track of a BIK file.
+* Decoded header of an audio track of a BIK video.
 */
 interface BikAudioTrackHeader {
+  /**
+  * Identifier for the audio track. This may not match the index of the track in the
+  * {@link BikFrame.audioTracks} array.
+  */
   trackId: number;
+  /**
+  * Number of separate audio channels stored by the track.
+  *
+  * Stereo channels (when {@link flags stereo} is `true`) are separate planes for audio
+  * encoded via DCTs (when {@link flags usesDCT} is `true`), so the value of {@link numChannels}
+  * will include the number of stereo channels.
+  *
+  * When audio is encoded via RDFTs (when {@link flags usesDCT} is `false`) then stereo channels
+  * are interleaved, so the value of {@link numChannels} will _not_ include the number of
+  * channels. This means that for a regular stereo track (when {@link flags stereo} is `true`),
+  * {@link numChannels} will have the value `1`.
+  */
   numChannels: number;
+  /**
+  * Sample rate/frequency of the audio data (in Hz).
+  */
   sampleRate: number;
+  /**
+  * Flags indicating whether specific features apply to the audio track.
+  */
   flags: {
+    /**
+    * `true` when the audio track is stereo, otherwise `false` (usually indicating mono audio).
+    */
     stereo: boolean;
-    useDCT: boolean;
+    /**
+    * `true` when the audio data is encoded using DCTs (discrete cosine transforms), otherwise
+    * `false` when the audio data is encoded using RDFTs (real discrete Fourier transforms).
+    */
+    usesDCT: boolean;
   };
 }
 /**
-* Decoded header of a (video) frame of a BIK file.
+* Decoded header of a frame of a BIK video.
 */
 interface BikFrameHeader {
   /**
-  * Offset of the start of the frame in the encoded file.
+  * Offset of the start of the frame in the encoded video.
   */
   offset: number;
   /**
-  * Total size (in bytes) of the frame in the encoded file, including both audio and video that
+  * Total size (in bytes) of the frame in the encoded video, including both audio and video that
   * are stored with the frame.
   */
   size: number;
   /**
   * When `true`, this frame is a "key frame" that can be used as a starting point for random
-  * access decoding. Should be `true` for at least the first frame of a BIK file.
+  * access decoding. Must be `true` for the first frame.
   */
   keyframe: boolean;
 }
 /**
-* Decoded contents of a single frame of a BIK file.
+* Decoded contents of a single frame of a BIK video.
 */
 interface BikFrame {
   /**
@@ -148,7 +194,7 @@ interface BikFrame {
   videoFrame: BikVideoFrame | null;
 }
 /**
-* Decoded contents of a single "packet" of data for an audio track in a BIK file.
+* Decoded contents of a single "packet" of data for an audio track in a BIK video.
 *
 * In each packet, audio samples are stored in one or more blocks, each block containing one or
 * more stereo-interleaved channels (so the number of stereo-interleaved channels in a stereo
@@ -174,62 +220,54 @@ interface BikAudioTrack {
   blocks: Float32Array[][];
 }
 /**
-* Function for returning a Web Streams API readable stream for reading sequential data
-* from a BIK file.
-*
-* Currently `len` is always undefined, so the function should just return a stream for
-* accessing the rest of the file from the given start position.
-*
-* **Advance deprecation warning:** It is intended that this function will soon be replaced with
-* a more flexible and easier to use system for accessing streams.
-*
-* @experimental
-*/
-type GetReadStreamFn = (offset: number, len?: number | undefined) => ReadableStream<Uint8Array> | Promise<ReadableStream<Uint8Array>>;
-/**
 * Main class for managing the state of a BIK decoder instance. One instance can decode a single
-* file at a time.
+* video from a single data source at a time.
 */
 declare class BikDecoder {
   #private;
   private constructor();
   /**
-  * Decoded header of the BIK file.
+  * Decoded header of the video.
   * @returns Decoded header.
   */
   get header(): BikHeader | null;
   /**
-  * Whether the audio/video streams in the BIK file can be processed by the decoder or not.
-  * @returns `true` when the audio/video streams can be processed by the decoder, otherwise
-  *   `false`.
+  * Whether the audio/images in the video can be processed by the decoder or not.
+  * @returns `true` when the audio/images can be processed by the decoder, otherwise `false`.
   */
   get isSupported(): boolean;
   /**
-  * Get the next frame of the BIK file and decode it.
+  * Get the next frame of the video and decode it.
   * @param prevFrame Optional data structure for a previously decoded frame to re-use (to reduce
   *   garbage collection).
   * @returns Next decoded frame (audio and video).
   */
   getNextFrame(prevFrame?: BikFrame | null): Promise<BikFrame | null>;
   /**
-  * Skip the specified number of frames of the BIK file. They will still be decoded as decoding
-  * a frame can effectively require data from any number of earlier frames.
+  * Skip the specified number of frames of the video. They will still be decoded as decoding a
+  * frame can effectively require data from any number of earlier frames.
   * @param numFrames Number of frames to skip, but still decode.
   */
   skipFrames(numFrames: number): Promise<void>;
   /**
-  * Reset the current frame index so the decoder is ready to start decoding the BIK file from the
-  * beginning. Note that this will result in the decoder requesting a new readable stream.
+  * Reset the state of the decoder so it is ready to start decoding the video from the beginning.
+  * Note that this will result in the decoder streaming the video again from the data source.
   */
   reset(): void;
   /**
-  * Attempt to read and parse the headers of a BIK file. If successful, return an instance of
-  * {@link BikDecoder} for decoding the rest of the file.
-  * @param getReadStreamFn -
-  *   Function that returns a stream for linear access to part of the file.
-  * @returns Decoder instance. Use {@link header} to access the parsed headers.
+  * Attempt to read and parse the headers of a BIK video. If successful, return an instance of
+  * {@link BikDecoder} for decoding the rest of the video from the data source.
+  * @param source Data source that will provide the encoded video data.
+  * @returns Decoder instance. Use {@link BikDecoder.header} to access the parsed headers.
   */
-  static open(getReadStreamFn: GetReadStreamFn): Promise<BikDecoder>;
+  static open_(source: Blob | File | URL | Request): Promise<BikDecoder>;
 }
+/**
+* Attempt to read and parse the headers of a BIK video. If successful, return an instance of
+* {@link BikDecoder} for decoding the rest of the video from the data source.
+* @param source Data source that will provide the encoded video data.
+* @returns Decoder instance. Use {@link BikDecoder.header} to access the parsed headers.
+*/
+declare const createBikDecoder: (source: Blob | File | URL | Request) => Promise<BikDecoder>;
 //#endregion
-export { type BikAudioTrack, type BikAudioTrackHeader, BikDecoder, type BikFrame, type BikFrameHeader, type BikHeader, type BikVideoFrame, type GetReadStreamFn };
+export { type BikAudioTrack, type BikAudioTrackHeader, type BikDecoder, type BikFrame, type BikFrameHeader, type BikHeader, type BikVideoFrame, createBikDecoder };

package/dist/unbikit.js

@@ -46,72 +46,60 @@ const BIK_QUANT = generateQuantTables(BASE_QUANT);
 //#region src/bik-decoder-utils.ts
 var BitReader = class {
 	#buffer;
-	#pos = 0;
+	#bufferBitLength;
 	#bitPos = 0;
 	constructor(buffer) {
 		this.#buffer = buffer;
+		this.#bufferBitLength = buffer.length << 3;
 	}
-	m(buffer) {
+	n(buffer) {
 		this.#buffer = buffer;
-		this.#pos = 0;
+		this.#bufferBitLength = buffer.length << 3;
 		this.#bitPos = 0;
 	}
+	/**
+	* Read the specified number of bits from the bit-stream.
+	* @param n Number of bits to read. Must be less than or equal to 32.
+	* @param peek When `true`, do not update the bit position in the bit-stream, otherwise do
+	*   update it.
+	* @returns The bits read from the bit-stream.
+	*/
 	a(n, peek = false) {
 		let result = 0;
-		let pos = this.#pos;
 		let bitPos = this.#bitPos;
-		let bitsRead = 0;
 		let bitsRemaining = n;
 		do {
 			const mask = (1 << bitsRemaining) - 1 & 255;
-			const bits = (this.#buffer[pos] ?? 0) >>> bitPos & mask;
-			result |= bits << bitsRead;
-			const newBitPos = bitPos + bitsRemaining;
-			if (newBitPos > 7) {
-				const bitChange = 8 - bitPos;
-				bitsRead += bitChange;
-				bitsRemaining -= bitChange;
-				pos++;
-				bitPos = 0;
+			const bits = (this.#buffer[bitPos >>> 3] ?? 0) >>> (bitPos & 7) & mask;
+			result |= bits << n - bitsRemaining;
+			if ((bitPos & 7) + bitsRemaining > 7) {
+				const posChange = 8 - (bitPos & 7);
+				bitsRemaining -= posChange;
+				bitPos += posChange;
 			} else {
-				bitPos = newBitPos;
+				bitPos += bitsRemaining;
 				break;
 			}
-		} while (bitsRead < n);
-		if (!peek) {
-			this.#pos = pos;
-			this.#bitPos = bitPos;
-		}
+		} while (bitsRemaining);
+		if (!peek) this.#bitPos = bitPos;
 		return result;
 	}
-	d() {
-		const bit = (this.#buffer[this.#pos] ?? 0) >>> this.#bitPos++ & 1;
-		if (this.#bitPos > 7) {
-			this.#pos++;
-			this.#bitPos = 0;
-		}
-		return bit;
-	}
-	q() {
-		return (this.#pos << 3) + this.#bitPos;
+	c() {
+		return (this.#buffer[this.#bitPos >>> 3] ?? 0) >>> (this.#bitPos++ & 7) & 1;
 	}
-	j(n) {
+	i(n) {
 		if (n < 1) return;
 		this.#bitPos += n;
-		while (this.#bitPos > 7) {
-			this.#pos++;
-			this.#bitPos -= 8;
-		}
-	}
-	n() {
-		const n = 32 - (this.q() & 31) & 31;
-		this.j(n);
 	}
 	o() {
-		return (this.#buffer.length - this.#pos << 3) - this.#bitPos;
+		const n = 32 - (this.#bitPos & 31) & 31;
+		this.i(n);
+	}
+	get p() {
+		return this.#bufferBitLength - this.#bitPos;
 	}
 	e(v) {
-		return this.d() ? -v : v;
+		return this.c() ? -v : v;
 	}
 };
 
@@ -130,15 +118,15 @@ var BikAudioDecoder = class {
 	#bands;
 	#output;
 	#overlapWindow = [];
-	#useDCT;
+	#usesDCT;
 	#idt;
-	constructor(sampleRate, numChannels, useDCT) {
+	constructor(sampleRate, numChannels, usesDCT) {
 		let frameLenBits;
 		if (sampleRate < 22050) frameLenBits = 9;
 		else if (sampleRate < 44100) frameLenBits = 10;
 		else frameLenBits = 11;
 		let numInternalChannels = numChannels;
-		if (!useDCT) {
+		if (!usesDCT) {
 			sampleRate *= numChannels;
 			frameLenBits += Math.ceil(Math.log2(numChannels)) & 3;
 			frameLenBits = frameLenBits;
@@ -150,7 +138,7 @@ var BikAudioDecoder = class {
 		this.#overlapLen = this.#frameLen / 16;
 		this.#blockSize = (this.#frameLen - this.#overlapLen) * numInternalChannels;
 		const sampleRateHalf = sampleRate + 1 >>> 1;
-		this.#baseQuant = (useDCT ? this.#frameLen : 2) / (Math.sqrt(this.#frameLen) * 32768);
+		this.#baseQuant = (usesDCT ? this.#frameLen : 2) / (Math.sqrt(this.#frameLen) * 32768);
 		const expMultiplier = .0664 / Math.log10(Math.E);
 		for (let i = 0; i < 96; i++) this.#quantTable[i] = Math.exp(i * expMultiplier) * this.#baseQuant;
 		let numBands = AUDIO_CRITICAL_FREQS.findIndex((x) => sampleRateHalf <= x);
@@ -163,8 +151,8 @@ var BikAudioDecoder = class {
 		this.#output = new Array(this.#numInternalChannels);
 		for (const [index] of this.#output.entries()) this.#output[index] = new Float32Array(this.#frameLen);
 		for (let i = 0; i < numInternalChannels; i++) this.#overlapWindow.push(new Float32Array(this.#overlapLen));
-		this.#useDCT = useDCT;
-		this.#idt = useDCT ? new IDCT(frameLenBits) : new IRDFT(frameLenBits);
+		this.#usesDCT = usesDCT;
+		this.#idt = usesDCT ? new IDCT(frameLenBits) : new IRDFT(frameLenBits);
 	}
 	/**
 	* Read a 29-bit floating point value (5 bits exponent, 23 bits mantissa, 1 bit sign) from a
@@ -174,20 +162,19 @@ var BikAudioDecoder = class {
 	*/
 	#getFloat(reader) {
 		const power = reader.a(5);
-		const f = reader.a(23) * 2 ** (power - 23);
-		return reader.d() ? -f : f;
+		return reader.e(reader.a(23) * 2 ** (power - 23));
 	}
 	/**
 	* Decode all blocks and channels of a frame of audio data.
 	* @param data Encoded frame audio data.
 	* @returns Decoded data indexed by block number and then by channel number.
 	*/
-	v(data) {
+	s(data) {
 		const reader = new BitReader(data);
 		const output = this.#output;
 		const allOutput = [];
-		while (reader.o() > 0) {
-			if (this.#useDCT) reader.j(2);
+		while (reader.p > 0) {
+			if (this.#usesDCT) reader.i(2);
 			for (let ch = 0; ch < this.#numInternalChannels; ch++) {
 				const coeffs = output[ch];
 				coeffs[0] = this.#getFloat(reader) * this.#baseQuant;
@@ -199,7 +186,7 @@ var BikAudioDecoder = class {
 				let i = 2;
 				while (i < this.#frameLen) {
 					let j;
-					if (reader.d()) {
+					if (reader.c()) {
 						const v = reader.a(4);
 						j = i + AUDIO_RLE_LENGTH_TABLE[v];
 					} else j = i + 8;
@@ -212,13 +199,13 @@ var BikAudioDecoder = class {
 					} else while (i < j) {
 						if (this.#bands[k] === i) q = quant[k++] ?? 0;
 						const coeff = reader.a(width);
-						if (coeff) coeffs[i] = reader.d() ? -q * coeff : q * coeff;
+						if (coeff) coeffs[i] = reader.c() ? -q * coeff : q * coeff;
 						else coeffs[i] = 0;
 						i++;
 					}
 				}
 				this.#idt.k(coeffs);
-				if (this.#useDCT) {
+				if (this.#usesDCT) {
 					const dctModifier = 4 * this.#baseQuant;
 					for (let i2 = 0; i2 < coeffs.length; i2++) coeffs[i2] *= dctModifier;
 				}
@@ -255,7 +242,7 @@ var BikAudioDecoder = class {
 			}
 			allOutput.push(outputBlock);
 			this.#first = false;
-			reader.n();
+			reader.o();
 		}
 		return allOutput;
 	}
@@ -443,27 +430,22 @@ var FFT = class {
 //#region src/bik-video-decoder.ts
 const EMPTY_UINT8_ARRAY = new Uint8Array();
 var HuffTable = class HuffTable {
-	#symbols;
-	#lens;
+	#symbolsLens;
 	#maxBits;
-	static #predefinedTables = new Array(16).fill(null).map((_, bikTreeIndex) => new HuffTable(bikTreeIndex));
+	static l = new Array(16).fill(null).map((_, bikTreeIndex) => new HuffTable(bikTreeIndex));
 	constructor(bikTreeIndex) {
 		const referenceTableOffset = bikTreeIndex << 4;
 		const maxBits = BIK_TREE_LENS[referenceTableOffset + 15];
 		this.#maxBits = maxBits;
 		const tableSize = 1 << maxBits;
-		this.#symbols = new Array(tableSize);
-		this.#lens = new Array(tableSize);
+		this.#symbolsLens = new Uint8Array(tableSize);
 		for (let i = 0; i < 16; i++) {
 			const code = BIK_TREE_CODES[referenceTableOffset + i];
 			const len = BIK_TREE_LENS[referenceTableOffset + i];
 			const numEntries = 1 << maxBits - len;
 			for (let j = 0; j < numEntries; j++) {
 				const index = j << len | code;
-				if (index < tableSize) {
-					this.#symbols[index] = i;
-					this.#lens[index] = len;
-				}
+				if (index < tableSize) this.#symbolsLens[index] = i << 4 | len;
 			}
 		}
 	}
@@ -474,12 +456,11 @@ var HuffTable = class HuffTable {
 	* @returns 4-bit value, Huffman-decoded from the bit-stream.
 	*/
 	static f(reader, tree) {
-		const table = HuffTable.#predefinedTables[tree.l];
+		const table = tree.m;
 		const peek = reader.a(table.#maxBits, true);
-		const len = table.#lens[peek];
-		const symbol = table.#symbols[peek];
-		reader.j(len);
-		return tree.g[symbol];
+		const entry = table.#symbolsLens[peek];
+		reader.i(entry & 15);
+		return tree.g[entry >>> 4];
 	}
 };
 var BikVideoDecoder = class {
@@ -490,8 +471,6 @@ var BikVideoDecoder = class {
 	#hasSwappedUVPlanes;
 	#numPixels;
 	#uvSize;
-	#blockXPos = 0;
-	#blockYPos = 0;
 	#stride = 0;
 	#data = EMPTY_UINT8_ARRAY;
 	#prevData = EMPTY_UINT8_ARRAY;
@@ -519,19 +498,19 @@ var BikVideoDecoder = class {
 		this.#numPixels = numPixels;
 		this.#uvSize = uvSize;
 		this.#prevData = new Uint8Array(frameSize);
-		const blocks = numPixels + 63 >>> 6;
+		const numBlockPixels = numPixels + 63 >>> 6 << 6;
 		for (let i = 0; i < 9; i++) this.#blockParams[i] = {
-			p: 0,
+			q: 0,
 			h: {
-				l: 0,
+				m: HuffTable.l[0],
 				g: new Uint8Array(16)
 			},
-			c: new Uint8Array(blocks * 64),
+			d: i > 3 && i < 8 ? new Int16Array(numBlockPixels) : new Uint8Array(numBlockPixels),
 			b: 0,
-			i: 0
+			j: 0
 		};
 		for (let i = 0; i < 16; i++) this.#colHigh[i] = {
-			l: 0,
+			m: HuffTable.l[0],
 			g: new Uint8Array(16)
 		};
 	}
@@ -563,12 +542,15 @@ var BikVideoDecoder = class {
 		const planeOffset = planeIndex === 0 ? 0 : planeIndex === 1 ? numPixels : planeIndex === 2 ? numPixels + uvSize : numPixels + (uvSize << 1);
 		const blockLineIncr = this.#stride * 7;
 		const mainDataBuf = this.#data;
-		this.#data = new Uint8Array(this.#data.buffer, planeOffset, isChroma ? uvSize : numPixels);
+		this.#data = new Uint8Array(mainDataBuf.buffer, planeOffset, isChroma ? uvSize : numPixels);
 		this.#dataPtr = 0;
 		const prevMainDataBuf = this.#prevData;
-		this.#prevData = new Uint8Array(this.#prevData.buffer, planeOffset, isChroma ? uvSize : numPixels);
-		for (this.#blockYPos = 0; this.#blockYPos < blockHeight; this.#blockYPos++) {
-			this.#readBlockTypes(blockParams[0]);
+		this.#prevData = new Uint8Array(prevMainDataBuf.buffer, planeOffset, isChroma ? uvSize : numPixels);
+		const blockTypeParam = blockParams[0];
+		const blockTypes = blockTypeParam.d;
+		let blockYPos = 0;
+		while (blockYPos++ < blockHeight) {
+			this.#readBlockTypes(blockTypeParam);
 			this.#readBlockTypes(blockParams[1]);
 			this.#readColors(blockParams[2]);
 			this.#readPatterns(blockParams[3]);
@@ -577,14 +559,16 @@ var BikVideoDecoder = class {
 			this.#readDCs(blockParams[6], false);
 			this.#readDCs(blockParams[7], true);
 			this.#readRuns(blockParams[8]);
-			for (this.#blockXPos = 0; this.#blockXPos < blockWidth; this.#blockXPos++) {
-				const blockType = this.#getValue(0);
+			let blockXPos = 0;
+			while (blockXPos++ < blockWidth) {
+				const blockType = blockTypes[blockTypeParam.j++];
 				switch (blockType) {
 					case 0: break;
 					case 1:
-						this.#decodeScaledBlock();
-						this.#dataPtr += 8;
-						break;
+						if (blockYPos & 1) this.#decodeScaledBlock();
+						blockXPos++;
+						this.#dataPtr += 16;
+						continue;
 					case 2:
 						this.#decodeMotionBlock();
 						break;
@@ -615,18 +599,22 @@ var BikVideoDecoder = class {
 			}
 			this.#dataPtr += blockLineIncr;
 		}
-		this.#reader.n();
+		this.#reader.o();
 		this.#prevData = prevMainDataBuf;
 		this.#data = mainDataBuf;
 	}
 	#copyBlock(srcOffset) {
-		if (this.#dataPtr === srcOffset) return;
-		let srcIndex = srcOffset;
-		let destIndex = this.#dataPtr;
-		for (let y = 0; y < 8; y++) {
-			for (let x = 0; x < 8; x++) this.#data[destIndex + x] = this.#prevData[srcIndex + x] ?? 0;
-			srcIndex += this.#stride;
-			destIndex += this.#stride;
+		const indexDiff = this.#dataPtr - srcOffset;
+		if (!indexDiff) return;
+		const strideMinusBlock = this.#stride - 8;
+		let lineCount = 8;
+		while (lineCount--) {
+			const srcOffsetMax = srcOffset + 8;
+			while (srcOffset < srcOffsetMax) {
+				this.#data[srcOffset + indexDiff] = this.#prevData[srcOffset];
+				srcOffset++;
+			}
+			srcOffset += strideMinusBlock;
 		}
 	}
 	#decodeMotionBlock() {
@@ -641,7 +629,7 @@ var BikVideoDecoder = class {
 		do {
 			const run = this.#getValue(8) + 1;
 			i += run;
-			if (this.#reader.d()) {
+			if (this.#reader.c()) {
 				const v = this.#getValue(2);
 				for (let j = 0; j < run; j++) {
 					const pos = BIK_PATTERNS[scanIndex++] ?? 0;
@@ -701,16 +689,14 @@ var BikVideoDecoder = class {
 	}
 	#decodeRawBlock() {
 		const blockParamValues = this.#blockParams[2];
-		for (let y = 0; y < 8; y++) for (let x = 0; x < 8; x++) this.#data[this.#dataPtr + y * this.#stride + x] = blockParamValues.c[blockParamValues.i++] ?? 0;
+		for (let y = 0; y < 8; y++) for (let x = 0; x < 8; x++) this.#data[this.#dataPtr + y * this.#stride + x] = blockParamValues.d[blockParamValues.j++];
 	}
 	#decodeScaledBlock() {
-		this.#blockXPos++;
-		if (this.#blockYPos & 1) return;
 		const tmpScalingBuf = this.#tmpScalingBuf;
 		const subBlk = this.#getValue(1);
 		switch (subBlk) {
-			case 3:
-				this.#decodeRunBlock(tmpScalingBuf);
+			case 9:
+				for (let i = 0; i < 64; i++) tmpScalingBuf[i] = this.#getValue(2);
 				break;
 			case 5:
 				this.#decodeIntraBlock(tmpScalingBuf);
@@ -718,30 +704,25 @@ var BikVideoDecoder = class {
 			case 6:
 				this.#decodeFillBlock(16);
 				return;
+			case 3:
+				this.#decodeRunBlock(tmpScalingBuf);
+				break;
 			case 8:
 				this.#decodePatternBlock(tmpScalingBuf);
 				break;
-			case 9:
-				for (let j = 0; j < 8; j++) for (let i = 0; i < 8; i++) tmpScalingBuf[i + (j << 3)] = this.#getValue(2);
-				break;
 			default: throw new Error(`Invalid sub-block type ${subBlk}`);
 		}
 		const dest = this.#data;
+		const stride = this.#stride;
 		let srcPos = 0;
-		let destPosLine0 = this.#dataPtr;
-		let destPosLine1 = this.#dataPtr + this.#stride;
-		const lineIncrement = this.#stride << 1;
-		for (let j = 0; j < 8; j++) {
-			let halfWordOffset = 0;
-			for (let i = 0; i < 8; i++) {
-				const v = tmpScalingBuf[srcPos++] ?? 0;
-				dest[destPosLine0 + halfWordOffset] = v;
-				dest[destPosLine1 + halfWordOffset++] = v;
-				dest[destPosLine0 + halfWordOffset] = v;
-				dest[destPosLine1 + halfWordOffset++] = v;
-			}
-			destPosLine0 += lineIncrement;
-			destPosLine1 += lineIncrement;
+		let destPosLine = this.#dataPtr;
+		const maxDestPosLine = destPosLine + (stride << 4);
+		const lineIncrement = (stride << 1) - 15;
+		while (destPosLine < maxDestPosLine) {
+			const value = tmpScalingBuf[srcPos++];
+			dest[destPosLine] = dest[stride + destPosLine++] = value;
+			dest[destPosLine] = dest[stride + destPosLine] = value;
+			destPosLine += srcPos & 7 ? 1 : lineIncrement;
 		}
 	}
 	/**
@@ -751,17 +732,18 @@ var BikVideoDecoder = class {
 	*/
 	#readTree(tree) {
 		const reader = this.#reader;
-		tree.l = reader.a(4);
-		if (!tree.l) {
+		const tableNum = reader.a(4);
+		tree.m = HuffTable.l[tableNum];
+		if (!tableNum) {
 			for (let i = 0; i < 16; i++) tree.g[i] = i;
 			return;
 		}
-		if (reader.d()) {
+		if (reader.c()) {
 			let len = reader.a(3);
 			const tmp = this.#inputTreeBuf.fill(0);
 			for (let i = 0; i <= len; i++) {
 				tree.g[i] = reader.a(4);
-				tmp[tree.g[i] ?? 0] = 1;
+				tmp[tree.g[i]] = 1;
 			}
 			for (let i = 0; i < 16; i++) if (!tmp[i]) tree.g[++len] = i;
 		} else {
@@ -769,7 +751,7 @@ var BikVideoDecoder = class {
 			let input = this.#inputTreeBuf;
 			let output = this.#outputTreeBuf;
 			for (let i = 0; i < 16; i += 2) {
-				const bit = this.#reader.d();
+				const bit = this.#reader.c();
 				input[i] = i + bit;
 				input[i + 1] = i + (bit ^ 1);
 			}
@@ -785,15 +767,15 @@ var BikVideoDecoder = class {
 		let src2Index = src1Index + size1;
 		let size2 = size1;
 		let destIndex = src1Index;
-		while (size1 && size2) if (this.#reader.d()) {
-			dest[destIndex++] = src[src2Index++] ?? 0;
+		while (size1 && size2) if (this.#reader.c()) {
+			dest[destIndex++] = src[src2Index++];
 			size2--;
 		} else {
-			dest[destIndex++] = src[src1Index++] ?? 0;
+			dest[destIndex++] = src[src1Index++];
 			size1--;
 		}
-		while (size1--) dest[destIndex++] = src[src1Index++] ?? 0;
-		while (size2--) dest[destIndex++] = src[src2Index++] ?? 0;
+		while (size1--) dest[destIndex++] = src[src1Index++];
+		while (size2--) dest[destIndex++] = src[src2Index++];
 	}
 	/**
 	* Read Huffman tree information from the bit-stream for each block type in the current
@@ -806,7 +788,7 @@ var BikVideoDecoder = class {
 		const extraLen = 511;
 		const commonLen = (adjustedWidth >>> 3) + extraLen;
 		for (const [blockParamNum, blockParamValues] of this.#blockParams.entries()) {
-			blockParamValues.p = ~~Math.log2([
+			blockParamValues.q = ~~Math.log2([
 				commonLen,
 				(adjustedWidth >>> 4) + extraLen,
 				(blockWidth << 6) + extraLen,
@@ -822,7 +804,7 @@ var BikVideoDecoder = class {
 				this.#colLastValue = 0;
 			}
 			if (blockParamNum < 6 || blockParamNum > 7) this.#readTree(blockParamValues.h);
-			blockParamValues.b = blockParamValues.i = 0;
+			blockParamValues.b = blockParamValues.j = 0;
 		}
 	}
 	/**
@@ -831,8 +813,8 @@ var BikVideoDecoder = class {
 	* @returns Number of block parameter values.
 	*/
 	#readCodedDataCount(blockParamValues) {
-		if (blockParamValues.b < 0 || blockParamValues.b > blockParamValues.i) return 0;
-		const count = this.#reader.a(blockParamValues.p);
+		if (blockParamValues.b < 0 || blockParamValues.b > blockParamValues.j) return 0;
+		const count = this.#reader.a(blockParamValues.q);
 		if (count === 0) blockParamValues.b = -1;
 		return count;
 	}
@@ -840,19 +822,19 @@ var BikVideoDecoder = class {
 		const count = this.#readCodedDataCount(blockParamValues);
 		if (!count) return;
 		const reader = this.#reader;
-		if (reader.d()) {
+		if (reader.c()) {
 			const v = reader.a(4);
-			for (let i = 0; i < count; i++) blockParamValues.c[blockParamValues.b++] = v;
+			for (let i = 0; i < count; i++) blockParamValues.d[blockParamValues.b++] = v;
 		} else {
 			let prevValue = 0;
 			for (let i = 0; i < count; i++) {
 				const v = HuffTable.f(reader, blockParamValues.h);
 				if (v < 12) {
 					prevValue = v;
-					blockParamValues.c[blockParamValues.b++] = v;
+					blockParamValues.d[blockParamValues.b++] = v;
 				} else {
 					const runLength = RLE_LENGTHS[v - 12];
-					for (let j = 0; j < runLength; j++) blockParamValues.c[blockParamValues.b++] = prevValue;
+					for (let j = 0; j < runLength; j++) blockParamValues.d[blockParamValues.b++] = prevValue;
 					i += runLength - 1;
 				}
 			}
@@ -862,7 +844,7 @@ var BikVideoDecoder = class {
 		const count = this.#readCodedDataCount(blockParamValues);
 		if (!count) return;
 		const reader = this.#reader;
-		const isRun = reader.d();
+		const isRun = reader.c();
 		let loopCount = isRun ? 1 : count;
 		do {
 			const colHighValue = HuffTable.f(reader, this.#colHigh[this.#colLastValue]);
@@ -870,9 +852,9 @@ var BikVideoDecoder = class {
 			this.#colLastValue = colHighValue;
 			if (this.#version < 105) v = v > 127 ? 256 - v : v + 128;
 			if (isRun) {
-				blockParamValues.c.fill(v, blockParamValues.b, blockParamValues.b + count);
+				blockParamValues.d.fill(v, blockParamValues.b, blockParamValues.b + count);
 				blockParamValues.b += count;
-			} else blockParamValues.c[blockParamValues.b++] = v;
+			} else blockParamValues.d[blockParamValues.b++] = v;
 		} while (--loopCount);
 	}
 	#readPatterns(blockParamValues) {
@@ -881,23 +863,25 @@ var BikVideoDecoder = class {
 		const reader = this.#reader;
 		for (let i = 0; i < count; i++) {
 			const v = HuffTable.f(reader, blockParamValues.h) | HuffTable.f(reader, blockParamValues.h) << 4;
-			blockParamValues.c[blockParamValues.b++] = v;
+			blockParamValues.d[blockParamValues.b++] = v;
 		}
 	}
 	#readMotionValues(blockParamValues) {
 		const count = this.#readCodedDataCount(blockParamValues);
 		if (!count) return;
 		const reader = this.#reader;
-		const items = blockParamValues.c;
+		const items = blockParamValues.d;
 		const maxDec = blockParamValues.b + count;
 		let v;
-		if (reader.d()) {
+		if (reader.c()) {
 			v = reader.a(4);
 			if (v) v = reader.e(v);
+			v = v << 24 >> 24;
 			items.fill(v, blockParamValues.b, maxDec);
 		} else while (blockParamValues.b < maxDec) {
 			v = HuffTable.f(reader, blockParamValues.h);
 			if (v) v = reader.e(v);
+			v = v << 24 >> 24;
 			items[blockParamValues.b++] = v;
 		}
 		blockParamValues.b = maxDec;
@@ -906,25 +890,21 @@ var BikVideoDecoder = class {
 		const count = this.#readCodedDataCount(blockParamValues);
 		if (!count) return;
 		const reader = this.#reader;
-		const view = new DataView(blockParamValues.c.buffer, blockParamValues.c.byteOffset, blockParamValues.c.byteLength);
 		let v = reader.a(hasSign ? 10 : 11);
 		if (v && hasSign) v = reader.e(v);
-		view.setInt16(blockParamValues.b, v, true);
-		blockParamValues.b += 2;
-		for (let i = 1; i < count;) {
+		const items = blockParamValues.d;
+		items[blockParamValues.b++] = v;
+		let i = 1;
+		while (i < count) {
 			const len = Math.min(count - i, 8);
-			const bsize = reader.a(4);
-			if (bsize) for (let j = 0; j < len; j++) {
-				let v2 = reader.a(bsize);
+			const v2Size = reader.a(4);
+			if (v2Size) for (let j = 0; j < len; j++) {
+				let v2 = reader.a(v2Size);
 				if (v2) v2 = reader.e(v2);
 				v += v2;
-				view.setInt16(blockParamValues.b, v, true);
-				blockParamValues.b += 2;
-			}
-			else for (let j = 0; j < len; j++) {
-				view.setInt16(blockParamValues.b, v, true);
-				blockParamValues.b += 2;
+				items[blockParamValues.b++] = v;
 			}
+			else for (let j = 0; j < len; j++) items[blockParamValues.b++] = v;
 			i += len;
 		}
 	}
@@ -932,10 +912,10 @@ var BikVideoDecoder = class {
 		const count = this.#readCodedDataCount(blockParamValues);
 		if (!count) return;
 		const reader = this.#reader;
-		if (reader.d()) {
+		if (reader.c()) {
 			const v = reader.a(4);
-			for (let i = 0; i < count; i++) blockParamValues.c[blockParamValues.b++] = v;
-		} else for (let i = 0; i < count; i++) blockParamValues.c[blockParamValues.b++] = HuffTable.f(reader, blockParamValues.h);
+			for (let i = 0; i < count; i++) blockParamValues.d[blockParamValues.b++] = v;
+		} else for (let i = 0; i < count; i++) blockParamValues.d[blockParamValues.b++] = HuffTable.f(reader, blockParamValues.h);
 	}
 	/**
 	* Get the next block parameter value for the current line.
@@ -944,11 +924,7 @@ var BikVideoDecoder = class {
 	*/
 	#getValue(blockParamNum) {
 		const blockParamValues = this.#blockParams[blockParamNum];
-		if (blockParamNum < 4 || blockParamNum === 8) return blockParamValues.c[blockParamValues.i++] ?? 0;
-		if (blockParamNum < 6) return (blockParamValues.c[blockParamValues.i++] ?? 0) << 24 >> 24;
-		const val = new DataView(blockParamValues.c.buffer, blockParamValues.c.byteOffset, blockParamValues.c.byteLength).getInt16(blockParamValues.i, true);
-		blockParamValues.i += 2;
-		return val;
+		return blockParamValues.d[blockParamValues.j++] ?? 0;
 	}
 	/**
 	* Mini-VM (virtual machine) to decode and optionally unquantize a block of integer values.
@@ -992,10 +968,10 @@ var BikVideoDecoder = class {
 		let bits = isResidue ? 1 << reader.a(3) : reader.a(4) - 1;
 		while (isResidue ? bits : bits >= 0) {
 			if (isResidue) {
-				for (i = 0; i < coeffCount; i++) if (reader.d()) {
+				for (i = 0; i < coeffCount; i++) if (reader.c()) {
 					const curNzCoeff = coeffIndex[i] ?? 0;
-					if ((block[curNzCoeff] ?? 0) < 0) block[curNzCoeff] -= bits;
-					else block[curNzCoeff] += bits;
+					const value = block[curNzCoeff] ?? 0;
+					block[curNzCoeff] = value < 0 ? value - bits : value + bits;
 					if (!masksCount--) return;
 				}
 			}
@@ -1003,7 +979,7 @@ var BikVideoDecoder = class {
 			while (listPos < listEnd) {
 				const ccoeff = coeffList[listPos] ?? 0;
 				const mode = modeList[listPos] ?? 0;
-				if (!(mode | ccoeff) || !reader.d()) {
+				if (!(mode | ccoeff) || !reader.c()) {
 					listPos++;
 					continue;
 				}
@@ -1017,7 +993,7 @@ var BikVideoDecoder = class {
 							coeffList[listPos] = 0;
 							modeList[listPos++] = 0;
 						}
-						for (i = ccoeff; i < ccoeff + 4; i++) if (reader.d()) {
+						for (i = ccoeff; i < ccoeff + 4; i++) if (reader.c()) {
 							coeffList[--listStart] = i;
 							modeList[listStart] = 3;
 						} else if (isResidue) {
@@ -1026,7 +1002,7 @@ var BikVideoDecoder = class {
 							block[offset] = reader.e(bits);
 							if (!masksCount--) return;
 						} else {
-							const offset = bits ? reader.e(reader.a(bits) | 1 << bits) : 1 - (reader.d() << 1);
+							const offset = bits ? reader.e(reader.a(bits) | 1 << bits) : 1 - (reader.c() << 1);
 							block[BIK_SCAN[i] ?? 0] = offset;
 							coeffIndex[coeffCount++] = i;
 						}
@@ -1047,7 +1023,7 @@ var BikVideoDecoder = class {
 							block[offset] = reader.e(bits);
 							if (!masksCount--) return;
 						} else {
-							const offset = bits ? reader.e(reader.a(bits) | 1 << bits) : 1 - (reader.d() << 1);
+							const offset = bits ? reader.e(reader.a(bits) | 1 << bits) : 1 - (reader.c() << 1);
 							block[BIK_SCAN[ccoeff] ?? 0] = offset;
 							coeffIndex[coeffCount++] = ccoeff;
 						}
@@ -1058,11 +1034,11 @@ var BikVideoDecoder = class {
 		}
 		if (!isResidue) {
 			const quantOffset = (reader.a(4) << 6) + quantStartIndex;
-			block[0] = Math.imul(block[0] ?? 0, BIK_QUANT[quantOffset] ?? 0) >> 11;
+			block[0] = (block[0] ?? 0) * (BIK_QUANT[quantOffset] ?? 0) >> 11;
 			while (coeffCount--) {
 				const index = coeffIndex[coeffCount] ?? 0;
 				const blockIndex = BIK_SCAN[index] ?? 0;
-				block[blockIndex] = Math.imul(block[blockIndex] ?? 0, BIK_QUANT[quantOffset + index] ?? 0) >> 11;
+				block[blockIndex] = (block[blockIndex] ?? 0) * (BIK_QUANT[quantOffset + index] ?? 0) >> 11;
 			}
 		}
 	}
@@ -1152,11 +1128,15 @@ var BikVideoDecoder = class {
 		this.#addPixels8x8(block, dest, destOffset, stride);
 	}
 	#addPixels8x8(block, dest, destOffset, stride) {
-		let destPos = destOffset;
-		let blockPos = 0;
-		for (let y = 0; y < 8; y++) {
-			for (let x = 0; x < 8; x++) dest[destPos + x] += block[blockPos++] ?? 0;
-			destPos += stride;
+		stride -= 8;
+		let i = -1;
+		let iMax = 6;
+		while (i++ < 63) {
+			dest[destOffset + i] += block[i];
+			if (i > iMax) {
+				destOffset += stride;
+				iMax += 8;
+			}
 		}
 	}
 	/**
@@ -1165,9 +1145,9 @@ var BikVideoDecoder = class {
 	* @param existingFrame Decoded frame to re-use for the returned value.
 	* @returns Decoded frame.
 	*/
-	w(data, existingFrame = null) {
+	t(data, existingFrame = null) {
 		const reader = this.#reader;
-		reader.m(data);
+		reader.n(data);
 		let frame;
 		if (existingFrame) {
 			frame = existingFrame;
@@ -1175,18 +1155,18 @@ var BikVideoDecoder = class {
 		} else frame = this.#createFrame();
 		this.#data = frame.yuv;
 		if (this.#hasAlpha) {
-			if (this.#version > 104) reader.j(32);
+			if (this.#version > 104) reader.i(32);
 			this.#decodePlane(frame, 3);
 		}
-		if (this.#version > 104) reader.j(32);
+		if (this.#version > 104) reader.i(32);
 		for (let plane = 0; plane < 3; plane++) {
 			const planeIndex = plane && this.#hasSwappedUVPlanes ? plane ^ 3 : plane;
 			this.#decodePlane(frame, planeIndex);
-			if (reader.o() < 1) break;
+			if (reader.p < 1) break;
 		}
 		this.#prevData.set(frame.yuv);
 		this.#data = EMPTY_UINT8_ARRAY;
-		this.#reader.m(EMPTY_UINT8_ARRAY);
+		this.#reader.n(EMPTY_UINT8_ARRAY);
 		return frame;
 	}
 };
@@ -1194,35 +1174,69 @@ var BikVideoDecoder = class {
 //#endregion
 //#region src/bik-decoder.ts
 var BikDecoder = class BikDecoder {
-	#getReadStreamFn;
+	/**
+	* Source of the video.
+	*/
+	#dataSource;
+	/**
+	* A {@link ReadableStreamDefaultReader} for the current position in the encoded video data.
+	*/
 	#streamReader = null;
+	/**
+	* Buffer of encoded video data being processed by the decoder.
+	*/
 	#bufBytes = null;
+	/**
+	* Start of the {@link #bufBytes} buffer relative to the start of the encoded video data.
+	*/
 	#bufPos = 0;
 	#curFrame = -1;
 	#audioTrackDecoders = [];
 	#videoDecoder = null;
 	#header = null;
 	#isSupported = false;
-	constructor(getReadStreamFn) {
-		this.#getReadStreamFn = getReadStreamFn;
+	constructor(source) {
+		this.#dataSource = source;
 	}
 	/**
-	* Set the current file read position to the specified position, updating the read buffer and
-	* potentially requesting a new readable stream if the file read position actually changes.
-	* @param pos Position in the file to seek to. Specified in bytes from the start of the file.
+	* Set the current video data read position to the specified position, updating the read
+	* buffer and potentially creating a new readable stream if the read position actually
+	* changes.
+	* @param pos Position in the video to seek to. Specified in bytes from the start of the
+	*   video.
 	*/
 	async #seek(pos) {
-		if (this.#bufBytes && pos === this.#bufPos) return;
-		this.#bufPos = pos;
-		this.#bufBytes = null;
+		if (pos < 0) return;
+		if (this.#bufBytes) {
+			if (pos === this.#bufPos) return;
+			if (pos > this.#bufPos && pos < this.#bufPos + this.#bufBytes.byteLength) {
+				this.#bufBytes = this.#bufBytes.subarray(pos - this.#bufPos);
+				this.#bufPos = pos;
+				return;
+			}
+		}
 		if (this.#streamReader) {
 			await this.#streamReader.cancel();
 			this.#streamReader.releaseLock();
 			this.#streamReader = null;
 		}
-		const streamReader = (await this.#getReadStreamFn(pos))?.getReader();
+		const dataSource = this.#dataSource;
+		let streamReader;
+		if (dataSource instanceof Blob) streamReader = dataSource.slice(pos).stream()?.getReader();
+		else {
+			const isRequest = dataSource instanceof Request;
+			if (dataSource instanceof URL || isRequest) {
+				const request = isRequest ? dataSource : new Request(dataSource);
+				const headers = request.headers;
+				headers.delete("range");
+				if (pos) headers.set("range", `bytes=${pos}-`);
+				streamReader = (await fetch(request))?.body?.getReader();
+			}
+		}
 		if (!streamReader) throw new Error("Invalid stream reader");
 		this.#streamReader = streamReader;
+		this.#bufBytes = null;
+		this.#bufPos = pos;
 	}
 	/**
 	* Read data from the readable stream.
@@ -1274,9 +1288,13 @@ var BikDecoder = class BikDecoder {
 	*/
 	async #ensureReadBytes(len) {
 		const bufBytes = await this.#readBytes(len);
-		if (bufBytes?.byteLength !== len) throw new Error(`Read ${bufBytes?.byteLength ?? 0} bytes but expected ${len}`);
+		if (bufBytes?.byteLength !== len) throw new Error(`Read ${bufBytes?.byteLength} bytes but expected ${len}`);
 		return bufBytes;
 	}
+	/**
+	* Initialize the decoder by parsing the header from the readable stream to get the required
+	* information about the encoded video, including the offsets of all the frames.
+	*/
 	async #init() {
 		await this.#seek(0);
 		const headerBytes = await this.#ensureReadBytes(44);
@@ -1310,12 +1328,12 @@ var BikDecoder = class BikDecoder {
 					sampleRate: audioHeaderDataView.getUint16((numAudioTracks << 2) + (index << 2), true),
 					flags: {
 						stereo: isStereo,
-						useDCT: !!(flags & 4096)
+						usesDCT: !!(flags & 4096)
 					}
 				};
 			});
 			audioTracks.forEach((audioTrack) => {
-				this.#audioTrackDecoders.push(new BikAudioDecoder(audioTrack.sampleRate, audioTrack.numChannels, audioTrack.flags.useDCT));
+				this.#audioTrackDecoders.push(new BikAudioDecoder(audioTrack.sampleRate, audioTrack.numChannels, audioTrack.flags.usesDCT));
 			});
 		}
 		const videoHeaderBytes = await this.#ensureReadBytes(frameListSize);
@@ -1334,7 +1352,7 @@ var BikDecoder = class BikDecoder {
 		this.#header = {
 			version,
 			subVersion,
-			fileSize: headerWords[1] + 8,
+			totalSize: headerWords[1] + 8,
 			numFrames,
 			largestFrameSize: headerWords[3],
 			width,
@@ -1352,22 +1370,21 @@ var BikDecoder = class BikDecoder {
 		};
 	}
 	/**
-	* Decoded header of the BIK file.
+	* Decoded header of the video.
 	* @returns Decoded header.
 	*/
 	get header() {
 		return this.#header;
 	}
 	/**
-	* Whether the audio/video streams in the BIK file can be processed by the decoder or not.
-	* @returns `true` when the audio/video streams can be processed by the decoder, otherwise
-	*   `false`.
+	* Whether the audio/images in the video can be processed by the decoder or not.
+	* @returns `true` when the audio/images can be processed by the decoder, otherwise `false`.
 	*/
 	get isSupported() {
 		return this.#isSupported;
 	}
 	/**
-	* Get the next frame of the BIK file and decode it.
+	* Get the next frame of the video and decode it.
 	* @param prevFrame Optional data structure for a previously decoded frame to re-use (to reduce
 	*   garbage collection).
 	* @returns Next decoded frame (audio and video).
@@ -1407,7 +1424,7 @@ var BikDecoder = class BikDecoder {
 					header: audioHeader,
 					size: audioTrackFrame.size,
 					numSamples: audioTrackFrame.numSamples,
-					blocks: audioDecoder.v(audioTrackFrame.bytes)
+					blocks: audioDecoder.s(audioTrackFrame.bytes)
 				});
 			}
 		}
@@ -1416,12 +1433,12 @@ var BikDecoder = class BikDecoder {
 		const videoFrameBytes = frameBytes.subarray(videoFramePos, videoFramePos + videoFrameSize);
 		return {
 			audioTracks,
-			videoFrame: this.#videoDecoder?.w(videoFrameBytes, prevFrame?.videoFrame) ?? null
+			videoFrame: this.#videoDecoder?.t(videoFrameBytes, prevFrame?.videoFrame) ?? null
 		};
 	}
 	/**
-	* Skip the specified number of frames of the BIK file. They will still be decoded as decoding
-	* a frame can effectively require data from any number of earlier frames.
+	* Skip the specified number of frames of the video. They will still be decoded as decoding a
+	* frame can effectively require data from any number of earlier frames.
 	* @param numFrames Number of frames to skip, but still decode.
 	*/
 	async skipFrames(numFrames) {
@@ -1432,25 +1449,25 @@ var BikDecoder = class BikDecoder {
 		}
 	}
 	/**
-	* Reset the current frame index so the decoder is ready to start decoding the BIK file from the
-	* beginning. Note that this will result in the decoder requesting a new readable stream.
+	* Reset the state of the decoder so it is ready to start decoding the video from the beginning.
+	* Note that this will result in the decoder streaming the video again from the data source.
 	*/
 	reset() {
 		this.#curFrame = -1;
 	}
 	/**
-	* Attempt to read and parse the headers of a BIK file. If successful, return an instance of
-	* {@link BikDecoder} for decoding the rest of the file.
-	* @param getReadStreamFn -
-	*   Function that returns a stream for linear access to part of the file.
-	* @returns Decoder instance. Use {@link header} to access the parsed headers.
+	* Attempt to read and parse the headers of a BIK video. If successful, return an instance of
+	* {@link BikDecoder} for decoding the rest of the video from the data source.
+	* @param source Data source that will provide the encoded video data.
+	* @returns Decoder instance. Use {@link BikDecoder.header} to access the parsed headers.
 	*/
-	static async open(getReadStreamFn) {
-		const decoder = new BikDecoder(getReadStreamFn);
+	static async u(source) {
+		const decoder = new BikDecoder(source);
 		await decoder.#init();
 		return decoder;
 	}
 };
+const createBikDecoder = BikDecoder.u;
 
 //#endregion
-export { BikDecoder };
+export { createBikDecoder };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unbikit",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Decoder for `.bik` video files.",
   "keywords": [
     "audio",
@@ -34,7 +34,7 @@
     "@arethetypeswrong/core": "0.18.2",
     "@astrojs/check": "0.9.5",
     "@astrojs/mdx": "4.3.12",
-    "@astrojs/starlight": "0.36.2",
+    "@astrojs/starlight": "0.36.3",
     "@biomejs/biome": "2.3.7",
     "@commitlint/config-conventional": "20.0.0",
     "@commitlint/types": "20.0.0",
@@ -42,8 +42,8 @@
     "@types/audioworklet": "0.0.91",
     "@types/node": "24.10.1",
     "@types/pngjs": "6.0.5",
-    "@vitest/coverage-v8": "4.0.13",
-    "@vitest/ui": "4.0.13",
+    "@vitest/coverage-v8": "4.0.14",
+    "@vitest/ui": "4.0.14",
     "astro": "5.16.0",
     "commitlint": "20.1.0",
     "globals": "16.5.0",
@@ -58,14 +58,14 @@
     "starlight-typedoc": "0.21.4",
     "tinybench": "5.1.0",
     "ts-extras": "0.16.0",
-    "tsdown": "0.16.6",
+    "tsdown": "0.16.7",
     "type-fest": "5.2.0",
     "typedoc": "0.28.14",
     "typedoc-plugin-markdown": "4.9.0",
     "typescript": "5.9.3",
     "unplugin-unused": "0.5.6",
     "vite": "npm:rolldown-vite@7.2.7",
-    "vitest": "4.0.13"
+    "vitest": "4.0.14"
   },
   "exports": {
     ".": {