@cornerstonejs/core 4.22.13 → 5.0.0

package/dist/esm/RenderingEngine/GenericViewport/Video/VideoResolvedView.js

@@ -0,0 +1,108 @@
+import ResolvedViewportView from '../ResolvedViewportView';
+import { getAnchorWorldForPan, getPanForVideoCanvasMapping, resolveVideoCanvasMapping, } from './videoViewportCamera';
+class VideoResolvedView extends ResolvedViewportView {
+    get zoom() {
+        return Math.max(this.state.viewState.scale ?? 1, 0.001);
+    }
+    get pan() {
+        return this.getCanvasMapping()
+            ? getPanForVideoCanvasMapping(this.getCanvasMapping())
+            : [0, 0];
+    }
+    get rotation() {
+        return this.state.viewState.rotation ?? 0;
+    }
+    canvasToWorld(canvasPos) {
+        const mapping = this.getCanvasMapping();
+        return [
+            (canvasPos[0] - mapping.left) / mapping.worldToCanvasRatio,
+            (canvasPos[1] - mapping.top) / mapping.worldToCanvasRatio,
+            0,
+        ];
+    }
+    worldToCanvas(worldPos) {
+        const mapping = this.getCanvasMapping();
+        return [
+            mapping.left + worldPos[0] * mapping.worldToCanvasRatio,
+            mapping.top + worldPos[1] * mapping.worldToCanvasRatio,
+        ];
+    }
+    getFrameOfReferenceUID() {
+        return this.state.frameOfReferenceUID;
+    }
+    withZoom(zoom, canvasPoint) {
+        const nextZoom = Math.max(zoom, 0.001);
+        if (!canvasPoint) {
+            return this.cloneWithViewState({
+                ...this.state.viewState,
+                scale: nextZoom,
+                scaleMode: 'fit',
+            });
+        }
+        const worldPoint = this.canvasToWorld(canvasPoint);
+        return this.cloneWithViewState({
+            ...this.state.viewState,
+            anchorCanvas: [
+                canvasPoint[0] / Math.max(this.state.containerWidth, 1),
+                canvasPoint[1] / Math.max(this.state.containerHeight, 1),
+            ],
+            anchorWorld: [worldPoint[0], worldPoint[1]],
+            scale: nextZoom,
+            scaleMode: 'fit',
+        });
+    }
+    withPan(pan) {
+        return this.cloneWithViewState({
+            ...this.state.viewState,
+            anchorWorld: getAnchorWorldForPan([pan[0], pan[1]], this.getCanvasMapping()),
+        });
+    }
+    buildICamera() {
+        const mapping = this.getCanvasMapping();
+        const focalPoint = this.canvasToWorld([
+            this.state.containerWidth / 2,
+            this.state.containerHeight / 2,
+        ]);
+        return {
+            parallelProjection: true,
+            focalPoint,
+            position: [0, 0, 0],
+            viewUp: [0, -1, 0],
+            parallelScale: this.state.containerHeight /
+                2 /
+                Math.max(mapping.worldToCanvasRatio, 0.001),
+            viewPlaneNormal: [0, 0, 1],
+            rotation: this.rotation,
+        };
+    }
+    getCanvasMapping() {
+        this.cachedCanvasMapping ||= resolveVideoCanvasMapping({
+            camera: this.state.viewState,
+            containerHeight: this.state.containerHeight,
+            containerWidth: this.state.containerWidth,
+            intrinsicHeight: this.state.intrinsicHeight,
+            intrinsicWidth: this.state.intrinsicWidth,
+            objectFit: this.state.objectFit,
+        }) || {
+            left: 0,
+            top: 0,
+            width: Math.max(this.state.intrinsicWidth, 1),
+            height: Math.max(this.state.intrinsicHeight, 1),
+            containerWidth: Math.max(this.state.containerWidth, 1),
+            containerHeight: Math.max(this.state.containerHeight, 1),
+            intrinsicWidth: Math.max(this.state.intrinsicWidth, 1),
+            intrinsicHeight: Math.max(this.state.intrinsicHeight, 1),
+            anchorWorld: [0, 0],
+            anchorCanvas: [0.5, 0.5],
+            worldToCanvasRatio: 1,
+        };
+        return this.cachedCanvasMapping;
+    }
+    cloneWithViewState(viewState) {
+        return new VideoResolvedView({
+            ...this.state,
+            viewState,
+        });
+    }
+}
+export default VideoResolvedView;

