Store animated images as lossless webp

backend/src/managers/image/image-converter.service.ts

@@ -2,21 +2,28 @@ import { Injectable } from '@nestjs/common';
 import ms from 'ms';
 import { ImageRequestParams } from 'picsur-shared/dist/dto/api/image.dto';
 import {
-    FileType,
+  FileType,
-    SupportedFileTypeCategory,
+  SupportedFileTypeCategory,
 } from 'picsur-shared/dist/dto/mimes.dto';
 import { SysPreference } from 'picsur-shared/dist/dto/sys-preferences.enum';
 import {
-    AsyncFailable,
+  AsyncFailable,
-    Fail,
+  Fail,
-    FT,
+  FT,
-    HasFailed,
+  HasFailed,
 } from 'picsur-shared/dist/types/failable';
 import { SharpOptions } from 'sharp';
 import { SysPreferenceDbService } from '../../collections/preference-db/sys-preference-db.service.js';
 import { SharpWrapper } from '../../workers/sharp.wrapper.js';
 import { ImageResult } from './imageresult.js';
 
+interface InternalConvertOptions {
+  lossless?: boolean;
+  effort?: number;
+}
+
+export type ConvertOptions = ImageRequestParams & InternalConvertOptions;
+
 @Injectable()
 export class ImageConverterService {
   constructor(private readonly sysPref: SysPreferenceDbService) {}
@@ -25,7 +32,7 @@ export class ImageConverterService {
     image: Buffer,
     sourceFiletype: FileType,
     targetFiletype: FileType,
-    options: ImageRequestParams,
+    options: ConvertOptions,
   ): AsyncFailable<ImageResult> {
     if (
       sourceFiletype.identifier === targetFiletype.identifier &&
@@ -37,23 +44,22 @@ export class ImageConverterService {
       };
     }
 
-    if (targetFiletype.category === SupportedFileTypeCategory.Image) {
+    if (
-      return this.convertStill(image, sourceFiletype, targetFiletype, options);
+      targetFiletype.category === SupportedFileTypeCategory.Image ||
-    } else if (
       targetFiletype.category === SupportedFileTypeCategory.Animation
     ) {
-      return this.convertStill(image, sourceFiletype, targetFiletype, options);
+      return this.convertImage(image, sourceFiletype, targetFiletype, options);
       //return this.convertAnimation(image, targetmime, options);
     } else {
       return Fail(FT.SysValidation, 'Unsupported mime type');
     }
   }
 
-  private async convertStill(
+  private async convertImage(
     image: Buffer,
     sourceFiletype: FileType,
     targetFiletype: FileType,
-    options: ImageRequestParams,
+    options: ConvertOptions,
   ): AsyncFailable<ImageResult> {
     const [memLimit, timeLimit] = await Promise.all([
       this.sysPref.getNumberPreference(SysPreference.ConversionMemoryLimit),

backend/src/managers/image/image-processor.service.ts

@@ -1,15 +1,15 @@
 import { Injectable } from '@nestjs/common';
 import {
-    FileType,
+  FileType,
-    ImageFileType,
+  ImageFileType,
-    SupportedFileTypeCategory,
+  SupportedFileTypeCategory,
 } from 'picsur-shared/dist/dto/mimes.dto';
 
 import {
-    AsyncFailable,
+  AsyncFailable,
-    Fail,
+  Fail,
-    FT,
+  FT,
-    HasFailed,
+  HasFailed,
 } from 'picsur-shared/dist/types/failable';
 import { ParseFileType } from 'picsur-shared/dist/util/parse-mime';
 import { ImageConverterService } from './image-converter.service.js';
@@ -46,10 +46,12 @@ export class ImageProcessorService {
     image: Buffer,
     filetype: FileType,
   ): AsyncFailable<ImageResult> {
-    // Webps and gifs are stored as is for now
+    const outputFileType = ParseFileType(AnimFileType.WEBP);
-    return {
+    if (HasFailed(outputFileType)) return outputFileType;
-      image: image,
+
-      filetype: filetype.identifier,
+    return this.imageConverter.convert(image, filetype, outputFileType, {
-    };
+      lossless: true,
+      effort: 0,
+    });
   }
 }

backend/src/workers/sharp/sharp.message.ts

@@ -26,6 +26,10 @@ export type SharpWorkerOperation =
 
 export interface SharpWorkerFinishOptions {
   quality?: number;
+
+  // Only for internal use
+  lossless?: boolean;
+  effort?: number;
 }
 
 // Messages

backend/src/workers/sharp/universal-sharp.ts

@@ -2,10 +2,11 @@ import { BMPdecode, BMPencode } from 'bmp-img';
 import {
   AnimFileType,
   FileType,
-  ImageFileType,
+  ImageFileType
 } from 'picsur-shared/dist/dto/mimes.dto';
 import { QOIdecode, QOIencode } from 'qoi-img';
 import sharp, { Sharp, SharpOptions } from 'sharp';
+import { SharpWorkerFinishOptions } from './sharp.message';
 
 export interface SharpResult {
   data: Buffer;
@@ -72,9 +73,7 @@ function qoiSharpIn(image: Buffer, options?: SharpOptions) {
 export async function UniversalSharpOut(
   image: Sharp,
   filetype: FileType,
-  options?: {
+  options?: SharpWorkerFinishOptions,
-    quality?: number;
-  },
 ): Promise<SharpResult> {
   let result: SharpResult | undefined;
 
@@ -103,7 +102,11 @@ export async function UniversalSharpOut(
     case ImageFileType.WEBP:
     case AnimFileType.WEBP:
       result = await image
-        .webp({ quality: options?.quality })
+        .webp({
+          quality: options?.quality,
+          lossless: options?.lossless,
+          effort: options?.effort,
+        })
         .toBuffer({ resolveWithObject: true });
       break;
     case AnimFileType.GIF: