335 lines
10 KiB
TypeScript
335 lines
10 KiB
TypeScript
import type { ExifStatus, GeoPoint, PhotoMetadata } from "./types";
|
|
|
|
type ByteOrder = "LE" | "BE";
|
|
|
|
type IfdEntry = {
|
|
type: number;
|
|
count: number;
|
|
valueOffset: number;
|
|
entryOffset: number;
|
|
};
|
|
|
|
const JPEG_START = 0xffd8;
|
|
const APP1_MARKER = 0xe1;
|
|
const EXIF_IFD_POINTER = 0x8769;
|
|
const GPS_IFD_POINTER = 0x8825;
|
|
const DATE_TIME = 0x0132;
|
|
const DATE_TIME_ORIGINAL = 0x9003;
|
|
const DATE_TIME_DIGITIZED = 0x9004;
|
|
|
|
const typeByteLength = (type: number) => {
|
|
if (type === 1 || type === 2 || type === 7) return 1;
|
|
if (type === 3) return 2;
|
|
if (type === 4 || type === 9) return 4;
|
|
if (type === 5 || type === 10) return 8;
|
|
return 0;
|
|
};
|
|
|
|
/**
|
|
* JPEG EXIF TIFF 블록을 읽는 범위 제한 reader이다.
|
|
* 손상된 offset이 파일 범위를 벗어나면 예외를 발생시켜 수동 입력 흐름으로 전환한다.
|
|
*/
|
|
class TiffReader {
|
|
private readonly view: DataView;
|
|
private readonly tiffStart: number;
|
|
private readonly order: ByteOrder;
|
|
|
|
constructor(buffer: ArrayBuffer, tiffStart: number) {
|
|
this.view = new DataView(buffer);
|
|
this.tiffStart = tiffStart;
|
|
this.ensureRange(tiffStart, 8);
|
|
|
|
const byteOrder = this.view.getUint16(tiffStart, false);
|
|
if (byteOrder === 0x4949) {
|
|
this.order = "LE";
|
|
} else if (byteOrder === 0x4d4d) {
|
|
this.order = "BE";
|
|
} else {
|
|
throw new Error("지원하지 않는 TIFF 바이트 순서입니다.");
|
|
}
|
|
|
|
if (this.uint16(2) !== 0x002a) {
|
|
throw new Error("유효한 TIFF 헤더가 아닙니다.");
|
|
}
|
|
}
|
|
|
|
private get littleEndian() {
|
|
return this.order === "LE";
|
|
}
|
|
|
|
private absolute(relativeOffset: number) {
|
|
return this.tiffStart + relativeOffset;
|
|
}
|
|
|
|
private ensureRange(absoluteOffset: number, byteLength: number) {
|
|
if (
|
|
absoluteOffset < 0 ||
|
|
byteLength < 0 ||
|
|
absoluteOffset + byteLength > this.view.byteLength
|
|
) {
|
|
throw new Error("EXIF offset이 파일 범위를 벗어났습니다.");
|
|
}
|
|
}
|
|
|
|
uint16(relativeOffset: number) {
|
|
const absoluteOffset = this.absolute(relativeOffset);
|
|
this.ensureRange(absoluteOffset, 2);
|
|
return this.view.getUint16(absoluteOffset, this.littleEndian);
|
|
}
|
|
|
|
uint32(relativeOffset: number) {
|
|
const absoluteOffset = this.absolute(relativeOffset);
|
|
this.ensureRange(absoluteOffset, 4);
|
|
return this.view.getUint32(absoluteOffset, this.littleEndian);
|
|
}
|
|
|
|
private readIfd(relativeOffset: number) {
|
|
const entryCount = this.uint16(relativeOffset);
|
|
const entries = new Map<number, IfdEntry>();
|
|
|
|
for (let index = 0; index < entryCount; index += 1) {
|
|
const entryOffset = relativeOffset + 2 + index * 12;
|
|
const tag = this.uint16(entryOffset);
|
|
const type = this.uint16(entryOffset + 2);
|
|
const count = this.uint32(entryOffset + 4);
|
|
const valueOffset = this.uint32(entryOffset + 8);
|
|
entries.set(tag, { type, count, valueOffset, entryOffset });
|
|
}
|
|
|
|
return entries;
|
|
}
|
|
|
|
private dataRelativeOffset(entry: IfdEntry) {
|
|
const byteLength = typeByteLength(entry.type) * entry.count;
|
|
if (byteLength <= 4) return entry.entryOffset + 8;
|
|
return entry.valueOffset;
|
|
}
|
|
|
|
private ascii(entry: IfdEntry) {
|
|
const relativeOffset = this.dataRelativeOffset(entry);
|
|
const absoluteOffset = this.absolute(relativeOffset);
|
|
const byteLength = typeByteLength(entry.type) * entry.count;
|
|
this.ensureRange(absoluteOffset, byteLength);
|
|
|
|
const bytes = new Uint8Array(this.view.buffer, absoluteOffset, byteLength);
|
|
return new TextDecoder("ascii").decode(bytes).replace(/\0+$/g, "").trim();
|
|
}
|
|
|
|
private rational(relativeOffset: number) {
|
|
const numerator = this.uint32(relativeOffset);
|
|
const denominator = this.uint32(relativeOffset + 4);
|
|
if (denominator === 0) return null;
|
|
return numerator / denominator;
|
|
}
|
|
|
|
private rationals(entry: IfdEntry) {
|
|
const relativeOffset = this.dataRelativeOffset(entry);
|
|
const values: number[] = [];
|
|
for (let index = 0; index < entry.count; index += 1) {
|
|
const value = this.rational(relativeOffset + index * 8);
|
|
if (value === null) return null;
|
|
values.push(value);
|
|
}
|
|
return values;
|
|
}
|
|
|
|
private pointer(entry: IfdEntry | undefined) {
|
|
if (!entry || entry.type !== 4 || entry.count !== 1) return null;
|
|
return entry.valueOffset;
|
|
}
|
|
|
|
private parseDate(value: string | null) {
|
|
if (!value) return null;
|
|
const match = value.match(
|
|
/^(\d{4}):(\d{2}):(\d{2})[ T](\d{2}):(\d{2}):(\d{2})/,
|
|
);
|
|
if (!match) return null;
|
|
|
|
const [, year, month, day, hour, minute, second] = match;
|
|
if (!year || !month || !day || !hour || !minute || !second) return null;
|
|
|
|
const monthNumber = Number(month);
|
|
const dayNumber = Number(day);
|
|
const hourNumber = Number(hour);
|
|
const minuteNumber = Number(minute);
|
|
const secondNumber = Number(second);
|
|
if (
|
|
monthNumber < 1 ||
|
|
monthNumber > 12 ||
|
|
dayNumber < 1 ||
|
|
dayNumber > 31 ||
|
|
hourNumber > 23 ||
|
|
minuteNumber > 59 ||
|
|
secondNumber > 59
|
|
) {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
capturedAt: `${year}-${month}-${day}T${hour}:${minute}:${second}`,
|
|
dredgingDate: `${year}-${month}-${day}`,
|
|
};
|
|
}
|
|
|
|
private parseGps(entries: Map<number, IfdEntry>): GeoPoint | null {
|
|
const latitudeRefEntry = entries.get(0x0001);
|
|
const latitudeEntry = entries.get(0x0002);
|
|
const longitudeRefEntry = entries.get(0x0003);
|
|
const longitudeEntry = entries.get(0x0004);
|
|
if (
|
|
!latitudeRefEntry ||
|
|
!latitudeEntry ||
|
|
!longitudeRefEntry ||
|
|
!longitudeEntry
|
|
) {
|
|
return null;
|
|
}
|
|
|
|
const latitudeRef = this.ascii(latitudeRefEntry).toUpperCase();
|
|
const longitudeRef = this.ascii(longitudeRefEntry).toUpperCase();
|
|
const latitudeDms = this.rationals(latitudeEntry);
|
|
const longitudeDms = this.rationals(longitudeEntry);
|
|
if (
|
|
!latitudeDms ||
|
|
latitudeDms.length < 3 ||
|
|
!longitudeDms ||
|
|
longitudeDms.length < 3
|
|
) {
|
|
return null;
|
|
}
|
|
|
|
const toDecimal = (values: number[]) =>
|
|
(values[0] ?? 0) + (values[1] ?? 0) / 60 + (values[2] ?? 0) / 3600;
|
|
|
|
let latitude = toDecimal(latitudeDms);
|
|
let longitude = toDecimal(longitudeDms);
|
|
if (latitudeRef === "S") latitude *= -1;
|
|
if (longitudeRef === "W") longitude *= -1;
|
|
|
|
if (
|
|
!Number.isFinite(latitude) ||
|
|
!Number.isFinite(longitude) ||
|
|
latitude < -90 ||
|
|
latitude > 90 ||
|
|
longitude < -180 ||
|
|
longitude > 180
|
|
) {
|
|
return null;
|
|
}
|
|
|
|
return { latitude, longitude };
|
|
}
|
|
|
|
parse() {
|
|
const ifd0Offset = this.uint32(4);
|
|
const ifd0 = this.readIfd(ifd0Offset);
|
|
|
|
const exifIfdOffset = this.pointer(ifd0.get(EXIF_IFD_POINTER));
|
|
const exifIfd = exifIfdOffset === null ? null : this.readIfd(exifIfdOffset);
|
|
const gpsIfdOffset = this.pointer(ifd0.get(GPS_IFD_POINTER));
|
|
const gpsIfd = gpsIfdOffset === null ? null : this.readIfd(gpsIfdOffset);
|
|
|
|
const dateValue =
|
|
(exifIfd?.get(DATE_TIME_ORIGINAL)
|
|
? this.ascii(exifIfd.get(DATE_TIME_ORIGINAL)!)
|
|
: null) ??
|
|
(exifIfd?.get(DATE_TIME_DIGITIZED)
|
|
? this.ascii(exifIfd.get(DATE_TIME_DIGITIZED)!)
|
|
: null) ??
|
|
(ifd0.get(DATE_TIME) ? this.ascii(ifd0.get(DATE_TIME)!) : null);
|
|
|
|
return {
|
|
date: this.parseDate(dateValue),
|
|
location: gpsIfd ? this.parseGps(gpsIfd) : null,
|
|
};
|
|
}
|
|
}
|
|
|
|
const toMetadata = (
|
|
capturedAt: string | null,
|
|
dredgingDate: string | null,
|
|
location: GeoPoint | null,
|
|
unsupported = false,
|
|
): PhotoMetadata => {
|
|
let status: ExifStatus;
|
|
let message: string;
|
|
|
|
if (unsupported) {
|
|
status = "UNSUPPORTED";
|
|
message = "JPEG EXIF가 없어 준설일자와 위치를 직접 입력해야 합니다.";
|
|
} else if (dredgingDate && location) {
|
|
status = "COMPLETE";
|
|
message = "촬영일자와 GPS를 확인했습니다.";
|
|
} else if (!dredgingDate && !location) {
|
|
status = "MISSING_BOTH";
|
|
message = "촬영일자와 GPS가 없어 수동 입력이 필요합니다.";
|
|
} else if (!dredgingDate) {
|
|
status = "MISSING_DATE";
|
|
message = "촬영일자가 없어 준설일자를 직접 입력해야 합니다.";
|
|
} else {
|
|
status = "MISSING_GPS";
|
|
message = "GPS가 없어 지도에서 준설위치를 등록해야 합니다.";
|
|
}
|
|
|
|
return { capturedAt, dredgingDate, location, status, message };
|
|
};
|
|
|
|
/**
|
|
* 브라우저에서 즉시 보여 줄 JPEG EXIF 미리보기를 만든다.
|
|
* 서버는 저장 시 원본 첨부파일을 기준으로 동일 정보를 다시 검증해야 한다.
|
|
*/
|
|
export const readPhotoMetadata = async (file: File): Promise<PhotoMetadata> => {
|
|
if (file.type !== "image/jpeg" && !/\.jpe?g$/i.test(file.name)) {
|
|
return toMetadata(null, null, null, true);
|
|
}
|
|
|
|
try {
|
|
const buffer = await file.arrayBuffer();
|
|
const view = new DataView(buffer);
|
|
if (view.byteLength < 4 || view.getUint16(0, false) !== JPEG_START) {
|
|
return toMetadata(null, null, null, true);
|
|
}
|
|
|
|
let offset = 2;
|
|
while (offset + 4 <= view.byteLength) {
|
|
if (view.getUint8(offset) !== 0xff) break;
|
|
|
|
const marker = view.getUint8(offset + 1);
|
|
if (marker === 0xda || marker === 0xd9) break;
|
|
|
|
const segmentLength = view.getUint16(offset + 2, false);
|
|
if (segmentLength < 2 || offset + 2 + segmentLength > view.byteLength) {
|
|
break;
|
|
}
|
|
|
|
if (marker === APP1_MARKER) {
|
|
const exifStart = offset + 4;
|
|
const exifSignature =
|
|
exifStart + 6 <= view.byteLength
|
|
? String.fromCharCode(
|
|
view.getUint8(exifStart),
|
|
view.getUint8(exifStart + 1),
|
|
view.getUint8(exifStart + 2),
|
|
view.getUint8(exifStart + 3),
|
|
)
|
|
: "";
|
|
|
|
if (exifSignature === "Exif") {
|
|
const parsed = new TiffReader(buffer, exifStart + 6).parse();
|
|
return toMetadata(
|
|
parsed.date?.capturedAt ?? null,
|
|
parsed.date?.dredgingDate ?? null,
|
|
parsed.location,
|
|
);
|
|
}
|
|
}
|
|
|
|
offset += 2 + segmentLength;
|
|
}
|
|
} catch (error) {
|
|
console.warn("준설 사진 EXIF 분석 실패", error);
|
|
}
|
|
|
|
return toMetadata(null, null, null, false);
|
|
};
|