@tushar-br/desktop 1.0.173 → 1.0.174

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/libultrahdr.js

@@ -0,0 +1,650 @@
+/**
+ * @monogrid/gainmap-js v3.4.0
+ * With ❤️, by MONOGRID <gainmap@monogrid.com>
+ */
+
+/**
+ * JPEG marker constants
+ * Based on JPEG specification and libultrahdr implementation
+ */
+/**
+ * JPEG marker prefix - all markers start with this byte
+ */
+const MARKER_PREFIX = 0xff;
+/**
+ * JPEG markers
+ */
+const MARKERS = {
+    /** Start of Image */
+    SOI: 0xd8,
+    /** Application segment 1 (EXIF/XMP) */
+    APP1: 0xe1,
+    /** Application segment 2 (ICC/MPF) */
+    APP2: 0xe2,
+    /** Start of Scan */
+    SOS: 0xda};
+/**
+ * XMP namespace identifier for APP1 marker
+ */
+const XMP_NAMESPACE = 'http://ns.adobe.com/xap/1.0/\0';
+
+/**
+ * Multi-Picture Format (MPF) generator
+ * Based on CIPA DC-007 specification and libultrahdr multipictureformat.cpp
+ *
+ * MPF is used to embed multiple images in a single JPEG file
+ */
+/**
+ * MPF constants from the specification
+ */
+const MPF_CONSTANTS = {
+    /** MPF signature "MPF\0" */
+    SIGNATURE: new Uint8Array([0x4d, 0x50, 0x46, 0x00]),
+    /** Big endian marker "MM" */
+    BIG_ENDIAN: new Uint8Array([0x4d, 0x4d]),
+    /** TIFF magic number */
+    TIFF_MAGIC: 0x002a,
+    /** Number of pictures in MPF */
+    NUM_PICTURES: 2,
+    /** Number of tags to serialize */
+    TAG_COUNT: 3,
+    /** Size of each tag in bytes */
+    TAG_SIZE: 12,
+    /** Size of each MP entry in bytes */
+    MP_ENTRY_SIZE: 16
+};
+/**
+ * MPF tag identifiers
+ */
+const MPF_TAGS = {
+    /** MPF version tag */
+    VERSION: 0xb000,
+    /** Number of images tag */
+    NUMBER_OF_IMAGES: 0xb001,
+    /** MP entry tag */
+    MP_ENTRY: 0xb002
+};
+/**
+ * MPF tag types
+ */
+const MPF_TAG_TYPES = {
+    /** Undefined type */
+    UNDEFINED: 7,
+    /** Unsigned long type */
+    ULONG: 4
+};
+/**
+ * MP entry attributes
+ */
+const MP_ENTRY_ATTRIBUTES = {
+    /** JPEG format */
+    FORMAT_JPEG: 0x00000000,
+    /** Primary image type */
+    TYPE_PRIMARY: 0x20000000
+};
+/**
+ * MPF version string
+ */
+const MPF_VERSION = new Uint8Array([0x30, 0x31, 0x30, 0x30]); // "0100"
+/**
+ * Calculate the total size of the MPF structure
+ */
+function calculateMpfSize() {
+    return (MPF_CONSTANTS.SIGNATURE.length + // Signature "MPF\0"
+        2 + // Endianness marker
+        2 + // TIFF magic number
+        4 + // Index IFD Offset
+        2 + // Tag count
+        MPF_CONSTANTS.TAG_COUNT * MPF_CONSTANTS.TAG_SIZE + // Tags
+        4 + // Attribute IFD offset
+        MPF_CONSTANTS.NUM_PICTURES * MPF_CONSTANTS.MP_ENTRY_SIZE // MP Entries
+    );
+}
+/**
+ * Generate MPF (Multi-Picture Format) data structure
+ *
+ * @param primaryImageSize - Size of the primary image in bytes
+ * @param primaryImageOffset - Offset of the primary image (typically 0 for FII - First Individual Image)
+ * @param secondaryImageSize - Size of the secondary (gain map) image in bytes
+ * @param secondaryImageOffset - Offset of the secondary image from the MP Endian field
+ * @returns Uint8Array containing the MPF data
+ */
+function generateMpf(primaryImageSize, primaryImageOffset, secondaryImageSize, secondaryImageOffset) {
+    const mpfSize = calculateMpfSize();
+    const buffer = new ArrayBuffer(mpfSize);
+    const view = new DataView(buffer);
+    const uint8View = new Uint8Array(buffer);
+    let pos = 0;
+    // Write MPF signature "MPF\0"
+    uint8View.set(MPF_CONSTANTS.SIGNATURE, pos);
+    pos += MPF_CONSTANTS.SIGNATURE.length;
+    // Write endianness marker (big endian "MM")
+    // Using big endian to match the C++ implementation's USE_BIG_ENDIAN
+    uint8View.set(MPF_CONSTANTS.BIG_ENDIAN, pos);
+    const bigEndian = false; // DataView uses little endian by default, so we need to flip this
+    pos += 2;
+    // Write TIFF magic number (0x002A)
+    view.setUint16(pos, MPF_CONSTANTS.TIFF_MAGIC, bigEndian);
+    pos += 2;
+    // Set the Index IFD offset
+    // This offset is from the start of the TIFF header (the endianness marker)
+    // After: endianness (2) + magic (2) + this offset field (4) = 8 bytes
+    const indexIfdOffset = 8;
+    view.setUint32(pos, indexIfdOffset, bigEndian);
+    pos += 4;
+    // Write tag count (3 tags: version, number of images, MP entries)
+    view.setUint16(pos, MPF_CONSTANTS.TAG_COUNT, bigEndian);
+    pos += 2;
+    // Write version tag
+    view.setUint16(pos, MPF_TAGS.VERSION, bigEndian);
+    pos += 2;
+    view.setUint16(pos, MPF_TAG_TYPES.UNDEFINED, bigEndian);
+    pos += 2;
+    view.setUint32(pos, MPF_VERSION.length, bigEndian);
+    pos += 4;
+    uint8View.set(MPF_VERSION, pos);
+    pos += 4; // Version is 4 bytes, embedded in the tag
+    // Write number of images tag
+    view.setUint16(pos, MPF_TAGS.NUMBER_OF_IMAGES, bigEndian);
+    pos += 2;
+    view.setUint16(pos, MPF_TAG_TYPES.ULONG, bigEndian);
+    pos += 2;
+    view.setUint32(pos, 1, bigEndian); // Count = 1
+    pos += 4;
+    view.setUint32(pos, MPF_CONSTANTS.NUM_PICTURES, bigEndian);
+    pos += 4;
+    // Write MP entry tag
+    view.setUint16(pos, MPF_TAGS.MP_ENTRY, bigEndian);
+    pos += 2;
+    view.setUint16(pos, MPF_TAG_TYPES.UNDEFINED, bigEndian);
+    pos += 2;
+    view.setUint32(pos, MPF_CONSTANTS.MP_ENTRY_SIZE * MPF_CONSTANTS.NUM_PICTURES, bigEndian);
+    pos += 4;
+    // Calculate MP entry offset
+    // The offset is from the start of the MP Endian field (after signature)
+    // Current position is at the value field of MP Entry tag
+    const mpEntryOffset = pos - MPF_CONSTANTS.SIGNATURE.length + 4 + 4;
+    view.setUint32(pos, mpEntryOffset, bigEndian);
+    pos += 4;
+    // Write attribute IFD offset (0 = none)
+    view.setUint32(pos, 0, bigEndian);
+    pos += 4;
+    // Write MP entries for primary image
+    // Attribute format: JPEG (0x00000000) | Type: Primary (0x20000000)
+    view.setUint32(pos, MP_ENTRY_ATTRIBUTES.FORMAT_JPEG | MP_ENTRY_ATTRIBUTES.TYPE_PRIMARY, bigEndian);
+    pos += 4;
+    view.setUint32(pos, primaryImageSize, bigEndian);
+    pos += 4;
+    view.setUint32(pos, primaryImageOffset, bigEndian);
+    pos += 4;
+    view.setUint16(pos, 0, bigEndian); // Dependent image 1
+    pos += 2;
+    view.setUint16(pos, 0, bigEndian); // Dependent image 2
+    pos += 2;
+    // Write MP entries for secondary image (gain map)
+    // Attribute format: JPEG only (no type flag)
+    view.setUint32(pos, MP_ENTRY_ATTRIBUTES.FORMAT_JPEG, bigEndian);
+    pos += 4;
+    view.setUint32(pos, secondaryImageSize, bigEndian);
+    pos += 4;
+    view.setUint32(pos, secondaryImageOffset, bigEndian);
+    pos += 4;
+    view.setUint16(pos, 0, bigEndian); // Dependent image 1
+    pos += 2;
+    view.setUint16(pos, 0, bigEndian); // Dependent image 2
+    // pos += 2
+    return uint8View;
+}
+
+/**
+ * XMP metadata generator for gain map images
+ * Based on libultrahdr jpegrutils.cpp implementation
+ */
+/**
+ * Item semantic types
+ */
+const ITEM_SEMANTIC = {
+    PRIMARY: 'Primary',
+    GAIN_MAP: 'GainMap'
+};
+/**
+ * MIME type for JPEG images
+ */
+const MIME_IMAGE_JPEG = 'image/jpeg';
+/**
+ * Escape XML special characters
+ */
+function escapeXml(str) {
+    return String(str)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+/**
+ * Generate XMP metadata for the primary image
+ *
+ * This XMP contains:
+ * - Container directory with references to primary and gain map images
+ * - Gain map version
+ * - Item metadata for both images
+ *
+ * @param secondaryImageLength - Length of the secondary (gain map) JPEG in bytes
+ * @param metadata - Gain map metadata
+ * @returns XMP packet as string
+ */
+function generateXmpForPrimaryImage(secondaryImageLength, metadata) {
+    const lines = [];
+    // XMP packet header
+    lines.push('<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>');
+    lines.push('<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 5.1.2">');
+    lines.push('  <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">');
+    lines.push('    <rdf:Description');
+    lines.push('      xmlns:Container="http://ns.google.com/photos/1.0/container/"');
+    lines.push('      xmlns:Item="http://ns.google.com/photos/1.0/container/item/"');
+    lines.push('      xmlns:hdrgm="http://ns.adobe.com/hdr-gain-map/1.0/"');
+    lines.push(`      hdrgm:Version="${escapeXml(metadata.version)}"`);
+    lines.push('      rdf:about="">');
+    // Container directory
+    lines.push('      <Container:Directory>');
+    lines.push('        <rdf:Seq>');
+    // Primary image item
+    lines.push('          <rdf:li rdf:parseType="Resource">');
+    lines.push('            <Container:Item');
+    lines.push(`              Item:Semantic="${ITEM_SEMANTIC.PRIMARY}"`);
+    lines.push(`              Item:Mime="${MIME_IMAGE_JPEG}"/>`);
+    lines.push('          </rdf:li>');
+    // Gain map image item
+    lines.push('          <rdf:li rdf:parseType="Resource">');
+    lines.push('            <Container:Item');
+    lines.push(`              Item:Semantic="${ITEM_SEMANTIC.GAIN_MAP}"`);
+    lines.push(`              Item:Mime="${MIME_IMAGE_JPEG}"`);
+    lines.push(`              Item:Length="${secondaryImageLength}"/>`);
+    lines.push('          </rdf:li>');
+    lines.push('        </rdf:Seq>');
+    lines.push('      </Container:Directory>');
+    lines.push('    </rdf:Description>');
+    lines.push('  </rdf:RDF>');
+    lines.push('</x:xmpmeta>');
+    lines.push('<?xpacket end="w"?>');
+    return lines.join('\n');
+}
+/**
+ * Generate XMP metadata for the secondary (gain map) image
+ *
+ * This XMP contains all the gain map parameters:
+ * - Version
+ * - Gain map min/max
+ * - Gamma
+ * - Offset SDR/HDR
+ * - HDR capacity min/max
+ * - Base rendition flag
+ *
+ * @param metadata - Gain map metadata
+ * @returns XMP packet as string
+ */
+function generateXmpForSecondaryImage(metadata) {
+    const lines = [];
+    // hdrCapacityMin/Max are already in log2 space (from GainMapEncoderMaterial)
+    // No conversion needed
+    const hdrCapacityMin = metadata.hdrCapacityMin;
+    const hdrCapacityMax = metadata.hdrCapacityMax;
+    // Handle array values - take average if array, or use single value
+    const getAverage = (val) => {
+        if (Array.isArray(val)) {
+            return val.reduce((sum, v) => sum + v, 0) / val.length;
+        }
+        return val;
+    };
+    const gainMapMinAvg = getAverage(metadata.gainMapMin);
+    const gainMapMaxAvg = getAverage(metadata.gainMapMax);
+    const gammaAvg = getAverage(metadata.gamma);
+    const offsetSdrAvg = getAverage(metadata.offsetSdr);
+    const offsetHdrAvg = getAverage(metadata.offsetHdr);
+    // XMP packet header
+    lines.push('<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>');
+    lines.push('<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 5.1.2">');
+    lines.push('  <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">');
+    lines.push('    <rdf:Description');
+    lines.push('      xmlns:hdrgm="http://ns.adobe.com/hdr-gain-map/1.0/"');
+    lines.push(`      hdrgm:Version="${escapeXml(metadata.version)}"`);
+    lines.push(`      hdrgm:GainMapMin="${escapeXml(gainMapMinAvg)}"`);
+    lines.push(`      hdrgm:GainMapMax="${escapeXml(gainMapMaxAvg)}"`);
+    lines.push(`      hdrgm:Gamma="${escapeXml(gammaAvg)}"`);
+    lines.push(`      hdrgm:OffsetSDR="${escapeXml(offsetSdrAvg)}"`);
+    lines.push(`      hdrgm:OffsetHDR="${escapeXml(offsetHdrAvg)}"`);
+    lines.push(`      hdrgm:HDRCapacityMin="${escapeXml(hdrCapacityMin)}"`);
+    lines.push(`      hdrgm:HDRCapacityMax="${escapeXml(hdrCapacityMax)}"`);
+    lines.push('      hdrgm:BaseRenditionIsHDR="False"');
+    lines.push('      rdf:about=""/>');
+    lines.push('  </rdf:RDF>');
+    lines.push('</x:xmpmeta>');
+    lines.push('<?xpacket end="w"?>');
+    return lines.join('\n');
+}
+
+/**
+ * JPEG assembler for creating JPEG-R (JPEG with gain map) files
+ * Based on libultrahdr jpegr.cpp implementation
+ */
+/**
+ * Extract EXIF data from a JPEG if present
+ *
+ * @param jpegData - JPEG file data
+ * @returns Object containing EXIF data and position, or null if not found
+ */
+function extractExif(jpegData) {
+    const view = new DataView(jpegData.buffer, jpegData.byteOffset, jpegData.byteLength);
+    // Check for JPEG SOI marker
+    if (view.getUint8(0) !== MARKER_PREFIX || view.getUint8(1) !== MARKERS.SOI) {
+        return null;
+    }
+    let offset = 2;
+    const EXIF_SIGNATURE = 'Exif\0\0';
+    while (offset < jpegData.length - 1) {
+        // Check for marker prefix
+        if (view.getUint8(offset) !== MARKER_PREFIX) {
+            break;
+        }
+        const marker = view.getUint8(offset + 1);
+        // Check for SOS (Start of Scan) - end of metadata
+        if (marker === MARKERS.SOS) {
+            break;
+        }
+        // Check for APP1 marker (EXIF/XMP)
+        if (marker === MARKERS.APP1) {
+            const length = view.getUint16(offset + 2, false); // Big endian
+            const dataStart = offset + 4;
+            // Check if this APP1 contains EXIF
+            let isExif = true;
+            for (let i = 0; i < EXIF_SIGNATURE.length; i++) {
+                if (dataStart + i >= jpegData.length || jpegData[dataStart + i] !== EXIF_SIGNATURE.charCodeAt(i)) {
+                    isExif = false;
+                    break;
+                }
+            }
+            if (isExif) {
+                // Found EXIF data
+                const exifSize = length - 2; // Length includes the 2-byte length field itself
+                const exifData = jpegData.slice(dataStart, dataStart + exifSize);
+                return {
+                    data: exifData,
+                    pos: offset,
+                    size: length + 2 // Include marker (2 bytes) + length (2 bytes) + data
+                };
+            }
+        }
+        // Move to next marker
+        const length = view.getUint16(offset + 2, false);
+        offset += 2 + length;
+    }
+    return null;
+}
+/**
+ * Copy JPEG data without EXIF segment
+ *
+ * @param jpegData - Original JPEG data
+ * @param exifPos - Position of EXIF segment
+ * @param exifSize - Size of EXIF segment (including marker and length)
+ * @returns JPEG data without EXIF
+ */
+function copyJpegWithoutExif(jpegData, exifPos, exifSize) {
+    const newSize = jpegData.length - exifSize;
+    const result = new Uint8Array(newSize);
+    // Copy data before EXIF
+    result.set(jpegData.subarray(0, exifPos), 0);
+    // Copy data after EXIF
+    result.set(jpegData.subarray(exifPos + exifSize), exifPos);
+    return result;
+}
+/**
+ * Write a JPEG marker and its data
+ *
+ * @param buffer - Target buffer
+ * @param pos - Current position in buffer
+ * @param marker - Marker type (without 0xFF prefix)
+ * @param data - Data to write after marker
+ * @returns New position after writing
+ */
+function writeMarker(buffer, pos, marker, data) {
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    // Write marker
+    view.setUint8(pos++, MARKER_PREFIX);
+    view.setUint8(pos++, marker);
+    // Write data if present
+    if (data && data.length > 0) {
+        // Write length (big endian, includes the 2-byte length field itself)
+        const length = data.length + 2;
+        view.setUint16(pos, length, false);
+        pos += 2;
+        // Write data
+        buffer.set(data, pos);
+        pos += data.length;
+    }
+    return pos;
+}
+/**
+ * Assemble a JPEG-R file (JPEG with embedded gain map)
+ *
+ * The structure is:
+ * 1. Primary image:
+ *    - SOI
+ *    - APP1 (EXIF if present)
+ *    - APP1 (XMP with gain map metadata)
+ *    - APP2 (ICC profile if present)
+ *    - APP2 (MPF data)
+ *    - Rest of primary JPEG data
+ * 2. Secondary image (gain map):
+ *    - SOI
+ *    - APP1 (XMP with gain map parameters)
+ *    - Rest of gain map JPEG data
+ *
+ * @param options - Assembly options
+ * @returns Complete JPEG-R file as Uint8Array
+ */
+function assembleJpegWithGainMap(options) {
+    const { sdr, gainMap, metadata, exif: externalExif, icc } = options;
+    // Validate input
+    if (sdr.mimeType !== 'image/jpeg') {
+        throw new Error('SDR image must be JPEG format');
+    }
+    if (gainMap.mimeType !== 'image/jpeg') {
+        throw new Error('Gain map image must be JPEG format');
+    }
+    // Check for EXIF in primary image
+    const exifFromJpeg = extractExif(sdr.data);
+    if (exifFromJpeg && externalExif) {
+        throw new Error('Primary image already contains EXIF data, cannot add external EXIF');
+    }
+    // Prepare primary JPEG (remove embedded EXIF if present)
+    let primaryJpegData = sdr.data;
+    let exifData = externalExif;
+    if (exifFromJpeg) {
+        primaryJpegData = copyJpegWithoutExif(sdr.data, exifFromJpeg.pos, exifFromJpeg.size);
+        exifData = exifFromJpeg.data;
+    }
+    // Generate XMP for secondary image
+    const xmpSecondary = generateXmpForSecondaryImage(metadata);
+    const xmpSecondaryBytes = new TextEncoder().encode(xmpSecondary);
+    // Calculate secondary image size
+    // 2 bytes SOI + 2 bytes marker + 2 bytes length field + namespace + XMP data + gain map data (without SOI)
+    const namespaceBytes = new TextEncoder().encode(XMP_NAMESPACE);
+    const secondaryImageSize = 2 + 2 + 2 + namespaceBytes.length + xmpSecondaryBytes.length + (gainMap.data.length - 2);
+    // Generate XMP for primary image
+    const xmpPrimary = generateXmpForPrimaryImage(secondaryImageSize, metadata);
+    const xmpPrimaryBytes = new TextEncoder().encode(xmpPrimary);
+    const xmpPrimaryData = new Uint8Array(namespaceBytes.length + xmpPrimaryBytes.length);
+    xmpPrimaryData.set(namespaceBytes, 0);
+    xmpPrimaryData.set(xmpPrimaryBytes, namespaceBytes.length);
+    // Calculate MPF size and offset
+    const mpfLength = calculateMpfSize();
+    // Calculate total size
+    let totalSize = 2; // SOI
+    if (exifData)
+        totalSize += 2 + 2 + exifData.length; // APP1 + length + EXIF
+    totalSize += 2 + 2 + xmpPrimaryData.length; // APP1 + length + XMP primary
+    if (icc)
+        totalSize += 2 + 2 + icc.length; // APP2 + length + ICC
+    totalSize += 2 + 2 + mpfLength; // APP2 + length + MPF
+    totalSize += primaryJpegData.length - 2; // Primary JPEG without SOI
+    totalSize += secondaryImageSize; // Secondary image
+    // Calculate offsets for MPF
+    const primaryImageSize = totalSize - secondaryImageSize;
+    // Offset is from MP Endian field (after APP2 marker + length + MPF signature)
+    const secondaryImageOffset = primaryImageSize - (2 + // SOI
+        (exifData ? 2 + 2 + exifData.length : 0) +
+        2 + 2 + xmpPrimaryData.length +
+        (icc ? 2 + 2 + icc.length : 0) +
+        2 + 2 + 4 // APP2 marker + length + MPF signature
+    );
+    // Generate MPF data
+    const mpfDataActual = generateMpf(primaryImageSize, 0, secondaryImageSize, secondaryImageOffset);
+    // Allocate output buffer
+    const output = new Uint8Array(totalSize);
+    let pos = 0;
+    // === PRIMARY IMAGE ===
+    // Write SOI
+    pos = writeMarker(output, pos, MARKERS.SOI);
+    // Write EXIF if present
+    if (exifData) {
+        pos = writeMarker(output, pos, MARKERS.APP1, exifData);
+    }
+    // Write XMP for primary image (already created above)
+    pos = writeMarker(output, pos, MARKERS.APP1, xmpPrimaryData);
+    // Write ICC profile if present
+    if (icc) {
+        pos = writeMarker(output, pos, MARKERS.APP2, icc);
+    }
+    // Write MPF
+    pos = writeMarker(output, pos, MARKERS.APP2, mpfDataActual);
+    // Write rest of primary JPEG (skip SOI)
+    output.set(primaryJpegData.subarray(2), pos);
+    pos += primaryJpegData.length - 2;
+    // === SECONDARY IMAGE (GAIN MAP) ===
+    // Write SOI
+    pos = writeMarker(output, pos, MARKERS.SOI);
+    // Write XMP for secondary image
+    const xmpSecondaryData = new Uint8Array(namespaceBytes.length + xmpSecondaryBytes.length);
+    xmpSecondaryData.set(namespaceBytes, 0);
+    xmpSecondaryData.set(xmpSecondaryBytes, namespaceBytes.length);
+    pos = writeMarker(output, pos, MARKERS.APP1, xmpSecondaryData);
+    // Write rest of gain map JPEG (skip SOI)
+    output.set(gainMap.data.subarray(2), pos);
+    // pos += gainMap.data.length - 2
+    return output;
+}
+
+/**
+ * Encapsulates a Gainmap into a single JPEG file (aka: JPEG-R) with the base map
+ * as the sdr visualization and the gainMap encoded into a MPF (Multi-Picture Format) tag.
+ *
+ * @category Encoding
+ * @group Encoding
+ *
+ * @example
+ * import { compress, encode, findTextureMinMax } from '@monogrid/gainmap-js'
+ * import { encodeJPEGMetadata } from '@monogrid/gainmap-js/libultrahdr'
+ * import { EXRLoader } from 'three/examples/jsm/loaders/EXRLoader.js'
+ *
+ * // load an HDR file
+ * const loader = new EXRLoader()
+ * const image = await loader.loadAsync('image.exr')
+ *
+ * // find RAW RGB Max value of a texture
+ * const textureMax = findTextureMinMax(image)
+ *
+ * // Encode the gainmap
+ * const encodingResult = encode({
+ *   image,
+ *   maxContentBoost: Math.max.apply(this, textureMax)
+ * })
+ *
+ * // obtain the RAW RGBA SDR buffer and create an ImageData
+ * const sdrImageData = new ImageData(
+ *   encodingResult.sdr.toArray(),
+ *   encodingResult.sdr.width,
+ *   encodingResult.sdr.height
+ * )
+ * // obtain the RAW RGBA Gain map buffer and create an ImageData
+ * const gainMapImageData = new ImageData(
+ *   encodingResult.gainMap.toArray(),
+ *   encodingResult.gainMap.width,
+ *   encodingResult.gainMap.height
+ * )
+ *
+ * // parallel compress the RAW buffers into the specified mimeType
+ * const mimeType = 'image/jpeg'
+ * const quality = 0.9
+ *
+ * const [sdr, gainMap] = await Promise.all([
+ *   compress({
+ *     source: sdrImageData,
+ *     mimeType,
+ *     quality,
+ *     flipY: true // output needs to be flipped
+ *   }),
+ *   compress({
+ *     source: gainMapImageData,
+ *     mimeType,
+ *     quality,
+ *     flipY: true // output needs to be flipped
+ *   })
+ * ])
+ *
+ * // obtain the metadata which will be embedded into
+ * // and XMP tag inside the final JPEG file
+ * const metadata = encodingResult.getMetadata()
+ *
+ * // embed the compressed images + metadata into a single
+ * // JPEG file
+ * const jpeg = encodeJPEGMetadata({
+ *   ...encodingResult,
+ *   ...metadata,
+ *   sdr,
+ *   gainMap
+ * })
+ *
+ * // `jpeg` will be an `Uint8Array` which can be saved somewhere
+ *
+ *
+ * @param encodingResult - Encoding result containing SDR image, gain map image, and metadata
+ * @returns A Uint8Array representing a JPEG-R file
+ * @throws {Error} If `encodingResult.sdr.mimeType !== 'image/jpeg'`
+ * @throws {Error} If `encodingResult.gainMap.mimeType !== 'image/jpeg'`
+ */
+const encodeJPEGMetadata = (encodingResult) => {
+    // Validate input
+    if (encodingResult.sdr.mimeType !== 'image/jpeg') {
+        throw new Error('This function expects an SDR image compressed in jpeg');
+    }
+    if (encodingResult.gainMap.mimeType !== 'image/jpeg') {
+        throw new Error('This function expects a GainMap image compressed in jpeg');
+    }
+    // Prepare metadata with proper conversions
+    // The XMP generator handles the log2 conversion internally for gain map min/max values
+    const metadata = {
+        version: '1.0',
+        gainMapMin: encodingResult.gainMapMin,
+        gainMapMax: encodingResult.gainMapMax,
+        gamma: encodingResult.gamma,
+        offsetSdr: encodingResult.offsetSdr,
+        offsetHdr: encodingResult.offsetHdr,
+        hdrCapacityMin: encodingResult.hdrCapacityMin,
+        hdrCapacityMax: encodingResult.hdrCapacityMax,
+        minContentBoost: Array.isArray(encodingResult.gainMapMin)
+            ? Math.pow(2, encodingResult.gainMapMin.reduce((a, b) => a + b, 0) / encodingResult.gainMapMin.length)
+            : Math.pow(2, encodingResult.gainMapMin),
+        maxContentBoost: Array.isArray(encodingResult.gainMapMax)
+            ? Math.pow(2, encodingResult.gainMapMax.reduce((a, b) => a + b, 0) / encodingResult.gainMapMax.length)
+            : Math.pow(2, encodingResult.gainMapMax)
+    };
+    // Assemble the JPEG with gain map using pure JavaScript
+    return assembleJpegWithGainMap({
+        sdr: encodingResult.sdr,
+        gainMap: encodingResult.gainMap,
+        metadata
+    });
+};
+
+export { encodeJPEGMetadata };

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/libultrahdr.min.js

@@ -0,0 +1,5 @@
+/**
+ * @monogrid/gainmap-js v3.4.0
+ * With ❤️, by MONOGRID <gainmap@monogrid.com>
+ */
+const t=216,e=225,n=226,a=218,r={SIGNATURE:new Uint8Array([77,80,70,0]),BIG_ENDIAN:new Uint8Array([77,77]),TIFF_MAGIC:42,NUM_PICTURES:2,TAG_COUNT:3,TAG_SIZE:12,MP_ENTRY_SIZE:16},s=45056,i=45057,p=45058,o=7,h=4,g=0,m=536870912,c=new Uint8Array([48,49,48,48]);function d(){return r.SIGNATURE.length+2+2+4+2+r.TAG_COUNT*r.TAG_SIZE+4+r.NUM_PICTURES*r.MP_ENTRY_SIZE}const u="Primary",f="GainMap",M="image/jpeg";function l(t){return String(t).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&apos;")}function U(t,e,n,a){const r=new DataView(t.buffer,t.byteOffset,t.byteLength);if(r.setUint8(e++,255),r.setUint8(e++,n),a&&a.length>0){const n=a.length+2;r.setUint16(e,n,!1),e+=2,t.set(a,e),e+=a.length}return e}function x(x){const{sdr:y,gainMap:w,metadata:T,exif:I,icc:A}=x;if("image/jpeg"!==y.mimeType)throw new Error("SDR image must be JPEG format");if("image/jpeg"!==w.mimeType)throw new Error("Gain map image must be JPEG format");const E=function(n){const r=new DataView(n.buffer,n.byteOffset,n.byteLength);if(255!==r.getUint8(0)||r.getUint8(1)!==t)return null;let s=2;const i="Exif\0\0";for(;s<n.length-1&&255===r.getUint8(s);){const t=r.getUint8(s+1);if(t===a)break;if(t===e){const t=r.getUint16(s+2,!1),e=s+4;let a=!0;for(let t=0;t<6;t++)if(e+t>=n.length||n[e+t]!==i.charCodeAt(t)){a=!1;break}if(a){const a=t-2;return{data:n.slice(e,e+a),pos:s,size:t+2}}}s+=2+r.getUint16(s+2,!1)}return null}(y.data);if(E&&I)throw new Error("Primary image already contains EXIF data, cannot add external EXIF");let C=y.data,S=I;E&&(C=function(t,e,n){const a=t.length-n,r=new Uint8Array(a);return r.set(t.subarray(0,e),0),r.set(t.subarray(e+n),e),r}(y.data,E.pos,E.size),S=E.data);const R=function(t){const e=[],n=t.hdrCapacityMin,a=t.hdrCapacityMax,r=t=>Array.isArray(t)?t.reduce((t,e)=>t+e,0)/t.length:t,s=r(t.gainMapMin),i=r(t.gainMapMax),p=r(t.gamma),o=r(t.offsetSdr),h=r(t.offsetHdr);return e.push('<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>'),e.push('<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 5.1.2">'),e.push('  <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">'),e.push("    <rdf:Description"),e.push('      xmlns:hdrgm="http://ns.adobe.com/hdr-gain-map/1.0/"'),e.push(`      hdrgm:Version="${l(t.version)}"`),e.push(`      hdrgm:GainMapMin="${l(s)}"`),e.push(`      hdrgm:GainMapMax="${l(i)}"`),e.push(`      hdrgm:Gamma="${l(p)}"`),e.push(`      hdrgm:OffsetSDR="${l(o)}"`),e.push(`      hdrgm:OffsetHDR="${l(h)}"`),e.push(`      hdrgm:HDRCapacityMin="${l(n)}"`),e.push(`      hdrgm:HDRCapacityMax="${l(a)}"`),e.push('      hdrgm:BaseRenditionIsHDR="False"'),e.push('      rdf:about=""/>'),e.push("  </rdf:RDF>"),e.push("</x:xmpmeta>"),e.push('<?xpacket end="w"?>'),e.join("\n")}(T),b=(new TextEncoder).encode(R),G=(new TextEncoder).encode("http://ns.adobe.com/xap/1.0/\0"),D=6+G.length+b.length+(w.data.length-2),N=function(t,e){const n=[];return n.push('<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>'),n.push('<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 5.1.2">'),n.push('  <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">'),n.push("    <rdf:Description"),n.push('      xmlns:Container="http://ns.google.com/photos/1.0/container/"'),n.push('      xmlns:Item="http://ns.google.com/photos/1.0/container/item/"'),n.push('      xmlns:hdrgm="http://ns.adobe.com/hdr-gain-map/1.0/"'),n.push(`      hdrgm:Version="${l(e.version)}"`),n.push('      rdf:about="">'),n.push("      <Container:Directory>"),n.push("        <rdf:Seq>"),n.push('          <rdf:li rdf:parseType="Resource">'),n.push("            <Container:Item"),n.push(`              Item:Semantic="${u}"`),n.push(`              Item:Mime="${M}"/>`),n.push("          </rdf:li>"),n.push('          <rdf:li rdf:parseType="Resource">'),n.push("            <Container:Item"),n.push(`              Item:Semantic="${f}"`),n.push(`              Item:Mime="${M}"`),n.push(`              Item:Length="${t}"/>`),n.push("          </rdf:li>"),n.push("        </rdf:Seq>"),n.push("      </Container:Directory>"),n.push("    </rdf:Description>"),n.push("  </rdf:RDF>"),n.push("</x:xmpmeta>"),n.push('<?xpacket end="w"?>'),n.join("\n")}(D,T),_=(new TextEncoder).encode(N),$=new Uint8Array(G.length+_.length);$.set(G,0),$.set(_,G.length);const P=d();let F=2;S&&(F+=4+S.length),F+=4+$.length,A&&(F+=4+A.length),F+=4+P,F+=C.length-2,F+=D;const k=F-D,j=function(t,e,n,a){const u=d(),f=new ArrayBuffer(u),M=new DataView(f),l=new Uint8Array(f);let U=0;l.set(r.SIGNATURE,U),U+=r.SIGNATURE.length,l.set(r.BIG_ENDIAN,U);const x=!1;U+=2,M.setUint16(U,r.TIFF_MAGIC,x),U+=2,M.setUint32(U,8,x),U+=4,M.setUint16(U,r.TAG_COUNT,x),U+=2,M.setUint16(U,s,x),U+=2,M.setUint16(U,o,x),U+=2,M.setUint32(U,c.length,x),U+=4,l.set(c,U),U+=4,M.setUint16(U,i,x),U+=2,M.setUint16(U,h,x),U+=2,M.setUint32(U,1,x),U+=4,M.setUint32(U,r.NUM_PICTURES,x),U+=4,M.setUint16(U,p,x),U+=2,M.setUint16(U,o,x),U+=2,M.setUint32(U,r.MP_ENTRY_SIZE*r.NUM_PICTURES,x),U+=4;const y=U-r.SIGNATURE.length+4+4;return M.setUint32(U,y,x),U+=4,M.setUint32(U,0,x),U+=4,M.setUint32(U,g|m,x),U+=4,M.setUint32(U,t,x),U+=4,M.setUint32(U,e,x),U+=4,M.setUint16(U,0,x),U+=2,M.setUint16(U,0,x),U+=2,M.setUint32(U,g,x),U+=4,M.setUint32(U,n,x),U+=4,M.setUint32(U,a,x),U+=4,M.setUint16(U,0,x),U+=2,M.setUint16(U,0,x),l}(k,0,D,k-(2+(S?4+S.length:0)+2+2+$.length+(A?4+A.length:0)+2+2+4)),H=new Uint8Array(F);let z=0;z=U(H,z,t),S&&(z=U(H,z,e,S)),z=U(H,z,e,$),A&&(z=U(H,z,n,A)),z=U(H,z,n,j),H.set(C.subarray(2),z),z+=C.length-2,z=U(H,z,t);const O=new Uint8Array(G.length+b.length);return O.set(G,0),O.set(b,G.length),z=U(H,z,e,O),H.set(w.data.subarray(2),z),H}const y=t=>{if("image/jpeg"!==t.sdr.mimeType)throw new Error("This function expects an SDR image compressed in jpeg");if("image/jpeg"!==t.gainMap.mimeType)throw new Error("This function expects a GainMap image compressed in jpeg");const e={version:"1.0",gainMapMin:t.gainMapMin,gainMapMax:t.gainMapMax,gamma:t.gamma,offsetSdr:t.offsetSdr,offsetHdr:t.offsetHdr,hdrCapacityMin:t.hdrCapacityMin,hdrCapacityMax:t.hdrCapacityMax,minContentBoost:Array.isArray(t.gainMapMin)?Math.pow(2,t.gainMapMin.reduce((t,e)=>t+e,0)/t.gainMapMin.length):Math.pow(2,t.gainMapMin),maxContentBoost:Array.isArray(t.gainMapMax)?Math.pow(2,t.gainMapMax.reduce((t,e)=>t+e,0)/t.gainMapMax.length):Math.pow(2,t.gainMapMax)};return x({sdr:t.sdr,gainMap:t.gainMap,metadata:e})};export{y as encodeJPEGMetadata};