LCOV - code coverage report
Current view: top level - src/scripts/metadata - avif.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 88.6 % 167 148
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type {
       2              :   ComfyApiWorkflow,
       3              :   ComfyWorkflowJSON
       4              : } from '@comfyorg/graph-model/workflowSchema'
       5              : import { ComfyMetadataTags } from '@/types/metadataTypes'
       6              : import type {
       7              :   AvifIinfBox,
       8              :   AvifIlocBox,
       9              :   AvifInfeBox,
      10              :   ComfyMetadata,
      11              :   IsobmffBoxContentRange
      12              : } from '@/types/metadataTypes'
      13              : import { readFileAsArrayBuffer } from '@/utils/fileUtil'
      14              : import { parseJsonWithNonFinite } from '@/utils/jsonUtil'
      15              : 
      16         2356 : const readNullTerminatedString = (
      17              :   dataView: DataView,
      18              :   start: number,
      19              :   end: number
      20              : ): { str: string; length: number } => {
      21            8 :   let length = 0
      22            8 :   while (start + length < end && dataView.getUint8(start + length) !== 0) {
      23           18 :     length++
      24              :   }
      25              :   const str = new TextDecoder('utf-8').decode(
      26              :     new Uint8Array(dataView.buffer, dataView.byteOffset + start, length)
      27              :   )
      28            8 :   return { str, length: length + 1 } // Include null terminator
      29              : }
      30              : 
      31         2356 : const parseInfeBox = (dataView: DataView, start: number): AvifInfeBox => {
      32            4 :   const version = dataView.getUint8(start)
      33            4 :   const flags = dataView.getUint32(start) & 0xffffff
      34            4 :   let offset = start + 4
      35              : 
      36            4 :   let item_ID: number, item_protection_index: number, item_type: string
      37              : 
      38            4 :   if (version >= 2) {
      39            4 :     if (version === 2) {
      40            4 :       item_ID = dataView.getUint16(offset)
      41            4 :       offset += 2
      42              :     } else {
      43            0 :       item_ID = dataView.getUint32(offset)
      44            0 :       offset += 4
      45              :     }
      46              : 
      47            4 :     item_protection_index = dataView.getUint16(offset)
      48            4 :     offset += 2
      49            4 :     item_type = String.fromCharCode(
      50              :       ...new Uint8Array(dataView.buffer, dataView.byteOffset + offset, 4)
      51              :     )
      52            4 :     offset += 4
      53              : 
      54            4 :     const { str: item_name, length: name_len } = readNullTerminatedString(
      55              :       dataView,
      56              :       offset,
      57              :       dataView.byteLength
      58              :     )
      59            4 :     offset += name_len
      60              : 
      61            4 :     const content_type = readNullTerminatedString(
      62              :       dataView,
      63              :       offset,
      64              :       dataView.byteLength
      65              :     ).str
      66              : 
      67            4 :     return {
      68              :       box_header: { size: 0, type: 'infe' }, // Size is dynamic
      69              :       version,
      70              :       flags,
      71              :       item_ID,
      72              :       item_protection_index,
      73              :       item_type,
      74              :       item_name,
      75              :       content_type
      76              :     }
      77              :   }
      78            0 :   throw new Error(`Unsupported infe box version: ${version}`)
      79              : }
      80              : 
      81         2356 : const parseIinfBox = (
      82              :   dataView: DataView,
      83              :   range: IsobmffBoxContentRange
      84              : ): AvifIinfBox => {
      85            2 :   if (!range) throw new Error('iinf box not found')
      86              : 
      87            2 :   const version = dataView.getUint8(range.start)
      88            2 :   const flags = dataView.getUint32(range.start) & 0xffffff
      89            2 :   let offset = range.start + 4
      90              : 
      91            2 :   const entry_count =
      92              :     version === 0 ? dataView.getUint16(offset) : dataView.getUint32(offset)
      93            2 :   offset += version === 0 ? 2 : 4
      94              : 
      95            2 :   const entries: AvifInfeBox[] = []
      96            2 :   for (let i = 0; i < entry_count; i++) {
      97            4 :     const boxSize = dataView.getUint32(offset)
      98              :     const boxType = String.fromCharCode(
      99              :       ...new Uint8Array(dataView.buffer, dataView.byteOffset + offset + 4, 4)
     100              :     )
     101              : 
     102            4 :     if (boxType === 'infe') {
     103            4 :       const infe = parseInfeBox(dataView, offset + 8)
     104            4 :       infe.box_header.size = boxSize
     105            4 :       entries.push(infe)
     106              :     }
     107            4 :     offset += boxSize
     108              :   }
     109              : 
     110            2 :   return {
     111              :     box_header: { size: range.end - range.start + 8, type: 'iinf' },
     112              :     version,
     113              :     flags,
     114              :     entry_count,
     115              :     entries
     116              :   }
     117              : }
     118              : 
     119         2356 : const parseIlocBox = (
     120              :   dataView: DataView,
     121              :   range: IsobmffBoxContentRange
     122              : ): AvifIlocBox => {
     123            2 :   if (!range) throw new Error('iloc box not found')
     124              : 
     125            2 :   const version = dataView.getUint8(range.start)
     126            2 :   const flags = dataView.getUint32(range.start) & 0xffffff
     127            2 :   let offset = range.start + 4
     128              : 
     129            2 :   const sizes = dataView.getUint8(offset++)
     130            2 :   const offset_size = (sizes >> 4) & 0x0f
     131            2 :   const length_size = sizes & 0x0f
     132              : 
     133            2 :   const base_offset_size = (dataView.getUint8(offset) >> 4) & 0x0f
     134            2 :   const index_size =
     135              :     version === 1 || version === 2 ? dataView.getUint8(offset) & 0x0f : 0
     136            2 :   offset++
     137              : 
     138            2 :   const item_count =
     139              :     version < 2 ? dataView.getUint16(offset) : dataView.getUint32(offset)
     140            2 :   offset += version < 2 ? 2 : 4
     141              : 
     142            2 :   const items = []
     143            2 :   for (let i = 0; i < item_count; i++) {
     144            4 :     const item_ID =
     145              :       version < 2 ? dataView.getUint16(offset) : dataView.getUint32(offset)
     146            4 :     offset += version < 2 ? 2 : 4
     147              : 
     148            4 :     if (version === 1 || version === 2) {
     149            0 :       offset += 2 // construction_method
     150              :     }
     151              : 
     152            4 :     const data_reference_index = dataView.getUint16(offset)
     153            4 :     offset += 2
     154              : 
     155            4 :     const base_offset = base_offset_size > 0 ? dataView.getUint32(offset) : 0 // Simplified
     156            4 :     offset += base_offset_size
     157              : 
     158            4 :     const extent_count = dataView.getUint16(offset)
     159            4 :     offset += 2
     160              : 
     161            4 :     const extents = []
     162            4 :     for (let j = 0; j < extent_count; j++) {
     163            4 :       if ((version === 1 || version === 2) && index_size > 0) {
     164            0 :         offset += index_size
     165              :       }
     166            4 :       const extent_offset = dataView.getUint32(offset) // Simplified
     167            4 :       offset += offset_size
     168            4 :       const extent_length = dataView.getUint32(offset) // Simplified
     169            4 :       offset += length_size
     170            4 :       extents.push({ extent_offset, extent_length })
     171              :     }
     172            4 :     items.push({
     173              :       item_ID,
     174              :       data_reference_index,
     175              :       base_offset,
     176              :       extent_count,
     177              :       extents
     178              :     })
     179              :   }
     180              : 
     181            2 :   return {
     182              :     box_header: { size: range.end - range.start + 8, type: 'iloc' },
     183              :     version,
     184              :     flags,
     185              :     offset_size,
     186              :     length_size,
     187              :     base_offset_size,
     188              :     index_size,
     189              :     item_count,
     190              :     items
     191              :   }
     192              : }
     193              : 
     194            6 : function findBox(
     195              :   dataView: DataView,
     196              :   start: number,
     197              :   end: number,
     198              :   type: string
     199              : ): IsobmffBoxContentRange {
     200            6 :   let offset = start
     201            6 :   while (offset < end) {
     202           18 :     if (offset + 8 > end) break
     203           18 :     const boxLength = dataView.getUint32(offset)
     204           18 :     const boxType = String.fromCharCode(
     205              :       ...new Uint8Array(dataView.buffer, dataView.byteOffset + offset + 4, 4)
     206              :     )
     207              : 
     208           18 :     if (boxLength === 0) break
     209              : 
     210           18 :     if (boxType === type) {
     211            6 :       return { start: offset + 8, end: offset + boxLength }
     212              :     }
     213           18 :     if (offset + boxLength > end) break
     214           12 :     offset += boxLength
     215              :   }
     216            0 :   return null
     217              : }
     218              : 
     219            2 : function parseAvifMetadata(buffer: ArrayBuffer): ComfyMetadata {
     220            2 :   const metadata: ComfyMetadata = {}
     221            2 :   const dataView = new DataView(buffer)
     222              : 
     223            2 :   if (
     224              :     dataView.getUint32(4) !== 0x66747970 ||
     225              :     dataView.getUint32(8) !== 0x61766966
     226              :   ) {
     227            0 :     console.error('Not a valid AVIF file')
     228            0 :     return {}
     229              :   }
     230              : 
     231            2 :   const metaBox = findBox(dataView, 0, dataView.byteLength, 'meta')
     232            2 :   if (!metaBox) return {}
     233              : 
     234            2 :   const metaBoxContentStart = metaBox.start + 4 // Skip version and flags
     235              : 
     236              :   const iinfBoxRange = findBox(
     237              :     dataView,
     238              :     metaBoxContentStart,
     239              :     metaBox.end,
     240              :     'iinf'
     241              :   )
     242              :   const iinf = parseIinfBox(dataView, iinfBoxRange)
     243              : 
     244            2 :   const exifInfe = iinf.entries.find((e) => e.item_type === 'Exif')
     245            2 :   if (!exifInfe) return {}
     246              : 
     247              :   const ilocBoxRange = findBox(
     248              :     dataView,
     249              :     metaBoxContentStart,
     250              :     metaBox.end,
     251              :     'iloc'
     252              :   )
     253              :   const iloc = parseIlocBox(dataView, ilocBoxRange)
     254              : 
     255            2 :   const exifIloc = iloc.items.find((i) => i.item_ID === exifInfe.item_ID)
     256            2 :   if (!exifIloc || exifIloc.extents.length === 0) return {}
     257              : 
     258            2 :   const exifExtent = exifIloc.extents[0]
     259            2 :   const itemData = new Uint8Array(
     260              :     buffer,
     261              :     exifExtent.extent_offset,
     262              :     exifExtent.extent_length
     263              :   )
     264              : 
     265            2 :   let tiffHeaderOffset = -1
     266            2 :   for (let i = 0; i < itemData.length - 4; i++) {
     267           22 :     if (
     268              :       (itemData[i] === 0x4d &&
     269              :         itemData[i + 1] === 0x4d &&
     270              :         itemData[i + 2] === 0x00 &&
     271              :         itemData[i + 3] === 0x2a) || // MM*
     272              :       (itemData[i] === 0x49 &&
     273              :         itemData[i + 1] === 0x49 &&
     274              :         itemData[i + 2] === 0x2a &&
     275              :         itemData[i + 3] === 0x00) // II*
     276              :     ) {
     277            2 :       tiffHeaderOffset = i
     278            2 :       break
     279              :     }
     280              :   }
     281              : 
     282            2 :   if (tiffHeaderOffset !== -1) {
     283              :     const exifData = itemData.subarray(tiffHeaderOffset)
     284            2 :     const data: Record<string, unknown> = parseExifData(exifData)
     285            2 :     for (const key in data) {
     286            3 :       const value = data[key]
     287            3 :       if (typeof value === 'string') {
     288            3 :         if (key === 'usercomment') {
     289            0 :           try {
     290            0 :             const metadataJson = parseJsonWithNonFinite<{
     291              :               prompt?: ComfyApiWorkflow
     292              :               workflow?: ComfyWorkflowJSON
     293              :             }>(value)
     294            0 :             if (metadataJson.prompt) {
     295            0 :               metadata[ComfyMetadataTags.PROMPT] = metadataJson.prompt
     296              :             }
     297            0 :             if (metadataJson.workflow) {
     298            0 :               metadata[ComfyMetadataTags.WORKFLOW] = metadataJson.workflow
     299              :             }
     300              :           } catch (e) {
     301            0 :             console.error('Failed to parse usercomment JSON', e)
     302              :           }
     303              :         } else {
     304            3 :           const [metadataKey, ...metadataValueParts] = value.split(':')
     305            3 :           const metadataValue = metadataValueParts.join(':').trim()
     306            3 :           if (
     307              :             metadataKey.toLowerCase() ===
     308              :               ComfyMetadataTags.PROMPT.toLowerCase() ||
     309              :             metadataKey.toLowerCase() ===
     310              :               ComfyMetadataTags.WORKFLOW.toLowerCase()
     311              :           ) {
     312            3 :             try {
     313            3 :               const jsonValue = parseJsonWithNonFinite<
     314              :                 ComfyApiWorkflow | ComfyWorkflowJSON
     315              :               >(metadataValue)
     316            3 :               metadata[metadataKey.toLowerCase() as keyof ComfyMetadata] =
     317              :                 jsonValue
     318              :             } catch (e) {
     319            0 :               console.error(`Failed to parse JSON for ${metadataKey}`, e)
     320              :             }
     321              :           }
     322              :         }
     323              :       }
     324              :     }
     325              :   } else {
     326            0 :     console.warn('TIFF header not found in EXIF data.')
     327              :   }
     328              : 
     329            2 :   return metadata
     330              : }
     331              : 
     332            2 : function parseExifData(exifData: Uint8Array) {
     333              :   // Check for the correct TIFF header (0x4949 for little-endian or 0x4D4D for big-endian)
     334            2 :   const isLittleEndian = String.fromCharCode(...exifData.slice(0, 2)) === 'II'
     335              : 
     336              :   // Function to read 16-bit and 32-bit integers from binary data
     337           16 :   function readInt(
     338              :     offset: number,
     339              :     isLittleEndian: boolean,
     340              :     length: 2 | 4
     341              :   ): number {
     342           16 :     const arr = exifData.slice(offset, offset + length)
     343           16 :     if (length === 2) {
     344            8 :       return new DataView(arr.buffer, arr.byteOffset, arr.byteLength).getUint16(
     345              :         0,
     346              :         isLittleEndian
     347              :       )
     348              :     }
     349            8 :     return new DataView(arr.buffer, arr.byteOffset, arr.byteLength).getUint32(
     350              :       0,
     351              :       isLittleEndian
     352              :     )
     353              :   }
     354              : 
     355              :   // Read the offset to the first IFD (Image File Directory)
     356            2 :   const ifdOffset = readInt(4, isLittleEndian, 4)
     357              : 
     358            2 :   function parseIFD(offset: number) {
     359            2 :     const numEntries = readInt(offset, isLittleEndian, 2)
     360            2 :     const result: Record<number, string | undefined> = {}
     361              : 
     362            2 :     for (let i = 0; i < numEntries; i++) {
     363            3 :       const entryOffset = offset + 2 + i * 12
     364            3 :       const tag = readInt(entryOffset, isLittleEndian, 2)
     365            3 :       const type = readInt(entryOffset + 2, isLittleEndian, 2)
     366            3 :       const numValues = readInt(entryOffset + 4, isLittleEndian, 4)
     367            3 :       const valueOffset = readInt(entryOffset + 8, isLittleEndian, 4)
     368              : 
     369              :       // Read the value(s) based on the data type
     370            3 :       let value
     371            3 :       if (type === 2) {
     372              :         // ASCII string
     373            3 :         value = new TextDecoder('utf-8').decode(
     374              :           exifData.subarray(valueOffset, valueOffset + numValues - 1)
     375              :         )
     376              :       }
     377              : 
     378            3 :       result[tag] = value
     379              :     }
     380              : 
     381            2 :     return result
     382              :   }
     383              : 
     384              :   // Parse the first IFD
     385              :   const ifdData = parseIFD(ifdOffset)
     386            2 :   return ifdData
     387              : }
     388              : 
     389            2 : export async function getFromAvifFile(
     390              :   file: File
     391              : ): Promise<Record<string, string>> {
     392            2 :   const buffer = await readFileAsArrayBuffer(file)
     393            2 :   if (!buffer) return {}
     394              : 
     395            2 :   try {
     396            2 :     const comfyMetadata = parseAvifMetadata(buffer)
     397            2 :     const result: Record<string, string> = {}
     398            2 :     if (comfyMetadata.prompt) {
     399            2 :       result.prompt = JSON.stringify(comfyMetadata.prompt)
     400              :     }
     401            2 :     if (comfyMetadata.workflow) {
     402            1 :       result.workflow = JSON.stringify(comfyMetadata.workflow)
     403              :     }
     404            2 :     return result
     405              :   } catch (e) {
     406            0 :     console.error('Parser: Error parsing AVIF metadata:', e)
     407            0 :     return {}
     408              :   }
     409              : }
        

Generated by: LCOV version 2.0-1