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 : }
|