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