exif(): read HEIF/HEIC originals with exifreader (closes #145)
check / check (push) Successful in 1m21s
check / check (push) Successful in 1m21s
photo.exif() and backup-metadata --exif read EXIF with exifreader, which reads JPEG, HEIC/HEIF, AVIF, PNG and WebP, so a HEIC original or a live photo's HEIC image gets its EXIF. exifreader replaces exif-reader and the hand-written JPEG segment scan. PhotoExif is unchanged. The exif field of backup-metadata --exif is now exifreader's tag output, and exifRaw holds the whole EXIF block it could not read. Tests use a real 933-byte HEIC fixture, test/exif.heic, whose recipe is in test/exif-heic.ts. Model: opus-5-5
This commit is contained in:
@@ -1,19 +1,24 @@
|
||||
/**
|
||||
* Tests for the JPEG EXIF scan behind `quak backup-metadata --exif`.
|
||||
* Tests for reading EXIF (`src/exif.ts`) and the image metadata
|
||||
* `quak backup-metadata --exif` records.
|
||||
*
|
||||
* The originals come from users' libraries, so a truncated or corrupt JPEG
|
||||
* must neither hang the scan nor throw out of it, and a malformed file must be
|
||||
* told apart from one that simply has no EXIF: the record carries the reason in
|
||||
* `exifError`. Each input below is a short hand-built byte array.
|
||||
* The originals come from users' libraries, so a truncated or corrupt file
|
||||
* must neither hang the read nor throw out of it: `readPhotoExif` gives `{}`,
|
||||
* and `backup-metadata` tells an EXIF block it cannot read apart from a file
|
||||
* that simply has no EXIF, carrying the reason in `exifError`. Each JPEG below
|
||||
* is a short hand-built byte array; the HEIC is a real file.
|
||||
*/
|
||||
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { extractExifFromJpeg } from "../../src/exif.js";
|
||||
import { readPhotoExif } from "../../src/exif.js";
|
||||
import { extractImageMetadata } from "../../src/metadata-backup.js";
|
||||
import { HEIC_WITH_EXIF } from "../exif-heic.js";
|
||||
|
||||
const SOI = [0xff, 0xd8]; // start of image
|
||||
const SOS = [0xff, 0xda, 0x00, 0x02]; // start of scan, where the scan stops
|
||||
const SOS = [0xff, 0xda, 0x00, 0x02]; // start of scan
|
||||
const EXIF_HEADER = [0x45, 0x78, 0x69, 0x66, 0x00, 0x00]; // "Exif\0\0"
|
||||
const APP0 = [0xff, 0xe0, 0x00, 0x04, 0x00, 0x00];
|
||||
const ZERO_LENGTH_APP0 = [0xff, 0xe0, 0x00, 0x00];
|
||||
|
||||
// A big-endian TIFF block with one IFD entry: Orientation (0x0112), SHORT, 6.
|
||||
const TIFF_ORIENTATION_6 = [
|
||||
@@ -31,74 +36,66 @@ const app1 = (data: number[]): number[] => {
|
||||
const bytes = (...parts: number[][]): Uint8Array =>
|
||||
new Uint8Array(parts.flat());
|
||||
|
||||
describe("extractExifFromJpeg", () => {
|
||||
it("returns the EXIF segment of a valid JPEG", () => {
|
||||
describe("readPhotoExif", () => {
|
||||
it("reads the common fields of a valid JPEG", () => {
|
||||
const data = [...EXIF_HEADER, ...TIFF_ORIENTATION_6];
|
||||
const scan = extractExifFromJpeg(bytes(SOI, app1(data), SOS));
|
||||
expect(scan.error).toBeUndefined();
|
||||
expect([...scan.exif!]).toEqual(data);
|
||||
expect(readPhotoExif(bytes(SOI, app1(data), SOS))).toStrictEqual({
|
||||
orientation: 6,
|
||||
});
|
||||
});
|
||||
|
||||
it("returns nothing for a file that is not a JPEG", () => {
|
||||
const png = bytes([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
|
||||
expect(extractExifFromJpeg(png)).toEqual({});
|
||||
});
|
||||
|
||||
it("returns nothing for a JPEG without EXIF", () => {
|
||||
const app0 = [0xff, 0xe0, 0x00, 0x04, 0x00, 0x00];
|
||||
expect(extractExifFromJpeg(bytes(SOI, app0, SOS))).toEqual({});
|
||||
});
|
||||
|
||||
it("ignores an APP1 segment too short to hold the Exif header", () => {
|
||||
// A length under 8 cannot hold the six-byte "Exif\0\0" header, so the
|
||||
// segment is not EXIF. This one has length 7 and holds only "Exif\0",
|
||||
// which the old code, lacking the length check, returned as EXIF.
|
||||
const short = app1(EXIF_HEADER.slice(0, 5));
|
||||
expect(extractExifFromJpeg(bytes(SOI, short, SOS))).toEqual({});
|
||||
});
|
||||
|
||||
it("accepts an APP1 segment of length 8 holding just the Exif header", () => {
|
||||
const scan = extractExifFromJpeg(bytes(SOI, app1(EXIF_HEADER), SOS));
|
||||
expect(scan.error).toBeUndefined();
|
||||
expect([...scan.exif!]).toEqual(EXIF_HEADER);
|
||||
});
|
||||
|
||||
it("reports a JPEG truncated inside a segment header", () => {
|
||||
const scan = extractExifFromJpeg(bytes(SOI, [0xff, 0xe1, 0x00]));
|
||||
expect(scan.exif).toBeUndefined();
|
||||
expect(scan.error).toMatch(/truncated segment length/);
|
||||
});
|
||||
|
||||
it("reports a JPEG that ends before the image data", () => {
|
||||
const app0 = [0xff, 0xe0, 0x00, 0x04, 0x00, 0x00];
|
||||
const scan = extractExifFromJpeg(bytes(SOI, app0));
|
||||
expect(scan.error).toMatch(/ends before the image data/);
|
||||
});
|
||||
|
||||
it("stops on a zero-length segment instead of looping", () => {
|
||||
// A length of 0 would otherwise step the scan by 2 bytes at a time
|
||||
// through the rest of the file, reading garbage as markers.
|
||||
const zero = [0xff, 0xe0, 0x00, 0x00];
|
||||
const scan = extractExifFromJpeg(
|
||||
bytes(SOI, zero, zero, zero, zero, SOS),
|
||||
);
|
||||
expect(scan.error).toMatch(/segment length 0 at byte 2 is too small/);
|
||||
});
|
||||
|
||||
it("stops on a segment length of 1", () => {
|
||||
const scan = extractExifFromJpeg(
|
||||
bytes(SOI, [0xff, 0xe0, 0x00, 0x01], SOS),
|
||||
);
|
||||
expect(scan.error).toMatch(/segment length 1 at byte 2 is too small/);
|
||||
});
|
||||
|
||||
it("reports a segment length that runs past the end of the file", () => {
|
||||
it.each([
|
||||
[
|
||||
"a file that is not an image",
|
||||
new TextEncoder().encode("just some text, not an image"),
|
||||
],
|
||||
[
|
||||
"a PNG without EXIF",
|
||||
bytes([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
|
||||
],
|
||||
["a JPEG without EXIF", bytes(SOI, APP0, SOS)],
|
||||
// A length under 8 cannot hold the six-byte "Exif\0\0" header. This one
|
||||
// has length 7 and holds only "Exif\0", so a read past its end would
|
||||
// take the next segment's bytes as EXIF.
|
||||
[
|
||||
"an APP1 segment too short to hold the Exif header",
|
||||
bytes(SOI, app1(EXIF_HEADER.slice(0, 5)), SOS),
|
||||
],
|
||||
[
|
||||
"an APP1 segment holding just the Exif header",
|
||||
bytes(SOI, app1(EXIF_HEADER), SOS),
|
||||
],
|
||||
[
|
||||
"a JPEG truncated inside a segment header",
|
||||
bytes(SOI, [0xff, 0xe1, 0x00]),
|
||||
],
|
||||
["a JPEG that ends before the image data", bytes(SOI, APP0)],
|
||||
// A length of 0 would step a scan by 2 bytes at a time through the
|
||||
// rest of the file, reading garbage as markers.
|
||||
[
|
||||
"a zero-length segment",
|
||||
bytes(
|
||||
SOI,
|
||||
ZERO_LENGTH_APP0,
|
||||
ZERO_LENGTH_APP0,
|
||||
ZERO_LENGTH_APP0,
|
||||
ZERO_LENGTH_APP0,
|
||||
SOS,
|
||||
),
|
||||
],
|
||||
["a segment length of 1", bytes(SOI, [0xff, 0xe0, 0x00, 0x01], SOS)],
|
||||
// APP1 claims 0x4000 bytes but only the "Exif\0\0" header follows.
|
||||
const scan = extractExifFromJpeg(
|
||||
[
|
||||
"a segment length that runs past the end of the file",
|
||||
bytes(SOI, [0xff, 0xe1, 0x40, 0x00], EXIF_HEADER),
|
||||
);
|
||||
expect(scan.exif).toBeUndefined();
|
||||
expect(scan.error).toMatch(/runs past the end of the file/);
|
||||
],
|
||||
// "XX" where the TIFF byte order belongs.
|
||||
[
|
||||
"an EXIF block that cannot be parsed",
|
||||
bytes(SOI, app1([...EXIF_HEADER, 0x58, 0x58]), SOS),
|
||||
],
|
||||
])("returns no fields for %s", (_, input) => {
|
||||
expect(readPhotoExif(input)).toStrictEqual({});
|
||||
});
|
||||
});
|
||||
|
||||
@@ -108,10 +105,22 @@ describe("extractImageMetadata", () => {
|
||||
bytes(SOI, app1([...EXIF_HEADER, ...TIFF_ORIENTATION_6]), SOS),
|
||||
);
|
||||
expect(meta?.exifError).toBeUndefined();
|
||||
expect(meta?.exif).toMatchObject({ Image: { Orientation: 6 } });
|
||||
expect(meta?.exif).toMatchObject({ Orientation: { value: 6 } });
|
||||
});
|
||||
|
||||
it("returns nothing for a file that is not a JPEG", () => {
|
||||
it("parses EXIF from a HEIC", () => {
|
||||
const meta = extractImageMetadata(HEIC_WITH_EXIF);
|
||||
expect(meta?.exifError).toBeUndefined();
|
||||
expect(meta?.exif).toMatchObject({
|
||||
Make: { value: ["Canon"] },
|
||||
Model: { value: ["EOS R5"] },
|
||||
DateTimeOriginal: { value: ["2021:07:15 14:30:00"] },
|
||||
Orientation: { value: 6 },
|
||||
GPSLatitudeRef: { value: ["N"] },
|
||||
});
|
||||
});
|
||||
|
||||
it("returns nothing for a file that is not an image", () => {
|
||||
const text = new TextEncoder().encode("just some text, not an image");
|
||||
expect(extractImageMetadata(text)).toBeUndefined();
|
||||
});
|
||||
@@ -121,14 +130,20 @@ describe("extractImageMetadata", () => {
|
||||
bytes(SOI, [0xff, 0xe1, 0x40, 0x00], EXIF_HEADER),
|
||||
);
|
||||
expect(meta?.exif).toBeUndefined();
|
||||
expect(meta?.exifError).toMatch(/runs past the end of the file/);
|
||||
expect(meta?.exifError).toBe(
|
||||
"no tag could be read from the EXIF block",
|
||||
);
|
||||
});
|
||||
|
||||
it("keeps the raw bytes and the reason when EXIF cannot be parsed", () => {
|
||||
const data = [...EXIF_HEADER, 0x58, 0x58];
|
||||
const meta = extractImageMetadata(bytes(SOI, app1(data), SOS));
|
||||
// The raw bytes are the whole EXIF block as exifreader finds it: for a
|
||||
// JPEG, the APP1 segment, marker and length included.
|
||||
const segment = app1([...EXIF_HEADER, 0x58, 0x58]);
|
||||
const meta = extractImageMetadata(bytes(SOI, segment, SOS));
|
||||
expect(meta?.exif).toBeUndefined();
|
||||
expect(meta?.exifRaw).toBe(Buffer.from(data).toString("base64"));
|
||||
expect(meta?.exifError).toEqual(expect.any(String));
|
||||
expect(meta?.exifRaw).toBe(Buffer.from(segment).toString("base64"));
|
||||
expect(meta?.exifError).toBe(
|
||||
"no tag could be read from the EXIF block",
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user