LCOV - code coverage report
Current view: top level - src/scripts/metadata - isobmff.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 95.9 % 97 93
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 { ASCII, ComfyMetadataTags } from '@/types/metadataTypes'
       6              : import type {
       7              :   ComfyMetadata,
       8              :   IsobmffBoxContentRange
       9              : } from '@/types/metadataTypes'
      10              : import { readFileAsArrayBuffer } from '@/utils/fileUtil'
      11              : import { parseJsonWithNonFinite } from '@/utils/jsonUtil'
      12              : 
      13              : // Set max read high, as atoms are stored near end of file
      14              : // while search is made to be efficient.
      15         2356 : const MAX_READ_BYTES = 64 * 1024 * 1024
      16              : 
      17         2356 : const BOX_TYPES = {
      18              :   USER_DATA: [0x75, 0x64, 0x74, 0x61],
      19              :   META_DATA: [0x6d, 0x65, 0x74, 0x61],
      20              :   ITEM_LIST: [0x69, 0x6c, 0x73, 0x74],
      21              :   KEYS: [0x6b, 0x65, 0x79, 0x73],
      22              :   DATA: [0x64, 0x61, 0x74, 0x61],
      23              :   MOVIE: [0x6d, 0x6f, 0x6f, 0x76]
      24              : }
      25         2356 : const SIZES = {
      26              :   HEADER: 8,
      27              :   VERSION: 4,
      28              :   LOCALE: 4,
      29              :   ITEM_MIN: 8
      30              : }
      31              : 
      32         2356 : const bufferMatchesBoxType = (
      33              :   data: Uint8Array,
      34              :   pos: number,
      35              :   boxType: number[]
      36              : ): boolean => {
      37          125 :   if (pos + 4 > data.length) return false
      38              : 
      39          125 :   for (let i = 0; i < 4; i++) {
      40          290 :     if (data[pos + i] !== boxType[i]) return false
      41              :   }
      42           53 :   return true
      43              : }
      44              : 
      45         2356 : const readUint32 = (data: Uint8Array, pos: number): number => {
      46          200 :   if (pos + 4 > data.length) return 0
      47          200 :   return (
      48              :     (data[pos] << 24) |
      49              :     (data[pos + 1] << 16) |
      50              :     (data[pos + 2] << 8) |
      51              :     data[pos + 3]
      52              :   )
      53              : }
      54              : 
      55         2356 : const findIsobmffBoxByType = (
      56              :   data: Uint8Array,
      57              :   startPos: number,
      58              :   endPos: number,
      59              :   boxType: number[]
      60              : ): IsobmffBoxContentRange => {
      61           59 :   for (let pos = startPos; pos < endPos - 8; pos++) {
      62          125 :     const size = readUint32(data, pos)
      63          125 :     if (size < SIZES.ITEM_MIN) continue // Minimum size is 8 bytes
      64              : 
      65          125 :     if (bufferMatchesBoxType(data, pos + 4, boxType))
      66           53 :       return { start: pos + SIZES.HEADER, end: pos + size } // Skip header
      67              : 
      68              :     // If type doesn't match, ensure size is valid before skipping
      69          125 :     if (pos + size > endPos) return null
      70              : 
      71           72 :     pos += size - 1 // Skip to the next potential box start
      72              :   }
      73            6 :   return null
      74              : }
      75              : 
      76         2356 : const extractJson = (
      77              :   data: Uint8Array,
      78              :   start: number,
      79              :   end: number
      80              : ): ComfyWorkflowJSON | ComfyApiWorkflow | null => {
      81            9 :   let jsonStart = start
      82            9 :   while (jsonStart < end && data[jsonStart] !== ASCII.OPEN_BRACE) {
      83            0 :     jsonStart++
      84              :   }
      85            9 :   if (jsonStart >= end) return null
      86              : 
      87            9 :   try {
      88              :     const jsonText = new TextDecoder().decode(data.slice(jsonStart, end))
      89            9 :     return parseJsonWithNonFinite<ComfyWorkflowJSON | ComfyApiWorkflow>(
      90              :       jsonText
      91              :     )
      92              :   } catch {
      93            0 :     return null
      94              :   }
      95              : }
      96              : 
      97         2356 : const readUtf8String = (data: Uint8Array, start: number, end: number): string =>
      98              :   new TextDecoder().decode(data.slice(start, end))
      99              : 
     100         2356 : const parseKeysBox = (
     101              :   data: Uint8Array,
     102              :   keysBoxStart: number,
     103              :   keysBoxEnd: number
     104              : ): Map<number, string> => {
     105            6 :   const keysMap = new Map<number, string>()
     106            6 :   let pos = keysBoxStart + 4 // Skip version/flags
     107            6 :   if (pos + 4 > keysBoxEnd) return keysMap
     108              : 
     109            6 :   const entryCount = readUint32(data, pos)
     110            6 :   pos += 4
     111              : 
     112            6 :   for (let i = 1; i <= entryCount; i++) {
     113              :     // Keys are 1-indexed
     114           23 :     if (pos + SIZES.HEADER > keysBoxEnd) break
     115              : 
     116           23 :     const keySize = readUint32(data, pos)
     117           23 :     pos += SIZES.HEADER
     118              : 
     119           23 :     const keyNameEnd = pos + keySize - SIZES.HEADER
     120           23 :     if (keySize < SIZES.ITEM_MIN || keyNameEnd > keysBoxEnd) break
     121              : 
     122           23 :     const keyName = readUtf8String(data, pos, keyNameEnd)
     123           23 :     keysMap.set(i, keyName)
     124           23 :     pos = keyNameEnd
     125              :   }
     126            6 :   return keysMap
     127              : }
     128              : 
     129         2356 : const extractMetadataValueFromDataBox = (
     130              :   data: Uint8Array,
     131              :   dataBoxStart: number,
     132              :   dataBoxEnd: number,
     133              :   keyName: string
     134              : ): ComfyWorkflowJSON | ComfyApiWorkflow | null => {
     135           23 :   const valueStart = dataBoxStart + SIZES.VERSION + SIZES.LOCALE
     136           23 :   if (valueStart >= dataBoxEnd) return null
     137              : 
     138           23 :   const lowerKeyName = keyName.toLowerCase()
     139           23 :   if (
     140              :     lowerKeyName === ComfyMetadataTags.PROMPT.toLowerCase() ||
     141              :     lowerKeyName === ComfyMetadataTags.WORKFLOW.toLowerCase()
     142              :   ) {
     143            9 :     return extractJson(data, valueStart, dataBoxEnd)
     144              :   }
     145           14 :   return null
     146              : }
     147              : 
     148         2356 : const parseIlstItem = (
     149              :   data: Uint8Array,
     150              :   itemStart: number,
     151              :   itemEnd: number,
     152              :   keysMap: Map<number, string>,
     153              :   metadata: ComfyMetadata
     154              : ) => {
     155           23 :   if (itemStart + SIZES.HEADER > itemEnd) return
     156              : 
     157           23 :   const itemIndex = readUint32(data, itemStart + 4)
     158           23 :   const keyName = keysMap.get(itemIndex)
     159           23 :   if (!keyName) return
     160              : 
     161           23 :   const dataBox = findIsobmffBoxByType(
     162              :     data,
     163              :     itemStart + SIZES.HEADER,
     164              :     itemEnd,
     165              :     BOX_TYPES.DATA
     166              :   )
     167           23 :   if (dataBox) {
     168           23 :     const value = extractMetadataValueFromDataBox(
     169              :       data,
     170              :       dataBox.start,
     171              :       dataBox.end,
     172              :       keyName
     173              :     )
     174           23 :     if (value !== null) {
     175            9 :       metadata[keyName.toLowerCase() as keyof ComfyMetadata] = value
     176              :     }
     177              :   }
     178              : }
     179              : 
     180         2356 : const parseIlstBox = (
     181              :   data: Uint8Array,
     182              :   ilstStart: number,
     183              :   ilstEnd: number,
     184              :   keysMap: Map<number, string>,
     185              :   metadata: ComfyMetadata
     186              : ) => {
     187            6 :   let pos = ilstStart
     188            6 :   while (pos < ilstEnd - SIZES.HEADER) {
     189           23 :     const itemSize = readUint32(data, pos)
     190           23 :     if (itemSize <= SIZES.HEADER || pos + itemSize > ilstEnd) break // Invalid item size
     191           23 :     parseIlstItem(data, pos, pos + itemSize, keysMap, metadata)
     192           23 :     pos += itemSize
     193              :   }
     194              : }
     195              : 
     196         2356 : const findUserDataBox = (data: Uint8Array): IsobmffBoxContentRange => {
     197              :   // Metadata can be in 'udta' at top level or inside 'moov'
     198            6 :   const topLevelBox = findIsobmffBoxByType(
     199              :     data,
     200              :     0,
     201              :     data.length,
     202              :     BOX_TYPES.USER_DATA
     203              :   )
     204            6 :   if (topLevelBox) return topLevelBox
     205              : 
     206            6 :   const moovBox = findIsobmffBoxByType(data, 0, data.length, BOX_TYPES.MOVIE)
     207            6 :   if (!moovBox) return null
     208            6 :   return findIsobmffBoxByType(
     209              :     data,
     210              :     moovBox.start,
     211              :     moovBox.end,
     212              :     BOX_TYPES.USER_DATA
     213              :   )
     214              : }
     215              : 
     216         2356 : const parseIsobmffMetadata = (data: Uint8Array): ComfyMetadata => {
     217            6 :   const metadata: ComfyMetadata = {}
     218            6 :   const userDataBox = findUserDataBox(data)
     219            6 :   if (!userDataBox) return metadata
     220              : 
     221            6 :   const metaBox = findIsobmffBoxByType(
     222              :     data,
     223              :     userDataBox.start,
     224              :     userDataBox.end,
     225              :     BOX_TYPES.META_DATA
     226              :   )
     227            6 :   if (!metaBox) return metadata
     228              : 
     229            6 :   const metaContentStart = metaBox.start + SIZES.VERSION
     230            6 :   const keysBox = findIsobmffBoxByType(
     231              :     data,
     232              :     metaContentStart,
     233              :     metaBox.end,
     234              :     BOX_TYPES.KEYS
     235              :   )
     236            6 :   if (!keysBox) return metadata
     237              : 
     238            6 :   const keysMap = parseKeysBox(data, keysBox.start, keysBox.end)
     239            6 :   if (keysMap.size === 0) return metadata // keys box is empty or failed to parse
     240              : 
     241            6 :   const ilstBox = findIsobmffBoxByType(
     242              :     data,
     243              :     metaContentStart,
     244              :     metaBox.end,
     245              :     BOX_TYPES.ITEM_LIST
     246              :   )
     247            6 :   if (!ilstBox) return metadata
     248              : 
     249            6 :   parseIlstBox(data, ilstBox.start, ilstBox.end, keysMap, metadata)
     250              : 
     251            6 :   return metadata
     252              : }
     253              : 
     254              : /**
     255              :  * Extracts ComfyUI Workflow metadata from an ISO Base Media File Format (ISOBMFF) file
     256              :  * (e.g., MP4, MOV) by parsing the `udta.meta.keys` and `udta.meta.ilst` boxes.
     257              :  * @param file - The file to extract metadata from.
     258              :  */
     259            6 : export async function getFromIsobmffFile(file: File): Promise<ComfyMetadata> {
     260            6 :   const buffer = await readFileAsArrayBuffer(file, MAX_READ_BYTES)
     261            6 :   if (!buffer) return {}
     262              : 
     263            6 :   try {
     264            6 :     return parseIsobmffMetadata(new Uint8Array(buffer))
     265              :   } catch (e) {
     266            0 :     console.error('Parser: Error parsing ISOBMFF metadata:', e)
     267            0 :     return {}
     268              :   }
     269              : }
        

Generated by: LCOV version 2.0-1