@lightningtv/renderer 2.16.1 → 3.2.3

package/src/core/CoreTextureManager.ts

@@ -1,22 +1,3 @@
-/*
- * If not stated otherwise in this file or this component's LICENSE file the
- * following copyright and licenses apply:
- *
- * Copyright 2023 Comcast Cable Communications Management, LLC.
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 import { ImageWorkerManager } from './lib/ImageWorker.js';
 import type { CoreRenderer } from './renderers/CoreRenderer.js';
 import { ColorTexture } from './textures/ColorTexture.js';
@@ -26,12 +7,13 @@ import { SubTexture } from './textures/SubTexture.js';
 import { RenderTexture } from './textures/RenderTexture.js';
 import { Texture, TextureType } from './textures/Texture.js';
 import { EventEmitter } from '../common/EventEmitter.js';
-import { getTimeStamp } from './platform.js';
 import type { Stage } from './Stage.js';
 import {
   validateCreateImageBitmap,
   type CreateImageBitmapSupport,
 } from './lib/validateImageBitmap.js';
+import type { Platform } from './platforms/Platform.js';
+import { TextureError, TextureErrorCode } from './TextureError.js';
 
 /**
  * Augmentable map of texture class types
@@ -64,6 +46,7 @@ export interface TextureManagerDebugInfo {
 export interface TextureManagerSettings {
   numImageWorkers: number;
   createImageBitmapSupport: 'auto' | 'basic' | 'options' | 'full';
+  maxRetryCount: number;
 }
 
 export type ResizeModeOptions =
@@ -138,6 +121,20 @@ export interface TextureOptions {
    */
   preventCleanup?: boolean;
 
+  /**
+   * Number of times to retry loading a failed texture
+   *
+   * @remarks
+   * When a texture fails to load, Lightning will retry up to this many times
+   * before permanently giving up. Each retry will clear the texture ownership
+   * and then re-establish it to trigger a new load attempt.
+   *
+   * Set to null to disable retries. Set to 0 to always try once and never retry.
+   * This is typically only used on ImageTexture instances.
+   *
+   */
+  maxRetryCount?: number | null;
+
   /**
    * Flip the texture horizontally when rendering
    *
@@ -178,14 +175,16 @@ export class CoreTextureManager extends EventEmitter {
    */
   txConstructors: Partial<TextureMap> = {};
 
-  private priorityQueue: Array<Texture> = [];
-  private uploadTextureQueue: Array<Texture> = [];
+  public maxRetryCount: number;
+  private uploadTextureQueue: Set<Texture> = new Set();
   private initialized = false;
   private stage: Stage;
   private numImageWorkers: number;
 
+  public platform: Platform;
+
   imageWorkerManager: ImageWorkerManager | null = null;
