Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

feat(upload-service):add-xmp-support

Aswin Asok98aa0b0134b6
diff --git a/web/apps/photos/src/services/upload-manager.ts b/web/apps/photos/src/services/upload-manager.ts
index 8830c2f213..f2d679dd05 100644
--- a/web/apps/photos/src/services/upload-manager.ts
+++ b/web/apps/photos/src/services/upload-manager.ts
@@ -21,7 +21,9 @@ import {
import {
matchJSONMetadata,
metadataJSONMapKeyForJSON,
+ metadataJSONMapKeyForXMP,
tryParseTakeoutMetadataJSON,
+ tryParseXMPSidecar,
type ParsedMetadataJSON,
} from "ente-gallery/services/upload/metadata-json";
import UploadService, {
@@ -493,18 +495,14 @@ class UploadManager {
for (const item of items) {
this.abortIfCancelled();
- const { uploadItem, pathPrefix, fileName, collectionID } = item;
- log.info(`Parsing metadata JSON ${fileName}`);
- const metadataJSON = await tryParseTakeoutMetadataJSON(uploadItem!);
- if (metadataJSON) {
- const key = metadataJSONMapKeyForJSON(
- pathPrefix,
- collectionID,
- fileName,
- );
- this.parsedMetadataJSONMap.set(key, metadataJSON);
- this.uiService.increaseFileUploaded();
+ log.info(`Parsing metadata ${item.fileName}`);
+ const parsedMetadata = await tryParseMetadataItem(item);
+ if (parsedMetadata) {
+ const [key, metadata, isJSON] = parsedMetadata;
+ if (isJSON || !this.parsedMetadataJSONMap.has(key))
+ this.parsedMetadataJSONMap.set(key, metadata);
}
+ this.uiService.increaseFileUploaded();
}
}
@@ -699,6 +697,26 @@ const makeUploadItemWithCollectionIDAndName = (
externalParsedMetadata: f.externalParsedMetadata,
});
+const tryParseMetadataItem = async (
+ item: UploadItemWithCollectionIDAndName,
+) => {
+ const { uploadItem, pathPrefix, collectionID, fileName } = item;
+ const extension = lowercaseExtension(fileName);
+ const metadata =
+ extension == "json"
+ ? await tryParseTakeoutMetadataJSON(uploadItem!)
+ : extension == "xmp"
+ ? await tryParseXMPSidecar(uploadItem!)
+ : undefined;
+ if (!metadata) return undefined;
+
+ const key =
+ extension == "json"
+ ? metadataJSONMapKeyForJSON(pathPrefix, collectionID, fileName)
+ : metadataJSONMapKeyForXMP(pathPrefix, collectionID, fileName);
+ return [key, metadata, extension == "json"] as const;
+};
+
const splitMetadataAndMediaItems = (
items: UploadItemWithCollectionIDAndName[],
): [
@@ -707,7 +725,8 @@ const splitMetadataAndMediaItems = (
] =>
items.reduce(
([metadata, media], f) => {
- if (lowercaseExtension(f.fileName) == "json") metadata.push(f);
+ if (["json", "xmp"].includes(lowercaseExtension(f.fileName) ?? ""))
+ metadata.push(f);
else media.push(f);
return [metadata, media];
},
@@ -794,27 +813,22 @@ export const uploadableMediaCount = async (
);
const [metadataItems, mediaItems] = splitMetadataAndMediaItems(namedItems);
const parsedMetadataJSONMap = new Map<string, ParsedMetadataJSON>();
-
- for (const {
- uploadItem,
- pathPrefix,
- collectionID,
- fileName,
- } of metadataItems) {
- const metadataJSON = await tryParseTakeoutMetadataJSON(uploadItem!);
- if (metadataJSON) {
- parsedMetadataJSONMap.set(
- metadataJSONMapKeyForJSON(pathPrefix, collectionID, fileName),
- metadataJSON,
- );
+ let parsedJSONCount = 0;
+
+ for (const item of metadataItems) {
+ const parsedMetadata = await tryParseMetadataItem(item);
+ if (parsedMetadata) {
+ const [key, metadata, isJSON] = parsedMetadata;
+ if (isJSON || !parsedMetadataJSONMap.has(key))
+ parsedMetadataJSONMap.set(key, metadata);
+ if (isJSON) parsedJSONCount++;
}
}
return {
count: (await clusterLivePhotos(mediaItems, parsedMetadataJSONMap))
.length,
- // Metadata sidecars identify a Takeout import.
- isTakeout: parsedMetadataJSONMap.size > 0,
+ isTakeout: parsedJSONCount > 0,
};
};
diff --git a/web/packages/gallery/services/upload/metadata-json.ts b/web/packages/gallery/services/upload/metadata-json.ts
index ce54d7a88e..cb9c6838e1 100644
--- a/web/packages/gallery/services/upload/metadata-json.ts
+++ b/web/packages/gallery/services/upload/metadata-json.ts
@@ -2,14 +2,21 @@ import { ensureElectron } from "ente-base/electron";
import { nameAndExtension } from "ente-base/file-name";
import log from "ente-base/log";
import type { Location } from "ente-base/types";
+import {
+ extractRawExif,
+ parseExif,
+ type RawExifTags,
+} from "ente-gallery/services/exif";
import type {
UploadItem,
UploadPathPrefix,
} from "ente-gallery/services/upload";
import { readStream } from "ente-gallery/utils/native-stream";
+import type { ParsedMetadataDate } from "ente-media/file-metadata";
export interface ParsedMetadataJSON {
creationTime?: number;
+ creationDate?: ParsedMetadataDate;
modificationTime?: number;
location?: Location;
description?: string;
@@ -28,6 +35,17 @@ export const metadataJSONMapKeyForJSON = (
jsonFileName.slice(0, -1 * ".json".length),
);
+export const metadataJSONMapKeyForXMP = (
+ pathPrefix: UploadPathPrefix | undefined,
+ collectionID: number,
+ xmpFileName: string,
+) =>
+ makeKey3(
+ pathPrefix,
+ collectionID,
+ `${nameAndExtension(xmpFileName)[0]}.xmp`,
+ );
+
const makeKey3 = (
pathPrefix: UploadPathPrefix | undefined,
collectionID: number,
@@ -93,9 +111,39 @@ export const matchJSONMetadata = (
const originalBaseFileName = `${originalName}${extension}${supplSuffix}`;
key = makeKey(originalBaseFileName.slice(0, maxGoogleFileNameLength));
takeoutMetadata = parsedMetadataJSONMap.get(key);
+ if (takeoutMetadata) return takeoutMetadata;
}
- return takeoutMetadata;
+ // XMP sidecars use a source-specific suffix.
+ return parsedMetadataJSONMap.get(makeKey(`${originalName}.xmp`));
+};
+
+export const parseXMPSidecarTags = (
+ tags: RawExifTags,
+): ParsedMetadataJSON | undefined => {
+ const { creationDate, description } = parseExif(tags);
+ const parseCoordinate = (value: string | undefined) => {
+ const match = /^(\d+(?:\.\d+)?)([NSEW])$/.exec(value ?? "");
+ if (!match) return undefined;
+
+ const coordinate = Number(match[1]);
+ return match[2] == "S" || match[2] == "W" ? -coordinate : coordinate;
+ };
+ const latitude = parseCoordinate(tags.xmp?.GPSLatitude?.description);
+ const longitude = parseCoordinate(tags.xmp?.GPSLongitude?.description);
+ const location =
+ latitude != undefined && longitude != undefined
+ ? { latitude, longitude }
+ : undefined;
+
+ if (!creationDate && !location && !description) return undefined;
+
+ return {
+ creationDate,
+ creationTime: creationDate?.timestamp,
+ location,
+ description,
+ };
};
export const tryParseTakeoutMetadataJSON = async (
@@ -109,6 +157,18 @@ export const tryParseTakeoutMetadataJSON = async (
}
};
+export const tryParseXMPSidecar = async (
+ uploadItem: UploadItem,
+): Promise<ParsedMetadataJSON | undefined> => {
+ try {
+ const text = await uploadItemText(uploadItem);
+ return parseXMPSidecarTags(await extractRawExif(new Blob([text])));
+ } catch (e) {
+ log.error("Failed to parse XMP sidecar", e);
+ return undefined;
+ }
+};
+
export const tryParseTakeoutAlbumNameMetadataJSON = async (
uploadItem: UploadItem,
): Promise<string | undefined> => {
diff --git a/web/packages/gallery/services/upload/upload-service.ts b/web/packages/gallery/services/upload/upload-service.ts
index a2d80c2e00..15aa7e5067 100644
--- a/web/packages/gallery/services/upload/upload-service.ts
+++ b/web/packages/gallery/services/upload/upload-service.ts
@@ -879,14 +879,19 @@ const extractImageOrVideoMetadata = async (
const modificationTime =
parsedMetadataJSON?.modificationTime ?? lastModifiedMs * 1000;
+ const creationDate =
+ parsedMetadataJSON?.creationDate ??
+ (parsedMetadataJSON?.creationTime
+ ? undefined
+ : parsedMetadata?.creationDate);
let creationTime: number;
- if (parsedMetadataJSON?.creationTime) {
- creationTime = parsedMetadataJSON.creationTime;
- } else if (parsedMetadata?.creationDate) {
- const { dateTime, offset, timestamp } = parsedMetadata.creationDate;
+ if (creationDate) {
+ const { dateTime, offset, timestamp } = creationDate;
creationTime = timestamp;
publicMagicMetadata.dateTime = dateTime;
if (offset) publicMagicMetadata.offsetTime = offset;
+ } else if (parsedMetadataJSON?.creationTime) {
+ creationTime = parsedMetadataJSON.creationTime;
} else if (parsedMetadata?.creationTime) {
creationTime = parsedMetadata.creationTime;
} else {