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