@meframe/core 0.0.4 → 0.0.6

package/dist/workers/stages/encode/encode.worker.js

@@ -45,7 +45,7 @@ class BaseEncoder {
     }
     const isSupported = await this.isConfigSupported(this.config);
     if (!isSupported.supported) {
-      throw new Error(`Codec not supported: ${this.config.codec}`);
+      throw new Error(`Codec not supported: ${JSON.stringify(this.config)}`);
     }
     this.encoder = this.createEncoder({
       output: this.handleOutput.bind(this),
@@ -105,8 +105,16 @@ class BaseEncoder {
   get queueSize() {
     return this.encoder?.encodeQueueSize ?? 0;
   }
-  handleOutput(chunk, _metadata) {
-    this.controller?.enqueue(chunk);
+  handleOutput(chunk, metadata) {
+    if (this.controller) {
+      try {
+        this.controller.enqueue({ chunk, metadata });
+      } catch (error) {
+        if (!(error instanceof TypeError && error.message.includes("closed"))) {
+          throw error;
+        }
+      }
+    }
   }
   handleError(error) {
     console.error(`${this.getEncoderType()} encoder error:`, error);
@@ -144,7 +152,8 @@ class BaseEncoder {
               check();
             });
           }
-          this.encode(input);
+          const frame = input.frame || input;
+          this.encode(frame);
         },
         flush: async () => {
           await this.flush();
@@ -207,12 +216,20 @@ class VideoChunkEncoder extends BaseEncoder {
 class AudioChunkEncoder extends BaseEncoder {
   static DEFAULT_HIGH_WATER_MARK = 4;
   static DEFAULT_ENCODE_QUEUE_THRESHOLD = 16;
+  static DEFAULT_CONFIG = {
+    codec: "mp4a.40.2",
+    // AAC-LC
+    sampleRate: 48e3,
+    numberOfChannels: 2,
+    bitrate: 128e3
+  };
   highWaterMark;
   encodeQueueThreshold;
   constructor(config) {
-    super(config);
-    this.highWaterMark = config.backpressure?.highWaterMark ?? AudioChunkEncoder.DEFAULT_HIGH_WATER_MARK;
-    this.encodeQueueThreshold = config.backpressure?.encodeQueueThreshold ?? AudioChunkEncoder.DEFAULT_ENCODE_QUEUE_THRESHOLD;
+    const fullConfig = { ...AudioChunkEncoder.DEFAULT_CONFIG, ...config };
+    super(fullConfig);
+    this.highWaterMark = fullConfig.backpressure?.highWaterMark ?? AudioChunkEncoder.DEFAULT_HIGH_WATER_MARK;
+    this.encodeQueueThreshold = fullConfig.backpressure?.encodeQueueThreshold ?? AudioChunkEncoder.DEFAULT_ENCODE_QUEUE_THRESHOLD;
   }
   async isConfigSupported(config) {
     const result = await AudioEncoder.isConfigSupported(config);
@@ -228,20 +245,131 @@ class AudioChunkEncoder extends BaseEncoder {
     if (this.encoder?.state !== "configured") {
       throw new Error("Audio encoder not configured");
     }
-    const config = this.getConfig();
-    if (data.sampleRate !== config.sampleRate || data.numberOfChannels !== config.numberOfChannels) {
-      throw new Error("AudioData requires resampling or channel remap before encoding");
-    }
     this.encoder.encode(data);
     data.close();
   }
 }
+class ClipEncoderManager {
+  videoEncoders = /* @__PURE__ */ new Map();
+  audioEncoders = /* @__PURE__ */ new Map();
+  videoCreationOrder = [];
+  audioCreationOrder = [];
+  maxEncoders;
+  constructor(maxEncoders = 6) {
+    this.maxEncoders = maxEncoders;
+  }
+  /**
+   * Acquire a video encoder for the given sessionId
+   * Creates new encoder if not exists; returns existing one if already created
+   */
+  async acquireVideo(sessionId, config) {
+    let encoder = this.videoEncoders.get(sessionId);
+    if (!encoder) {
+      if (this.videoEncoders.size >= this.maxEncoders) {
+        throw new Error(
+          `[ClipEncoderManager] Video encoder limit reached (${this.maxEncoders}). Active clips: ${Array.from(this.videoEncoders.keys()).join(", ")}. Please release unused encoders before acquiring new ones.`
+        );
+      }
+      encoder = new VideoChunkEncoder(config);
+      await encoder.initialize();
+      this.videoEncoders.set(sessionId, encoder);
+      this.videoCreationOrder.push(sessionId);
+    }
+    return encoder;
+  }
+  /**
+   * Acquire an audio encoder for the given sessionId
+   */
+  async acquireAudio(sessionId, config) {
+    let encoder = this.audioEncoders.get(sessionId);
+    if (!encoder) {
+      if (this.audioEncoders.size >= this.maxEncoders) {
+        throw new Error(
+          `[ClipEncoderManager] Audio encoder limit reached (${this.maxEncoders}). Active clips: ${Array.from(this.audioEncoders.keys()).join(", ")}. Please release unused encoders before acquiring new ones.`
+        );
+      }
+      encoder = new AudioChunkEncoder(config);
+      await encoder.initialize();
+      this.audioEncoders.set(sessionId, encoder);
+      this.audioCreationOrder.push(sessionId);
+    }
+    return encoder;
+  }
+  /**
+   * Release video encoder for the given sessionId
+   */
+  async releaseVideo(sessionId) {
+    const encoder = this.videoEncoders.get(sessionId);
+    if (encoder) {
+      await encoder.close();
+      this.videoEncoders.delete(sessionId);
+      const index = this.videoCreationOrder.indexOf(sessionId);
+      if (index !== -1) {
+        this.videoCreationOrder.splice(index, 1);
+      }
+    }
+  }
+  /**
+   * Release audio encoder for the given sessionId
+   */
+  async releaseAudio(sessionId) {
+    const encoder = this.audioEncoders.get(sessionId);
+    if (encoder) {
+      await encoder.close();
+      this.audioEncoders.delete(sessionId);
+      const index = this.audioCreationOrder.indexOf(sessionId);
+      if (index !== -1) {
+        this.audioCreationOrder.splice(index, 1);
+      }
+    }
+  }
+  /**
+   * Release both video and audio encoders for the given sessionId
+   */
+  async releaseClip(sessionId) {
+    await Promise.all([this.releaseVideo(sessionId), this.releaseAudio(sessionId)]);
+  }
+  /**
+   * Close all encoders and clear state
+   */
+  async closeAll() {
+    const promises = [
+      ...Array.from(this.videoEncoders.values()).map((e) => e.close()),
+      ...Array.from(this.audioEncoders.values()).map((e) => e.close())
+    ];
+    await Promise.all(promises);
+    this.videoEncoders.clear();
+    this.audioEncoders.clear();
+    this.videoCreationOrder = [];
+    this.audioCreationOrder = [];
+  }
+  /**
+   * Check if encoders exist for the given sessionId
+   */
+  has(sessionId) {
+    return this.videoEncoders.has(sessionId) || this.audioEncoders.has(sessionId);
+  }
+  /**
+   * Get statistics about current encoder state
+   */
+  getStats() {
+    return {
+      videoEncoders: this.videoEncoders.size,
+      audioEncoders: this.audioEncoders.size,
+      maxEncoders: this.maxEncoders,
+      videoCreationOrder: [...this.videoCreationOrder],
+      audioCreationOrder: [...this.audioCreationOrder]
+    };
+  }
+}
 class EncodeWorker {
   channel;
-  videoEncoder = null;
-  audioEncoder = null;
+  encoderManager = new ClipEncoderManager(12);
+  // Increased to prevent eviction during active streams
+  // Default encoder configs
+  defaultVideoConfig = null;
+  defaultAudioConfig = null;
   // Connections to other workers
-  cachePort = null;
   muxPort = null;
   composePorts = /* @__PURE__ */ new Map();
   // Connections from compose workers
@@ -256,9 +384,9 @@ class EncodeWorker {
     this.channel.registerHandler("configure", this.handleConfigure.bind(this));
     this.channel.registerHandler("connect", this.handleConnect.bind(this));
     this.channel.registerHandler("configure_video", this.handleConfigureVideo.bind(this));
-    this.channel.registerHandler("configure_audio", this.handleConfigureAudio.bind(this));
     this.channel.registerHandler("flush", this.handleFlush.bind(this));
     this.channel.registerHandler("reset", this.handleReset.bind(this));
+    this.channel.registerHandler("release_clip_encoder", this.handleReleaseClipEncoder.bind(this));
     this.channel.registerHandler("get_stats", this.handleGetStats.bind(this));
     this.channel.registerHandler(WorkerMessageType.Dispose, this.handleDispose.bind(this));
   }
@@ -266,15 +394,19 @@ class EncodeWorker {
    * Connect handler used by stream pipeline
    */
   async handleConnect(payload) {
-    const { port, streamType } = payload;
-    if (streamType === "video") return this.handleConnectComposer({ composeType: "video", port });
-    if (streamType === "audio") return this.handleConnectComposer({ composeType: "audio", port });
+    const { port, streamType, sessionId } = payload;
+    if (streamType === "video") {
+      return this.handleConnectComposer({ composeType: "video", port, sessionId });
+    }
+    if (streamType === "audio") {
+      return this.handleConnectComposer({ composeType: "audio", port, sessionId });
+    }
     if (streamType === "chunk") return this.handleConnectMux({ port });
     return { success: true };
   }
   /**
    * Handle configuration message from orchestrator
-   * @param payload.initial - If true, initialize worker and recreate encoder instances; otherwise just update config
+   * @param payload.initial - If true, initialize worker; saves default encoder configs
    */
   async handleConfigure(payload) {
     const { config, initial = false } = payload;
@@ -282,51 +414,10 @@ class EncodeWorker {
       this.channel.state = WorkerState.Ready;
     }
     if (config.video) {
-      if (initial || !this.videoEncoder) {
-        if (this.videoEncoder) {
-          await this.videoEncoder.close();
-        }
-        this.videoEncoder = new VideoChunkEncoder(config.video);
-        await this.videoEncoder.initialize();
-        const videoStream = config.video.stream?.pipeThrough(this.videoEncoder.createStream());
-        if (videoStream && this.cachePort) {
-          const cacheChannel = new WorkerChannel(this.cachePort, {
-            name: "Encode-Cache-Video",
-            timeout: 3e4
-          });
-          await cacheChannel.sendStream(videoStream, {
-            type: "video",
-            width: config.video.width,
-            height: config.video.height,
-            framerate: config.video.framerate
-          });
-        }
-      } else {
-        await this.videoEncoder.reconfigure(config.video);
-      }
+      this.defaultVideoConfig = config.video;
     }
     if (config.audio) {
-      if (initial || !this.audioEncoder) {
-        if (this.audioEncoder) {
-          await this.audioEncoder.close();
-        }
-        this.audioEncoder = new AudioChunkEncoder(config.audio);
-        await this.audioEncoder.initialize();
-        const audioStream = config.audio.stream?.pipeThrough(this.audioEncoder.createStream());
-        if (audioStream && this.cachePort) {
-          const cacheChannel = new WorkerChannel(this.cachePort, {
-            name: "Encode-Cache-Audio",
-            timeout: 3e4
-          });
-          await cacheChannel.sendStream(audioStream, {
-            type: "audio",
-            sampleRate: config.audio.sampleRate,
-            numberOfChannels: config.audio.numberOfChannels
-          });
-        }
-      } else {
-        await this.audioEncoder.reconfigure(config.audio);
-      }
+      this.defaultAudioConfig = config.audio;
     }
     return { success: true };
   }
@@ -334,55 +425,28 @@ class EncodeWorker {
    * Connect to a compose worker to receive frames/audio data
    */
   async handleConnectComposer(payload) {
-    const { composeType, port } = payload;
+    const { composeType, port, sessionId } = payload;
     this.composePorts.set(composeType, port);
     const composeChannel = new WorkerChannel(port, {
       name: `Encode-${composeType}Compose`,
       timeout: 3e4
     });
     composeChannel.receiveStream(async (stream, metadata) => {
-      if (metadata?.streamType === "video" && this.videoEncoder) {
-        const reader = stream.getReader();
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            const wrappedValue = value;
-            const videoFrame = wrappedValue.frame || wrappedValue;
-            try {
-              const frame = videoFrame.clone();
-              this.videoEncoder.encode(frame);
-            } finally {
-              videoFrame.close();
-            }
-          }
-        } finally {
-          reader.releaseLock();
-        }
-      } else if (metadata?.streamType === "audio" && this.audioEncoder) {
-        const composedConfig = {
-          sampleRate: metadata.sampleRate,
-          numberOfChannels: metadata.numberOfChannels
-        };
-        const currentConfig = this.audioEncoder.getConfig();
-        if (typeof composedConfig.sampleRate === "number" && composedConfig.sampleRate > 0 && composedConfig.sampleRate !== currentConfig.sampleRate) {
-          await this.audioEncoder.reconfigure({ sampleRate: composedConfig.sampleRate });
-        }
-        if (typeof composedConfig.numberOfChannels === "number" && composedConfig.numberOfChannels > 0 && composedConfig.numberOfChannels !== currentConfig.numberOfChannels) {
-          await this.audioEncoder.reconfigure({
-            numberOfChannels: composedConfig.numberOfChannels
-          });
-        }
-        const reader = stream.getReader();
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            this.audioEncoder.encode(value);
-          }
-        } finally {
-          reader.releaseLock();
-        }
+      const streamSessionId = metadata?.sessionId || sessionId || "unknown";
+      if (metadata?.streamType === "video" && this.defaultVideoConfig) {
+        const encoder = await this.encoderManager.acquireVideo(
+          streamSessionId,
+          this.defaultVideoConfig
+        );
+        const encodingTransform = encoder.createStream();
+        const encodedStream = stream.pipeThrough(
+          encodingTransform
+        );
+        this.channel.sendStream(encodedStream, {
+          streamType: "video",
+          track: "video",
+          sessionId: streamSessionId
+        });
       }
     });
     return { success: true };
@@ -406,12 +470,7 @@ class EncodeWorker {
    */
   async handleConfigureVideo(config) {
     try {
-      if (!this.videoEncoder) {
-        this.videoEncoder = new VideoChunkEncoder(config);
-        await this.videoEncoder.initialize();
-      } else {
-        await this.videoEncoder.reconfigure(config);
-      }
+      this.defaultVideoConfig = config;
       this.channel.notify("video_configured", {
         codec: config.codec,
         width: config.width,
@@ -427,109 +486,46 @@ class EncodeWorker {
     }
   }
   /**
-   * Configure audio encoder with specific settings
+   * Flush encoders (deprecated with per-clip encoder architecture)
    */
-  async handleConfigureAudio(config) {
-    try {
-      if (!this.audioEncoder) {
-        this.audioEncoder = new AudioChunkEncoder(config);
-        await this.audioEncoder.initialize();
-      } else {
-        await this.audioEncoder.reconfigure(config);
-      }
-      this.channel.notify("audio_configured", {
-        codec: config.codec,
-        sampleRate: config.sampleRate,
-        numberOfChannels: config.numberOfChannels,
-        bitrate: config.bitrate
-      });
-      return { success: true };
-    } catch (error) {
-      throw {
-        code: "AUDIO_CONFIG_ERROR",
-        message: error.message
-      };
-    }
+  async handleFlush(_payload) {
+    console.warn("[EncodeWorker] handleFlush is deprecated with per-clip encoder architecture");
+    return {};
   }
   /**
-   * Flush encoders and get buffered chunks
+   * Reset encoders (deprecated with per-clip encoder architecture)
    */
-  async handleFlush(payload) {
-    try {
-      const result = {};
-      if (!payload?.type || payload.type === "video") {
-        const chunks = await this.videoEncoder?.flush();
-        if (chunks) {
-          result.videoChunks = chunks;
-        }
-      }
-      if (!payload?.type || payload.type === "audio") {
-        const chunks = await this.audioEncoder?.flush();
-        if (chunks) {
-          result.audioChunks = chunks;
-        }
-      }
-      return result;
-    } catch (error) {
-      throw {
-        code: "FLUSH_ERROR",
-        message: error.message
-      };
-    }
+  async handleReset(payload) {
+    console.warn("[EncodeWorker] handleReset is deprecated with per-clip encoder architecture");
+    this.channel.notify("reset_complete", {
+      type: payload?.type || "all"
+    });
+    return { success: true };
   }
   /**
-   * Reset encoders
+   * Release encoder for a specific clip
    */
-  async handleReset(payload) {
-    try {
-      if (!payload?.type || payload.type === "video") {
-        await this.videoEncoder?.reset();
-      }
-      if (!payload?.type || payload.type === "audio") {
-        await this.audioEncoder?.reset();
-      }
-      this.channel.notify("reset_complete", {
-        type: payload?.type || "all"
-      });
-      return { success: true };
-    } catch (error) {
-      throw {
-        code: "RESET_ERROR",
-        message: error.message
-      };
-    }
+  async handleReleaseClipEncoder(payload) {
+    const { sessionId } = payload;
+    await this.encoderManager.releaseClip(sessionId);
+    return { success: true };
   }
   /**
    * Get encoder statistics
    */
   async handleGetStats() {
-    const stats = {};
-    if (this.videoEncoder) {
-      stats.video = {
-        configured: this.videoEncoder.isReady,
-        queueSize: this.videoEncoder.queueSize
-      };
-    }
-    if (this.audioEncoder) {
-      stats.audio = {
-        configured: this.audioEncoder.isReady,
-        queueSize: this.audioEncoder.queueSize
-      };
-    }
+    const stats = {
+      encoders: this.encoderManager.getStats()
+    };
     return stats;
   }
-  // Output and error handling is done via streams in the encoder itself
-  // These placeholder methods can be implemented when needed for direct callback handling
   /**
    * Dispose worker and cleanup resources
    */
   async handleDispose() {
-    await this.videoEncoder?.close();
-    await this.audioEncoder?.close();
-    this.videoEncoder = null;
-    this.audioEncoder = null;
-    this.cachePort?.close();
-    this.cachePort = null;
+    await this.encoderManager.closeAll();
+    this.defaultVideoConfig = null;
+    this.defaultAudioConfig = null;
     this.muxPort?.close();
     this.muxPort = null;
     for (const port of this.composePorts.values()) {