7820592030

Committed 07 Feb 2024 08:11PM UTC coverage: 64.464% (-0.6%) from 65.017%

Build # 7820592030

Build Type

Pull #826

github

Committed by

web-flow

Commit Message

Merge 59506d7ac into 16350a9c2

Pull Request Pull Request #826: Fix for issue #794 (bugfix)

Run Details

1410 of 2516 branches covered (0.0%)

Branch coverage included in aggregate %.

25 of 29 new or added lines in 1 file covered. (86.21%)

47 existing lines in 4 files now uncovered.

4239 of 6247 relevant lines covered (67.86%)

13787.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

14.95

/src/backend/model/fileaccess/PhotoWorker.ts

/* eslint-disable @typescript-eslint/no-var-requires */
import * as sharp from 'sharp';
import {Metadata, Sharp} from 'sharp';
import {Logger} from '../../Logger';
import {FfmpegCommand, FfprobeData} from 'fluent-ffmpeg';
import {FFmpegFactory} from '../FFmpegFactory';
import * as path from 'path';
import {ExtensionDecorator} from '../extension/ExtensionDecorator';


sharp.cache(false);

export class PhotoWorker {
  private static videoRenderer: (input: MediaRendererInput) => Promise<void> = null;

  public static render(input: SvgRendererInput | MediaRendererInput): Promise<void> {
    if (input.type === ThumbnailSourceType.Photo) {
      return this.renderFromImage(input);
    }
    if (input.type === ThumbnailSourceType.Video) {
      return this.renderFromVideo(input as MediaRendererInput);
    }
    throw new Error('Unsupported media type to render thumbnail:' + input.type);
  }

  public static renderFromImage(input: SvgRendererInput | MediaRendererInput): Promise<void> {
    return ImageRendererFactory.render(input);
  }

  public static renderFromVideo(input: MediaRendererInput): Promise<void> {
    if (PhotoWorker.videoRenderer === null) {
      PhotoWorker.videoRenderer = VideoRendererFactory.build();
    }
    return PhotoWorker.videoRenderer(input);
  }
}

export enum ThumbnailSourceType {
  Photo = 1,
  Video = 2,
}

interface RendererInput {
  type: ThumbnailSourceType;
  size: number;
  makeSquare: boolean;
  outPath: string;
  quality: number;
  useLanczos3: boolean;
  animate: boolean; // animates the output. Used for Gifs
  cut?: {
    left: number;
    top: number;
    width: number;
    height: number;
  };
}

export interface MediaRendererInput extends RendererInput {
  mediaPath: string;
  smartSubsample: boolean;
}

export interface SvgRendererInput extends RendererInput {
  svgString: string;
}

export class VideoRendererFactory {
  public static build(): (input: MediaRendererInput) => Promise<void> {
    const ffmpeg = FFmpegFactory.get();
    return (input: MediaRendererInput): Promise<void> => {
      return new Promise((resolve, reject): void => {
        Logger.silly('[FFmpeg] rendering thumbnail: ' + input.mediaPath);

        ffmpeg(input.mediaPath).ffprobe((err: Error, data: FfprobeData): void => {
          if (!!err || data === null) {
            return reject('[FFmpeg] ' + err.toString());
          }

          let width = null;
          let height = null;
          for (const stream of data.streams) {
            if (stream.width) {
              width = stream.width;
              height = stream.height;
              break;
            }
          }
          if (!width || !height) {
            return reject('[FFmpeg] Can not read video dimension');
          }
          const command: FfmpegCommand = ffmpeg(input.mediaPath);
          const fileName = path.basename(input.outPath);
          const folder = path.dirname(input.outPath);
          let executedCmd = '';
          command
            .on('start', (cmd): void => {
              executedCmd = cmd;
            })
            .on('end', (): void => {
              resolve();
            })
            .on('error', (e): void => {
              reject('[FFmpeg] ' + e.toString() + ' executed: ' + executedCmd);
            })
            .outputOptions(['-qscale:v 4']);
          if (input.makeSquare === false) {
            const newSize =
              width < height
                ? Math.min(input.size, width) + 'x?'
                : '?x' + Math.min(input.size, height);
            command.takeScreenshots({
              timemarks: ['10%'],
              size: newSize,
              filename: fileName,
              folder,
            });
          } else {
            command.takeScreenshots({
              timemarks: ['10%'],
              size: input.size + 'x' + input.size,
              filename: fileName,
              folder,
            });
          }
        });
      });
    };
  }
}

