mirror of
https://github.com/immich-app/immich.git
synced 2026-03-22 16:09:29 +03:00
4a384bca86
* Fix opus handling as accepted audio codec in transcode policy Fix the issue when opus is among accepted audio codecs in transcode policy (which is default) but it still triggers transcoding because the codec name from ffprobe (opus) does not match `libopus` literal in Immich. Make a distinction between a codec name and encoder: - codec name: switch to `opus` as the audio codec name. This matches what ffprobe returns for a media file with opus audio. - encoder: continue using the `libopus` encoder in ffmpeg. * Add unit tests for accepted audio codecs and for libopus encoder * Add db migration for ffmpeg.targetAudioCodec opus * backward compatibility * tweak * noisy logs * full mapping * make check happy * mark deprecated * update api * indexOf --------- Co-authored-by: mertalev <101130780+mertalev@users.noreply.github.com>
4049 lines
157 KiB
TypeScript
4049 lines
157 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 { PersonFactory } from 'test/factories/person.factory';
|
|
import { probeStub } from 'test/fixtures/media.stub';
|
|
import { personThumbnailStub } from 'test/fixtures/person.stub';
|
|
import { systemConfigStub } from 'test/fixtures/system-config.stub';
|
|
import { factory, newUuid } 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();
|
|
const person = PersonFactory.create({ faceAssetId: newUuid() });
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([asset]));
|
|
|
|
mocks.person.getAll.mockReturnValue(makeStream([person]));
|
|
|
|
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: person.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 () => {
|
|
const [person1, person2] = [
|
|
PersonFactory.create({ thumbnailPath: undefined }),
|
|
PersonFactory.create({ thumbnailPath: undefined }),
|
|
];
|
|
|
|
mocks.assetJob.streamForThumbnailJob.mockReturnValue(makeStream([AssetFactory.create()]));
|
|
mocks.person.getAll.mockReturnValue(makeStream([person1, person2]));
|
|
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: person1.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();
|
|
const person = PersonFactory.create();
|
|
|
|
mocks.assetJob.streamForMigrationJob.mockReturnValue(makeStream([asset]));
|
|
mocks.job.getJobCounts.mockResolvedValue({ active: 1, waiting: 0 } as JobCounts);
|
|
mocks.person.getAll.mockReturnValue(makeStream([person]));
|
|
|
|
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: person.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 () => {
|
|
const person = PersonFactory.create({ faceAssetId: null });
|
|
mocks.person.getById.mockResolvedValue(person);
|
|
await sut.handleGeneratePersonThumbnail({ id: person.id });
|
|
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 () => {
|
|
const person = PersonFactory.create();
|
|
|
|
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: person.id })).resolves.toBe(JobStatus.Success);
|
|
|
|
expect(mocks.person.getDataForThumbnailGenerationJob).toHaveBeenCalledWith(person.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.id, thumbnailPath: expect.any(String) });
|
|
});
|
|
|
|
it('should use preview path if video', async () => {
|
|
const person = PersonFactory.create();
|
|
|
|
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: person.id })).resolves.toBe(JobStatus.Success);
|
|
|
|
expect(mocks.person.getDataForThumbnailGenerationJob).toHaveBeenCalledWith(person.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.id, thumbnailPath: expect.any(String) });
|
|
});
|
|
|
|
it('should generate a thumbnail without going negative', async () => {
|
|
const person = PersonFactory.create();
|
|
|
|
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: person.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 () => {
|
|
const person = PersonFactory.create();
|
|
|
|
mocks.person.getDataForThumbnailGenerationJob.mockResolvedValue(personThumbnailStub.newThumbnailEnd);
|
|
mocks.person.update.mockResolvedValue(person);
|
|
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: person.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 () => {
|
|
const person = PersonFactory.create();
|
|
|
|
mocks.person.getDataForThumbnailGenerationJob.mockResolvedValue(personThumbnailStub.negativeCoordinate);
|
|
mocks.person.update.mockResolvedValue(person);
|
|
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: person.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 () => {
|
|
const person = PersonFactory.create();
|
|
|
|
mocks.person.getDataForThumbnailGenerationJob.mockResolvedValue(personThumbnailStub.overflowingCoordinate);
|
|
mocks.person.update.mockResolvedValue(person);
|
|
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: person.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 () => {
|
|
const person = PersonFactory.create();
|
|
|
|
mocks.systemMetadata.get.mockResolvedValue({ image: { extractEmbedded: true } });
|
|
mocks.person.getDataForThumbnailGenerationJob.mockResolvedValue(personThumbnailStub.rawEmbeddedThumbnail);
|
|
mocks.person.update.mockResolvedValue(person);
|
|
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: person.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 () => {
|
|
const person = PersonFactory.create();
|
|
|
|
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: person.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 () => {
|
|
const person = PersonFactory.create();
|
|
|
|
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: person.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 () => {
|
|
const person = PersonFactory.create();
|
|
|
|
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: person.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 not transcode when policy bitrate and bitrate lower than max bitrate', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream40Mbps);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Bitrate, maxBitrate: '50M' } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
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 not 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).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should not transcode when max bitrate is 0', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.videoStream40Mbps);
|
|
mocks.systemMetadata.get.mockResolvedValue({ ffmpeg: { transcode: TranscodePolicy.Bitrate, maxBitrate: '0' } });
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
|
|
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();
|
|
});
|
|
|
|
describe('should skip transcoding for accepted audio codecs with optimal policy if video is fine', () => {
|
|
const acceptedCodecs = [
|
|
{ codec: 'aac', probeStub: probeStub.audioStreamAac },
|
|
{ codec: 'mp3', probeStub: probeStub.audioStreamMp3 },
|
|
{ codec: 'opus', probeStub: probeStub.audioStreamOpus },
|
|
];
|
|
|
|
beforeEach(() => {
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: {
|
|
targetVideoCodec: VideoCodec.Hevc,
|
|
transcode: TranscodePolicy.Optimal,
|
|
targetResolution: '1080p',
|
|
},
|
|
});
|
|
});
|
|
|
|
it.each(acceptedCodecs)('should skip $codec', async ({ probeStub }) => {
|
|
mocks.media.probe.mockResolvedValue(probeStub);
|
|
await sut.handleVideoConversion({ id: 'video-id' });
|
|
expect(mocks.media.transcode).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
it('should use libopus audio encoder when target audio is opus', async () => {
|
|
mocks.media.probe.mockResolvedValue(probeStub.audioStreamAac);
|
|
mocks.systemMetadata.get.mockResolvedValue({
|
|
ffmpeg: {
|
|
targetAudioCodec: AudioCodec.Opus,
|
|
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.arrayContaining(['-c:a libopus']),
|
|
twoPass: false,
|
|
}),
|
|
);
|
|
});
|
|
|
|
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();
|
|
});
|
|
});
|
|
});
|