mirror of
https://github.com/immich-app/immich.git
synced 2026-03-22 10:50:02 +03:00
3991 lines
154 KiB
TypeScript
3991 lines
154 KiB
TypeScript
import { OutputInfo } from 'sharp';
|
|
import { SystemConfig } from 'src/config';
|
|
import { Exif } from 'src/database';
|
|
import { AssetEditAction } from 'src/dtos/editing.dto';
|
|
import {
|
|
AssetFileType,
|
|
AssetPathType,
|
|
AssetStatus,
|
|
AssetType,
|
|
AssetVisibility,
|
|
AudioCodec,
|
|
Colorspace,
|
|
ExifOrientation,
|
|
ImageFormat,
|
|
JobName,
|
|
JobStatus,
|
|
RawExtractedFormat,
|
|
TranscodeHardwareAcceleration,
|
|
TranscodePolicy,
|
|
VideoCodec,
|
|
} from 'src/enum';
|
|
import { MediaService } from 'src/services/media.service';
|
|
import { JobCounts, RawImageInfo } from 'src/types';
|
|
import { AssetFaceFactory } from 'test/factories/asset-face.factory';
|
|
import { AssetFactory } from 'test/factories/asset.factory';
|
|
import { probeStub } from 'test/fixtures/media.stub';
|
|
import { personStub, personThumbnailStub } from 'test/fixtures/person.stub';
|
|
import { systemConfigStub } from 'test/fixtures/system-config.stub';
|
|
import { factory } from 'test/small.factory';
|
|
import { makeStream, newTestService, ServiceMocks } from 'test/utils';
|
|
|
|
const fullsizeBuffer = Buffer.from('embedded image data');
|
|
const rawBuffer = Buffer.from('raw image data');
|
|
const extractedBuffer = Buffer.from('embedded image file');
|
|
|
|
describe(MediaService.name, () => {
|
|
let sut: MediaService;
|
|
let mocks: ServiceMocks;
|
|
|
|
beforeEach(() => {
|
|
({ sut, mocks } = newTestService(MediaService));
|
|
});
|
|
|
|
it('should be defined', () => {
|
|
expect(sut).toBeDefined();
|
|
});
|
|
|
|
// TODO these should all become medium tests of either the service or the repository.
|
|
// The entire logic of what to queue lives in the SQL query now
|
|
describe('handleQueueGenerateThumbnails', () => {
|
|
it('should queue all assets', async () => {
|
|
const asset = AssetFactory.create();
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([asset]));
|
|
|
|
mocks.person.getAll.mockReturnValue(makeStream([personStub.newThumbnail]));
|
|
|
|
await sut.handleQueueGenerateThumbnails({ force: true });
|
|
|
|
expect(mocks.assetJob.streamForThumbnailJob).toHaveBeenCalledWith({ force: true, fullsizeEnabled: false });
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{
|
|
name: JobName.AssetGenerateThumbnails,
|
|
data: { id: asset.id },
|
|
},
|
|
]);
|
|
|
|
expect(mocks.person.getAll).toHaveBeenCalledWith(undefined);
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{
|
|
name: JobName.PersonGenerateThumbnail,
|
|
data: { id: personStub.newThumbnail.id },
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('should queue trashed assets when force is true', async () => {
|
|
const asset = AssetFactory.create({ status: AssetStatus.Trashed, deletedAt: new Date() });
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([asset]));
|
|
mocks.person.getAll.mockReturnValue(makeStream());
|
|
|
|
await sut.handleQueueGenerateThumbnails({ force: true });
|
|
|
|
expect(mocks.assetJob.streamForThumbnailJob).toHaveBeenCalledWith({ force: true, fullsizeEnabled: false });
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{
|
|
name: JobName.AssetGenerateThumbnails,
|
|
data: { id: asset.id },
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('should queue archived assets when force is true', async () => {
|
|
const asset = AssetFactory.create({ visibility: AssetVisibility.Archive });
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([asset]));
|
|
mocks.person.getAll.mockReturnValue(makeStream());
|
|
|
|
await sut.handleQueueGenerateThumbnails({ force: true });
|
|
|
|
expect(mocks.assetJob.streamForThumbnailJob).toHaveBeenCalledWith({ force: true, fullsizeEnabled: false });
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{
|
|
name: JobName.AssetGenerateThumbnails,
|
|
data: { id: asset.id },
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('should queue all people with missing thumbnail path', async () => {
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([AssetFactory.create()]));
|
|
mocks.person.getAll.mockReturnValue(makeStream([personStub.noThumbnail, personStub.noThumbnail]));
|
|
mocks.person.getRandomFace.mockResolvedValueOnce(AssetFaceFactory.create());
|
|
|
|
await sut.handleQueueGenerateThumbnails({ force: false });
|
|
|
|
expect(mocks.assetJob.streamForThumbnailJob).toHaveBeenCalledWith({ force: false, fullsizeEnabled: false });
|
|
expect(mocks.person.getAll).toHaveBeenCalledWith({ thumbnailPath: '' });
|
|
expect(mocks.person.getRandomFace).toHaveBeenCalled();
|
|
expect(mocks.person.update).toHaveBeenCalledTimes(1);
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{
|
|
name: JobName.PersonGenerateThumbnail,
|
|
data: {
|
|
id: personStub.newThumbnail.id,
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('should queue all assets with missing resize path', async () => {
|
|
const asset = AssetFactory.create();
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([asset]));
|
|
mocks.person.getAll.mockReturnValue(makeStream());
|
|
await sut.handleQueueGenerateThumbnails({ force: false });
|
|
|
|
expect(mocks.assetJob.streamForThumbnailJob).toHaveBeenCalledWith({ force: false, fullsizeEnabled: false });
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{
|
|
name: JobName.AssetGenerateThumbnails,
|
|
data: { id: asset.id },
|
|
},
|
|
]);
|
|
|
|
expect(mocks.person.getAll).toHaveBeenCalledWith({ thumbnailPath: '' });
|
|
});
|
|
|
|
it('should queue all assets with missing preview', async () => {
|
|
const asset = AssetFactory.create();
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([asset]));
|
|
mocks.person.getAll.mockReturnValue(makeStream());
|
|
await sut.handleQueueGenerateThumbnails({ force: false });
|
|
|
|
expect(mocks.assetJob.streamForThumbnailJob).toHaveBeenCalledWith({ force: false, fullsizeEnabled: false });
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{ name: JobName.AssetGenerateThumbnails, data: { id: asset.id } },
|
|
]);
|
|
expect(mocks.person.getAll).toHaveBeenCalledWith({ thumbnailPath: '' });
|
|
});
|
|
|
|
it('should queue all assets with missing thumbhash', async () => {
|
|
const asset = AssetFactory.from({ thumbhash: null })
|
|
.files([AssetFileType.Thumbnail, AssetFileType.Preview])
|
|
.build();
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([asset]));
|
|
mocks.person.getAll.mockReturnValue(makeStream());
|
|
await sut.handleQueueGenerateThumbnails({ force: false });
|
|
|
|
expect(mocks.assetJob.streamForThumbnailJob).toHaveBeenCalledWith({ force: false, fullsizeEnabled: false });
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{ name: JobName.AssetGenerateThumbnails, data: { id: asset.id } },
|
|
]);
|
|
|
|
expect(mocks.person.getAll).toHaveBeenCalledWith({ thumbnailPath: '' });
|
|
});
|
|
|
|
it('should queue all assets with missing fullsize when feature is enabled', async () => {
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { fullsize: { enabled: true } } });
|
|
const asset = { id: factory.uuid(), isEdited: false };
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([asset]));
|
|
mocks.person.getAll.mockReturnValue(makeStream());
|
|
await sut.handleQueueGenerateThumbnails({ force: false });
|
|
|
|
expect(mocks.assetJob.streamForThumbnailJob).toHaveBeenCalledWith({ force: false, fullsizeEnabled: true });
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{
|
|
name: JobName.AssetGenerateThumbnails,
|
|
data: { id: asset.id },
|
|
},
|
|
]);
|
|
|
|
expect(mocks.person.getAll).toHaveBeenCalledWith({ thumbnailPath: '' });
|
|
});
|
|
|
|
it('should not queue assets with missing fullsize when feature is disabled', async () => {
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { fullsize: { enabled: false } } });
|
|
const asset = { id: factory.uuid(), isEdited: false };
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([asset]));
|
|
mocks.person.getAll.mockReturnValue(makeStream());
|
|
await sut.handleQueueGenerateThumbnails({ force: false });
|
|
|
|
expect(mocks.assetJob.streamForThumbnailJob).toHaveBeenCalledWith({ force: false, fullsizeEnabled: false });
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([]);
|
|
|
|
expect(mocks.person.getAll).toHaveBeenCalledWith({ thumbnailPath: '' });
|
|
});
|
|
|
|
it('should queue assets with edits but missing edited thumbnails', async () => {
|
|
const asset = AssetFactory.from().edit().build();
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([asset]));
|
|
mocks.person.getAll.mockReturnValue(makeStream());
|
|
await sut.handleQueueGenerateThumbnails({ force: false });
|
|
|
|
expect(mocks.assetJob.streamForThumbnailJob).toHaveBeenCalledWith({ force: false, fullsizeEnabled: false });
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{
|
|
name: JobName.AssetEditThumbnailGeneration,
|
|
data: { id: asset.id },
|
|
},
|
|
]);
|
|
|
|
expect(mocks.person.getAll).toHaveBeenCalledWith({ thumbnailPath: '' });
|
|
});
|
|
|
|
it('should not queue assets with missing edited fullsize when feature is disabled', async () => {
|
|
const asset = AssetFactory.from().edit().build();
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { fullsize: { enabled: false } } });
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([asset]));
|
|
mocks.person.getAll.mockReturnValue(makeStream());
|
|
await sut.handleQueueGenerateThumbnails({ force: false });
|
|
|
|
expect(mocks.assetJob.streamForThumbnailJob).toHaveBeenCalledWith({ force: false, fullsizeEnabled: false });
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([]);
|
|
|
|
expect(mocks.person.getAll).toHaveBeenCalledWith({ thumbnailPath: '' });
|
|
});
|
|
|
|
it('should queue assets with missing fullsize when force is true, regardless of setting', async () => {
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { fullsize: { enabled: false } } });
|
|
const asset = { id: factory.uuid(), isEdited: false };
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([asset]));
|
|
mocks.person.getAll.mockReturnValue(makeStream());
|
|
await sut.handleQueueGenerateThumbnails({ force: true });
|
|
|
|
expect(mocks.assetJob.streamForThumbnailJob).toHaveBeenCalledWith({ force: true, fullsizeEnabled: false });
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{
|
|
name: JobName.AssetGenerateThumbnails,
|
|
data: { id: asset.id },
|
|
},
|
|
]);
|
|
|
|
expect(mocks.person.getAll).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should queue both regular and edited thumbnails for assets with edits when force is true', async () => {
|
|
const asset = AssetFactory.from().edit().build();
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([asset]));
|
|
mocks.person.getAll.mockReturnValue(makeStream());
|
|
await sut.handleQueueGenerateThumbnails({ force: true });
|
|
|
|
expect(mocks.assetJob.streamForThumbnailJob).toHaveBeenCalledWith({ force: true, fullsizeEnabled: false });
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{
|
|
name: JobName.AssetGenerateThumbnails,
|
|
data: { id: asset.id },
|
|
},
|
|
{
|
|
name: JobName.AssetEditThumbnailGeneration,
|
|
data: { id: asset.id },
|
|
},
|
|
]);
|
|
|
|
expect(mocks.person.getAll).toHaveBeenCalledWith(undefined);
|
|
});
|
|
});
|
|
|
|
describe('handleQueueMigration', () => {
|
|
it('should remove empty directories and queue jobs', async () => {
|
|
const asset = AssetFactory.create();
|
|
mocks.assetJob.streamForMigrationJob.mockReturnValue(makeStream([asset]));
|
|
mocks.job.getJobCounts.mockResolvedValue({ active: 1, waiting: 0 } as JobCounts);
|
|
mocks.person.getAll.mockReturnValue(makeStream([personStub.withName]));
|
|
|
|
await expect(sut.handleQueueMigration()).resolves.toBe(JobStatus.Success);
|
|
|
|
expect(mocks.storage.removeEmptyDirs).toHaveBeenCalledTimes(2);
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([{ name: JobName.AssetFileMigration, data: { id: asset.id } }]);
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{ name: JobName.PersonFileMigration, data: { id: personStub.withName.id } },
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('handleAssetMigration', () => {
|
|
it('should fail if asset does not exist', async () => {
|
|
mocks.assetJob.getForMigrationJob.mockResolvedValue(void 0);
|
|
await expect(sut.handleAssetMigration({ id: 'non-existent' })).resolves.toBe(JobStatus.Failed);
|
|
|
|
expect(mocks.move.getByEntity).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should move asset files', async () => {
|
|
const asset = AssetFactory.from()
|
|
.files([AssetFileType.FullSize, AssetFileType.Preview, AssetFileType.Thumbnail])
|
|
.build();
|
|
mocks.assetJob.getForMigrationJob.mockResolvedValue(asset);
|
|
mocks.move.create.mockResolvedValue({
|
|
entityId: asset.id,
|
|
id: 'move-id',
|
|
newPath: '/new/path',
|
|
oldPath: '/old/path',
|
|
pathType: AssetPathType.Original,
|
|
});
|
|
|
|
await expect(sut.handleAssetMigration({ id: asset.id })).resolves.toBe(JobStatus.Success);
|
|
expect(mocks.move.create).toHaveBeenCalledWith({
|
|
entityId: asset.id,
|
|
pathType: AssetFileType.FullSize,
|
|
oldPath: asset.files[0].path,
|
|
newPath: `/data/thumbs/${asset.ownerId}/${asset.id.slice(0, 2)}/${asset.id.slice(2, 4)}/${asset.id}_fullsize.jpeg`,
|
|
});
|
|
expect(mocks.move.create).toHaveBeenCalledWith({
|
|
entityId: asset.id,
|
|
pathType: AssetFileType.Preview,
|
|
oldPath: asset.files[1].path,
|
|
newPath: `/data/thumbs/${asset.ownerId}/${asset.id.slice(0, 2)}/${asset.id.slice(2, 4)}/${asset.id}_preview.jpeg`,
|
|
});
|
|
expect(mocks.move.create).toHaveBeenCalledWith({
|
|
entityId: asset.id,
|
|
pathType: AssetFileType.Thumbnail,
|
|
oldPath: asset.files[2].path,
|
|
newPath: `/data/thumbs/${asset.ownerId}/${asset.id.slice(0, 2)}/${asset.id.slice(2, 4)}/${asset.id}_thumbnail.webp`,
|
|
});
|
|
expect(mocks.move.create).toHaveBeenCalledTimes(3);
|
|
});
|
|
});
|
|
|
|
describe('handleGenerateThumbnails', () => {
|
|
let rawInfo: RawImageInfo;
|
|
|
|
beforeEach(() => {
|
|
rawInfo = { width: 100, height: 100, channels: 3 };
|
|
mocks.person.getFaces.mockResolvedValue([]);
|
|
mocks.ocr.getByAssetId.mockResolvedValue([]);
|
|
mocks.media.decodeImage.mockImplementation((input) =>
|
|
Promise.resolve(
|
|
typeof input === 'string'
|
|
? { data: rawBuffer, info: rawInfo as OutputInfo } // string implies original file
|
|
: { data: fullsizeBuffer, info: rawInfo as OutputInfo }, // buffer implies embedded image extracted
|
|
),
|
|
);
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 100, height: 100, isTransparent: false });
|
|
});
|
|
|
|
it('should skip thumbnail generation if asset not found', async () => {
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(void 0);
|
|
await sut.handleGenerateThumbnails({ id: 'non-existent' });
|
|
|
|
expect(mocks.media.generateThumbnail).not.toHaveBeenCalled();
|
|
expect(mocks.asset.update).not.toHaveBeenCalledWith();
|
|
});
|
|
|
|
it('should skip thumbnail generation if asset type is unknown', async () => {
|
|
const asset = AssetFactory.create({ type: 'foo' as AssetType });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await expect(sut.handleGenerateThumbnails({ id: asset.id })).resolves.toBe(JobStatus.Skipped);
|
|
expect(mocks.media.probe).not.toHaveBeenCalled();
|
|
expect(mocks.media.generateThumbnail).not.toHaveBeenCalled();
|
|
expect(mocks.asset.update).not.toHaveBeenCalledWith();
|
|
});
|
|
|
|
it('should skip video thumbnail generation if no video stream', async () => {
|
|
const asset = AssetFactory.create({ type: AssetType.Video });
|
|
mocks.media.probe.mockResolvedValue(probeStub.noVideoStreams);
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
await expect(sut.handleGenerateThumbnails({ id: asset.id })).rejects.toThrowError();
|
|
expect(mocks.media.generateThumbnail).not.toHaveBeenCalled();
|
|
expect(mocks.asset.update).not.toHaveBeenCalledWith();
|
|
});
|
|
|
|
it('should skip invisible assets', async () => {
|
|
const asset = AssetFactory.create({ visibility: AssetVisibility.Hidden });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
expect(await sut.handleGenerateThumbnails({ id: asset.id })).toEqual(JobStatus.Skipped);
|
|
|
|
expect(mocks.media.generateThumbnail).not.toHaveBeenCalled();
|
|
expect(mocks.asset.update).not.toHaveBeenCalledWith();
|
|
});
|
|
|
|
it('should delete previous preview if different path', async () => {
|
|
const asset = AssetFactory.from().file({ type: AssetFileType.Preview }).exif().build();
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { thumbnail: { format: ImageFormat.Webp } } });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.job.queue).toHaveBeenCalledWith({
|
|
name: JobName.FileDelete,
|
|
data: {
|
|
files: expect.arrayContaining([asset.files[0].path]),
|
|
},
|
|
});
|
|
});
|
|
|
|
it('should generate P3 thumbnails for a wide gamut image', async () => {
|
|
const asset = AssetFactory.from()
|
|
.exif({ profileDescription: 'Adobe RGB', bitsPerSample: 14 })
|
|
.files([AssetFileType.Preview, AssetFileType.Thumbnail])
|
|
.build();
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
const thumbhashBuffer = Buffer.from('a thumbhash', 'utf8');
|
|
mocks.media.generateThumbhash.mockResolvedValue(thumbhashBuffer);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.storage.mkdirSync).toHaveBeenCalledWith(expect.any(String));
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledOnce();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(asset.originalPath, {
|
|
colorspace: Colorspace.P3,
|
|
processInvalidImages: false,
|
|
size: 1440,
|
|
});
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledTimes(2);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Jpeg,
|
|
size: 1440,
|
|
quality: 80,
|
|
progressive: false,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
},
|
|
expect.any(String),
|
|
);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Webp,
|
|
size: 250,
|
|
quality: 80,
|
|
progressive: false,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
},
|
|
expect.any(String),
|
|
);
|
|
|
|
expect(mocks.media.generateThumbhash).toHaveBeenCalledOnce();
|
|
expect(mocks.media.generateThumbhash).toHaveBeenCalledWith(rawBuffer, {
|
|
colorspace: Colorspace.P3,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
});
|
|
|
|
expect(mocks.asset.upsertFiles).toHaveBeenCalledWith([
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Preview,
|
|
path: expect.any(String),
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Thumbnail,
|
|
path: expect.any(String),
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
]);
|
|
expect(mocks.asset.update).toHaveBeenCalledWith({ id: asset.id, thumbhash: thumbhashBuffer });
|
|
});
|
|
|
|
it('should generate a thumbnail for a video', async () => {
|
|
const asset = AssetFactory.create({ type: AssetType.Video, originalPath: '/original/path.ext' });
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream2160p);
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.storage.mkdirSync).toHaveBeenCalledWith(expect.any(String));
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: ['-skip_frame nointra', '-sws_flags accurate_rnd+full_chroma_int'],
|
|
outputOptions: [
|
|
'-fps_mode vfr',
|
|
'-frames:v 1',
|
|
'-update 1',
|
|
'-v verbose',
|
|
String.raw`-vf fps=12:start_time=0:eof_action=pass:round=down,thumbnail=12,select=gt(scene\,0.1)-eq(prev_selected_n\,n)+isnan(prev_selected_n)+gt(n\,20),trim=end_frame=2,reverse,scale=-2:1440:flags=lanczos+accurate_rnd+full_chroma_int:out_range=pc`,
|
|
],
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
expect(mocks.asset.upsertFiles).toHaveBeenCalledWith([
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Preview,
|
|
path: expect.any(String),
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Thumbnail,
|
|
path: expect.any(String),
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('should tonemap thumbnail for hdr video', async () => {
|
|
const asset = AssetFactory.create({ type: AssetType.Video, originalPath: '/original/path.ext' });
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamHDR);
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.storage.mkdirSync).toHaveBeenCalledWith(expect.any(String));
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: ['-skip_frame nointra', '-sws_flags accurate_rnd+full_chroma_int'],
|
|
outputOptions: [
|
|
'-fps_mode vfr',
|
|
'-frames:v 1',
|
|
'-update 1',
|
|
'-v verbose',
|
|
String.raw`-vf fps=12:start_time=0:eof_action=pass:round=down,thumbnail=12,select=gt(scene\,0.1)-eq(prev_selected_n\,n)+isnan(prev_selected_n)+gt(n\,20),trim=end_frame=2,reverse,tonemapx=tonemap=hable:desat=0:p=bt709:t=bt709:m=bt709:r=pc:peak=100:format=yuv420p`,
|
|
],
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
expect(mocks.asset.upsertFiles).toHaveBeenCalledWith([
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Preview,
|
|
path: expect.any(String),
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Thumbnail,
|
|
path: expect.any(String),
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('should always generate video thumbnail in one pass', async () => {
|
|
const asset = AssetFactory.create({ type: AssetType.Video, originalPath: '/original/path.ext' });
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamHDR);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { twoPass: true, maxBitrate: '5000k' },
|
|
});
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: ['-skip_frame nointra', '-sws_flags accurate_rnd+full_chroma_int'],
|
|
outputOptions: [
|
|
'-fps_mode vfr',
|
|
'-frames:v 1',
|
|
'-update 1',
|
|
'-v verbose',
|
|
String.raw`-vf fps=12:start_time=0:eof_action=pass:round=down,thumbnail=12,select=gt(scene\,0.1)-eq(prev_selected_n\,n)+isnan(prev_selected_n)+gt(n\,20),trim=end_frame=2,reverse,tonemapx=tonemap=hable:desat=0:p=bt709:t=bt709:m=bt709:r=pc:peak=100:format=yuv420p`,
|
|
],
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should not skip intra frames for MTS file', async () => {
|
|
const asset = AssetFactory.create({ type: AssetType.Video, originalPath: '/original/path.ext' });
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamMTS);
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: ['-sws_flags accurate_rnd+full_chroma_int'],
|
|
outputOptions: expect.any(Array),
|
|
progress: expect.any(Object),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should override reserved color metadata', async () => {
|
|
const asset = AssetFactory.create({ type: AssetType.Video, originalPath: '/original/path.ext' });
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamReserved);
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-bsf:v hevc_metadata=colour_primaries=1:matrix_coefficients=1:transfer_characteristics=1',
|
|
]),
|
|
outputOptions: expect.any(Array),
|
|
progress: expect.any(Object),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should use scaling divisible by 2 even when using quick sync', async () => {
|
|
const asset = AssetFactory.create({ type: AssetType.Video, originalPath: '/original/path.ext' });
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream2160p);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { accel: TranscodeHardwareAcceleration.Qsv } });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining([expect.stringContaining('scale=-2:1440')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it.each(Object.values(ImageFormat))('should generate an image preview in %s format', async (format) => {
|
|
const asset = AssetFactory.from().exif().build();
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { preview: { format } } });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
const thumbhashBuffer = Buffer.from('a thumbhash', 'utf8');
|
|
mocks.media.generateThumbhash.mockResolvedValue(thumbhashBuffer);
|
|
const previewPath = `/data/thumbs/${asset.ownerId}/${asset.id.slice(0, 2)}/${asset.id.slice(2, 4)}/${asset.id}_preview.${format}`;
|
|
const thumbnailPath = `/data/thumbs/${asset.ownerId}/${asset.id.slice(0, 2)}/${asset.id.slice(2, 4)}/${asset.id}_thumbnail.webp`;
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.storage.mkdirSync).toHaveBeenCalledWith(expect.any(String));
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledOnce();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(asset.originalPath, {
|
|
colorspace: Colorspace.Srgb,
|
|
processInvalidImages: false,
|
|
size: 1440,
|
|
});
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledTimes(2);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
{
|
|
colorspace: Colorspace.Srgb,
|
|
format,
|
|
size: 1440,
|
|
quality: 80,
|
|
progressive: false,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
},
|
|
previewPath,
|
|
);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
{
|
|
colorspace: Colorspace.Srgb,
|
|
format: ImageFormat.Webp,
|
|
size: 250,
|
|
quality: 80,
|
|
progressive: false,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
},
|
|
thumbnailPath,
|
|
);
|
|
});
|
|
|
|
it.each(Object.values(ImageFormat))('should generate an image thumbnail in %s format', async (format) => {
|
|
const asset = AssetFactory.from().exif().build();
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { thumbnail: { format } } });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
const thumbhashBuffer = Buffer.from('a thumbhash', 'utf8');
|
|
mocks.media.generateThumbhash.mockResolvedValue(thumbhashBuffer);
|
|
const previewPath = `/data/thumbs/${asset.ownerId}/${asset.id.slice(0, 2)}/${asset.id.slice(2, 4)}/${asset.id}_preview.jpeg`;
|
|
const thumbnailPath = `/data/thumbs/${asset.ownerId}/${asset.id.slice(0, 2)}/${asset.id.slice(2, 4)}/${asset.id}_thumbnail.${format}`;
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.storage.mkdirSync).toHaveBeenCalledWith(expect.any(String));
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledOnce();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(asset.originalPath, {
|
|
colorspace: Colorspace.Srgb,
|
|
processInvalidImages: false,
|
|
size: 1440,
|
|
});
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledTimes(2);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
{
|
|
colorspace: Colorspace.Srgb,
|
|
format: ImageFormat.Jpeg,
|
|
size: 1440,
|
|
quality: 80,
|
|
progressive: false,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
},
|
|
previewPath,
|
|
);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
{
|
|
colorspace: Colorspace.Srgb,
|
|
format,
|
|
size: 250,
|
|
quality: 80,
|
|
progressive: false,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
},
|
|
thumbnailPath,
|
|
);
|
|
});
|
|
|
|
it('should generate progressive JPEG for preview when enabled', async () => {
|
|
const asset = AssetFactory.from().exif().build();
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
image: { preview: { progressive: true }, thumbnail: { progressive: false } },
|
|
});
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
expect.objectContaining({
|
|
format: ImageFormat.Jpeg,
|
|
progressive: true,
|
|
}),
|
|
expect.stringContaining('preview.jpeg'),
|
|
);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
expect.objectContaining({
|
|
format: ImageFormat.Webp,
|
|
progressive: false,
|
|
}),
|
|
expect.stringContaining('thumbnail.webp'),
|
|
);
|
|
expect(mocks.asset.upsertFiles).toHaveBeenCalledWith([
|
|
expect.objectContaining({
|
|
type: AssetFileType.Preview,
|
|
isProgressive: true,
|
|
isTransparent: false,
|
|
}),
|
|
expect.objectContaining({
|
|
type: AssetFileType.Thumbnail,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
}),
|
|
]);
|
|
});
|
|
|
|
it('should generate progressive JPEG for thumbnail when enabled', async () => {
|
|
const asset = AssetFactory.from().exif().build();
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
image: { preview: { progressive: false }, thumbnail: { format: ImageFormat.Jpeg, progressive: true } },
|
|
});
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
expect.objectContaining({
|
|
format: ImageFormat.Jpeg,
|
|
progressive: false,
|
|
}),
|
|
expect.stringContaining('preview.jpeg'),
|
|
);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
expect.objectContaining({
|
|
format: ImageFormat.Jpeg,
|
|
progressive: true,
|
|
}),
|
|
expect.stringContaining('thumbnail.jpeg'),
|
|
);
|
|
expect(mocks.asset.upsertFiles).toHaveBeenCalledWith([
|
|
expect.objectContaining({
|
|
type: AssetFileType.Preview,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
}),
|
|
expect.objectContaining({
|
|
type: AssetFileType.Thumbnail,
|
|
isProgressive: true,
|
|
isTransparent: false,
|
|
}),
|
|
]);
|
|
});
|
|
|
|
it('should never set isProgressive for videos', async () => {
|
|
const asset = AssetFactory.create({ type: AssetType.Video, originalPath: '/original/path.ext' });
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamHDR);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
image: { preview: { progressive: true }, thumbnail: { progressive: true } },
|
|
});
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.asset.upsertFiles).toHaveBeenCalledWith([
|
|
expect.objectContaining({
|
|
type: AssetFileType.Preview,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
}),
|
|
expect.objectContaining({
|
|
type: AssetFileType.Thumbnail,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
}),
|
|
]);
|
|
});
|
|
|
|
it('should delete previous thumbnail if different path', async () => {
|
|
const asset = AssetFactory.from().exif().file({ type: AssetFileType.Preview }).build();
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { thumbnail: { format: ImageFormat.Webp } } });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.job.queue).toHaveBeenCalledWith({
|
|
name: JobName.FileDelete,
|
|
data: {
|
|
files: expect.arrayContaining([asset.files[0].path]),
|
|
},
|
|
});
|
|
});
|
|
|
|
it('should extract embedded image if enabled and available', async () => {
|
|
const asset = AssetFactory.from({ originalFileName: 'file.dng' })
|
|
.exif({ fileSizeInByte: 5000, profileDescription: 'Adobe RGB', bitsPerSample: 14, orientation: undefined })
|
|
.build();
|
|
mocks.media.extract.mockResolvedValue({ buffer: extractedBuffer, format: RawExtractedFormat.Jpeg });
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 3840, height: 2160, isTransparent: false });
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { extractEmbedded: true } });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledOnce();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(extractedBuffer, {
|
|
colorspace: Colorspace.P3,
|
|
processInvalidImages: false,
|
|
size: 1440,
|
|
});
|
|
});
|
|
|
|
it('should not check transparency metadata for raw files without extracted images', async () => {
|
|
const asset = AssetFactory.from({ originalFileName: 'file.dng' })
|
|
.exif({ fileSizeInByte: 5000, profileDescription: 'Adobe RGB', bitsPerSample: 14, orientation: undefined })
|
|
.build();
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { extractEmbedded: false } });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.getImageMetadata).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should not check transparency metadata for raw files with extracted images', async () => {
|
|
const asset = AssetFactory.from({ originalFileName: 'file.dng' })
|
|
.exif({ fileSizeInByte: 5000, profileDescription: 'Adobe RGB', bitsPerSample: 14, orientation: undefined })
|
|
.build();
|
|
mocks.media.extract.mockResolvedValue({ buffer: extractedBuffer, format: RawExtractedFormat.Jpeg });
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 3840, height: 2160, isTransparent: false });
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { extractEmbedded: true } });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.getImageMetadata).toHaveBeenCalledOnce();
|
|
expect(mocks.media.getImageMetadata).toHaveBeenCalledWith(extractedBuffer);
|
|
});
|
|
|
|
it('should resize original image if embedded image is too small', async () => {
|
|
const asset = AssetFactory.from({ originalFileName: 'file.dng' })
|
|
.exif({ fileSizeInByte: 5000, profileDescription: 'Adobe RGB', bitsPerSample: 14, orientation: undefined })
|
|
.build();
|
|
mocks.media.extract.mockResolvedValue({ buffer: extractedBuffer, format: RawExtractedFormat.Jpeg });
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 1000, height: 1000, isTransparent: false });
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { extractEmbedded: true } });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(asset.originalPath, {
|
|
colorspace: Colorspace.P3,
|
|
processInvalidImages: false,
|
|
size: 1440,
|
|
});
|
|
});
|
|
|
|
it('should resize original image if embedded image not found', async () => {
|
|
const asset = AssetFactory.from({ originalFileName: 'file.dng' })
|
|
.exif({ fileSizeInByte: 5000, profileDescription: 'Adobe RGB', bitsPerSample: 14, orientation: undefined })
|
|
.build();
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { extractEmbedded: true } });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledOnce();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(asset.originalPath, {
|
|
colorspace: Colorspace.P3,
|
|
processInvalidImages: false,
|
|
size: 1440,
|
|
});
|
|
});
|
|
|
|
it('should resize original image if embedded image extraction is not enabled', async () => {
|
|
const asset = AssetFactory.from({ originalFileName: 'file.dng' })
|
|
.exif({ fileSizeInByte: 5000, profileDescription: 'Adobe RGB', bitsPerSample: 14, orientation: undefined })
|
|
.build();
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { extractEmbedded: false } });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.extract).not.toHaveBeenCalled();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledOnce();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(asset.originalPath, {
|
|
colorspace: Colorspace.P3,
|
|
processInvalidImages: false,
|
|
size: 1440,
|
|
});
|
|
});
|
|
|
|
it('should process invalid images if enabled', async () => {
|
|
vi.stubEnv('IMMICH_PROCESS_INVALID_IMAGES', 'true');
|
|
const asset = AssetFactory.from({ originalFileName: 'file.dng' })
|
|
.exif({ fileSizeInByte: 5000, profileDescription: 'Adobe RGB', bitsPerSample: 14, orientation: undefined })
|
|
.build();
|
|
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledOnce();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(
|
|
asset.originalPath,
|
|
expect.objectContaining({ processInvalidImages: true }),
|
|
);
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledTimes(2);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
expect.objectContaining({ processInvalidImages: false }),
|
|
expect.any(String),
|
|
);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
expect.objectContaining({ processInvalidImages: false }),
|
|
expect.any(String),
|
|
);
|
|
|
|
expect(mocks.media.generateThumbhash).toHaveBeenCalledOnce();
|
|
expect(mocks.media.generateThumbhash).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
expect.objectContaining({ processInvalidImages: false }),
|
|
);
|
|
|
|
vi.unstubAllEnvs();
|
|
});
|
|
|
|
it('should extract full-size JPEG preview from RAW', async () => {
|
|
const asset = AssetFactory.from({ originalFileName: 'file.dng' })
|
|
.exif({ fileSizeInByte: 5000, profileDescription: 'Adobe RGB', bitsPerSample: 14, orientation: undefined })
|
|
.build();
|
|
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
image: { fullsize: { enabled: true, format: ImageFormat.Webp }, extractEmbedded: true },
|
|
});
|
|
mocks.media.extract.mockResolvedValue({ buffer: extractedBuffer, format: RawExtractedFormat.Jpeg });
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 3840, height: 2160, isTransparent: false });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledOnce();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(extractedBuffer, {
|
|
colorspace: Colorspace.P3,
|
|
processInvalidImages: false,
|
|
size: 1440, // capped to preview size as fullsize conversion is skipped
|
|
});
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledTimes(2);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
fullsizeBuffer,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Jpeg,
|
|
size: 1440,
|
|
quality: 80,
|
|
progressive: false,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
},
|
|
expect.any(String),
|
|
);
|
|
});
|
|
|
|
it('should convert full-size WEBP preview from JXL preview of RAW', async () => {
|
|
const asset = AssetFactory.from({ originalFileName: 'file.dng' })
|
|
.exif({ fileSizeInByte: 5000, profileDescription: 'Adobe RGB', bitsPerSample: 14, orientation: undefined })
|
|
.build();
|
|
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
image: { fullsize: { enabled: true, format: ImageFormat.Webp }, extractEmbedded: true },
|
|
});
|
|
mocks.media.extract.mockResolvedValue({ buffer: extractedBuffer, format: RawExtractedFormat.Jxl });
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 3840, height: 2160, isTransparent: false });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledOnce();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(extractedBuffer, {
|
|
colorspace: Colorspace.P3,
|
|
processInvalidImages: false,
|
|
});
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledTimes(3);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
fullsizeBuffer,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Webp,
|
|
quality: 80,
|
|
progressive: false,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
},
|
|
expect.any(String),
|
|
);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
fullsizeBuffer,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Jpeg,
|
|
size: 1440,
|
|
quality: 80,
|
|
progressive: false,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
},
|
|
expect.any(String),
|
|
);
|
|
});
|
|
|
|
it('should generate full-size preview directly from RAW images when extractEmbedded is false', async () => {
|
|
const asset = AssetFactory.from({ originalFileName: 'file.dng' })
|
|
.exif({ fileSizeInByte: 5000, profileDescription: 'Adobe RGB', bitsPerSample: 14, orientation: undefined })
|
|
.build();
|
|
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { fullsize: { enabled: true }, extractEmbedded: false } });
|
|
mocks.media.extract.mockResolvedValue({ buffer: extractedBuffer, format: RawExtractedFormat.Jpeg });
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 3840, height: 2160, isTransparent: false });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledOnce();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(asset.originalPath, {
|
|
colorspace: Colorspace.P3,
|
|
processInvalidImages: false,
|
|
});
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledTimes(3);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Jpeg,
|
|
quality: 80,
|
|
progressive: false,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
},
|
|
expect.any(String),
|
|
);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Jpeg,
|
|
quality: 80,
|
|
progressive: false,
|
|
size: 1440,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
},
|
|
expect.any(String),
|
|
);
|
|
});
|
|
|
|
it('should generate full-size preview from non-web-friendly images', async () => {
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { fullsize: { enabled: true } } });
|
|
mocks.media.extract.mockResolvedValue({ buffer: extractedBuffer, format: RawExtractedFormat.Jpeg });
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 3840, height: 2160, isTransparent: false });
|
|
// HEIF/HIF image taken by cameras are not web-friendly, only has limited support on Safari.
|
|
const asset = AssetFactory.from({ originalFileName: 'image.hif' })
|
|
.exif({
|
|
fileSizeInByte: 5000,
|
|
profileDescription: 'Adobe RGB',
|
|
bitsPerSample: 14,
|
|
})
|
|
.build();
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledOnce();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(asset.originalPath, {
|
|
colorspace: Colorspace.P3,
|
|
processInvalidImages: false,
|
|
});
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledTimes(3);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Jpeg,
|
|
quality: 80,
|
|
progressive: false,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
},
|
|
expect.any(String),
|
|
);
|
|
});
|
|
|
|
it('should skip generating full-size preview for web-friendly images', async () => {
|
|
const asset = AssetFactory.from().exif().build();
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { fullsize: { enabled: true } } });
|
|
mocks.media.extract.mockResolvedValue({ buffer: extractedBuffer, format: RawExtractedFormat.Jpeg });
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 3840, height: 2160, isTransparent: false });
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledOnce();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(asset.originalPath, {
|
|
colorspace: Colorspace.Srgb,
|
|
processInvalidImages: false,
|
|
size: 1440,
|
|
});
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledTimes(2);
|
|
expect(mocks.media.generateThumbnail).not.toHaveBeenCalledWith(
|
|
expect.anything(),
|
|
expect.anything(),
|
|
expect.stringContaining('fullsize.jpeg'),
|
|
);
|
|
});
|
|
|
|
it('should always generate full-size preview from non-web-friendly panoramas', async () => {
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { fullsize: { enabled: false } } });
|
|
mocks.media.extract.mockResolvedValue({ buffer: extractedBuffer, format: RawExtractedFormat.Jpeg });
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 3840, height: 2160, isTransparent: false });
|
|
mocks.media.copyTagGroup.mockResolvedValue(true);
|
|
|
|
const asset = AssetFactory.from({ originalFileName: 'panorama.tif' })
|
|
.exif({
|
|
fileSizeInByte: 5000,
|
|
projectionType: 'EQUIRECTANGULAR',
|
|
})
|
|
.build();
|
|
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledOnce();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(asset.originalPath, {
|
|
colorspace: Colorspace.Srgb,
|
|
orientation: undefined,
|
|
processInvalidImages: false,
|
|
size: undefined,
|
|
});
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledTimes(3);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
{
|
|
colorspace: Colorspace.Srgb,
|
|
format: ImageFormat.Jpeg,
|
|
quality: 80,
|
|
progressive: false,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
},
|
|
expect.any(String),
|
|
);
|
|
|
|
expect(mocks.media.copyTagGroup).toHaveBeenCalledTimes(2);
|
|
expect(mocks.media.copyTagGroup).toHaveBeenCalledWith('XMP-GPano', asset.originalPath, expect.any(String));
|
|
});
|
|
|
|
it('should respect encoding options when generating full-size preview', async () => {
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
image: { fullsize: { enabled: true, format: ImageFormat.Webp, quality: 90 } },
|
|
});
|
|
mocks.media.extract.mockResolvedValue({ buffer: extractedBuffer, format: RawExtractedFormat.Jpeg });
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 3840, height: 2160, isTransparent: false });
|
|
// HEIF/HIF image taken by cameras are not web-friendly, only has limited support on Safari.
|
|
const asset = AssetFactory.from({ originalFileName: 'image.hif' })
|
|
.exif({
|
|
fileSizeInByte: 5000,
|
|
profileDescription: 'Adobe RGB',
|
|
bitsPerSample: 14,
|
|
})
|
|
.build();
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledOnce();
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(asset.originalPath, {
|
|
colorspace: Colorspace.P3,
|
|
processInvalidImages: false,
|
|
});
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledTimes(3);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Webp,
|
|
quality: 90,
|
|
progressive: false,
|
|
processInvalidImages: false,
|
|
raw: rawInfo,
|
|
edits: [],
|
|
},
|
|
expect.any(String),
|
|
);
|
|
});
|
|
|
|
it('should generate progressive JPEG for fullsize when enabled', async () => {
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
image: { fullsize: { enabled: true, format: ImageFormat.Jpeg, progressive: true } },
|
|
});
|
|
mocks.media.extract.mockResolvedValue({ buffer: extractedBuffer, format: RawExtractedFormat.Jpeg });
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 3840, height: 2160, isTransparent: false });
|
|
const asset = AssetFactory.from({ originalFileName: 'image.hif' })
|
|
.exif({
|
|
fileSizeInByte: 5000,
|
|
profileDescription: 'Adobe RGB',
|
|
bitsPerSample: 14,
|
|
})
|
|
.build();
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await sut.handleGenerateThumbnails({ id: asset.id });
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledTimes(3);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
expect.objectContaining({
|
|
format: ImageFormat.Jpeg,
|
|
progressive: true,
|
|
}),
|
|
expect.stringContaining('fullsize.jpeg'),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('handleAssetEditThumbnailGeneration', () => {
|
|
let rawInfo: RawImageInfo;
|
|
|
|
beforeEach(() => {
|
|
rawInfo = { width: 100, height: 100, channels: 3 };
|
|
mocks.person.getFaces.mockResolvedValue([]);
|
|
mocks.ocr.getByAssetId.mockResolvedValue([]);
|
|
mocks.media.decodeImage.mockImplementation((input) =>
|
|
Promise.resolve(
|
|
typeof input === 'string'
|
|
? { data: rawBuffer, info: rawInfo as OutputInfo } // string implies original file
|
|
: { data: fullsizeBuffer, info: rawInfo as OutputInfo }, // buffer implies embedded image extracted
|
|
),
|
|
);
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 100, height: 100, isTransparent: false });
|
|
});
|
|
|
|
it('should skip videos', async () => {
|
|
const asset = AssetFactory.from({ type: AssetType.Video }).exif().build();
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
await expect(sut.handleAssetEditThumbnailGeneration({ id: asset.id })).resolves.toBe(JobStatus.Success);
|
|
expect(mocks.media.generateThumbnail).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should upsert 3 edited files for edit jobs', async () => {
|
|
const asset = AssetFactory.from()
|
|
.exif()
|
|
.edit({ action: AssetEditAction.Crop })
|
|
.files([
|
|
{ type: AssetFileType.FullSize, isEdited: true },
|
|
{ type: AssetFileType.Preview, isEdited: true },
|
|
{ type: AssetFileType.Thumbnail, isEdited: true },
|
|
])
|
|
.build();
|
|
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
const thumbhashBuffer = Buffer.from('a thumbhash', 'utf8');
|
|
mocks.media.generateThumbhash.mockResolvedValue(thumbhashBuffer);
|
|
mocks.person.getFaces.mockResolvedValue([]);
|
|
mocks.ocr.getByAssetId.mockResolvedValue([]);
|
|
|
|
await sut.handleAssetEditThumbnailGeneration({ id: asset.id });
|
|
|
|
expect(mocks.asset.upsertFiles).toHaveBeenCalledWith(
|
|
expect.arrayContaining([
|
|
expect.objectContaining({ type: AssetFileType.FullSize, isEdited: true }),
|
|
expect.objectContaining({ type: AssetFileType.Preview, isEdited: true }),
|
|
expect.objectContaining({ type: AssetFileType.Thumbnail, isEdited: true }),
|
|
]),
|
|
);
|
|
});
|
|
|
|
it('should apply edits when generating thumbnails', async () => {
|
|
const asset = AssetFactory.from()
|
|
.exif()
|
|
.edit({ action: AssetEditAction.Crop, parameters: { height: 1152, width: 1512, x: 216, y: 1512 } })
|
|
.build();
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
mocks.person.getFaces.mockResolvedValue([]);
|
|
mocks.ocr.getByAssetId.mockResolvedValue([]);
|
|
|
|
await sut.handleAssetEditThumbnailGeneration({ id: asset.id });
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
expect.objectContaining({
|
|
edits: [
|
|
expect.objectContaining({
|
|
action: 'crop',
|
|
parameters: { height: 1152, width: 1512, x: 216, y: 1512 },
|
|
}),
|
|
],
|
|
}),
|
|
expect.any(String),
|
|
);
|
|
});
|
|
|
|
it('should clean up edited files if an asset has no edits', async () => {
|
|
const asset = AssetFactory.from({ thumbhash: factory.buffer() })
|
|
.exif()
|
|
.files([
|
|
{ type: AssetFileType.Preview, path: 'edited1.jpg', isEdited: true },
|
|
{ type: AssetFileType.Thumbnail, path: 'edited2.jpg', isEdited: true },
|
|
{ type: AssetFileType.FullSize, path: 'edited3.jpg', isEdited: true },
|
|
])
|
|
.build();
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
|
|
const status = await sut.handleAssetEditThumbnailGeneration({ id: asset.id });
|
|
|
|
expect(mocks.job.queue).toHaveBeenCalledWith({
|
|
name: JobName.FileDelete,
|
|
data: {
|
|
files: expect.arrayContaining(['edited1.jpg', 'edited2.jpg', 'edited3.jpg']),
|
|
},
|
|
});
|
|
|
|
expect(status).toBe(JobStatus.Success);
|
|
expect(mocks.media.generateThumbnail).not.toHaveBeenCalled();
|
|
expect(mocks.asset.upsertFiles).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should generate all 3 edited files if an asset has edits', async () => {
|
|
const asset = AssetFactory.from().exif().edit().build();
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
mocks.person.getFaces.mockResolvedValue([]);
|
|
mocks.ocr.getByAssetId.mockResolvedValue([]);
|
|
|
|
await sut.handleAssetEditThumbnailGeneration({ id: asset.id });
|
|
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledTimes(3);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
expect.anything(),
|
|
expect.stringContaining('preview_edited.jpeg'),
|
|
);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
expect.anything(),
|
|
expect.stringContaining('thumbnail_edited.webp'),
|
|
);
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
rawBuffer,
|
|
expect.anything(),
|
|
expect.stringContaining('fullsize_edited.jpeg'),
|
|
);
|
|
});
|
|
|
|
it('should generate the original thumbhash if no edits exist', async () => {
|
|
const asset = AssetFactory.from().exif().build();
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
mocks.media.generateThumbhash.mockResolvedValue(factory.buffer());
|
|
|
|
await sut.handleAssetEditThumbnailGeneration({ id: asset.id, source: 'upload' });
|
|
|
|
expect(mocks.media.generateThumbhash).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should apply thumbhash if job source is edit and edits exist', async () => {
|
|
const asset = AssetFactory.from().exif().edit().build();
|
|
mocks.assetJob.getForGenerateThumbnailJob.mockResolvedValue(asset);
|
|
const thumbhashBuffer = factory.buffer();
|
|
mocks.media.generateThumbhash.mockResolvedValue(thumbhashBuffer);
|
|
mocks.person.getFaces.mockResolvedValue([]);
|
|
mocks.ocr.getByAssetId.mockResolvedValue([]);
|
|
|
|
await sut.handleAssetEditThumbnailGeneration({ id: asset.id });
|
|
|
|
expect(mocks.asset.update).toHaveBeenCalledWith(expect.objectContaining({ thumbhash: thumbhashBuffer }));
|
|
});
|
|
});
|
|
|
|
describe('handleGeneratePersonThumbnail', () => {
|
|
it('should skip if machine learning is disabled', async () => {
|
|
mocks.systemMetadata.get.mockResolvedValue(systemConfigStub.machineLearningDisabled);
|
|
|
|
await expect(sut.handleGeneratePersonThumbnail({ id: 'person-1' })).resolves.toBe(JobStatus.Skipped);
|
|
expect(mocks.asset.getByIds).not.toHaveBeenCalled();
|
|
expect(mocks.systemMetadata.get).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should skip a person not found', async () => {
|
|
await sut.handleGeneratePersonThumbnail({ id: 'person-1' });
|
|
expect(mocks.media.generateThumbnail).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should skip a person without a face asset id', async () => {
|
|
mocks.person.getById.mockResolvedValue(personStub.noThumbnail);
|
|
await sut.handleGeneratePersonThumbnail({ id: 'person-1' });
|
|
expect(mocks.media.generateThumbnail).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should skip a person with face not found', async () => {
|
|
await sut.handleGeneratePersonThumbnail({ id: 'person-1' });
|
|
expect(mocks.media.generateThumbnail).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should generate a thumbnail', async () => {
|
|
mocks.person.getDataForThumbnailGenerationJob.mockResolvedValue(personThumbnailStub.newThumbnailMiddle);
|
|
mocks.media.generateThumbnail.mockResolvedValue();
|
|
const data = Buffer.from('');
|
|
const info = { width: 1000, height: 1000 } as OutputInfo;
|
|
mocks.media.decodeImage.mockResolvedValue({ data, info });
|
|
|
|
await expect(sut.handleGeneratePersonThumbnail({ id: personStub.primaryPerson.id })).resolves.toBe(
|
|
JobStatus.Success,
|
|
);
|
|
|
|
expect(mocks.person.getDataForThumbnailGenerationJob).toHaveBeenCalledWith(personStub.primaryPerson.id);
|
|
expect(mocks.storage.mkdirSync).toHaveBeenCalledWith(expect.any(String));
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(personThumbnailStub.newThumbnailMiddle.originalPath, {
|
|
colorspace: Colorspace.P3,
|
|
orientation: undefined,
|
|
processInvalidImages: false,
|
|
});
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
data,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Jpeg,
|
|
quality: 80,
|
|
progressive: false,
|
|
edits: [
|
|
{
|
|
action: 'crop',
|
|
parameters: {
|
|
height: 274,
|
|
width: 274,
|
|
x: 238,
|
|
y: 163,
|
|
},
|
|
},
|
|
],
|
|
raw: info,
|
|
processInvalidImages: false,
|
|
size: 250,
|
|
},
|
|
expect.any(String),
|
|
);
|
|
expect(mocks.person.update).toHaveBeenCalledWith({ id: 'person-1', thumbnailPath: expect.any(String) });
|
|
});
|
|
|
|
it('should use preview path if video', async () => {
|
|
mocks.person.getDataForThumbnailGenerationJob.mockResolvedValue(personThumbnailStub.videoThumbnail);
|
|
mocks.media.generateThumbnail.mockResolvedValue();
|
|
const data = Buffer.from('');
|
|
const info = { width: 1000, height: 1000 } as OutputInfo;
|
|
mocks.media.decodeImage.mockResolvedValue({ data, info });
|
|
|
|
await expect(sut.handleGeneratePersonThumbnail({ id: personStub.primaryPerson.id })).resolves.toBe(
|
|
JobStatus.Success,
|
|
);
|
|
|
|
expect(mocks.person.getDataForThumbnailGenerationJob).toHaveBeenCalledWith(personStub.primaryPerson.id);
|
|
expect(mocks.storage.mkdirSync).toHaveBeenCalledWith(expect.any(String));
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(expect.any(String), {
|
|
colorspace: Colorspace.P3,
|
|
orientation: undefined,
|
|
processInvalidImages: false,
|
|
});
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
data,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Jpeg,
|
|
quality: 80,
|
|
progressive: false,
|
|
edits: [
|
|
{
|
|
action: 'crop',
|
|
parameters: {
|
|
height: 274,
|
|
width: 274,
|
|
x: 238,
|
|
y: 163,
|
|
},
|
|
},
|
|
],
|
|
raw: info,
|
|
processInvalidImages: false,
|
|
size: 250,
|
|
},
|
|
expect.any(String),
|
|
);
|
|
expect(mocks.person.update).toHaveBeenCalledWith({ id: 'person-1', thumbnailPath: expect.any(String) });
|
|
});
|
|
|
|
it('should generate a thumbnail without going negative', async () => {
|
|
mocks.person.getDataForThumbnailGenerationJob.mockResolvedValue(personThumbnailStub.newThumbnailStart);
|
|
mocks.media.generateThumbnail.mockResolvedValue();
|
|
const data = Buffer.from('');
|
|
const info = { width: 2160, height: 3840 } as OutputInfo;
|
|
mocks.media.decodeImage.mockResolvedValue({ data, info });
|
|
|
|
await expect(sut.handleGeneratePersonThumbnail({ id: personStub.primaryPerson.id })).resolves.toBe(
|
|
JobStatus.Success,
|
|
);
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(personThumbnailStub.newThumbnailStart.originalPath, {
|
|
colorspace: Colorspace.P3,
|
|
orientation: undefined,
|
|
processInvalidImages: false,
|
|
});
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
data,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Jpeg,
|
|
quality: 80,
|
|
progressive: false,
|
|
edits: [
|
|
{
|
|
action: 'crop',
|
|
parameters: {
|
|
height: 510,
|
|
width: 510,
|
|
x: 0,
|
|
y: 85,
|
|
},
|
|
},
|
|
],
|
|
raw: info,
|
|
processInvalidImages: false,
|
|
size: 250,
|
|
},
|
|
expect.any(String),
|
|
);
|
|
});
|
|
|
|
it('should generate a thumbnail without overflowing', async () => {
|
|
mocks.person.getDataForThumbnailGenerationJob.mockResolvedValue(personThumbnailStub.newThumbnailEnd);
|
|
mocks.person.update.mockResolvedValue(personStub.primaryPerson);
|
|
mocks.media.generateThumbnail.mockResolvedValue();
|
|
const data = Buffer.from('');
|
|
const info = { width: 1000, height: 1000 } as OutputInfo;
|
|
mocks.media.decodeImage.mockResolvedValue({ data, info });
|
|
|
|
await expect(sut.handleGeneratePersonThumbnail({ id: personStub.primaryPerson.id })).resolves.toBe(
|
|
JobStatus.Success,
|
|
);
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(personThumbnailStub.newThumbnailEnd.originalPath, {
|
|
colorspace: Colorspace.P3,
|
|
orientation: undefined,
|
|
processInvalidImages: false,
|
|
});
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
data,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Jpeg,
|
|
quality: 80,
|
|
progressive: false,
|
|
edits: [
|
|
{
|
|
action: 'crop',
|
|
parameters: {
|
|
height: 408,
|
|
width: 408,
|
|
x: 591,
|
|
y: 591,
|
|
},
|
|
},
|
|
],
|
|
raw: info,
|
|
processInvalidImages: false,
|
|
size: 250,
|
|
},
|
|
expect.any(String),
|
|
);
|
|
});
|
|
|
|
it('should handle negative coordinates', async () => {
|
|
mocks.person.getDataForThumbnailGenerationJob.mockResolvedValue(personThumbnailStub.negativeCoordinate);
|
|
mocks.person.update.mockResolvedValue(personStub.primaryPerson);
|
|
mocks.media.generateThumbnail.mockResolvedValue();
|
|
const data = Buffer.from('');
|
|
const info = { width: 4624, height: 3080 } as OutputInfo;
|
|
mocks.media.decodeImage.mockResolvedValue({ data, info });
|
|
|
|
await expect(sut.handleGeneratePersonThumbnail({ id: personStub.primaryPerson.id })).resolves.toBe(
|
|
JobStatus.Success,
|
|
);
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(personThumbnailStub.negativeCoordinate.originalPath, {
|
|
colorspace: Colorspace.P3,
|
|
orientation: undefined,
|
|
processInvalidImages: false,
|
|
});
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
data,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Jpeg,
|
|
quality: 80,
|
|
progressive: false,
|
|
edits: [
|
|
{
|
|
action: 'crop',
|
|
parameters: {
|
|
height: 412,
|
|
width: 412,
|
|
x: 0,
|
|
y: 62,
|
|
},
|
|
},
|
|
],
|
|
raw: info,
|
|
processInvalidImages: false,
|
|
size: 250,
|
|
},
|
|
expect.any(String),
|
|
);
|
|
});
|
|
|
|
it('should handle overflowing coordinate', async () => {
|
|
mocks.person.getDataForThumbnailGenerationJob.mockResolvedValue(personThumbnailStub.overflowingCoordinate);
|
|
mocks.person.update.mockResolvedValue(personStub.primaryPerson);
|
|
mocks.media.generateThumbnail.mockResolvedValue();
|
|
const data = Buffer.from('');
|
|
const info = { width: 4624, height: 3080 } as OutputInfo;
|
|
mocks.media.decodeImage.mockResolvedValue({ data, info });
|
|
|
|
await expect(sut.handleGeneratePersonThumbnail({ id: personStub.primaryPerson.id })).resolves.toBe(
|
|
JobStatus.Success,
|
|
);
|
|
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(personThumbnailStub.overflowingCoordinate.originalPath, {
|
|
colorspace: Colorspace.P3,
|
|
orientation: undefined,
|
|
processInvalidImages: false,
|
|
});
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
data,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Jpeg,
|
|
quality: 80,
|
|
progressive: false,
|
|
edits: [
|
|
{
|
|
action: 'crop',
|
|
parameters: {
|
|
height: 138,
|
|
width: 138,
|
|
x: 4485,
|
|
y: 94,
|
|
},
|
|
},
|
|
],
|
|
raw: info,
|
|
processInvalidImages: false,
|
|
size: 250,
|
|
},
|
|
expect.any(String),
|
|
);
|
|
});
|
|
|
|
it('should use embedded preview if enabled and raw image', async () => {
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { extractEmbedded: true } });
|
|
mocks.person.getDataForThumbnailGenerationJob.mockResolvedValue(personThumbnailStub.rawEmbeddedThumbnail);
|
|
mocks.person.update.mockResolvedValue(personStub.primaryPerson);
|
|
mocks.media.generateThumbnail.mockResolvedValue();
|
|
const extracted = Buffer.from('');
|
|
const data = Buffer.from('');
|
|
const info = { width: 2160, height: 3840 } as OutputInfo;
|
|
mocks.media.extract.mockResolvedValue({ buffer: extracted, format: RawExtractedFormat.Jpeg });
|
|
mocks.media.decodeImage.mockResolvedValue({ data, info });
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 2160, height: 3840, isTransparent: false });
|
|
|
|
await expect(sut.handleGeneratePersonThumbnail({ id: personStub.primaryPerson.id })).resolves.toBe(
|
|
JobStatus.Success,
|
|
);
|
|
|
|
expect(mocks.media.extract).toHaveBeenCalledWith(personThumbnailStub.rawEmbeddedThumbnail.originalPath);
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(extracted, {
|
|
colorspace: Colorspace.P3,
|
|
orientation: ExifOrientation.Horizontal,
|
|
processInvalidImages: false,
|
|
});
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalledWith(
|
|
data,
|
|
{
|
|
colorspace: Colorspace.P3,
|
|
format: ImageFormat.Jpeg,
|
|
quality: 80,
|
|
progressive: false,
|
|
edits: [
|
|
{
|
|
action: 'crop',
|
|
parameters: {
|
|
height: 844,
|
|
width: 844,
|
|
x: 388,
|
|
y: 730,
|
|
},
|
|
},
|
|
],
|
|
raw: info,
|
|
processInvalidImages: false,
|
|
size: 250,
|
|
},
|
|
expect.any(String),
|
|
);
|
|
});
|
|
|
|
it('should not use embedded preview if enabled and not raw image', async () => {
|
|
mocks.person.getDataForThumbnailGenerationJob.mockResolvedValue(personThumbnailStub.newThumbnailMiddle);
|
|
mocks.media.generateThumbnail.mockResolvedValue();
|
|
const data = Buffer.from('');
|
|
const info = { width: 2160, height: 3840 } as OutputInfo;
|
|
mocks.media.decodeImage.mockResolvedValue({ data, info });
|
|
|
|
await expect(sut.handleGeneratePersonThumbnail({ id: personStub.primaryPerson.id })).resolves.toBe(
|
|
JobStatus.Success,
|
|
);
|
|
|
|
expect(mocks.media.extract).not.toHaveBeenCalled();
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should not use embedded preview if enabled and raw image if not exists', async () => {
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { extractEmbedded: true } });
|
|
mocks.person.getDataForThumbnailGenerationJob.mockResolvedValue(personThumbnailStub.rawEmbeddedThumbnail);
|
|
mocks.media.generateThumbnail.mockResolvedValue();
|
|
const data = Buffer.from('');
|
|
const info = { width: 2160, height: 3840 } as OutputInfo;
|
|
mocks.media.decodeImage.mockResolvedValue({ data, info });
|
|
|
|
await expect(sut.handleGeneratePersonThumbnail({ id: personStub.primaryPerson.id })).resolves.toBe(
|
|
JobStatus.Success,
|
|
);
|
|
|
|
expect(mocks.media.extract).toHaveBeenCalledWith(personThumbnailStub.rawEmbeddedThumbnail.originalPath);
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(personThumbnailStub.rawEmbeddedThumbnail.originalPath, {
|
|
colorspace: Colorspace.P3,
|
|
orientation: undefined,
|
|
processInvalidImages: false,
|
|
});
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should not use embedded preview if enabled and raw image if low resolution', async () => {
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { extractEmbedded: true } });
|
|
mocks.person.getDataForThumbnailGenerationJob.mockResolvedValue(personThumbnailStub.rawEmbeddedThumbnail);
|
|
mocks.media.generateThumbnail.mockResolvedValue();
|
|
const extracted = Buffer.from('');
|
|
const data = Buffer.from('');
|
|
const info = { width: 1000, height: 1000 } as OutputInfo;
|
|
mocks.media.decodeImage.mockResolvedValue({ data, info });
|
|
mocks.media.extract.mockResolvedValue({ buffer: extracted, format: RawExtractedFormat.Jpeg });
|
|
mocks.media.getImageMetadata.mockResolvedValue({ width: 1000, height: 1000, isTransparent: false });
|
|
|
|
await expect(sut.handleGeneratePersonThumbnail({ id: personStub.primaryPerson.id })).resolves.toBe(
|
|
JobStatus.Success,
|
|
);
|
|
|
|
expect(mocks.media.extract).toHaveBeenCalledWith(personThumbnailStub.rawEmbeddedThumbnail.originalPath);
|
|
expect(mocks.media.decodeImage).toHaveBeenCalledWith(personThumbnailStub.rawEmbeddedThumbnail.originalPath, {
|
|
colorspace: Colorspace.P3,
|
|
orientation: undefined,
|
|
processInvalidImages: false,
|
|
});
|
|
expect(mocks.media.generateThumbnail).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('handleQueueVideoConversion', () => {
|
|
it('should queue all video assets', async () => {
|
|
const asset = AssetFactory.create({ type: AssetType.Video });
|
|
mocks.assetJob.streamForVideoConversion.mockReturnValue(makeStream([asset]));
|
|
mocks.person.getAll.mockReturnValue(makeStream());
|
|
|
|
await sut.handleQueueVideoConversion({ force: true });
|
|
|
|
expect(mocks.assetJob.streamForVideoConversion).toHaveBeenCalledWith(true);
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{
|
|
name: JobName.AssetEncodeVideo,
|
|
data: { id: asset.id },
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('should queue all video assets without encoded videos', async () => {
|
|
const asset = AssetFactory.create({ type: AssetType.Video });
|
|
mocks.assetJob.streamForVideoConversion.mockReturnValue(makeStream([asset]));
|
|
|
|
await sut.handleQueueVideoConversion({});
|
|
|
|
expect(mocks.assetJob.streamForVideoConversion).toHaveBeenCalledWith(void 0);
|
|
expect(mocks.job.queueAll).toHaveBeenCalledWith([
|
|
{
|
|
name: JobName.AssetEncodeVideo,
|
|
data: { id: asset.id },
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('handleVideoConversion', () => {
|
|
beforeEach(() => {
|
|
const asset = AssetFactory.create({ id: 'video-id', type: AssetType.Video, originalPath: '/original/path.ext' });
|
|
mocks.assetJob.getForVideoConversion.mockResolvedValue(asset);
|
|
sut.videoInterfaces = { dri: ['renderD128'], mali: true };
|
|
});
|
|
|
|
it('should skip transcoding if asset not found', async () => {
|
|
mocks.assetJob.getForVideoConversion.mockResolvedValue(void 0);
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.probe).not.toHaveBeenCalled();
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should transcode the highest bitrate video stream', async () => {
|
|
mocks.logger.isLevelEnabled.mockReturnValue(false);
|
|
mocks.media.probe.mockResolvedValue(probeStub.multipleVideoStreams);
|
|
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
|
|
expect(mocks.media.probe).toHaveBeenCalledWith('/original/path.ext', { countFrames: false });
|
|
expect(mocks.systemMetadata.get).toHaveBeenCalled();
|
|
expect(mocks.storage.mkdirSync).toHaveBeenCalled();
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-map 0:1', '-map 0:3']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should transcode the highest bitrate audio stream', async () => {
|
|
mocks.logger.isLevelEnabled.mockReturnValue(false);
|
|
mocks.media.probe.mockResolvedValue(probeStub.multipleAudioStreams);
|
|
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
|
|
expect(mocks.media.probe).toHaveBeenCalledWith('/original/path.ext', { countFrames: false });
|
|
expect(mocks.systemMetadata.get).toHaveBeenCalled();
|
|
expect(mocks.storage.mkdirSync).toHaveBeenCalled();
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-map 0:0', '-map 0:2']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should skip a video without any streams', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.noVideoStreams);
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should skip a video without any height', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.noHeight);
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should throw an error if an unknown transcode policy is configured', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.noAudioStreams);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: 'foo' } } as never as SystemConfig);
|
|
|
|
await expect(sut.handleVideoConversion({ id: 'video-id' })).rejects.toThrowError();
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should throw an error if transcoding fails and hw acceleration is disabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.multipleVideoStreams);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { transcode: TranscodePolicy.All, accel: TranscodeHardwareAcceleration.Disabled },
|
|
});
|
|
mocks.media.transcode.mockRejectedValue(new Error('Error transcoding video'));
|
|
|
|
await expect(sut.handleVideoConversion({ id: 'video-id' })).resolves.toBe(JobStatus.Failed);
|
|
expect(mocks.media.transcode).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('should transcode when set to all', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.multipleVideoStreams);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.All } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.any(Array),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should transcode when optimal and too big', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream2160p);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Optimal } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.any(Array),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should transcode when policy bitrate and bitrate higher than max bitrate', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream40Mbps);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Bitrate, maxBitrate: '30M' } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.any(Array),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should transcode when max bitrate is not a number', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream40Mbps);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Bitrate, maxBitrate: 'foo' } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.any(Array),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should not scale resolution if no target resolution', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream2160p);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { transcode: TranscodePolicy.All, targetResolution: 'original' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.not.arrayContaining([expect.stringContaining('scale')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should scale horizontally when video is horizontal', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream2160p);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Optimal } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining([expect.stringMatching(/scale(_.+)?=-2:720/)]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should scale vertically when video is vertical', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamVertical2160p);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Optimal } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining([expect.stringMatching(/scale(_.+)?=720:-2/)]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should always scale video if height is uneven', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamOddHeight);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { transcode: TranscodePolicy.All, targetResolution: 'original' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining([expect.stringMatching(/scale(_.+)?=-2:354/)]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should always scale video if width is uneven', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamOddWidth);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { transcode: TranscodePolicy.All, targetResolution: 'original' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining([expect.stringMatching(/scale(_.+)?=354:-2/)]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should copy video stream when video matches target', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { targetVideoCodec: VideoCodec.Hevc, acceptedAudioCodecs: [AudioCodec.Aac] },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-c:v copy', '-c:a aac']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should not include hevc tag when target is hevc and video stream is copied from a different codec', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamH264);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: {
|
|
targetVideoCodec: VideoCodec.Hevc,
|
|
acceptedVideoCodecs: [VideoCodec.H264, VideoCodec.Hevc],
|
|
acceptedAudioCodecs: [AudioCodec.Aac],
|
|
},
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.not.arrayContaining(['-tag:v hvc1']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should include hevc tag when target is hevc and copying hevc video stream', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: {
|
|
targetVideoCodec: VideoCodec.Hevc,
|
|
acceptedVideoCodecs: [VideoCodec.H264, VideoCodec.Hevc],
|
|
acceptedAudioCodecs: [AudioCodec.Aac],
|
|
},
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-c:v copy', '-tag:v hvc1']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should copy audio stream when audio matches target', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.audioStreamAac);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Optimal } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-c:v h264', '-c:a copy']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should remux when input is not an accepted container', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamAvi);
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-c:v copy', '-c:a copy']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should throw an exception if transcode value is invalid', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream2160p);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: 'invalid' as any } });
|
|
|
|
await expect(sut.handleVideoConversion({ id: 'video-id' })).rejects.toThrowError();
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should not transcode if transcoding is disabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream2160p);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Disabled } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should not remux when input is not an accepted container and transcoding is disabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Disabled } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should not transcode if target codec is invalid', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream2160p);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { targetVideoCodec: 'invalid' as any } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should delete existing transcode if current policy does not require transcoding', async () => {
|
|
const asset = AssetFactory.create({ type: AssetType.Video, encodedVideoPath: '/encoded/video/path.mp4' });
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream2160p);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Disabled } });
|
|
mocks.assetJob.getForVideoConversion.mockResolvedValue(asset);
|
|
|
|
await sut.handleVideoConversion({ id: asset.id });
|
|
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
expect(mocks.job.queue).toHaveBeenCalledWith({
|
|
name: JobName.FileDelete,
|
|
data: { files: [asset.encodedVideoPath] },
|
|
});
|
|
});
|
|
|
|
it('should set max bitrate if above 0', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { maxBitrate: '4500k' } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-c:v h264', '-maxrate 4500k', '-bufsize 9000k']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should default max bitrate to kbps if no unit is provided', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { maxBitrate: '4500' } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-c:v h264', '-maxrate 4500k', '-bufsize 9000k']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should transcode in two passes for h264/h265 when enabled and max bitrate is above 0', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { twoPass: true, maxBitrate: '4500k' } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-c:v h264', '-b:v 3104k', '-minrate 1552k', '-maxrate 4500k']),
|
|
twoPass: true,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should fallback to one pass for h264/h265 if two-pass is enabled but no max bitrate is set', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { twoPass: true } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-c:v h264', '-c:a copy']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should transcode by bitrate in two passes for vp9 when two pass mode and max bitrate are enabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: {
|
|
maxBitrate: '4500k',
|
|
twoPass: true,
|
|
targetVideoCodec: VideoCodec.Vp9,
|
|
},
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-b:v 3104k', '-minrate 1552k', '-maxrate 4500k']),
|
|
twoPass: true,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should transcode by crf in two passes for vp9 when two pass mode is enabled and max bitrate is disabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: {
|
|
maxBitrate: '0',
|
|
twoPass: true,
|
|
targetVideoCodec: VideoCodec.Vp9,
|
|
},
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.not.arrayContaining([expect.stringContaining('-maxrate')]),
|
|
twoPass: true,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should configure preset for vp9', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { targetVideoCodec: VideoCodec.Vp9, preset: 'slow' } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-cpu-used 2']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should not configure preset for vp9 if invalid', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { preset: 'invalid', targetVideoCodec: VideoCodec.Vp9 } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.not.arrayContaining([expect.stringContaining('-cpu-used')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should configure threads if above 0', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { targetVideoCodec: VideoCodec.Vp9, threads: 2 } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-threads 2']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should disable thread pooling for h264 if thread limit is 1', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { threads: 1 } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-threads 1', '-x264-params frame-threads=1:pools=none']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should omit thread flags for h264 if thread limit is at or below 0', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { threads: 0 } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.not.arrayContaining([expect.stringContaining('-threads')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should disable thread pooling for hevc if thread limit is 1', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamVp9);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { threads: 1, targetVideoCodec: VideoCodec.Hevc } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-c:v hevc', '-threads 1', '-x265-params frame-threads=1:pools=none']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should omit thread flags for hevc if thread limit is at or below 0', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamVp9);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { threads: 0, targetVideoCodec: VideoCodec.Hevc } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.not.arrayContaining([expect.stringContaining('-threads')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should use av1 if specified', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamVp9);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { targetVideoCodec: VideoCodec.Av1 } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining([
|
|
'-c:v libsvtav1',
|
|
'-movflags faststart',
|
|
'-fps_mode passthrough',
|
|
'-map 0:0',
|
|
'-map 0:3',
|
|
'-v verbose',
|
|
'-vf scale=-2:720',
|
|
'-preset 12',
|
|
'-crf 23',
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should map `veryslow` preset to 4 for av1', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamVp9);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { targetVideoCodec: VideoCodec.Av1, preset: 'veryslow' } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-preset 4']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set max bitrate for av1 if specified', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamVp9);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { targetVideoCodec: VideoCodec.Av1, maxBitrate: '2M' } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-svtav1-params mbr=2M']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set threads for av1 if specified', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamVp9);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { targetVideoCodec: VideoCodec.Av1, threads: 4 } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-svtav1-params lp=4']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set both bitrate and threads for av1 if specified', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamVp9);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { targetVideoCodec: VideoCodec.Av1, threads: 4, maxBitrate: '2M' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-svtav1-params lp=4:mbr=2M']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should skip transcoding for audioless videos with optimal policy if video codec is correct', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.noAudioStreams);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: {
|
|
targetVideoCodec: VideoCodec.Hevc,
|
|
transcode: TranscodePolicy.Optimal,
|
|
targetResolution: '1080p',
|
|
},
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should fail if hwaccel is enabled for an unsupported codec', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Nvenc, targetVideoCodec: VideoCodec.Vp9 },
|
|
});
|
|
await expect(sut.handleVideoConversion({ id: 'video-id' })).rejects.toThrowError();
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should fail if hwaccel option is invalid', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { accel: 'invalid' as any } });
|
|
await expect(sut.handleVideoConversion({ id: 'video-id' })).rejects.toThrowError();
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should set options for nvenc', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { accel: TranscodeHardwareAcceleration.Nvenc } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-init_hw_device cuda=cuda:0', '-filter_hw_device cuda']),
|
|
outputOptions: expect.arrayContaining([
|
|
'-tune hq',
|
|
'-qmin 0',
|
|
'-rc-lookahead 20',
|
|
'-i_qfactor 0.75',
|
|
`-c:v h264_nvenc`,
|
|
'-c:a copy',
|
|
'-movflags faststart',
|
|
'-fps_mode passthrough',
|
|
'-map 0:0',
|
|
'-map 0:3',
|
|
'-g 256',
|
|
'-v verbose',
|
|
'-vf hwupload_cuda,scale_cuda=-2:720:format=nv12',
|
|
'-preset p1',
|
|
'-cq:v 23',
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set two pass options for nvenc when enabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: {
|
|
accel: TranscodeHardwareAcceleration.Nvenc,
|
|
maxBitrate: '10000k',
|
|
twoPass: true,
|
|
},
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-init_hw_device cuda=cuda:0', '-filter_hw_device cuda']),
|
|
outputOptions: expect.arrayContaining([expect.stringContaining('-multipass')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set vbr options for nvenc when max bitrate is enabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Nvenc, maxBitrate: '10000k' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-init_hw_device cuda=cuda:0', '-filter_hw_device cuda']),
|
|
outputOptions: expect.arrayContaining(['-cq:v 23', '-maxrate 10000k', '-bufsize 6897k']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set cq options for nvenc when max bitrate is disabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Nvenc, maxBitrate: '10000k' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-init_hw_device cuda=cuda:0', '-filter_hw_device cuda']),
|
|
outputOptions: expect.not.stringContaining('-maxrate'),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should omit preset for nvenc if invalid', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Nvenc, preset: 'invalid' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-init_hw_device cuda=cuda:0', '-filter_hw_device cuda']),
|
|
outputOptions: expect.not.arrayContaining([expect.stringContaining('-preset')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should ignore two pass for nvenc if max bitrate is disabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { accel: TranscodeHardwareAcceleration.Nvenc } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-init_hw_device cuda=cuda:0', '-filter_hw_device cuda']),
|
|
outputOptions: expect.not.arrayContaining([expect.stringContaining('-multipass')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should use hardware decoding for nvenc if enabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Nvenc, accelDecode: true },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-hwaccel cuda',
|
|
'-hwaccel_output_format cuda',
|
|
'-noautorotate',
|
|
'-threads 1',
|
|
]),
|
|
outputOptions: expect.arrayContaining([expect.stringContaining('scale_cuda=-2:720:format=nv12')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should use hardware tone-mapping for nvenc if hardware decoding is enabled and should tone map', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamHDR);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Nvenc, accelDecode: true },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-hwaccel cuda', '-hwaccel_output_format cuda']),
|
|
outputOptions: expect.arrayContaining([
|
|
expect.stringContaining(
|
|
'tonemap_cuda=desat=0:matrix=bt709:primaries=bt709:range=pc:tonemap=hable:tonemap_mode=lum:transfer=bt709:peak=100:format=nv12',
|
|
),
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set format to nv12 for nvenc if input is not yuv420p', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream10Bit);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Nvenc, accelDecode: true },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-hwaccel cuda', '-hwaccel_output_format cuda']),
|
|
outputOptions: expect.arrayContaining([expect.stringContaining('scale_cuda=-2:720:format=nv12')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set options for qsv', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Qsv, maxBitrate: '10000k' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-init_hw_device qsv=hw,child_device=/dev/dri/renderD128',
|
|
'-filter_hw_device hw',
|
|
]),
|
|
outputOptions: expect.arrayContaining([
|
|
`-c:v h264_qsv`,
|
|
'-c:a copy',
|
|
'-movflags faststart',
|
|
'-fps_mode passthrough',
|
|
'-map 0:0',
|
|
'-map 0:3',
|
|
'-bf 7',
|
|
'-refs 5',
|
|
'-g 256',
|
|
'-v verbose',
|
|
'-vf hwupload=extra_hw_frames=64,scale_qsv=-1:720:mode=hq:format=nv12',
|
|
'-preset 7',
|
|
'-global_quality:v 23',
|
|
'-maxrate 10000k',
|
|
'-bufsize 20000k',
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set options for qsv with custom dri node', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: {
|
|
accel: TranscodeHardwareAcceleration.Qsv,
|
|
maxBitrate: '10000k',
|
|
preferredHwDevice: '/dev/dri/renderD128',
|
|
},
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-init_hw_device qsv=hw,child_device=/dev/dri/renderD128',
|
|
'-filter_hw_device hw',
|
|
]),
|
|
outputOptions: expect.any(Array),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should omit preset for qsv if invalid', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Qsv, preset: 'invalid' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-init_hw_device qsv=hw,child_device=/dev/dri/renderD128',
|
|
'-filter_hw_device hw',
|
|
]),
|
|
outputOptions: expect.not.arrayContaining([expect.stringContaining('-preset')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set low power mode for qsv if target video codec is vp9', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Qsv, targetVideoCodec: VideoCodec.Vp9 },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-init_hw_device qsv=hw,child_device=/dev/dri/renderD128',
|
|
'-filter_hw_device hw',
|
|
]),
|
|
outputOptions: expect.arrayContaining(['-low_power 1']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should fail for qsv if no hw devices', async () => {
|
|
sut.videoInterfaces = { dri: [], mali: false };
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { accel: TranscodeHardwareAcceleration.Qsv } });
|
|
|
|
await expect(sut.handleVideoConversion({ id: 'video-id' })).rejects.toThrowError();
|
|
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should prefer higher index renderD* device for qsv', async () => {
|
|
sut.videoInterfaces = { dri: ['card1', 'renderD129', 'card0', 'renderD128'], mali: false };
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { accel: TranscodeHardwareAcceleration.Qsv } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-init_hw_device qsv=hw,child_device=/dev/dri/renderD129',
|
|
'-filter_hw_device hw',
|
|
]),
|
|
outputOptions: expect.arrayContaining([`-c:v h264_qsv`]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should use hardware decoding for qsv if enabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Qsv, accelDecode: true },
|
|
});
|
|
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-hwaccel qsv',
|
|
'-hwaccel_output_format qsv',
|
|
'-async_depth 4',
|
|
'-noautorotate',
|
|
'-threads 1',
|
|
'-qsv_device /dev/dri/renderD128',
|
|
]),
|
|
outputOptions: expect.arrayContaining([expect.stringContaining('scale_qsv=-1:720:async_depth=4:mode=hq')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should use hardware tone-mapping for qsv if hardware decoding is enabled and should tone map', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamHDR);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Qsv, accelDecode: true },
|
|
});
|
|
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-hwaccel qsv',
|
|
'-hwaccel_output_format qsv',
|
|
'-async_depth 4',
|
|
'-threads 1',
|
|
]),
|
|
outputOptions: expect.arrayContaining([
|
|
expect.stringContaining(
|
|
'hwmap=derive_device=opencl,tonemap_opencl=desat=0:format=nv12:matrix=bt709:primaries=bt709:transfer=bt709:range=pc:tonemap=hable:tonemap_mode=lum:peak=100,hwmap=derive_device=qsv:reverse=1,format=qsv',
|
|
),
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should use preferred device for qsv when hardware decoding', async () => {
|
|
sut.videoInterfaces = { dri: ['renderD128', 'renderD129', 'renderD130'], mali: false };
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Qsv, accelDecode: true, preferredHwDevice: 'renderD129' },
|
|
});
|
|
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-hwaccel qsv', '-qsv_device /dev/dri/renderD129']),
|
|
outputOptions: expect.any(Array),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set format to nv12 for qsv if input is not yuv420p', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream10Bit);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Qsv, accelDecode: true },
|
|
});
|
|
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-hwaccel qsv',
|
|
'-hwaccel_output_format qsv',
|
|
'-async_depth 4',
|
|
'-threads 1',
|
|
]),
|
|
outputOptions: expect.arrayContaining([expect.stringContaining('format=nv12')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set options for vaapi', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { accel: TranscodeHardwareAcceleration.Vaapi } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-init_hw_device vaapi=accel:/dev/dri/renderD128',
|
|
'-filter_hw_device accel',
|
|
]),
|
|
outputOptions: expect.arrayContaining([
|
|
`-c:v h264_vaapi`,
|
|
'-c:a copy',
|
|
'-movflags faststart',
|
|
'-fps_mode passthrough',
|
|
'-map 0:0',
|
|
'-map 0:3',
|
|
'-g 256',
|
|
'-v verbose',
|
|
'-vf hwupload=extra_hw_frames=64,scale_vaapi=-2:720:mode=hq:out_range=pc:format=nv12',
|
|
'-compression_level 7',
|
|
'-rc_mode 1',
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set vbr options for vaapi when max bitrate is enabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Vaapi, maxBitrate: '10000k' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-init_hw_device vaapi=accel:/dev/dri/renderD128',
|
|
'-filter_hw_device accel',
|
|
]),
|
|
outputOptions: expect.arrayContaining([
|
|
`-c:v h264_vaapi`,
|
|
'-b:v 6897k',
|
|
'-maxrate 10000k',
|
|
'-minrate 3448.5k',
|
|
'-rc_mode 3',
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set cq options for vaapi when max bitrate is disabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { accel: TranscodeHardwareAcceleration.Vaapi } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-init_hw_device vaapi=accel:/dev/dri/renderD128',
|
|
'-filter_hw_device accel',
|
|
]),
|
|
outputOptions: expect.arrayContaining([
|
|
`-c:v h264_vaapi`,
|
|
'-c:a copy',
|
|
'-qp:v 23',
|
|
'-global_quality:v 23',
|
|
'-rc_mode 1',
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should omit preset for vaapi if invalid', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Vaapi, preset: 'invalid' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-init_hw_device vaapi=accel:/dev/dri/renderD128',
|
|
'-filter_hw_device accel',
|
|
]),
|
|
outputOptions: expect.not.arrayContaining([expect.stringContaining('-compression_level')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should prefer higher index renderD* device for vaapi', async () => {
|
|
sut.videoInterfaces = { dri: ['card1', 'renderD129', 'card0', 'renderD128'], mali: false };
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { accel: TranscodeHardwareAcceleration.Vaapi } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-init_hw_device vaapi=accel:/dev/dri/renderD129',
|
|
'-filter_hw_device accel',
|
|
]),
|
|
outputOptions: expect.arrayContaining([`-c:v h264_vaapi`]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should select specific gpu node if selected', async () => {
|
|
sut.videoInterfaces = { dri: ['renderD129', 'card1', 'card0', 'renderD128'], mali: false };
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Vaapi, preferredHwDevice: '/dev/dri/renderD128' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-init_hw_device vaapi=accel:/dev/dri/renderD128',
|
|
'-filter_hw_device accel',
|
|
]),
|
|
outputOptions: expect.arrayContaining([`-c:v h264_vaapi`]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should use hardware decoding for vaapi if enabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Vaapi, accelDecode: true },
|
|
});
|
|
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-hwaccel vaapi',
|
|
'-hwaccel_output_format vaapi',
|
|
'-noautorotate',
|
|
'-threads 1',
|
|
'-hwaccel_device /dev/dri/renderD128',
|
|
]),
|
|
outputOptions: expect.arrayContaining([expect.stringContaining('scale_vaapi=-2:720:mode=hq:out_range=pc')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should use hardware tone-mapping for vaapi if hardware decoding is enabled and should tone map', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamHDR);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Vaapi, accelDecode: true },
|
|
});
|
|
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-hwaccel vaapi', '-hwaccel_output_format vaapi', '-threads 1']),
|
|
outputOptions: expect.arrayContaining([
|
|
expect.stringContaining(
|
|
'hwmap=derive_device=opencl,tonemap_opencl=desat=0:format=nv12:matrix=bt709:primaries=bt709:transfer=bt709:range=pc:tonemap=hable:tonemap_mode=lum:peak=100,hwmap=derive_device=vaapi:reverse=1,format=vaapi',
|
|
),
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set format to nv12 for vaapi if input is not yuv420p', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream10Bit);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Vaapi, accelDecode: true },
|
|
});
|
|
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-hwaccel vaapi', '-hwaccel_output_format vaapi', '-threads 1']),
|
|
outputOptions: expect.arrayContaining([expect.stringContaining('format=nv12')]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should use preferred device for vaapi when hardware decoding', async () => {
|
|
sut.videoInterfaces = { dri: ['renderD128', 'renderD129', 'renderD130'], mali: false };
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Vaapi, accelDecode: true, preferredHwDevice: 'renderD129' },
|
|
});
|
|
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-hwaccel vaapi', '-hwaccel_device /dev/dri/renderD129']),
|
|
outputOptions: expect.any(Array),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should fallback to hw encoding and sw decoding if hw transcoding fails and hw decoding is enabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Vaapi, accelDecode: true },
|
|
});
|
|
mocks.media.transcode.mockRejectedValueOnce(new Error('error'));
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledTimes(2);
|
|
expect(mocks.media.transcode).toHaveBeenLastCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-init_hw_device vaapi=accel:/dev/dri/renderD128',
|
|
'-filter_hw_device accel',
|
|
]),
|
|
outputOptions: expect.arrayContaining([`-c:v h264_vaapi`]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should fallback to sw decoding if fallback to sw decoding + hw encoding fails', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Vaapi, accelDecode: true },
|
|
});
|
|
mocks.media.transcode.mockRejectedValueOnce(new Error('error'));
|
|
mocks.media.transcode.mockRejectedValueOnce(new Error('error'));
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledTimes(3);
|
|
expect(mocks.media.transcode).toHaveBeenLastCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-c:v h264']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should fallback to sw transcoding if hw transcoding fails and hw decoding is disabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { accel: TranscodeHardwareAcceleration.Vaapi } });
|
|
mocks.media.transcode.mockRejectedValueOnce(new Error('error'));
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledTimes(2);
|
|
expect(mocks.media.transcode).toHaveBeenLastCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-c:v h264']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should fail for vaapi if no hw devices', async () => {
|
|
sut.videoInterfaces = { dri: [], mali: true };
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { accel: TranscodeHardwareAcceleration.Vaapi } });
|
|
await expect(sut.handleVideoConversion({ id: 'video-id' })).rejects.toThrowError();
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should set options for rkmpp', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Rkmpp, accelDecode: true },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining([
|
|
'-hwaccel rkmpp',
|
|
'-hwaccel_output_format drm_prime',
|
|
'-afbc rga',
|
|
'-noautorotate',
|
|
]),
|
|
outputOptions: expect.arrayContaining([
|
|
`-c:v h264_rkmpp`,
|
|
'-c:a copy',
|
|
'-movflags faststart',
|
|
'-fps_mode passthrough',
|
|
'-map 0:0',
|
|
'-map 0:3',
|
|
'-g 256',
|
|
'-v verbose',
|
|
'-vf scale_rkrga=-2:720:format=nv12:afbc=1:async_depth=4',
|
|
'-level 51',
|
|
'-rc_mode CQP',
|
|
'-qp_init 23',
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set vbr options for rkmpp when max bitrate is enabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamVp9);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: {
|
|
accel: TranscodeHardwareAcceleration.Rkmpp,
|
|
accelDecode: true,
|
|
maxBitrate: '10000k',
|
|
targetVideoCodec: VideoCodec.Hevc,
|
|
},
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-hwaccel rkmpp', '-hwaccel_output_format drm_prime', '-afbc rga']),
|
|
outputOptions: expect.arrayContaining([`-c:v hevc_rkmpp`, '-level 153', '-rc_mode AVBR', '-b:v 10000k']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set cqp options for rkmpp when max bitrate is disabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Rkmpp, accelDecode: true, crf: 30, maxBitrate: '0' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-hwaccel rkmpp', '-hwaccel_output_format drm_prime', '-afbc rga']),
|
|
outputOptions: expect.arrayContaining([`-c:v h264_rkmpp`, '-level 51', '-rc_mode CQP', '-qp_init 30']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set OpenCL tonemapping options for rkmpp when OpenCL is available', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamHDR);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Rkmpp, accelDecode: true, crf: 30, maxBitrate: '0' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-hwaccel rkmpp', '-hwaccel_output_format drm_prime', '-afbc rga']),
|
|
outputOptions: expect.arrayContaining([
|
|
expect.stringContaining(
|
|
'scale_rkrga=-2:720:format=p010:afbc=1:async_depth=4,hwmap=derive_device=opencl:mode=read,tonemap_opencl=format=nv12:r=pc:p=bt709:t=bt709:m=bt709:tonemap=hable:desat=0:tonemap_mode=lum:peak=100,hwmap=derive_device=rkmpp:mode=write:reverse=1,format=drm_prime',
|
|
),
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should set hardware decoding options for rkmpp when hardware decoding is enabled with no OpenCL on non-HDR file', async () => {
|
|
sut.videoInterfaces = { dri: ['renderD128'], mali: false };
|
|
mocks.media.probe.mockResolvedValue(probeStub.noAudioStreams);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Rkmpp, accelDecode: true, crf: 30, maxBitrate: '0' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.arrayContaining(['-hwaccel rkmpp', '-hwaccel_output_format drm_prime', '-afbc rga']),
|
|
outputOptions: expect.arrayContaining([
|
|
expect.stringContaining('scale_rkrga=-2:720:format=nv12:afbc=1:async_depth=4'),
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should use software decoding and tone-mapping if hardware decoding is disabled', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamHDR);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Rkmpp, accelDecode: false, crf: 30, maxBitrate: '0' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: [],
|
|
outputOptions: expect.arrayContaining([
|
|
expect.stringContaining(
|
|
'tonemapx=tonemap=hable:desat=0:p=bt709:t=bt709:m=bt709:r=pc:peak=100:format=yuv420p',
|
|
),
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should use software tone-mapping if opencl is not available', async () => {
|
|
sut.videoInterfaces = { dri: ['renderD128'], mali: false };
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamHDR);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: { accel: TranscodeHardwareAcceleration.Rkmpp, accelDecode: true, crf: 30, maxBitrate: '0' },
|
|
});
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining([
|
|
expect.stringContaining(
|
|
'tonemapx=tonemap=hable:desat=0:p=bt709:t=bt709:m=bt709:r=pc:peak=100:format=yuv420p',
|
|
),
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should tonemap when policy is required and video is hdr', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamHDR);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Required } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining([
|
|
'-c:v h264',
|
|
'-c:a copy',
|
|
'-vf tonemapx=tonemap=hable:desat=0:p=bt709:t=bt709:m=bt709:r=pc:peak=100:format=yuv420p',
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should tonemap when policy is optimal and video is hdr', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStreamHDR);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Optimal } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining([
|
|
'-c:v h264',
|
|
'-c:a copy',
|
|
'-vf tonemapx=tonemap=hable:desat=0:p=bt709:t=bt709:m=bt709:r=pc:peak=100:format=yuv420p',
|
|
]),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should transcode when policy is required and video is not yuv420p', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream10Bit);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Required } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-c:v h264', '-c:a copy', '-vf format=yuv420p']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should convert to yuv420p when scaling without tone-mapping', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream4K10Bit);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Required } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
'/original/path.ext',
|
|
expect.any(String),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-c:v h264', '-c:a copy', '-vf scale=-2:720,format=yuv420p']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should count frames for progress when log level is debug', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.matroskaContainer);
|
|
mocks.logger.isLevelEnabled.mockReturnValue(true);
|
|
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
|
|
expect(mocks.media.probe).toHaveBeenCalledWith('/original/path.ext', { countFrames: true });
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith('/original/path.ext', expect.any(String), {
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.any(Array),
|
|
twoPass: false,
|
|
progress: {
|
|
frameCount: probeStub.videoStream2160p.videoStreams[0].frameCount,
|
|
percentInterval: expect.any(Number),
|
|
},
|
|
});
|
|
});
|
|
|
|
it('should not count frames for progress when log level is not debug', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream2160p);
|
|
mocks.logger.isLevelEnabled.mockReturnValue(false);
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
|
|
expect(mocks.media.probe).toHaveBeenCalledWith('/original/path.ext', { countFrames: false });
|
|
});
|
|
|
|
it('should process unknown audio stream', async () => {
|
|
const asset = AssetFactory.create({
|
|
type: AssetType.Video,
|
|
originalPath: '/original/path.ext',
|
|
});
|
|
mocks.media.probe.mockResolvedValue(probeStub.audioStreamUnknown);
|
|
mocks.asset.getByIds.mockResolvedValue([asset]);
|
|
await sut.handleVideoConversion({ id: asset.id });
|
|
|
|
expect(mocks.media.transcode).toHaveBeenCalledWith(
|
|
asset.originalPath,
|
|
expect.stringContaining('video-id.mp4'),
|
|
expect.objectContaining({
|
|
inputOptions: expect.any(Array),
|
|
outputOptions: expect.arrayContaining(['-c:a copy']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('isSRGB', () => {
|
|
it('should return true for srgb colorspace', () => {
|
|
expect(sut.isSRGB({ colorspace: 'sRGB' } as Exif)).toEqual(true);
|
|
});
|
|
|
|
it('should return true for srgb profile description', () => {
|
|
expect(sut.isSRGB({ profileDescription: 'sRGB v1.31' } as Exif)).toEqual(true);
|
|
});
|
|
|
|
it('should return true for 8-bit image with no colorspace metadata', () => {
|
|
expect(sut.isSRGB({ bitsPerSample: 8 } as Exif)).toEqual(true);
|
|
});
|
|
|
|
it('should return true for image with no colorspace or bit depth metadata', () => {
|
|
expect(sut.isSRGB({} as Exif)).toEqual(true);
|
|
});
|
|
|
|
it('should return false for non-srgb colorspace', () => {
|
|
expect(sut.isSRGB({ colorspace: 'Adobe RGB' } as Exif)).toEqual(false);
|
|
});
|
|
|
|
it('should return false for non-srgb profile description', () => {
|
|
expect(sut.isSRGB({ profileDescription: 'sP3C' } as Exif)).toEqual(false);
|
|
});
|
|
|
|
it('should return false for 16-bit image with no colorspace metadata', () => {
|
|
expect(sut.isSRGB({ bitsPerSample: 16 } as Exif)).toEqual(false);
|
|
});
|
|
|
|
it('should return true for 16-bit image with sRGB colorspace', () => {
|
|
expect(sut.isSRGB({ colorspace: 'sRGB', bitsPerSample: 16 } as Exif)).toEqual(true);
|
|
});
|
|
|
|
it('should return true for 16-bit image with sRGB profile', () => {
|
|
expect(sut.isSRGB({ profileDescription: 'sRGB', bitsPerSample: 16 } as Exif)).toEqual(true);
|
|
});
|
|
});
|
|
|
|
describe('syncFiles', () => {
|
|
it('should upsert new files when they do not exist', async () => {
|
|
const asset = {
|
|
id: 'asset-id',
|
|
files: [],
|
|
};
|
|
|
|
await sut['syncFiles'](asset.files, [
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Preview,
|
|
path: '/new/preview.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Thumbnail,
|
|
path: '/new/thumbnail.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
]);
|
|
|
|
expect(mocks.asset.upsertFiles).toHaveBeenCalledWith([
|
|
{
|
|
assetId: 'asset-id',
|
|
path: '/new/preview.jpg',
|
|
type: AssetFileType.Preview,
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
assetId: 'asset-id',
|
|
path: '/new/thumbnail.jpg',
|
|
type: AssetFileType.Thumbnail,
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
]);
|
|
expect(mocks.asset.deleteFiles).not.toHaveBeenCalled();
|
|
expect(mocks.job.queue).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should replace existing files with new paths', async () => {
|
|
const asset = {
|
|
id: 'asset-id',
|
|
files: [
|
|
{
|
|
id: 'file-1',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Preview,
|
|
path: '/old/preview.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
id: 'file-2',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Thumbnail,
|
|
path: '/old/thumbnail.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
],
|
|
};
|
|
|
|
await sut['syncFiles'](asset.files, [
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Preview,
|
|
path: '/new/preview.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Thumbnail,
|
|
path: '/new/thumbnail.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
]);
|
|
|
|
expect(mocks.asset.upsertFiles).toHaveBeenCalledWith([
|
|
{
|
|
assetId: 'asset-id',
|
|
path: '/new/preview.jpg',
|
|
type: AssetFileType.Preview,
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
assetId: 'asset-id',
|
|
path: '/new/thumbnail.jpg',
|
|
type: AssetFileType.Thumbnail,
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
]);
|
|
expect(mocks.asset.deleteFiles).not.toHaveBeenCalled();
|
|
expect(mocks.job.queue).toHaveBeenCalledWith({
|
|
name: JobName.FileDelete,
|
|
data: { files: ['/old/preview.jpg', '/old/thumbnail.jpg'] },
|
|
});
|
|
});
|
|
|
|
it('should delete files when newPath is not provided', async () => {
|
|
const asset = {
|
|
id: 'asset-id',
|
|
files: [
|
|
{
|
|
id: 'file-1',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Preview,
|
|
path: '/old/preview.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
id: 'file-2',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Thumbnail,
|
|
path: '/old/thumbnail.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
],
|
|
};
|
|
|
|
await sut['syncFiles'](asset.files, []);
|
|
|
|
expect(mocks.asset.upsertFiles).not.toHaveBeenCalled();
|
|
expect(mocks.asset.deleteFiles).toHaveBeenCalledWith([
|
|
{
|
|
id: 'file-1',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Preview,
|
|
path: '/old/preview.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
id: 'file-2',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Thumbnail,
|
|
path: '/old/thumbnail.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
]);
|
|
expect(mocks.job.queue).toHaveBeenCalledWith({
|
|
name: JobName.FileDelete,
|
|
data: { files: ['/old/preview.jpg', '/old/thumbnail.jpg'] },
|
|
});
|
|
});
|
|
|
|
it('should not make changes when file paths already match', async () => {
|
|
const asset = {
|
|
id: 'asset-id',
|
|
files: [
|
|
{
|
|
id: 'file-1',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Preview,
|
|
path: '/same/preview.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
id: 'file-2',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Thumbnail,
|
|
path: '/same/thumbnail.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
],
|
|
};
|
|
|
|
await sut['syncFiles'](asset.files, [
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Preview,
|
|
path: '/same/preview.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Thumbnail,
|
|
path: '/same/thumbnail.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
]);
|
|
|
|
expect(mocks.asset.upsertFiles).not.toHaveBeenCalled();
|
|
expect(mocks.asset.deleteFiles).not.toHaveBeenCalled();
|
|
expect(mocks.job.queue).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should handle mixed operations (upsert, replace, delete)', async () => {
|
|
const asset = {
|
|
id: 'asset-id',
|
|
files: [
|
|
{
|
|
id: 'file-1',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Preview,
|
|
path: '/old/preview.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
id: 'file-2',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Thumbnail,
|
|
path: '/old/thumbnail.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
],
|
|
};
|
|
|
|
await sut['syncFiles'](asset.files, [
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Preview,
|
|
path: '/new/preview.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
}, // replace
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.FullSize,
|
|
path: '/new/fullsize.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
}, // new
|
|
]);
|
|
|
|
expect(mocks.asset.upsertFiles).toHaveBeenCalledWith([
|
|
{
|
|
assetId: 'asset-id',
|
|
path: '/new/preview.jpg',
|
|
type: AssetFileType.Preview,
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
assetId: 'asset-id',
|
|
path: '/new/fullsize.jpg',
|
|
type: AssetFileType.FullSize,
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
]);
|
|
expect(mocks.asset.deleteFiles).toHaveBeenCalledWith([
|
|
{
|
|
id: 'file-2',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Thumbnail,
|
|
path: '/old/thumbnail.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
]);
|
|
expect(mocks.job.queue).toHaveBeenCalledWith({
|
|
name: JobName.FileDelete,
|
|
data: { files: ['/old/preview.jpg', '/old/thumbnail.jpg'] },
|
|
});
|
|
});
|
|
|
|
it('should handle empty file list', async () => {
|
|
const asset = {
|
|
id: 'asset-id',
|
|
files: [],
|
|
};
|
|
|
|
await sut['syncFiles'](asset.files, []);
|
|
|
|
expect(mocks.asset.upsertFiles).not.toHaveBeenCalled();
|
|
expect(mocks.asset.deleteFiles).not.toHaveBeenCalled();
|
|
expect(mocks.job.queue).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should delete non-existent file types when newPath is not provided', async () => {
|
|
const asset = {
|
|
id: 'asset-id',
|
|
files: [
|
|
{
|
|
id: 'file-1',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Preview,
|
|
path: '/old/preview.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
],
|
|
};
|
|
|
|
await sut['syncFiles'](asset.files, []);
|
|
|
|
expect(mocks.asset.upsertFiles).not.toHaveBeenCalled();
|
|
expect(mocks.asset.deleteFiles).toHaveBeenCalledWith([
|
|
{
|
|
id: 'file-1',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Preview,
|
|
path: '/old/preview.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
]);
|
|
expect(mocks.job.queue).toHaveBeenCalledWith({
|
|
name: JobName.FileDelete,
|
|
data: { files: ['/old/preview.jpg'] },
|
|
});
|
|
});
|
|
|
|
it('should update database when isProgressive changes', async () => {
|
|
const asset = {
|
|
id: 'asset-id',
|
|
files: [
|
|
{
|
|
id: 'file-1',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Preview,
|
|
path: '/old/preview.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
id: 'file-2',
|
|
assetId: 'asset-id',
|
|
type: AssetFileType.Thumbnail,
|
|
path: '/old/thumbnail.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
],
|
|
};
|
|
|
|
await sut['syncFiles'](asset.files, [
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Preview,
|
|
path: '/old/preview.jpg',
|
|
isEdited: false,
|
|
isProgressive: true,
|
|
isTransparent: false,
|
|
},
|
|
{
|
|
assetId: asset.id,
|
|
type: AssetFileType.Thumbnail,
|
|
path: '/old/thumbnail.jpg',
|
|
isEdited: false,
|
|
isProgressive: false,
|
|
isTransparent: false,
|
|
},
|
|
]);
|
|
|
|
expect(mocks.asset.upsertFiles).toHaveBeenCalledWith([
|
|
{
|
|
assetId: 'asset-id',
|
|
path: '/old/preview.jpg',
|
|
type: AssetFileType.Preview,
|
|
isEdited: false,
|
|
isProgressive: true,
|
|
isTransparent: false,
|
|
},
|
|
]);
|
|
expect(mocks.asset.deleteFiles).not.toHaveBeenCalled();
|
|
expect(mocks.job.queue).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
});
|