-  hasCreateImageBitmap = !!self.createImageBitmap;
+  hasCreateImageBitmap = false;
   imageBitmapSupported = {
     basic: false,
     options: false,
@@ -216,12 +215,16 @@ export class CoreTextureManager extends EventEmitter {
   constructor(stage: Stage, settings: TextureManagerSettings) {
     super();
 
-    const { numImageWorkers, createImageBitmapSupport } = settings;
+    const { numImageWorkers, createImageBitmapSupport, maxRetryCount } =
+      settings;
+
     this.stage = stage;
+    this.platform = stage.platform;
     this.numImageWorkers = numImageWorkers;
+    this.maxRetryCount = maxRetryCount;
 
     if (createImageBitmapSupport === 'auto') {
-      validateCreateImageBitmap()
+      validateCreateImageBitmap(this.platform)
         .then((result) => {
           this.initialize(result);
         })
@@ -261,15 +264,15 @@ export class CoreTextureManager extends EventEmitter {
       support.basic || support.options || support.full;
     this.imageBitmapSupported = support;
 
-    if (!this.hasCreateImageBitmap) {
+    if (this.hasCreateImageBitmap === false) {
       console.warn(
         '[Lightning] createImageBitmap is not supported on this browser. ImageTexture will be slower.',
       );
     }
 
     if (
-      this.hasCreateImageBitmap &&
-      this.hasWorker &&
+      this.hasCreateImageBitmap === true &&
+      this.hasWorker === true &&
       this.numImageWorkers > 0
     ) {
       this.imageWorkerManager = new ImageWorkerManager(
@@ -292,9 +295,7 @@ export class CoreTextureManager extends EventEmitter {
    * @param texture - The texture to upload
    */
   enqueueUploadTexture(texture: Texture): void {
-    if (this.uploadTextureQueue.includes(texture) === false) {
-      this.uploadTextureQueue.push(texture);
-    }
+    this.uploadTextureQueue.add(texture);
   }
 
   /**
@@ -312,14 +313,14 @@ export class CoreTextureManager extends EventEmitter {
     if (!TextureClass) {
       throw new Error(`Texture type "${textureType}" is not registered`);
     }
-
-    const cacheKey = TextureClass.makeCacheKey(props as any);
+    const resolvedProps = TextureClass.resolveDefaults(props as any);
+    const cacheKey = TextureClass.makeCacheKey(resolvedProps as any);
     if (cacheKey && this.keyCache.has(cacheKey)) {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       texture = this.keyCache.get(cacheKey)!;
     } else {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
-      texture = new TextureClass(this, props as any);
+      texture = new TextureClass(this, resolvedProps as any);
 
       if (cacheKey) {
         this.initTextureToCache(texture, cacheKey);
@@ -329,25 +330,13 @@ export class CoreTextureManager extends EventEmitter {
     return texture as InstanceType<TextureMap[Type]>;
   }
 
-  orphanTexture(texture: Texture): void {
-    // if it is part of the download or upload queue, remove it
-    this.removeTextureFromQueue(texture);
-
-    if (texture.type === TextureType.subTexture) {
-      // ignore subtextures
-      return;
-    }
-
-    this.stage.txMemManager.addToOrphanedTextures(texture);
-  }
-
   /**
    * Override loadTexture to use the batched approach.
    *
    * @param texture - The texture to load
    * @param immediate - Whether to prioritize the texture for immediate loading
    */
-  loadTexture(texture: Texture, priority?: boolean): void {
+  async loadTexture(texture: Texture, priority?: boolean): Promise<void> {
     this.stage.txMemManager.removeFromOrphanedTextures(texture);
 
     if (texture.type === TextureType.subTexture) {
@@ -360,56 +349,39 @@ export class CoreTextureManager extends EventEmitter {
       return;
     }
 
-    if (Texture.TRANSITIONAL_TEXTURE_STATES.includes(texture.state)) {
-      return;
-    }
-
-    // if we're not initialized, just queue the texture into the priority queue
+    // if we're not initialized, just queue the texture into the upload queue
     if (this.initialized === false) {
-      this.priorityQueue.push(texture);
+      this.uploadTextureQueue.add(texture);
       return;
     }
 
-    // If the texture failed to load, we need to re-download it.
-    if (texture.state === 'failed') {
-      texture.free();
-      texture.freeTextureData();
-    }
-
     texture.setState('loading');
 
-    // Get the texture data
-    texture
-      .getTextureData()
-      .then(() => {
-        if (texture.state !== 'fetched') {
-          texture.setState('failed');
-          return;
-        }
+    // Get texture data - early return on failure
+    const textureDataResult = await texture.getTextureData().catch((err) => {
+      console.error(err);
+      texture.setState('failed');
+      return null;
+    });
 
-        // For non-image textures, upload immediately
-        if (texture.type !== TextureType.image) {
-          this.uploadTexture(texture).catch((err) => {
-            console.error('Failed to upload non-image texture:', err);
-            texture.setState('failed');
-          });
-        } else {
-          // For image textures, queue for throttled upload
-          // If it's a priority texture, upload it immediately
-          if (priority === true) {
-            this.uploadTexture(texture).catch((err) => {
-              console.error('Failed to upload priority texture:', err);
-              texture.setState('failed');
-            });
-          } else {
-            this.enqueueUploadTexture(texture);
-          }
-        }
-      })
-      .catch((err) => {
-        console.error(err);
+    // Early return if texture data fetch failed
+    if (textureDataResult === null || texture.state === 'failed') {
+      return;
+    }
+
+    // Handle non-image textures: upload immediately
+    const shouldUploadImmediately =
+      texture.type !== TextureType.image || priority === true;
+    if (shouldUploadImmediately === true) {
+      await this.uploadTexture(texture).catch((err) => {
+        console.error(`Failed to upload texture:`, err);
         texture.setState('failed');
       });
+      return;
+    }
+
+    // Queue image textures for throttled upload
+    this.enqueueUploadTexture(texture);
   }
 
   /**
@@ -428,6 +400,27 @@ export class CoreTextureManager extends EventEmitter {
       return;
     }
 
+    if (texture.state === 'failed' || texture.state === 'freed') {
+      // don't upload failed or freed textures
+      return;
+    }
+
+    if (texture.state === 'loaded') {
+      // already loaded
+      return;
+    }
+
+    if (texture.textureData === null) {
+      texture.setState(
+        'failed',
+        new TextureError(
+          TextureErrorCode.TEXTURE_DATA_NULL,
+          'Texture data is null, cannot upload texture',
+        ),
+      );
+      return;
+    }
+
     const coreContext = texture.loadCtxTexture();
     if (coreContext !== null && coreContext.state === 'loaded') {
       texture.setState('loaded');
@@ -441,7 +434,7 @@ export class CoreTextureManager extends EventEmitter {
    * Check if a texture is being processed
    */
   isProcessingTexture(texture: Texture): boolean {
-    return this.uploadTextureQueue.includes(texture) === true;
+    return this.uploadTextureQueue.has(texture);
   }
 
   /**
@@ -454,32 +447,21 @@ export class CoreTextureManager extends EventEmitter {
       return;
     }
 
-    const startTime = getTimeStamp();
-
-    // Process priority queue
-    while (
-      this.priorityQueue.length > 0 &&
-      getTimeStamp() - startTime < maxProcessingTime
-    ) {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const texture = this.priorityQueue.pop()!;
-      try {
-        await texture.getTextureData();
-        await this.uploadTexture(texture);
-      } catch (error) {
-        console.error('Failed to process priority texture:', error);
-        // Continue with next texture instead of stopping entire queue
-      }
-    }
+    const platform = this.platform;
+    const startTime = platform.getTimeStamp();
 
     // Process uploads - await each upload to prevent GPU overload
     while (
-      this.uploadTextureQueue.length > 0 &&
-      getTimeStamp() - startTime < maxProcessingTime
+      this.uploadTextureQueue.size > 0 &&
+      platform.getTimeStamp() - startTime < maxProcessingTime
     ) {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const texture = this.uploadTextureQueue.shift()!;
+      const [texture] = this.uploadTextureQueue;
+      if (!texture) break;
+      this.uploadTextureQueue.delete(texture);
       try {
+        if (texture.textureData === null) {
+          await texture.getTextureData();
+        }
         await this.uploadTexture(texture);
       } catch (error) {
         console.error('Failed to upload texture:', error);
@@ -489,7 +471,7 @@ export class CoreTextureManager extends EventEmitter {
   }
 
   public hasUpdates(): boolean {
-    return this.uploadTextureQueue.length > 0;
+    return this.uploadTextureQueue.size > 0;
   }
 
   /**
@@ -535,10 +517,7 @@ export class CoreTextureManager extends EventEmitter {
    * @param texture - The texture to remove
    */
   removeTextureFromQueue(texture: Texture): void {
-    const uploadIndex = this.uploadTextureQueue.indexOf(texture);
-    if (uploadIndex !== -1) {
-      this.uploadTextureQueue.splice(uploadIndex, 1);
-    }
+    this.uploadTextureQueue.delete(texture);
   }
 
   /**