package/dist/esm/RenderingEngine/GenericViewport/Video/VideoViewport.d.ts

@@ -0,0 +1,59 @@
+import GenericViewport from '../GenericViewport';
+import type { Point2, ViewReference, ViewReferenceSpecifier } from '../../../types';
+import { ViewportType } from '../../../enums';
+import type { GenericViewportReferenceContext } from '../genericViewportReferenceCompatibility';
+import type { VideoViewState, VideoDataPresentation, VideoElementRenderContext, VideoViewportInput } from './VideoViewportTypes';
+import VideoResolvedView from './VideoResolvedView';
+declare class VideoViewport extends GenericViewport<VideoViewState, VideoDataPresentation, VideoElementRenderContext> {
+    readonly type = ViewportType.VIDEO_NEXT;
+    readonly renderingEngineId: string;
+    protected renderContext: VideoElementRenderContext;
+    private trackedVideoElement?;
+    private cleanupTrackedVideoElement?;
+    static get useCustomRenderingPipeline(): boolean;
+    constructor(args: VideoViewportInput);
+    setDisplaySets(...entries: Array<{
+        displaySetId: string;
+    }>): Promise<void>;
+    removeData(dataId: string): void;
+    getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
+    getCurrentImageId(index?: number): string | undefined;
+    getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
+    setViewReference(viewRef: ViewReference): void;
+    getSliceIndex(): number;
+    getZoom(): number;
+    setZoom(zoom: number, canvasPoint?: Point2): void;
+    getPan(): Point2;
+    setPan(pan: Point2): void;
+    getResolvedView(): VideoResolvedView | undefined;
+    protected getReferenceViewContexts(): GenericViewportReferenceContext[];
+    play(): Promise<void>;
+    pause(): void;
+    seek(timeSeconds: number): void;
+    setFrameNumber(frameNumber: number): void;
+    setPlaybackRate(playbackRate: number): void;
+    scroll(delta?: number, _debounceLoading?: boolean, loop?: boolean): void;
+    getFrameRate(): number;
+    getNumberOfFrames(): number;
+    getNumberOfSlices(): number;
+    getCurrentTime(): number;
+    getFrameNumber(): number;
+    getCurrentImageIdIndex(): number;
+    getImageIds(): string[];
+    render(): void;
+    resetViewState(): boolean;
+    dispose(): void;
+    getUseCustomRenderingPipeline(): boolean;
+    protected normalizeViewState(viewState: VideoViewState): VideoViewState;
+    protected onDestroy(): void;
+    private getVideoElement;
+    private getVideoData;
+    private getVideoDataFromBinding;
+    private getVideoRendering;
+    private syncCameraCurrentTimeFromElement;
+    private trackVideoElement;
+    private untrackVideoElement;
+    private applyResolvedViewState;
+    private primeInitialFrame;
+}
+export default VideoViewport;

package/dist/esm/RenderingEngine/GenericViewport/Video/VideoViewport.js

