feat: add compression

This commit is contained in:
jfmcarreira committed 2026-09-24 11:02:41 +01:00
1 parent 505c6c7db7
commit 730f759e5a
13 files changed
+830 -2

No files matched your search

+1 -1
View File
@@ -25,7 +25,7 @@ ENV VERSION=$VERSION
ENV NODE_ENV=production
RUN apk add --no-cache curl
RUN apk add --no-cache curl ffmpeg
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001
+4
View File
@@ -0,0 +1,4 @@
export const FFMPEG_COMMAND_SETTING = "video_compression_ffmpeg_command";
export const DEFAULT_FFMPEG_COMMAND =
'ffmpeg -i "{input}" -c:v libx265 -crf 28 -c:a aac "{output}"';
+1
View File
@@ -28,6 +28,7 @@ export const sidebarGroups: SidebarGroup[] = [
{ title: "Potential Albums", link: "/albums/potential-albums", icon: <GalleryVerticalEnd className="h-4 w-4" /> },
{ title: "Missing Locations", link: "/assets/missing-locations", icon: <MapPinX className="h-4 w-4" /> },
{ title: "Empty Videos", link: "/assets/empty-videos", icon: <Video className="h-4 w-4" /> },
{ title: "Compress Videos", link: "/assets/compress-videos", icon: <Video className="h-4 w-4" /> },
{ title: "Bulk Duplicate Finder", link: "/assets/bulk-duplicate-finder", icon: <Copy className="h-4 w-4" /> },
{ title: "Orphan Finder", link: "/assets/orphan-finder", icon: <PackageSearch className="h-4 w-4" /> },
],
+4
View File
@@ -48,6 +48,10 @@ export const ASSET_VIDEO_PATH = (id: string) => BASE_PROXY_ENDPOINT + "/asset/vi
export const ASSET_GEO_HEATMAP_PATH = BASE_API_ENDPOINT + "/assets/geo-heatmap";
export const LIST_EMPTY_VIDEOS_PATH = BASE_API_ENDPOINT + "/assets/empty-videos";
export const LIST_ORPHAN_ASSETS_PATH = BASE_API_ENDPOINT + "/assets/orphan-finder";
export const LIST_COMPRESSION_VIDEOS_PATH = BASE_API_ENDPOINT + "/assets/compression/videos";
export const TRANSCODE_VIDEO_PATH = BASE_API_ENDPOINT + "/assets/compression/transcode";
export const REPLACE_COMPRESSED_VIDEO_PATH = BASE_API_ENDPOINT + "/assets/compression/replace";
export const COMPRESSION_RESULT_PATH = (id: string) => BASE_API_ENDPOINT + "/assets/compression/result/" + id;
+27
View File
@@ -9,6 +9,10 @@ import {
UPDATE_ASSETS_PATH,
LIST_DUPLICATES_PATH,
LIST_ORPHAN_ASSETS_PATH,
LIST_COMPRESSION_VIDEOS_PATH,
TRANSCODE_VIDEO_PATH,
REPLACE_COMPRESSED_VIDEO_PATH,
COMPRESSION_RESULT_PATH,
} from "@/config/routes";
import { cleanUpAsset } from "@/helpers/asset.helper";
import API from "@/lib/api";
@@ -125,3 +129,26 @@ export const listOrphanAssets = async (filters: IOrphanFilters): Promise<IAsset[
if (filters.page) params.page = String(filters.page);
return API.get(LIST_ORPHAN_ASSETS_PATH, params).then((assets) => assets.map(cleanUpAsset));
}
export const listCompressionVideos = async (page = 1, limit = 200): Promise<IAsset[]> => {
return API.get(LIST_COMPRESSION_VIDEOS_PATH, { page, limit }).then((assets) => assets.map(cleanUpAsset));
};
export interface ICompressionResult {
assetId: string;
originalSize: number;
compressedSize: number;
resultUrl: string;
}
export const transcodeVideo = async (assetId: string): Promise<ICompressionResult> => {
return API.post(TRANSCODE_VIDEO_PATH, { assetId });
};
export const replaceCompressedVideo = async (assetId: string) => {
return API.post(REPLACE_COMPRESSED_VIDEO_PATH, { assetId });
};
export const discardCompressedVideo = async (assetId: string) => {
return API.delete(COMPRESSION_RESULT_PATH(assetId));
};
+69
View File
@@ -0,0 +1,69 @@
import { appDb } from "@/db";
import { settings } from "@/db/schema/settings.schema";
import { DEFAULT_FFMPEG_COMMAND, FFMPEG_COMMAND_SETTING } from "@/config/compression";
import { and, eq } from "drizzle-orm";
import { mkdir, rm } from "node:fs/promises";
import path from "node:path";
import { Readable } from "node:stream";
import { pipeline } from "node:stream/promises";
import { createWriteStream } from "node:fs";
import { spawn } from "node:child_process";
const COMPRESSION_ROOT = "/app/data/compression";
export const getCompressionDirectory = (assetId: string) =>
path.join(COMPRESSION_ROOT, assetId);
export const getCompressionInputPath = (assetId: string) =>
path.join(getCompressionDirectory(assetId), "input");
export const getCompressionOutputPath = (assetId: string) =>
path.join(getCompressionDirectory(assetId), "output.mp4");
export const ensureCompressionDirectory = async (assetId: string) => {
await mkdir(getCompressionDirectory(assetId), { recursive: true });
};
export const clearCompressionDirectory = async (assetId: string) => {
await rm(getCompressionDirectory(assetId), { recursive: true, force: true });
};
export const getFfmpegCommand = async (ownerId: string) => {
const [row] = await appDb
.select({ value: settings.value })
.from(settings)
.where(and(eq(settings.key, FFMPEG_COMMAND_SETTING), eq(settings.ownerId, ownerId)));
return row?.value || DEFAULT_FFMPEG_COMMAND;
};
export const saveResponseBody = async (response: Response, filePath: string) => {
if (!response.body) throw new Error("Immich returned an empty asset body");
await pipeline(
Readable.fromWeb(response.body as any),
createWriteStream(filePath)
);
};
export const runFfmpegCommand = async (
command: string,
inputPath: string,
outputPath: string
) => {
const resolvedCommand = command
.split("{input}").join(inputPath)
.split("{output}").join(outputPath);
await new Promise<void>((resolve, reject) => {
const child = spawn(resolvedCommand, {
shell: true,
stdio: "ignore",
});
child.once("error", reject);
child.once("close", (code) => {
if (code === 0) resolve();
else reject(new Error(`FFmpeg exited with code ${code ?? "unknown"}`));
});
});
};
+226
View File
@@ -0,0 +1,226 @@
import { ENV } from "@/config/environment";
import { db } from "@/config/db";
import { getCurrentUser } from "@/handlers/serverUtils/user.utils";
import { getUserHeaders } from "@/helpers/user.helper";
import { clearCompressionDirectory, getCompressionOutputPath } from "@/helpers/compression.server";
import { assets } from "@/schema";
import { and, eq } from "drizzle-orm";
import { openAsBlob } from "node:fs";
import path from "node:path";
import type { NextApiRequest, NextApiResponse } from "next";
const readError = async (response: Response) => {
const body = await response.text().catch(() => "");
return body || response.statusText || `HTTP ${response.status}`;
};
export default async function handler(req: NextApiRequest, res: NextApiResponse) {
if (req.method !== "POST") return res.status(405).json({ message: "Method not allowed" });
const currentUser = await getCurrentUser(req);
if (!currentUser) return res.status(401).json({ message: "Unauthorized" });
const rawAssetId = req.body?.assetId as string;
const [dbAsset] = await db
.select({ id: assets.id, type: assets.type })
.from(assets)
.where(and(eq(assets.id, rawAssetId), eq(assets.ownerId, currentUser.id)));
if (!dbAsset || dbAsset.type !== "VIDEO") {
return res.status(404).json({ message: "Video not found" });
}
const livePhotoParents = await db
.select({ id: assets.id })
.from(assets)
.where(and(eq(assets.livePhotoVideoId, dbAsset.id), eq(assets.ownerId, currentUser.id)));
const jsonHeaders = {
...getUserHeaders(currentUser),
Accept: "application/json",
"Content-Type": "application/json",
};
let newAssetId: string | null = null;
let createdNewAsset = false;
let sourcePrimaryStackId: string | null = null;
let stackPrimaryChanged = false;
const changedLivePhotoParentIds: string[] = [];
let rollbackSafe = true;
try {
const sourceResponse = await fetch(`${ENV.IMMICH_URL}/api/assets/${dbAsset.id}`, {
headers: jsonHeaders,
});
if (!sourceResponse.ok) throw new Error(`Failed to read source asset: ${await readError(sourceResponse)}`);
const source = await sourceResponse.json();
if (source.stack?.id && source.stack.primaryAssetId === dbAsset.id) {
sourcePrimaryStackId = source.stack.id;
}
const metadataResponse = await fetch(`${ENV.IMMICH_URL}/api/assets/${dbAsset.id}/metadata`, {
headers: jsonHeaders,
});
const customMetadata = metadataResponse.ok ? await metadataResponse.json() : [];
const originalExtension = path.extname(source.originalFileName || "");
const originalBase = originalExtension
? path.basename(source.originalFileName, originalExtension)
: (source.originalFileName || dbAsset.id);
const replacementFileName = originalExtension.toLowerCase() === ".mp4"
? source.originalFileName
: `${originalBase}.mp4`;
const fileBlob = await openAsBlob(getCompressionOutputPath(dbAsset.id), { type: "video/mp4" });
const formData = new FormData();
formData.set("fileCreatedAt", source.fileCreatedAt);
formData.set("fileModifiedAt", source.fileModifiedAt);
formData.set("filename", replacementFileName);
formData.set("assetData", fileBlob, replacementFileName);
if (typeof source.duration === "number") formData.set("duration", String(source.duration));
if (source.visibility) formData.set("visibility", source.visibility);
if (source.isFavorite) formData.set("isFavorite", "true");
if (Array.isArray(customMetadata) && customMetadata.length > 0) {
formData.set("metadata", JSON.stringify(customMetadata.map(({ key, value }: any) => ({ key, value }))));
}
const { ["Content-Type"]: _contentType, ...uploadHeaders } = jsonHeaders;
const uploadResponse = await fetch(`${ENV.IMMICH_URL}/api/assets`, {
method: "POST",
headers: uploadHeaders,
body: formData,
});
if (!uploadResponse.ok) throw new Error(`Failed to upload compressed asset: ${await readError(uploadResponse)}`);
const uploaded = await uploadResponse.json();
if (!uploaded?.id) throw new Error("Immich upload response did not include an asset id");
if (uploaded.status === "duplicate") {
throw new Error("The compressed file already exists in Immich");
}
newAssetId = uploaded.id;
createdNewAsset = true;
const copyResponse = await fetch(`${ENV.IMMICH_URL}/api/assets/copy`, {
method: "PUT",
headers: jsonHeaders,
body: JSON.stringify({ sourceId: dbAsset.id, targetId: newAssetId }),
});
if (!copyResponse.ok) throw new Error(`Failed to copy asset associations: ${await readError(copyResponse)}`);
const exifInfo = source.exifInfo || {};
const update: Record<string, unknown> = {
isFavorite: Boolean(source.isFavorite),
visibility: source.visibility,
};
if (exifInfo.dateTimeOriginal) update.dateTimeOriginal = exifInfo.dateTimeOriginal;
if (typeof exifInfo.description === "string") update.description = exifInfo.description;
if (exifInfo.rating !== undefined) update.rating = exifInfo.rating;
if (exifInfo.latitude != null && exifInfo.longitude != null) {
update.latitude = exifInfo.latitude;
update.longitude = exifInfo.longitude;
}
const updateResponse = await fetch(`${ENV.IMMICH_URL}/api/assets/${newAssetId}`, {
method: "PATCH",
headers: jsonHeaders,
body: JSON.stringify(update),
});
if (!updateResponse.ok) throw new Error(`Failed to restore asset metadata: ${await readError(updateResponse)}`);
if (source.duplicateId) {
const duplicateResponse = await fetch(`${ENV.IMMICH_URL}/api/assets`, {
method: "PATCH",
headers: jsonHeaders,
body: JSON.stringify({ ids: [newAssetId], duplicateId: source.duplicateId }),
});
if (!duplicateResponse.ok) throw new Error(`Failed to restore duplicate group: ${await readError(duplicateResponse)}`);
}
const tagIds = Array.isArray(source.tags) ? source.tags.map((tag: any) => tag.id).filter(Boolean) : [];
if (tagIds.length > 0) {
const tagsResponse = await fetch(`${ENV.IMMICH_URL}/api/tags/assets`, {
method: "PUT",
headers: jsonHeaders,
body: JSON.stringify({ tagIds, assetIds: [newAssetId] }),
});
if (!tagsResponse.ok) throw new Error(`Failed to restore tags: ${await readError(tagsResponse)}`);
}
for (const parent of livePhotoParents) {
const parentResponse = await fetch(`${ENV.IMMICH_URL}/api/assets/${parent.id}`, {
method: "PATCH",
headers: jsonHeaders,
body: JSON.stringify({ livePhotoVideoId: newAssetId }),
});
if (!parentResponse.ok) {
throw new Error(`Failed to restore live photo association: ${await readError(parentResponse)}`);
}
changedLivePhotoParentIds.push(parent.id);
}
if (sourcePrimaryStackId) {
const stackResponse = await fetch(`${ENV.IMMICH_URL}/api/stacks/${sourcePrimaryStackId}`, {
method: "PATCH",
headers: jsonHeaders,
body: JSON.stringify({ primaryAssetId: newAssetId }),
});
if (!stackResponse.ok) throw new Error(`Failed to restore primary stack asset: ${await readError(stackResponse)}`);
stackPrimaryChanged = true;
}
let deleteResponse: Response;
try {
deleteResponse = await fetch(`${ENV.IMMICH_URL}/api/assets`, {
method: "DELETE",
headers: jsonHeaders,
body: JSON.stringify({ ids: [dbAsset.id], force: true }),
});
} catch {
// The server may have processed the delete even if the response was lost.
// Keep the new asset rather than risk deleting both copies.
rollbackSafe = false;
throw new Error("Connection lost while deleting the original. The new compressed asset was kept to avoid data loss.");
}
if (!deleteResponse.ok) throw new Error(`Failed to delete original asset: ${await readError(deleteResponse)}`);
await clearCompressionDirectory(dbAsset.id).catch(() => undefined);
return res.status(200).json({
oldAssetId: dbAsset.id,
newAssetId,
fileName: replacementFileName,
});
} catch (error: any) {
if (rollbackSafe && changedLivePhotoParentIds.length > 0) {
await Promise.all(changedLivePhotoParentIds.map((parentId) =>
fetch(`${ENV.IMMICH_URL}/api/assets/${parentId}`, {
method: "PATCH",
headers: jsonHeaders,
body: JSON.stringify({ livePhotoVideoId: dbAsset.id }),
}).catch(() => undefined)
));
}
if (rollbackSafe && stackPrimaryChanged && sourcePrimaryStackId) {
await fetch(`${ENV.IMMICH_URL}/api/stacks/${sourcePrimaryStackId}`, {
method: "PATCH",
headers: jsonHeaders,
body: JSON.stringify({ primaryAssetId: dbAsset.id }),
}).catch(() => undefined);
}
if (rollbackSafe && createdNewAsset && newAssetId) {
await fetch(`${ENV.IMMICH_URL}/api/assets`, {
method: "DELETE",
headers: jsonHeaders,
body: JSON.stringify({ ids: [newAssetId], force: true }),
}).catch(() => undefined);
}
return res.status(500).json({ message: error?.message ?? "Failed to replace asset" });
}
}
export const config = {
api: { responseLimit: false },
};
@@ -0,0 +1,70 @@
import { db } from "@/config/db";
import { getCurrentUser } from "@/handlers/serverUtils/user.utils";
import { clearCompressionDirectory, getCompressionOutputPath } from "@/helpers/compression.server";
import { assets } from "@/schema";
import { and, eq } from "drizzle-orm";
import { createReadStream } from "node:fs";
import { stat } from "node:fs/promises";
import type { NextApiRequest, NextApiResponse } from "next";
export default async function handler(req: NextApiRequest, res: NextApiResponse) {
const currentUser = await getCurrentUser(req);
if (!currentUser) return res.status(401).json({ message: "Unauthorized" });
const rawAssetId = req.query.assetId as string;
const [asset] = await db
.select({ id: assets.id })
.from(assets)
.where(and(eq(assets.id, rawAssetId), eq(assets.ownerId, currentUser.id)));
if (!asset) return res.status(404).json({ message: "Asset not found" });
if (req.method === "DELETE") {
await clearCompressionDirectory(asset.id);
return res.status(204).end();
}
if (req.method !== "GET") return res.status(405).json({ message: "Method not allowed" });
const filePath = getCompressionOutputPath(asset.id);
try {
const fileStat = await stat(filePath);
const range = req.headers.range;
res.setHeader("Content-Type", "video/mp4");
res.setHeader("Accept-Ranges", "bytes");
res.setHeader("Cache-Control", "no-store");
if (!range) {
res.setHeader("Content-Length", fileStat.size);
createReadStream(filePath).pipe(res);
return;
}
const match = /^bytes=(\d+)-(\d*)$/.exec(range);
if (!match) {
res.setHeader("Content-Range", `bytes */${fileStat.size}`);
return res.status(416).end();
}
const start = Number(match[1]);
const requestedEnd = match[2] ? Number(match[2]) : fileStat.size - 1;
const end = Math.min(requestedEnd, fileStat.size - 1);
if (start >= fileStat.size || start > end) {
res.setHeader("Content-Range", `bytes */${fileStat.size}`);
return res.status(416).end();
}
res.status(206);
res.setHeader("Content-Range", `bytes ${start}-${end}/${fileStat.size}`);
res.setHeader("Content-Length", end - start + 1);
createReadStream(filePath, { start, end }).pipe(res);
} catch {
return res.status(404).json({ message: "Compressed file not found" });
}
}
export const config = {
api: { responseLimit: false },
};
@@ -0,0 +1,79 @@
import { ENV } from "@/config/environment";
import { db } from "@/config/db";
import { getCurrentUser } from "@/handlers/serverUtils/user.utils";
import { getUserHeaders } from "@/helpers/user.helper";
import {
clearCompressionDirectory,
ensureCompressionDirectory,
getCompressionInputPath,
getCompressionOutputPath,
getFfmpegCommand,
runFfmpegCommand,
saveResponseBody,
} from "@/helpers/compression.server";
import { assets } from "@/schema";
import { and, eq } from "drizzle-orm";
import { rm, stat } from "node:fs/promises";
import type { NextApiRequest, NextApiResponse } from "next";
export default async function handler(req: NextApiRequest, res: NextApiResponse) {
if (req.method !== "POST") return res.status(405).json({ message: "Method not allowed" });
const currentUser = await getCurrentUser(req);
if (!currentUser) return res.status(401).json({ message: "Unauthorized" });
const assetId = req.body?.assetId as string;
const [asset] = await db
.select({
id: assets.id,
type: assets.type,
})
.from(assets)
.where(and(eq(assets.id, assetId), eq(assets.ownerId, currentUser.id)));
if (!asset || asset.type !== "VIDEO") {
return res.status(404).json({ message: "Video not found" });
}
const inputPath = getCompressionInputPath(asset.id);
const outputPath = getCompressionOutputPath(asset.id);
try {
await clearCompressionDirectory(asset.id);
await ensureCompressionDirectory(asset.id);
const downloadResponse = await fetch(`${ENV.IMMICH_URL}/api/assets/${asset.id}/original`, {
headers: {
...getUserHeaders(currentUser),
Accept: "application/octet-stream",
},
});
if (!downloadResponse.ok) {
throw new Error(`Failed to download original asset (${downloadResponse.status})`);
}
await saveResponseBody(downloadResponse, inputPath);
const originalStat = await stat(inputPath);
const command = await getFfmpegCommand(currentUser.id);
await runFfmpegCommand(command, inputPath, outputPath);
const outputStat = await stat(outputPath);
await rm(inputPath, { force: true });
return res.status(200).json({
assetId: asset.id,
originalSize: originalStat.size,
compressedSize: outputStat.size,
resultUrl: `/api/assets/compression/result/${asset.id}`,
});
} catch (error: any) {
await rm(inputPath, { force: true }).catch(() => undefined);
await rm(outputPath, { force: true }).catch(() => undefined);
return res.status(500).json({ message: error?.message ?? "Compression failed" });
}
}
export const config = {
api: { responseLimit: false },
};
@@ -0,0 +1,51 @@
import { db } from "@/config/db";
import { ASSET_VIDEO_PATH } from "@/config/routes";
import { getCurrentUser } from "@/handlers/serverUtils/user.utils";
import { isFlipped } from "@/helpers/asset.helper";
import { assets, exif } from "@/schema";
import { and, desc, eq, isNull } from "drizzle-orm";
import type { NextApiRequest, NextApiResponse } from "next";
export default async function handler(req: NextApiRequest, res: NextApiResponse) {
const currentUser = await getCurrentUser(req);
if (!currentUser) return res.status(401).json({ message: "Unauthorized" });
if (req.method !== "GET") return res.status(405).json({ message: "Method not allowed" });
const page = Math.max(1, Number(req.query.page) || 1);
const limit = Math.max(1, Number(req.query.limit) || 200);
const rows = await db
.select({
id: assets.id,
type: assets.type,
originalPath: assets.originalPath,
isFavorite: assets.isFavorite,
duration: assets.duration,
originalFileName: assets.originalFileName,
localDateTime: assets.localDateTime,
exifImageWidth: exif.exifImageWidth,
exifImageHeight: exif.exifImageHeight,
ownerId: assets.ownerId,
dateTimeOriginal: exif.dateTimeOriginal,
orientation: exif.orientation,
fileSizeInByte: exif.fileSizeInByte,
})
.from(assets)
.leftJoin(exif, eq(assets.id, exif.assetId))
.where(and(
eq(assets.ownerId, currentUser.id),
eq(assets.type, "VIDEO"),
eq(assets.status, "active"),
isNull(assets.deletedAt)
))
.orderBy(desc(assets.localDateTime))
.limit(limit)
.offset((page - 1) * limit);
return res.status(200).json(rows.map((asset) => ({
...asset,
exifImageHeight: isFlipped(asset.orientation) ? asset.exifImageWidth : asset.exifImageHeight,
exifImageWidth: isFlipped(asset.orientation) ? asset.exifImageHeight : asset.exifImageWidth,
downloadUrl: ASSET_VIDEO_PATH(asset.id),
})));
}
+245
View File
@@ -0,0 +1,245 @@
import PageLayout from '@/components/layouts/PageLayout'
import Header from '@/components/shared/Header'
import AssetGrid from '@/components/shared/AssetGrid'
import FloatingBar from '@/components/shared/FloatingBar'
import Loader from '@/components/ui/loader'
import { Button } from '@/components/ui/button'
import { AlertDialog } from '@/components/ui/alert-dialog'
import PhotoSelectionContext, { IPhotoSelectionContext } from '@/contexts/PhotoSelectionContext'
import {
discardCompressedVideo,
ICompressionResult,
listCompressionVideos,
replaceCompressedVideo,
transcodeVideo,
} from '@/handlers/api/asset.handler'
import { IAsset } from '@/types/asset'
import { ChevronLeft, ChevronRight, ExternalLink, Trash2, Video } from 'lucide-react'
import { useEffect, useMemo, useState } from 'react'
import toast from 'react-hot-toast'
const PAGE_SIZE = 200
const formatMB = (bytes?: number | null) => {
if (bytes == null) return 'Unknown'
return `${(bytes / 1024 / 1024).toFixed(1)} MB`
}
export default function CompressVideosPage() {
const [assets, setAssets] = useState<IAsset[]>([])
const [loading, setLoading] = useState(false)
const [page, setPage] = useState(1)
const [errorMessage, setErrorMessage] = useState('')
const [compressing, setCompressing] = useState(false)
const [replacing, setReplacing] = useState(false)
const [discarding, setDiscarding] = useState(false)
const [result, setResult] = useState<ICompressionResult | null>(null)
const [contextState, setContextState] = useState<IPhotoSelectionContext>({
selectedIds: [],
assets: [],
config: {
albumId: '',
sort: 'fileOriginalDate',
sortOrder: 'asc',
},
updateContext: (newConfig: Partial<IPhotoSelectionContext>) => {
setContextState((previous) => ({
...previous,
...newConfig,
config: newConfig.config
? { ...previous.config, ...newConfig.config }
: previous.config,
}))
},
})
const selectedAsset = useMemo(() => {
const selectedId = contextState.selectedIds[0]
return contextState.assets.find((asset) => asset.id === selectedId) ?? null
}, [contextState.assets, contextState.selectedIds])
const loadVideos = async () => {
setLoading(true)
setErrorMessage('')
try {
const fetchedAssets = await listCompressionVideos(page, PAGE_SIZE)
setAssets(fetchedAssets)
contextState.updateContext({ assets: fetchedAssets, selectedIds: [] })
setResult(null)
} catch (error: any) {
setErrorMessage(error?.message ?? 'Failed to load videos')
} finally {
setLoading(false)
}
}
useEffect(() => {
loadVideos()
}, [page])
const handleSelectionChange = (ids: string[]) => {
if (result) {
contextState.updateContext({ selectedIds: [result.assetId] })
return
}
const selectedIds = ids.length > 0 ? [ids[ids.length - 1]] : []
contextState.updateContext({ selectedIds })
}
const handleCompress = async () => {
if (!selectedAsset) return
setCompressing(true)
setResult(null)
try {
const compressionResult = await transcodeVideo(selectedAsset.id)
setResult(compressionResult)
toast.success('Compression finished')
} catch (error: any) {
toast.error(error?.message ?? 'Compression failed')
} finally {
setCompressing(false)
}
}
const handleDiscard = async () => {
if (!result) return
setDiscarding(true)
try {
await discardCompressedVideo(result.assetId)
setResult(null)
toast.success('Compressed file discarded')
} catch (error: any) {
toast.error(error?.message ?? 'Failed to discard compressed file')
} finally {
setDiscarding(false)
}
}
const handleReplace = async () => {
if (!result) return
setReplacing(true)
try {
await replaceCompressedVideo(result.assetId)
const remainingAssets = assets.filter((asset) => asset.id !== result.assetId)
setAssets(remainingAssets)
contextState.updateContext({ assets: remainingAssets, selectedIds: [] })
setResult(null)
toast.success('Asset replaced in Immich')
} catch (error: any) {
toast.error(error?.message ?? 'Failed to replace asset')
} finally {
setReplacing(false)
}
}
const savedBytes = result ? result.originalSize - result.compressedSize : 0
const savedPercent = result && result.originalSize > 0
? Math.round((savedBytes / result.originalSize) * 100)
: 0
return (
<PageLayout className="!p-0 !mb-0 relative pb-24">
<Header
leftComponent="Compress Videos"
rightComponent={
<div className="flex items-center gap-2">
<Button
variant="outline"
size="sm"
disabled={page === 1 || loading || !!result}
onClick={() => setPage((value) => Math.max(1, value - 1))}
>
<ChevronLeft className="w-4 h-4" />
</Button>
<span className="text-sm text-muted-foreground">Page {page}</span>
<Button
variant="outline"
size="sm"
disabled={assets.length < PAGE_SIZE || loading || !!result}
onClick={() => setPage((value) => value + 1)}
>
<ChevronRight className="w-4 h-4" />
</Button>
</div>
}
/>
<PhotoSelectionContext.Provider value={{ ...contextState, updateContext: contextState.updateContext }}>
{loading ? (
<div className="flex justify-center py-16"><Loader /></div>
) : errorMessage ? (
<div className="p-6 text-destructive">{errorMessage}</div>
) : assets.length === 0 ? (
<div className="text-center py-16 text-muted-foreground">
<Video className="w-10 h-10 mx-auto mb-3" />
No videos found.
</div>
) : (
<div className="p-4">
<AssetGrid
assets={assets}
selectable
onSelectionChange={handleSelectionChange}
/>
</div>
)}
{selectedAsset && (
<FloatingBar className="max-w-3xl">
<div className="w-full flex items-center gap-4 justify-between">
<div className="min-w-0">
<div className="text-sm font-medium truncate">{selectedAsset.originalFileName}</div>
{!result ? (
<div className="text-xs text-muted-foreground">{formatMB(selectedAsset.fileSizeInByte)}</div>
) : (
<div className="text-xs text-muted-foreground flex flex-wrap gap-x-3">
<span>Original: {formatMB(result.originalSize)}</span>
<span>Compressed: {formatMB(result.compressedSize)}</span>
<span>Saved: {formatMB(savedBytes)} ({savedPercent}%)</span>
</div>
)}
</div>
{!result ? (
<Button onClick={handleCompress} disabled={compressing}>
{compressing ? 'Compressing...' : 'Compress'}
</Button>
) : (
<div className="flex items-center gap-2 shrink-0">
<Button
variant="outline"
onClick={() => window.open(result.resultUrl, '_blank')}
>
<ExternalLink className="w-4 h-4 mr-2" />
Preview
</Button>
<Button
variant="outline"
onClick={handleDiscard}
disabled={discarding || replacing}
>
<Trash2 className="w-4 h-4 mr-2" />
{discarding ? 'Discarding...' : 'Discard'}
</Button>
<AlertDialog
title="Replace this asset in Immich?"
description="The compressed video will be uploaded as a new Immich asset. Its associations and metadata will be copied, then the original asset will be permanently deleted."
onConfirm={handleReplace}
variant="destructive"
disabled={replacing || discarding}
asChild
>
<Button variant="destructive" disabled={replacing || discarding}>
{replacing ? 'Replacing...' : 'Replace in Immich'}
</Button>
</AlertDialog>
</div>
)}
</div>
</FloatingBar>
)}
</PhotoSelectionContext.Provider>
</PageLayout>
)
}
+52 -1
View File
@@ -5,7 +5,7 @@ import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/input";
import {
Save, Eye, EyeOff, ExternalLink,
Workflow, Shield, CheckCircle, XCircle, Server, Globe, Download, Wand2,
Workflow, Shield, CheckCircle, XCircle, Server, Globe, Download, Wand2, Video,
} from "lucide-react";
import { useEffect, useState } from "react";
import toast from "react-hot-toast";
@@ -13,6 +13,7 @@ import API from "@/lib/api";
import { useConfig } from "@/contexts/ConfigContext";
import Link from "next/link";
import { WORKFLOW_PERMISSIONS } from "@/config/permissions";
import { DEFAULT_FFMPEG_COMMAND, FFMPEG_COMMAND_SETTING } from "@/config/compression";
function ConnectionStatus({ label, url, icon: Icon }: { label: string; url: string; icon: any }) {
return (
@@ -55,6 +56,30 @@ export default function SettingsPage() {
valid: boolean; error: string | null; permissions: string[]; missing: string[];
} | null>(null);
const [ffmpegCommand, setFfmpegCommand] = useState(DEFAULT_FFMPEG_COMMAND);
const [ffmpegCommandLoading, setFfmpegCommandLoading] = useState(false);
const fetchFfmpegCommand = async () => {
try {
const data = await API.get(`/api/settings/kv/${FFMPEG_COMMAND_SETTING}`);
setFfmpegCommand(data.value || DEFAULT_FFMPEG_COMMAND);
} catch {
setFfmpegCommand(DEFAULT_FFMPEG_COMMAND);
}
};
const saveFfmpegCommand = async () => {
setFfmpegCommandLoading(true);
try {
await API.put(`/api/settings/kv/${FFMPEG_COMMAND_SETTING}`, { value: ffmpegCommand });
toast.success("FFmpeg command saved");
} catch {
toast.error("Failed to save FFmpeg command");
} finally {
setFfmpegCommandLoading(false);
}
};
const fetchWorkflowApiKey = async () => {
try {
const data = await API.get("/api/settings/kv/workflow_api_key");
@@ -174,6 +199,7 @@ export default function SettingsPage() {
useEffect(() => {
fetchWorkflowApiKey();
fetchImportApiKey();
fetchFfmpegCommand();
}, []);
return (
@@ -203,6 +229,31 @@ export default function SettingsPage() {
</div>
</section>
{/* Video Compression */}
<section>
<div className="flex items-center gap-2 mb-3">
<Video className="h-4 w-4 text-muted-foreground" />
<h2 className="text-sm font-semibold tracking-wide uppercase text-muted-foreground">Video Compression</h2>
</div>
<div className="border rounded-lg p-4 space-y-3">
<p className="text-xs text-muted-foreground">
FFmpeg command used by the video compression tool. Available placeholders: <code>{"{input}"}</code> and <code>{"{output}"}</code>.
</p>
<textarea
className="w-full min-h-24 rounded-md border border-input bg-background px-3 py-2 text-sm font-mono ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2"
value={ffmpegCommand}
onChange={(event) => setFfmpegCommand(event.target.value)}
spellCheck={false}
/>
<div className="flex justify-end">
<Button size="sm" onClick={saveFfmpegCommand} disabled={ffmpegCommandLoading}>
<Save className="h-3.5 w-3.5 mr-1" />
{ffmpegCommandLoading ? "Saving..." : "Save"}
</Button>
</div>
</div>
</section>
{/* Workflow API Key */}
<section>
<div className="flex items-center gap-2 mb-3">
+1
View File
@@ -16,6 +16,7 @@ export interface IAsset {
dateTimeOriginal: string;
orientation?: number | null | string;
downloadUrl?: string;
fileSizeInByte?: number | null;
}
export interface IAssetThumbhash {