LCOV - code coverage report
Current view: top level - src/scripts/metadata - ebml.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 94.7 % 133 126
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              :   ComfyMetadata,
       8              :   EbmlElementRange,
       9              :   EbmlTagPosition,
      10              :   TextRange,
      11              :   VInt
      12              : } from '@/types/metadataTypes'
      13              : import { readFileAsArrayBuffer } from '@/utils/fileUtil'
      14              : import { parseJsonWithNonFinite } from '@/utils/jsonUtil'
      15              : 
      16         2356 : const WEBM_SIGNATURE = [0x1a, 0x45, 0xdf, 0xa3]
      17         2356 : const MAX_READ_BYTES = 2 * 1024 * 1024
      18         2356 : const EBML_ID = {
      19              :   SIMPLE_TAG: new Uint8Array([0x67, 0xc8]),
      20              :   TAG_NAME: new Uint8Array([0x45, 0xa3]),
      21              :   TAG_VALUE: new Uint8Array([0x44, 0x87])
      22              : }
      23         2356 : const ASCII = {
      24              :   OPEN_BRACE: 0x7b,
      25              :   NULL: 0,
      26              :   PRINTABLE_MIN: 32,
      27              :   PRINTABLE_MAX: 126
      28              : }
      29         2356 : const MASK = {
      30              :   MSB: 0x80,
      31              :   ALL_BITS_SET: -1
      32              : }
      33              : 
      34         2356 : const hasWebmSignature = (data: Uint8Array): boolean =>
      35              :   WEBM_SIGNATURE.every((byte, index) => data[index] === byte)
      36              : 
      37         2356 : const readVint = (data: Uint8Array, pos: number): VInt | null => {
      38           33 :   if (pos >= data.length) return null
      39              : 
      40           33 :   const byte = data[pos]
      41              : 
      42              :   // Fast path for common case (1-byte vint)
      43           33 :   if ((byte & MASK.MSB) === MASK.MSB) {
      44           29 :     return { value: byte & ~MASK.MSB, length: 1 }
      45              :   }
      46              : 
      47            4 :   const length = findFirstSetBitPosition(byte)
      48           33 :   if (length === 0 || pos + length > data.length) {
      49            0 :     return null
      50              :   }
      51              : 
      52            4 :   return {
      53              :     value: calculateVintValue(data, pos, length),
      54              :     length
      55              :   }
      56              : }
      57              : 
      58         2356 : const calculateVintValue = (
      59              :   data: Uint8Array,
      60              :   pos: number,
      61              :   length: number
      62              : ): number => {
      63            4 :   let value = data[pos] & (0xff >> length)
      64              : 
      65            4 :   for (let i = 1; i < length; i++) {
      66            4 :     value = (value << 8) | data[pos + i]
      67              :   }
      68              : 
      69            4 :   const allBitsSet = Math.pow(2, 7 * length) - 1
      70            4 :   return value === allBitsSet ? MASK.ALL_BITS_SET : value
      71              : }
      72              : 
      73         2356 : const findFirstSetBitPosition = (byte: number): number => {
      74            4 :   for (let mask = MASK.MSB, position = 1; mask !== 0; mask >>= 1, position++) {
      75            8 :     if ((byte & mask) !== 0) return position
      76              :   }
      77            0 :   return 0
      78              : }
      79              : 
      80         2356 : const matchesId = (data: Uint8Array, pos: number, id: Uint8Array): boolean => {
      81         8245 :   if (pos + id.length > data.length) return false
      82              : 
      83         8245 :   for (let i = 0; i < id.length; i++) {
      84         8304 :     if (data[pos + i] !== id[i]) return false
      85              :   }
      86              : 
      87           33 :   return true
      88              : }
      89              : 
      90         2356 : const findNextTag = (
      91              :   data: Uint8Array,
      92              :   pos: number
      93              : ): { tagEnd: number; contents: EbmlTagPosition | null } | null => {
      94         8111 :   if (!matchesId(data, pos, EBML_ID.SIMPLE_TAG)) return null
      95              : 
      96           11 :   const tagSize = readVint(data, pos + 2)
      97         8111 :   if (!tagSize || tagSize.value <= 0) return null
      98              : 
      99           11 :   const tagEnd = pos + 2 + tagSize.length + tagSize.value
     100         8111 :   if (tagEnd > data.length) return null
     101              : 
     102              :   const contents = extractTagContents(data, pos + 2 + tagSize.length, tagEnd)
     103           11 :   return { tagEnd, contents }
     104              : }
     105              : 
     106         2356 : const extractTagContents = (
     107              :   data: Uint8Array,
     108              :   start: number,
     109              :   end: number
     110              : ): EbmlTagPosition | null => {
     111           11 :   const nameInfo = findElementsInTag(data, start, end, EBML_ID.TAG_NAME)
     112           11 :   const valueInfo = findElementsInTag(data, start, end, EBML_ID.TAG_VALUE)
     113              : 
     114           11 :   if (!nameInfo || !valueInfo) return null
     115              : 
     116           11 :   return {
     117              :     name: nameInfo,
     118              :     value: valueInfo
     119              :   }
     120              : }
     121              : 
     122         2356 : const findElementsInTag = (
     123              :   data: Uint8Array,
     124              :   start: number,
     125              :   end: number,
     126              :   id: Uint8Array
     127              : ): EbmlElementRange | null => {
     128           22 :   for (let pos = start; pos < end - 1;) {
     129          134 :     if (matchesId(data, pos, id)) {
     130           22 :       const size = readVint(data, pos + 2)
     131           22 :       if (size && size.value > 0) {
     132              :         const elementPos = pos + 2 + size.length
     133           22 :         return { pos: elementPos, len: size.value }
     134              :       }
     135              :     }
     136          112 :     pos++
     137              :   }
     138              : 
     139            0 :   return null
     140              : }
     141              : 
     142         2356 : const processTagContents = (
     143              :   data: Uint8Array,
     144              :   contents: EbmlTagPosition,
     145              :   meta: ComfyMetadata
     146              : ) => {
     147           11 :   try {
     148           11 :     const name = extractEbmlTagName(data, contents.name.pos, contents.name.len)
     149           11 :     if (!name) return
     150              : 
     151           11 :     const value = extractEbmlTagValue(
     152              :       data,
     153              :       name,
     154              :       contents.value.pos,
     155              :       contents.value.len
     156              :     )
     157           11 :     if (value !== null) {
     158           11 :       meta[name.toLowerCase()] = value
     159              :     }
     160              :   } catch {
     161              :     // Silently continue on error
     162              :   }
     163              : }
     164              : 
     165         2356 : const extractEbmlTagValue = (
     166              :   data: Uint8Array,
     167              :   name: string,
     168              :   pos: number,
     169              :   len: number
     170              : ): string | ComfyWorkflowJSON | ComfyApiWorkflow | null => {
     171           11 :   if (
     172              :     name === ComfyMetadataTags.PROMPT ||
     173              :     name === ComfyMetadataTags.WORKFLOW
     174              :   ) {
     175            5 :     return readJson(data, pos, len)
     176              :   }
     177              : 
     178            6 :   return ebmlToString(data, pos, len)
     179              : }
     180              : 
     181         2356 : const extractEbmlTagName = (
     182              :   data: Uint8Array,
     183              :   start: number,
     184              :   length: number
     185              : ): string | null => {
     186           11 :   if (length <= 0) return null
     187              : 
     188           11 :   const textRange = findReadableTextRange(data, start, length)
     189           11 :   if (!textRange) return null
     190              : 
     191           11 :   return new TextDecoder()
     192              :     .decode(data.subarray(textRange.start, textRange.end))
     193              :     .trim()
     194              : }
     195              : 
     196         2356 : const findReadableTextRange = (
     197              :   data: Uint8Array,
     198              :   start: number,
     199              :   length: number
     200              : ): TextRange | null => {
     201           11 :   const isPrintableAscii = (byte: number) =>
     202              :     byte >= ASCII.PRINTABLE_MIN && byte <= ASCII.PRINTABLE_MAX
     203              : 
     204           11 :   let textStart = start
     205           11 :   while (textStart < start + length && !isPrintableAscii(data[textStart])) {
     206            0 :     textStart++
     207              :   }
     208              : 
     209           11 :   if (textStart >= start + length) return null
     210              : 
     211           11 :   let textEnd = textStart
     212           11 :   while (textEnd < start + length && data[textEnd] !== ASCII.NULL) {
     213           79 :     textEnd++
     214              :   }
     215              : 
     216           11 :   return { start: textStart, end: textEnd }
     217              : }
     218              : 
     219         2356 : const readJson = (
     220              :   data: Uint8Array,
     221              :   start: number,
     222              :   length: number
     223              : ): ComfyWorkflowJSON | ComfyApiWorkflow | null => {
     224            5 :   if (length <= 0) return null
     225              : 
     226            5 :   const nullTerminatorPos = findNullTerminator(data, start, length)
     227            5 :   const jsonStartPos = findJsonStart(data, start, nullTerminatorPos - start)
     228              : 
     229            5 :   if (jsonStartPos === null) return null
     230              : 
     231              :   const jsonText = decodeJsonText(data, jsonStartPos, nullTerminatorPos)
     232            5 :   return parseJsonText(jsonText)
     233              : }
     234              : 
     235         2356 : const decodeJsonText = (
     236              :   data: Uint8Array,
     237              :   start: number,
     238              :   end: number
     239              : ): string => {
     240            5 :   return new TextDecoder().decode(data.subarray(start, end))
     241              : }
     242              : 
     243         2356 : const parseJsonText = (
     244              :   jsonText: string
     245              : ): ComfyWorkflowJSON | ComfyApiWorkflow | null => {
     246            5 :   const jsonEndPos = findJsonEnd(jsonText)
     247            5 :   if (jsonEndPos === null) return null
     248              : 
     249            5 :   try {
     250            5 :     return parseJsonWithNonFinite<ComfyWorkflowJSON | ComfyApiWorkflow>(
     251              :       jsonText.substring(0, jsonEndPos)
     252              :     )
     253              :   } catch {
     254            0 :     return null
     255              :   }
     256              : }
     257              : 
     258         2356 : const findNullTerminator = (
     259              :   data: Uint8Array,
     260              :   start: number,
     261              :   maxLength: number
     262              : ): number => {
     263           11 :   const end = Math.min(start + maxLength, data.length)
     264              : 
     265           11 :   for (let pos = start; pos < end; pos++) {
     266          826 :     if (data[pos] === ASCII.NULL) return pos
     267              :   }
     268              : 
     269            8 :   return end
     270              : }
     271              : 
     272         2356 : const findJsonStart = (
     273              :   data: Uint8Array,
     274              :   start: number,
     275              :   length: number
     276              : ): number | null => {
     277            5 :   for (let pos = start; pos < start + length; pos++) {
     278            5 :     if (data[pos] === ASCII.OPEN_BRACE) return pos
     279              :   }
     280              : 
     281            0 :   return null
     282              : }
     283              : 
     284         2356 : const findJsonEnd = (text: string): number | null => {
     285            5 :   let braceCount = 1
     286            5 :   let pos = 1 // Start after the opening brace
     287              : 
     288            5 :   while (braceCount > 0 && pos < text.length) {
     289          727 :     if (text[pos] === '{') braceCount++
     290          727 :     if (text[pos] === '}') braceCount--
     291          727 :     pos++
     292              :   }
     293              : 
     294            5 :   return braceCount === 0 ? pos : null
     295              : }
     296              : 
     297         2356 : const ebmlToString = (
     298              :   data: Uint8Array,
     299              :   start: number,
     300              :   length: number
     301              : ): string => {
     302            6 :   if (length <= 0) return ''
     303              : 
     304            6 :   const endPos = findNullTerminator(data, start, length)
     305            6 :   return new TextDecoder().decode(data.subarray(start, endPos)).trim()
     306              : }
     307              : 
     308         2356 : const parseMetadata = (data: Uint8Array): ComfyMetadata => {
     309            3 :   const meta: ComfyMetadata = {}
     310              : 
     311            3 :   for (let pos = 0; pos < data.length - 2;) {
     312         8111 :     const tagInfo = findNextTag(data, pos)
     313         8111 :     if (!tagInfo) {
     314         8100 :       pos++
     315         8100 :       continue
     316              :     }
     317              : 
     318           11 :     const { tagEnd, contents } = tagInfo
     319           11 :     if (contents) {
     320           11 :       processTagContents(data, contents, meta)
     321              :     }
     322              : 
     323           11 :     pos = tagEnd
     324              :   }
     325              : 
     326            3 :   return meta
     327              : }
     328              : 
     329         2356 : const parseWebmBuffer = (buffer: ArrayBuffer): ComfyMetadata => {
     330            3 :   try {
     331            3 :     const data = new Uint8Array(buffer)
     332            3 :     if (data.length < 4 || !hasWebmSignature(data)) return {}
     333              : 
     334            3 :     return parseMetadata(data)
     335              :   } catch {
     336            0 :     return {}
     337              :   }
     338              : }
     339              : 
     340              : /**
     341              :  * Extracts ComfyUI Workflow metadata from a WebM file
     342              :  * @param file - The WebM file to extract metadata from
     343              :  */
     344            3 : export async function getFromWebmFile(file: File): Promise<ComfyMetadata> {
     345            3 :   const buffer = await readFileAsArrayBuffer(file, MAX_READ_BYTES)
     346            3 :   if (!buffer) return {}
     347              : 
     348            3 :   return parseWebmBuffer(buffer)
     349              : }
        

Generated by: LCOV version 2.0-1