@@ -0,0 +1,458 @@
+import GenericViewport from '../GenericViewport';
+import { ViewportType } from '../../../enums';
+import { frameNumberToTimeSeconds, timeSecondsToFrameNumber, } from '../../../utilities/VideoUtilities';
+import { generateFrameImageId } from '../../../utilities/splitImageIdsBy4DTags';
+import { DefaultVideoDataProvider } from './DefaultVideoDataProvider';
+import { getGenericViewportSourceDataId } from '../genericViewportDataSetAccess';
+import { createDefaultVideoViewState, normalizeVideoViewState, } from './videoViewportCamera';
+import { createVideoRenderPathResolver } from './VideoRenderPathResolver';
+import VideoResolvedView from './VideoResolvedView';
+class VideoViewport extends GenericViewport {
+    static get useCustomRenderingPipeline() {
+        return true;
+    }
+    constructor(args) {
+        super(args);
+        this.type = ViewportType.VIDEO_NEXT;
+        this.renderingEngineId = args.renderingEngineId;
+        this.element.style.position = this.element.style.position || 'relative';
+        this.element.style.overflow = 'hidden';
+        this.element.style.background = this.element.style.background || '#000';
+        this.dataProvider = args.dataProvider || new DefaultVideoDataProvider();
+        this.renderPathResolver =
+            args.renderPathResolver || createVideoRenderPathResolver();
+        this.renderContext = {
+            viewportId: this.id,
+            renderingEngineId: this.renderingEngineId,
+            type: 'video',
+            element: this.element,
+        };
+        this.viewState = createDefaultVideoViewState();
+        this.element.setAttribute('data-viewport-uid', this.id);
+        this.element.setAttribute('data-rendering-engine-uid', this.renderingEngineId);
+    }
+    async setDisplaySets(...entries) {
+        this.removeAllData();
+        for (const [index, { displaySetId }] of entries.entries()) {
+            await this.addDisplaySet(displaySetId, {
+                renderMode: 'video2d',
+                role: index === 0 ? 'source' : 'overlay',
+            });
+            const binding = this.getBinding(displaySetId);
+            if (!binding) {
+                continue;
+            }
+            this.setDefaultDataPresentation(displaySetId, {
+                visible: true,
+                opacity: 1,
+                playbackRate: 1,
+                loop: true,
+                muted: true,
+                objectFit: 'contain',
+            });
+            const videoData = this.getVideoDataFromBinding(binding);
+            if (!videoData) {
+                throw new Error(`[VideoViewport] Loaded data for ${displaySetId} is not a valid video stream`);
+            }
+            this.viewState = createDefaultVideoViewState();
+            if (videoData.frameRange[0] > 1) {
+                this.viewState.currentTimeSeconds = frameNumberToTimeSeconds(videoData.frameRange[0], videoData.fps);
+            }
+            this.modified();
+            this.trackVideoElement();
+            await this.primeInitialFrame(videoData);
+        }
+    }
+    removeData(dataId) {
+        const firstDataId = this.getFirstBinding()?.data.id;
+        super.removeData(dataId);
+        if (firstDataId === dataId) {
+            this.untrackVideoElement();
+            this.trackVideoElement();
+        }
+    }
+    getViewReference(viewRefSpecifier = {}) {
+        const frameNumber = viewRefSpecifier.frameNumber ??
+            (typeof viewRefSpecifier.sliceIndex === 'number'
+                ? viewRefSpecifier.sliceIndex + 1
+                : this.getFrameNumber());
+        const sliceIndex = typeof viewRefSpecifier.sliceIndex === 'number'
+            ? viewRefSpecifier.sliceIndex
+            : frameNumber - 1;
+        const referencedImageId = typeof sliceIndex === 'number'
+            ? this.getCurrentImageId(sliceIndex)
+            : this.getCurrentImageId();
+        const dataId = this.getFirstBinding()?.data.id;
+        return {
+            FrameOfReferenceUID: this.getFrameOfReferenceUID(),
+            dataId,
+            dimensionGroupNumber: frameNumber,
+            referencedImageId,
+            sliceIndex,
+        };
+    }
+    getCurrentImageId(index = this.getCurrentImageIdIndex()) {
+        const sourceDataId = getGenericViewportSourceDataId(this.getFirstBinding()?.data.id || '');
+        if (!sourceDataId) {
+            return;
+        }
+        return generateFrameImageId(sourceDataId, index + 1);
+    }
+    getViewReferenceId(specifier = {}) {
+        const sliceIndex = specifier.sliceIndex;
+        if (sliceIndex === undefined) {
+            return `videoId:${this.getCurrentImageId()}`;
+        }
+        return `videoId:${this.getCurrentImageId(sliceIndex)}`;
+    }
+    setViewReference(viewRef) {
+        if (typeof viewRef.dimensionGroupNumber === 'number') {
+            this.setFrameNumber(viewRef.dimensionGroupNumber);
+            return;
+        }
+        if (typeof viewRef.sliceIndex === 'number') {
+            this.setFrameNumber(viewRef.sliceIndex + 1);
+        }
+    }
+    getSliceIndex() {
+        return this.getCurrentImageIdIndex();
+    }
+    getZoom() {
+        return (this.getResolvedView()?.zoom ?? Math.max(this.viewState.scale ?? 1, 0.001));
+    }
+    setZoom(zoom, canvasPoint) {
+        const resolvedView = this.getResolvedView();
+        if (resolvedView) {
+            this.applyResolvedViewState(resolvedView.withZoom(zoom, canvasPoint).state.viewState);
+            return;
+        }
+        this.setViewState({
+            scale: Math.max(zoom, 0.001),
+            scaleMode: 'fit',
+        });
+    }
+    getPan() {
+        return this.getResolvedView()?.pan ?? [0, 0];
+    }
+    setPan(pan) {
+        const resolvedView = this.getResolvedView();
+        if (!resolvedView) {
+            return;
+        }
+        this.applyResolvedViewState(resolvedView.withPan(pan).state.viewState);
+    }
+    getResolvedView() {
+        const videoElement = this.getVideoElement();
+        const videoData = this.getVideoData();
+        if (!videoElement || !videoData) {
+            return;
+        }
+        return new VideoResolvedView({
+            viewState: this.viewState,
+            containerHeight: this.element.clientHeight,
+            containerWidth: this.element.clientWidth,
+            frameOfReferenceUID: videoData.metadata.imagePlaneModule?.frameOfReferenceUID || videoData.renderedUrl,
+            intrinsicHeight: videoElement.videoHeight || this.element.clientHeight,
+            intrinsicWidth: videoElement.videoWidth || this.element.clientWidth,
+            objectFit: this.getDisplaySetPresentation(videoData.id)?.objectFit,
+            payload: videoData,
+        });
+    }
+    getReferenceViewContexts() {
+        const binding = this.getFirstBinding();
+        const videoData = this.getVideoData();
+        if (!binding || !videoData) {
+            return super.getReferenceViewContexts();
+        }
+        const sourceDataId = getGenericViewportSourceDataId(binding.data.id);
+        const frameNumber = this.getFrameNumber();
+        return [
+            {
+                dataId: binding.data.id,
+                dataIds: [binding.data.id, sourceDataId],
+                frameOfReferenceUID: this.getFrameOfReferenceUID(),
+                imageIds: this.getImageIds(),
+                currentImageIdIndex: frameNumber - 1,
+                dimensionGroupNumber: frameNumber,
+                numDimensionGroups: videoData.numberOfFrames,
+            },
+        ];
+    }
+    play() {
+        const element = this.getVideoElement();
+        if (!element) {
+            return Promise.resolve();
+        }
+        return element
+            .play()
+            .then(() => undefined)
+            .catch(() => undefined);
+    }
+    pause() {
+        this.getVideoElement()?.pause();
+        this.syncCameraCurrentTimeFromElement();
+    }
+    seek(timeSeconds) {
+        const videoData = this.getVideoData();
+        const maxTimeSeconds = videoData?.durationSeconds
+            ? Math.max(videoData.durationSeconds, 0)
+            : Number.POSITIVE_INFINITY;
+        this.setViewState({
+            currentTimeSeconds: Math.max(0, Math.min(timeSeconds, maxTimeSeconds)),
+        });
+    }
+    setFrameNumber(frameNumber) {
+        const videoData = this.getVideoData();
+        if (!videoData) {
+            return;
+        }
+        this.seek(frameNumberToTimeSeconds(frameNumber, videoData.fps));
+    }
+    setPlaybackRate(playbackRate) {
+        const dataId = this.getFirstBinding()?.data.id;
+        if (!dataId) {
+            return;
+        }
+        this.setDisplaySetPresentation(dataId, {
+            playbackRate,
+        });
+    }
+    scroll(delta = 1, _debounceLoading = true, loop = false) {
+        const videoData = this.getVideoData();
+        if (!videoData?.fps) {
+            return;
+        }
+        this.pause();
+        const minTimeSeconds = frameNumberToTimeSeconds(videoData.frameRange[0], videoData.fps);
+        const maxTimeSeconds = videoData.durationSeconds ??
+            frameNumberToTimeSeconds(videoData.frameRange[1], videoData.fps);
+        let nextTimeSeconds = this.getCurrentTime() + delta / videoData.fps;
+        if (loop) {
+            const durationSeconds = Math.max(maxTimeSeconds - minTimeSeconds, 1 / videoData.fps);
+            while (nextTimeSeconds < minTimeSeconds) {
+                nextTimeSeconds += durationSeconds;
+            }
+            while (nextTimeSeconds > maxTimeSeconds) {
+                nextTimeSeconds -= durationSeconds;
+            }
+        }
+        else {
+            nextTimeSeconds = Math.max(minTimeSeconds, Math.min(nextTimeSeconds, maxTimeSeconds));
+        }
+        this.seek(nextTimeSeconds);
+    }
+    getFrameRate() {
+        return this.getVideoData()?.fps ?? 0;
+    }
+    getNumberOfFrames() {
+        return this.getVideoData()?.numberOfFrames ?? 0;
+    }
+    getNumberOfSlices() {
+        return this.getImageIds().length || this.getNumberOfFrames();
+    }
+    getCurrentTime() {
+        this.syncCameraCurrentTimeFromElement();
+        return this.viewState.currentTimeSeconds ?? 0;
+    }
+    getFrameNumber() {
+        const videoData = this.getVideoData();
+        if (!videoData) {
+            return 1;
+        }
+        const frameNumber = timeSecondsToFrameNumber(this.getCurrentTime(), videoData.fps);
+        return Math.max(videoData.frameRange[0], Math.min(frameNumber, videoData.frameRange[1]));
+    }
+    getCurrentImageIdIndex() {
+        return Math.max(0, this.getFrameNumber() - 1);
+    }
+    getImageIds() {
+        const dataId = this.getFirstBinding()?.data.id;
+        const videoData = this.getVideoData();
+        if (!dataId || !videoData) {
+            return [];
+        }
+        const sourceDataId = getGenericViewportSourceDataId(dataId);
+        const imageIds = Array(videoData.numberOfFrames);
+        for (let frameNumber = 1; frameNumber <= videoData.numberOfFrames; frameNumber++) {
+            try {
+                imageIds[frameNumber - 1] = generateFrameImageId(sourceDataId, frameNumber);
+            }
+            catch {
+                return [sourceDataId];
+            }
+        }
+        return imageIds;
+    }
+    render() {
+        if (this.isDestroyed) {
+            return;
+        }
+    }
+    resetViewState() {
+        if (this.isDestroyed) {
+            return false;
+        }
+        const previousCamera = this.getCameraForEvent();
+        const { currentTimeSeconds } = this.viewState;
+        this.viewState = this.normalizeViewState({
+            ...createDefaultVideoViewState(),
+            currentTimeSeconds,
+        });
+        this.modified(previousCamera);
+        this.triggerCameraResetEvent();
+        return true;
+    }
+    dispose() {
+        this.destroy();
+    }
+    getUseCustomRenderingPipeline() {
+        return true;
+    }
+    normalizeViewState(viewState) {
+        return normalizeVideoViewState(viewState);
+    }
+    onDestroy() {
+        this.untrackVideoElement();
+    }
+    getVideoElement() {
+        return this.getVideoRendering()?.element;
+    }
+    getVideoData() {
+        const binding = this.getCurrentBinding();
+        if (!binding) {
+            return;
+        }
+        return this.getVideoDataFromBinding(binding);
+    }
+    getVideoDataFromBinding(binding) {
+        if (!isVideoStreamData(binding.data)) {
+            return;
+        }
+        return binding.data;
+    }
+    getVideoRendering() {
+        const binding = this.getFirstBinding();
+        if (!binding || !isVideoElementRendering(binding.rendering)) {
+            return;
+        }
+        return binding.rendering;
+    }
+    syncCameraCurrentTimeFromElement() {
+        const element = this.getVideoElement();
+        if (!element) {
+            return;
+        }
+        const currentTimeSeconds = Math.max(0, element.currentTime || 0);
+        if (currentTimeSeconds === (this.viewState.currentTimeSeconds ?? 0)) {
+            return;
+        }
+        this.viewState = {
+            ...this.viewState,
+            currentTimeSeconds,
+        };
+    }
+    trackVideoElement() {
+        const element = this.getVideoElement();
+        if (!element || this.trackedVideoElement === element) {
+            return;
+        }
+        this.untrackVideoElement();
+        const syncCurrentTime = () => {
+            this.syncCameraCurrentTimeFromElement();
+        };
+        element.addEventListener('loadedmetadata', syncCurrentTime);
+        element.addEventListener('seeked', syncCurrentTime);
+        element.addEventListener('timeupdate', syncCurrentTime);
+        this.trackedVideoElement = element;
+        this.cleanupTrackedVideoElement = () => {
+            element.removeEventListener('loadedmetadata', syncCurrentTime);
+            element.removeEventListener('seeked', syncCurrentTime);
+            element.removeEventListener('timeupdate', syncCurrentTime);
+        };
+        syncCurrentTime();
+    }
+    untrackVideoElement() {
+        this.cleanupTrackedVideoElement?.();
+        this.cleanupTrackedVideoElement = undefined;
+        this.trackedVideoElement = undefined;
+    }
+    applyResolvedViewState(nextViewState) {
+        this.setViewState(nextViewState);
+    }
+    async primeInitialFrame(videoData) {
+        const element = this.getVideoElement();
+        if (!element) {
+            return;
+        }
+        await waitForVideoReady(element);
+        const targetTimeSeconds = videoData.frameRange[0] > 1
+            ? frameNumberToTimeSeconds(videoData.frameRange[0], videoData.fps)
+            : 0;
+        try {
+            await element.play().catch(() => undefined);
+        }
+        catch (_error) {
+        }
+        await seekVideoElement(element, targetTimeSeconds);
+        await waitForVideoFramePaint(element);
+        element.pause();
+        this.syncCameraCurrentTimeFromElement();
+    }
+}
+export default VideoViewport;
+async function waitForVideoReady(element) {
+    if (element.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA) {
+        return;
+    }
+    await new Promise((resolve) => {
+        const onReady = () => {
+            cleanup();
+            resolve();
+        };
+        const cleanup = () => {
+            element.removeEventListener('loadeddata', onReady);
+            element.removeEventListener('canplay', onReady);
+        };
+        element.addEventListener('loadeddata', onReady, { once: true });
+        element.addEventListener('canplay', onReady, { once: true });
+    });
+}
+async function seekVideoElement(element, timeSeconds) {
+    if (Math.abs((element.currentTime || 0) - timeSeconds) <= 0.001) {
+        return;
+    }
+    await new Promise((resolve) => {
+        const onSeeked = () => {
+            element.removeEventListener('seeked', onSeeked);
+            resolve();
+        };
+        element.addEventListener('seeked', onSeeked, { once: true });
+        element.currentTime = timeSeconds;
+    });
+}
+async function waitForVideoFramePaint(element) {
+    const requestFrameCallback = element.requestVideoFrameCallback;
+    if (requestFrameCallback) {
+        await new Promise((resolve) => {
+            requestFrameCallback.call(element, () => resolve());
+        });
+        return;
+    }
+    await new Promise((resolve) => requestAnimationFrame(() => resolve()));
+}
+function isVideoStreamData(data) {
+    if (typeof data !== 'object' || data === null || data.type !== 'video') {
+        return false;
+    }
+    const payload = data;
+    return (typeof payload.renderedUrl === 'string' &&
+        typeof payload.fps === 'number' &&
+        typeof payload.numberOfFrames === 'number' &&
+        Array.isArray(payload.frameRange) &&
+        payload.frameRange.length === 2 &&
+        typeof payload.frameRange[0] === 'number' &&
+        typeof payload.frameRange[1] === 'number');
+}
+function isVideoElementRendering(rendering) {
+    return rendering.renderMode === 'video2d';
+}

package/dist/esm/RenderingEngine/GenericViewport/Video/VideoViewportLegacyAdapter.d.ts

@@ -0,0 +1,15 @@
+import type { ImageSetOptions, VideoViewportProperties, VOIRange, ViewPresentation, ViewPresentationSelector } from '../../../types';
+import VideoViewport from './VideoViewport';
+declare class VideoViewportLegacyAdapter extends VideoViewport {
+    setDataIds(imageIds: string[], options?: ImageSetOptions): Promise<this>;
+    setVideo(imageId: string, frameNumber?: number): Promise<this>;
+    setProperties(props: VideoViewportProperties): void;
+    getViewPresentation(selector?: ViewPresentationSelector): ViewPresentation | undefined;
+    setViewPresentation(viewPres?: ViewPresentation): void;
+    resetCamera(): boolean;
+    getProperties(): VideoViewportProperties;
+    resetProperties(): void;
+    setVOI(voiRange: VOIRange): void;
+    setAverageWhite(averageWhite: [number, number, number]): void;
+}
+export default VideoViewportLegacyAdapter;