export class ImageRendererFactory {

  @ExtensionDecorator(e => e.gallery.ImageRenderer.render)
  public static async render(input: MediaRendererInput | SvgRendererInput): Promise<void> {

    let image: Sharp;
    if ((input as MediaRendererInput).mediaPath) {
      Logger.silly(
        '[SharpRenderer] rendering photo:' +
        (input as MediaRendererInput).mediaPath +
        ', size:' +
        input.size
      );
      image = sharp((input as MediaRendererInput).mediaPath, {failOnError: false, animated: input.animate});
    } else {
      const svg_buffer = Buffer.from((input as SvgRendererInput).svgString);
      image = sharp(svg_buffer, {density: 450});
    }
    image.rotate();
    const metadata: Metadata = await image.metadata();
    const kernel =
      input.useLanczos3 === true
        ? sharp.kernel.lanczos3
        : sharp.kernel.nearest;

    if (input.cut) {
      image.extract(input.cut);
    }
    if (input.makeSquare === false) {
      if (metadata.height > metadata.width) {
        image.resize(Math.min(input.size, metadata.width), null, {
          kernel,
        });
      } else {
        image.resize(null, Math.min(input.size, metadata.height), {
          kernel,
        });
      }
    } else {
      image.resize(input.size, input.size, {
        kernel,
        position: sharp.gravity.centre,
        fit: 'cover',
      });
    }
    if ((input as MediaRendererInput).mediaPath) {
      await image.webp({
        effort: 6,
        quality: input.quality,
        smartSubsample: (input as MediaRendererInput).smartSubsample
      }).toFile(input.outPath);
    } else {
      if ((input as SvgRendererInput).svgString) {
        await image.png({effort: 6, quality: input.quality}).toFile(input.outPath);
      }
    }

  }
}

