Skip to content

armgit / ente

Public Imported from GitHub
0

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

feat(streaming):show-precentage-progress

Aswin Asok0a7d3f93cb88
diff --git a/web/apps/photos/src/components/Sidebar.tsx b/web/apps/photos/src/components/Sidebar.tsx
index 1f6a829f56..8476e6bca3 100644
--- a/web/apps/photos/src/components/Sidebar.tsx
+++ b/web/apps/photos/src/components/Sidebar.tsx
@@ -1215,6 +1215,9 @@ const Preferences: React.FC<PreferencesProps> = ({
const hlsGenStatusSnapshot = useHLSGenerationStatusSnapshot();
const isHLSGenerationEnabled = !!hlsGenStatusSnapshot?.enabled;
+ const hlsProcessedFraction = hlsGenStatusSnapshot?.enabled
+ ? hlsGenStatusSnapshot.processedFraction
+ : undefined;
useEffect(() => {
if (open) void pullSettings();
@@ -1299,13 +1302,41 @@ const Preferences: React.FC<PreferencesProps> = ({
/>
)}
{isHLSGenerationSupported && (
- <RowButtonGroup>
- <RowSwitch
- label={t("streamable_videos")}
- checked={isHLSGenerationEnabled}
- onClick={() => void toggleHLSGeneration()}
- />
- </RowButtonGroup>
+ <Stack>
+ <RowButtonGroup>
+ <RowSwitch
+ label={t("streamable_videos")}
+ checked={isHLSGenerationEnabled}
+ onClick={() => void toggleHLSGeneration()}
+ />
+ </RowButtonGroup>
+ {isHLSGenerationEnabled && (
+ <SpacedRow sx={{ gap: 2, px: 2, pt: 2, pb: 1 }}>
+ <Typography sx={{ color: "text.faint" }}>
+ {t("processed")}
+ </Typography>
+ {hlsProcessedFraction == undefined ? (
+ <RowButtonEndActivityIndicator />
+ ) : (
+ <Typography sx={{ textAlign: "right" }}>
+ {t("percent_complete", {
+ percent: hlsProcessedFraction * 100,
+ formatParams: {
+ percent: {
+ minimumFractionDigits:
+ hlsProcessedFraction ==
+ 0
+ ? 0
+ : 2,
+ maximumFractionDigits: 2,
+ },
+ },
+ })}
+ </Typography>
+ )}
+ </SpacedRow>
+ )}
+ </Stack>
)}
</Stack>
<DomainSettings
diff --git a/web/apps/photos/tests/video-streaming-percentage.test.ts b/web/apps/photos/tests/video-streaming-percentage.test.ts
new file mode 100644
index 0000000000..742db398e8
--- /dev/null
+++ b/web/apps/photos/tests/video-streaming-percentage.test.ts
@@ -0,0 +1,208 @@
+import type { EnteFile } from "ente-media/file";
+import { FileType } from "ente-media/file-type";
+import { afterEach, describe, expect, test, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+ kv: new Map<string, unknown>(),
+ collectionFiles: [] as EnteFile[],
+ collectionFilesReadCount: 0,
+ collectionFilesReadGate: undefined as Promise<void> | undefined,
+ pulledFileIDs: new Set<number>(),
+ previewStatusPullCount: 0,
+ previewStatusPullGate: undefined as Promise<void> | undefined,
+}));
+
+vi.mock("ente-base/app", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("ente-base/app")>()),
+ isDesktop: true,
+}));
+vi.mock("ente-base/kv", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("ente-base/kv")>()),
+ getKV: (key: string) => Promise.resolve(mocks.kv.get(key)),
+ getKVB: (key: string) => Promise.resolve(mocks.kv.get(key)),
+ getKVN: (key: string) => Promise.resolve(mocks.kv.get(key)),
+ setKV: (key: string, value: unknown) => {
+ mocks.kv.set(key, value);
+ return Promise.resolve();
+ },
+}));
+vi.mock("ente-accounts/services/user", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("ente-accounts/services/user")>()),
+ ensureLocalUser: () => ({ id: 1 }),
+}));
+vi.mock("ente-new/photos/services/photos-fdb", async (importOriginal) => ({
+ ...(await importOriginal<
+ typeof import("ente-new/photos/services/photos-fdb")
+ >()),
+ savedCollectionFiles: async () => {
+ mocks.collectionFilesReadCount++;
+ await mocks.collectionFilesReadGate;
+ return mocks.collectionFiles;
+ },
+}));
+vi.mock("ente-new/photos/services/trash", async (importOriginal) => ({
+ ...(await importOriginal<
+ typeof import("ente-new/photos/services/trash")
+ >()),
+ savedTrashItemFileIDs: () => Promise.resolve(new Set<number>()),
+}));
+vi.mock("ente-gallery/services/file-data", async (importOriginal) => ({
+ ...(await importOriginal<
+ typeof import("ente-gallery/services/file-data")
+ >()),
+ syncUpdatedFileDataFileIDs: async (
+ _type: string,
+ _lastUpdatedAt: number,
+ onPage: (page: {
+ fileIDs: Set<number>;
+ lastUpdatedAt: number;
+ }) => Promise<void>,
+ ) => {
+ mocks.previewStatusPullCount++;
+ await mocks.previewStatusPullGate;
+ return onPage({ fileIDs: mocks.pulledFileIDs, lastUpdatedAt: 1 });
+ },
+}));
+vi.mock("ente-utils/promise", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("ente-utils/promise")>()),
+ wait: () => new Promise<void>(() => undefined),
+}));
+
+const {
+ hlsGenerationStatusSnapshot,
+ initVideoProcessing,
+ processedVideoFraction,
+ resetVideoState,
+ streamCandidateFiles,
+ toggleHLSGeneration,
+ videoProcessingSyncIfNeeded,
+} = await import("ente-gallery/services/video");
+
+const MiB = 1024 * 1024;
+
+const file = (
+ id: number,
+ overrides: {
+ ownerID?: number;
+ fileType?: FileType;
+ sv?: number;
+ fileSize?: number;
+ duration?: number;
+ } = {},
+) =>
+ ({
+ id,
+ ownerID: overrides.ownerID ?? 1,
+ metadata: {
+ fileType: overrides.fileType ?? FileType.video,
+ duration: overrides.duration ?? 30,
+ },
+ info: { fileSize: overrides.fileSize ?? 10 * MiB },
+ ...(overrides.sv == undefined
+ ? {}
+ : { pubMagicMetadata: { data: { sv: overrides.sv } } }),
+ }) as EnteFile;
+
+describe("video streaming percentage", () => {
+ afterEach(() => {
+ resetVideoState();
+ mocks.kv.clear();
+ mocks.collectionFiles = [];
+ mocks.collectionFilesReadCount = 0;
+ mocks.collectionFilesReadGate = undefined;
+ mocks.pulledFileIDs = new Set();
+ mocks.previewStatusPullCount = 0;
+ mocks.previewStatusPullGate = undefined;
+ });
+
+ test("calculates the processed fraction using mobile's limits", () => {
+ expect(processedVideoFraction(new Set(), [])).toBe(1);
+ expect(processedVideoFraction(new Set(), [file(1), file(2)])).toBe(0);
+ expect(
+ processedVideoFraction(new Set([1, 3]), [
+ file(1),
+ file(2),
+ file(3),
+ file(4),
+ ]),
+ ).toBe(0.5);
+
+ const candidates = [
+ file(1),
+ file(2, { duration: 61 }),
+ file(3, { fileSize: 500 * MiB + 1 }),
+ ];
+ expect(processedVideoFraction(new Set([2, 3]), candidates)).toBe(2 / 3);
+ });
+
+ test("reuses Desktop's backfill population", () => {
+ const candidates = streamCandidateFiles(
+ [
+ file(1),
+ file(1),
+ file(2, { ownerID: 2 }),
+ file(3),
+ file(4, { fileType: FileType.image }),
+ file(5, { sv: 1 }),
+ file(6, { duration: 600 }),
+ file(7, { fileSize: 600 * MiB }),
+ ],
+ new Set([3]),
+ 1,
+ );
+
+ expect(candidates.map(({ id }) => id)).toEqual([1, 6, 7]);
+ });
+
+ test("syncs previews before calculating when enabled", async () => {
+ mocks.collectionFiles = [file(1)];
+ mocks.pulledFileIDs = new Set([1]);
+ let releasePreviewStatusPull!: () => void;
+ mocks.previewStatusPullGate = new Promise<void>((resolve) => {
+ releasePreviewStatusPull = resolve;
+ });
+
+ // A normal pull while disabled deliberately skips preview status.
+ await videoProcessingSyncIfNeeded();
+ const toggle = toggleHLSGeneration();
+
+ await vi.waitFor(() => expect(mocks.previewStatusPullCount).toBe(1));
+ expect(hlsGenerationStatusSnapshot()).toEqual({ enabled: true });
+ expect(mocks.collectionFilesReadCount).toBe(0);
+
+ releasePreviewStatusPull();
+ await toggle;
+
+ await vi.waitFor(() =>
+ expect(hlsGenerationStatusSnapshot()).toMatchObject({
+ enabled: true,
+ processedFraction: 1,
+ }),
+ );
+ });
+
+ test("coalesces overlapping fraction refresh requests", async () => {
+ mocks.kv.set("generateHLS", true);
+ mocks.collectionFiles = [file(1)];
+ let releaseCollectionFilesRead!: () => void;
+ mocks.collectionFilesReadGate = new Promise<void>((resolve) => {
+ releaseCollectionFilesRead = resolve;
+ });
+
+ await initVideoProcessing();
+ await initVideoProcessing();
+ await initVideoProcessing();
+
+ expect(mocks.collectionFilesReadCount).toBe(1);
+
+ releaseCollectionFilesRead();
+
+ await vi.waitFor(() => {
+ expect(mocks.collectionFilesReadCount).toBe(2);
+ expect(hlsGenerationStatusSnapshot()).toMatchObject({
+ enabled: true,
+ processedFraction: 0,
+ });
+ });
+ });
+});
diff --git a/web/packages/gallery/services/video.ts b/web/packages/gallery/services/video.ts
index 7c75cc25b2..8faab87703 100644
--- a/web/packages/gallery/services/video.ts
+++ b/web/packages/gallery/services/video.ts
@@ -45,7 +45,12 @@ export type HLSGenerationEnabledStatus = "processing" | "idle";
export type HLSGenerationStatus =
| { enabled: false }
- | { enabled: true; status?: HLSGenerationEnabledStatus };
+ | {
+ enabled: true;
+ status?: HLSGenerationEnabledStatus;
+ /** `undefined` until the processed fraction has been calculated. */
+ processedFraction?: number;
+ };
interface VideoProcessingQueueItem {
file: EnteFile;
@@ -60,6 +65,9 @@ class VideoState {
hlsGenerationStatusListeners: (() => void)[] = [];
hlsGenerationStatusSnapshot: HLSGenerationStatus | undefined;
lastEnabledStatus: HLSGenerationEnabledStatus | undefined;
+ processedFraction: number | undefined;
+ processedFractionRefresh: Promise<void> | undefined;
+ processedFractionRefreshRequests = 0;
liveQueue: VideoProcessingQueueItem[] = [];
queueProcessor: Promise<void> | undefined;
tick: Promise<void> | undefined;
@@ -93,13 +101,19 @@ const setHLSGenerationStatusSnapshot = (snapshot: HLSGenerationStatus) => {
_state.hlsGenerationStatusListeners.forEach((l) => l());
};
+const publishEnabledSnapshot = () =>
+ setHLSGenerationStatusSnapshot({
+ enabled: true,
+ status: _state.lastEnabledStatus,
+ processedFraction: _state.processedFraction,
+ });
+
const updateSnapshotIfNeeded = (
status: HLSGenerationEnabledStatus | undefined,
) => {
- const enabled = _state.isHLSGenerationEnabled;
- if (enabled && status != _state.lastEnabledStatus) {
+ if (_state.isHLSGenerationEnabled && status != _state.lastEnabledStatus) {
_state.lastEnabledStatus = status;
- setHLSGenerationStatusSnapshot({ enabled, status });
+ publishEnabledSnapshot();
}
};
@@ -112,6 +126,8 @@ export const initVideoProcessing = async () => {
_state.isHLSGenerationEnabled = enabled;
setHLSGenerationStatusSnapshot({ enabled });
+
+ if (enabled) refreshProcessedFractionIfNeeded();
};
const savedGenerateHLS = async () => await getKVB("generateHLS");
@@ -127,13 +143,22 @@ export const toggleHLSGeneration = async () => {
const enabled = !_state.isHLSGenerationEnabled;
_state.lastEnabledStatus = undefined;
+ _state.processedFraction = undefined;
await saveGenerateHLS(enabled);
_state.isHLSGenerationEnabled = enabled;
setHLSGenerationStatusSnapshot({ enabled });
- if (enabled) tickNow();
+ if (enabled) {
+ try {
+ await pullProcessedFileIDs();
+ refreshProcessedFractionIfNeeded();
+ } catch (e) {
+ log.error("Failed to sync video preview status", e);
+ }
+ tickNow();
+ }
};
export interface HLSPlaylistData {
@@ -288,6 +313,80 @@ export const videoPrunePermanentlyDeletedFileIDsIfNeeded = async (
}
};
+const mobileStreamMaxSize = 500 * 1024 * 1024;
+const mobileStreamMaxDuration = 60; /* seconds */
+
+const isWithinMobileStreamLimits = (file: EnteFile) => {
+ const size = file.info?.fileSize;
+ const duration = file.metadata.duration;
+ return (
+ size != undefined &&
+ size <= mobileStreamMaxSize &&
+ duration != undefined &&
+ duration > 0 &&
+ duration <= mobileStreamMaxDuration
+ );
+};
+
+export const processedVideoFraction = (
+ processedFileIDs: Set<number>,
+ candidateFiles: EnteFile[],
+) => {
+ const candidateFileIDs = new Set(candidateFiles.map((f) => f.id));
+ const previewFileIDs = processedFileIDs.intersection(candidateFileIDs);
+ const countedFileIDs = new Set(
+ candidateFiles.filter(isWithinMobileStreamLimits).map((f) => f.id),
+ );
+ const total = previewFileIDs.union(countedFileIDs);
+ return total.size == 0 ? 1 : previewFileIDs.size / total.size;
+};
+
+const refreshProcessedFractionIfNeeded = () => {
+ if (!isHLSGenerationSupported || !isHLSGenerationEnabled()) return;
+
+ const state = _state;
+ state.processedFractionRefreshRequests++;
+ if (state.processedFractionRefresh) return;
+
+ let handledRequests = 0;
+ state.processedFractionRefresh = (async () => {
+ while (handledRequests != state.processedFractionRefreshRequests) {
+ const request = state.processedFractionRefreshRequests;
+ try {
+ // ponytail: Recompute on rare events; use incremental counts
+ // only if profiling shows the library scan is material.
+ const [candidates, processedFileIDs] = await Promise.all([
+ savedStreamCandidateFiles(ensureLocalUser().id),
+ savedProcessedVideoFileIDs(),
+ ]);
+ const fraction = processedVideoFraction(
+ processedFileIDs,
+ candidates,
+ );
+ if (state != _state || !state.isHLSGenerationEnabled) return;
+ if (
+ request == state.processedFractionRefreshRequests &&
+ fraction != state.processedFraction
+ ) {
+ state.processedFraction = fraction;
+ publishEnabledSnapshot();
+ }
+ } catch (e) {
+ log.error("Failed to compute video processed fraction", e);
+ }
+ handledRequests = request;
+ }
+ })().finally(() => {
+ state.processedFractionRefresh = undefined;
+ if (
+ state == _state &&
+ handledRequests != state.processedFractionRefreshRequests
+ ) {
+ refreshProcessedFractionIfNeeded();
+ }
+ });
+};
+
export const videoProcessingSyncIfNeeded = async () => {
if (!isHLSGenerationSupported) return;
@@ -297,6 +396,7 @@ export const videoProcessingSyncIfNeeded = async () => {
if (!isHLSGenerationEnabled()) return;
await pullProcessedFileIDs();
+ refreshProcessedFractionIfNeeded();
tickNow();
};
@@ -360,6 +460,7 @@ const processQueue = async () => {
try {
await processQueueItem(item);
await markProcessedVideoFileID(item.file.id);
+ refreshProcessedFractionIfNeeded();
_state.idleWait = idleWaitInitial;
} catch (e) {
log.error(`Failed to process video ${fileLogID(item.file)}`, e);
@@ -384,21 +485,34 @@ const processQueue = async () => {
_state.queueProcessor = undefined;
};
-const backfillQueue = async (
+// Shared with backfill so the percentage and queue use the same population.
+export const streamCandidateFiles = (
+ files: EnteFile[],
+ trashFileIDs: Set<number>,
userID: number,
-): Promise<VideoProcessingQueueItem[]> => {
- const allCollectionFiles = await savedCollectionFiles();
- const localTrashFileIDs = await savedTrashItemFileIDs();
- const videoFiles = uniqueFilesByID(
- allCollectionFiles.filter(
+) =>
+ uniqueFilesByID(
+ files.filter(
(f) =>
f.ownerID == userID &&
f.metadata.fileType == FileType.video &&
- !localTrashFileIDs.has(f.id) &&
+ !trashFileIDs.has(f.id) &&
f.pubMagicMetadata?.data.sv != 1,
),
);
+const savedStreamCandidateFiles = async (userID: number) =>
+ streamCandidateFiles(
+ await savedCollectionFiles(),
+ await savedTrashItemFileIDs(),
+ userID,
+ );
+
+const backfillQueue = async (
+ userID: number,
+): Promise<VideoProcessingQueueItem[]> => {
+ const videoFiles = await savedStreamCandidateFiles(userID);
+
const doneIDs = (await savedProcessedVideoFileIDs()).union(
await savedFailedVideoFileIDs(),
);