1	/* eslint-disable @typescript-eslint/no-var-requires */
2	import * as sharp from 'sharp';	1✔
3	import {Metadata, Sharp} from 'sharp';
4	import {Logger} from '../../Logger';	1✔
5	import {FfmpegCommand, FfprobeData} from 'fluent-ffmpeg';
6	import {FFmpegFactory} from '../FFmpegFactory';	1✔
7	import * as path from 'path';	1✔
8	import {ExtensionDecorator} from '../extension/ExtensionDecorator';	1✔
9
10
11	sharp.cache(false);	1✔
12
13	export class PhotoWorker {	1✔
14	private static videoRenderer: (input: MediaRendererInput) => Promise<void> = null;	1✔
15
16	public static render(input: SvgRendererInput \| MediaRendererInput): Promise<void> {
UNCOV 17	if (input.type === ThumbnailSourceType.Photo) {	×
18	return this.renderFromImage(input);	×
19	}
UNCOV 20	if (input.type === ThumbnailSourceType.Video) {	×
UNCOV 21	return this.renderFromVideo(input as MediaRendererInput);	×
22	}
23	throw new Error('Unsupported media type to render thumbnail:' + input.type);	×
24	}
25
26	public static renderFromImage(input: SvgRendererInput \| MediaRendererInput): Promise<void> {
27	return ImageRendererFactory.render(input);	×
28	}
29
30	public static renderFromVideo(input: MediaRendererInput): Promise<void> {
UNCOV 31	if (PhotoWorker.videoRenderer === null) {	×
UNCOV 32	PhotoWorker.videoRenderer = VideoRendererFactory.build();	×
33	}
UNCOV 34	return PhotoWorker.videoRenderer(input);	×
35	}
36	}
37
38	export enum ThumbnailSourceType {	1✔
39	Photo = 1,	1✔
40	Video = 2,	1✔
41	}
42
43	interface RendererInput {
44	type: ThumbnailSourceType;
45	size: number;
46	makeSquare: boolean;
47	outPath: string;
48	quality: number;
49	useLanczos3: boolean;
50	animate: boolean; // animates the output. Used for Gifs
51	cut?: {
52	left: number;
53	top: number;
54	width: number;
55	height: number;
56	};
57	}
58
59	export interface MediaRendererInput extends RendererInput {
60	mediaPath: string;
61	smartSubsample: boolean;
62	}
63
64	export interface SvgRendererInput extends RendererInput {
65	svgString: string;
66	}
67
68	export class VideoRendererFactory {	1✔
69	public static build(): (input: MediaRendererInput) => Promise<void> {
UNCOV 70	const ffmpeg = FFmpegFactory.get();	×
UNCOV 71	return (input: MediaRendererInput): Promise<void> => {	×
UNCOV 72	return new Promise((resolve, reject): void => {	×
UNCOV 73	Logger.silly('[FFmpeg] rendering thumbnail: ' + input.mediaPath);	×
74
UNCOV 75	ffmpeg(input.mediaPath).ffprobe((err: Error, data: FfprobeData): void => {	×
UNCOV 76	if (!!err \|\| data === null) {	×
77	return reject('[FFmpeg] ' + err.toString());	×
78	}
79
UNCOV 80	let width = null;	×
UNCOV 81	let height = null;	×
UNCOV 82	for (const stream of data.streams) {	×
UNCOV 83	if (stream.width) {	×
UNCOV 84	width = stream.width;	×
UNCOV 85	height = stream.height;	×
UNCOV 86	break;	×
87	}
88	}
UNCOV 89	if (!width \|\| !height) {	×
90	return reject('[FFmpeg] Can not read video dimension');	×
91	}
UNCOV 92	const command: FfmpegCommand = ffmpeg(input.mediaPath);	×
UNCOV 93	const fileName = path.basename(input.outPath);	×
UNCOV 94	const folder = path.dirname(input.outPath);	×
UNCOV 95	let executedCmd = '';	×
UNCOV 96	command	×
97	.on('start', (cmd): void => {
UNCOV 98	executedCmd = cmd;	×
99	})
100	.on('end', (): void => {
UNCOV 101	resolve();	×
102	})
103	.on('error', (e): void => {
104	reject('[FFmpeg] ' + e.toString() + ' executed: ' + executedCmd);	×
105	})
106	.outputOptions(['-qscale:v 4']);
UNCOV 107	if (input.makeSquare === false) {	×
108	const newSize =
UNCOV 109	width < height	×
110	? Math.min(input.size, width) + 'x?'
111	: '?x' + Math.min(input.size, height);
UNCOV 112	command.takeScreenshots({	×
113	timemarks: ['10%'],
114	size: newSize,
115	filename: fileName,
116	folder,
117	});
118	} else {
119	command.takeScreenshots({	×
120	timemarks: ['10%'],
121	size: input.size + 'x' + input.size,
122	filename: fileName,
123	folder,
124	});
125	}
126	});
127	});
128	};
129	}
130	}
131
132	export class ImageRendererFactory {	1✔
133
134	@ExtensionDecorator(e => e.gallery.ImageRenderer.render)	×
135	public static async render(input: MediaRendererInput \| SvgRendererInput): Promise<void> {	1✔
136
137	let image: Sharp;
138	if ((input as MediaRendererInput).mediaPath) {	×
139	Logger.silly(	×
140	'[SharpRenderer] rendering photo:' +
141	(input as MediaRendererInput).mediaPath +
142	', size:' +
143	input.size
144	);
145	image = sharp((input as MediaRendererInput).mediaPath, {failOnError: false, animated: input.animate});	×
146	} else {
147	const svg_buffer = Buffer.from((input as SvgRendererInput).svgString);	×
148	image = sharp(svg_buffer, {density: 450});	×
149	}
150	image.rotate();	×
151	const metadata: Metadata = await image.metadata();	×
152	const kernel =
153	input.useLanczos3 === true	×
154	? sharp.kernel.lanczos3
155	: sharp.kernel.nearest;
156
157	if (input.cut) {	×
158	image.extract(input.cut);	×
159	}
160	if (input.makeSquare === false) {	×
161	if (metadata.height > metadata.width) {	×
162	image.resize(Math.min(input.size, metadata.width), null, {	×
163	kernel,
164	});
165	} else {
166	image.resize(null, Math.min(input.size, metadata.height), {	×
167	kernel,
168	});
169	}
170	} else {
171	image.resize(input.size, input.size, {	×
172	kernel,
173	position: sharp.gravity.centre,
174	fit: 'cover',
175	});
176	}
177	if ((input as MediaRendererInput).mediaPath) {	×
178	await image.webp({	×
179	effort: 6,
180	quality: input.quality,
181	smartSubsample: (input as MediaRendererInput).smartSubsample
182	}).toFile(input.outPath);
183	} else {
184	if ((input as SvgRendererInput).svgString) {	×
185	await image.png({effort: 6, quality: input.quality}).toFile(input.outPath);	×
186	}
187	}
188
189	}
190	}

bpatrik / pigallery2 / 7820592030

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous