@vidtreo/recorder 0.9.1 → 0.9.2

package/dist/index.js

@@ -1,3 +1,27 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/core/utils/error-handler.ts
 function extractErrorMessage(error) {
   if (error instanceof Error) {
@@ -127,6 +151,9 @@ class AudioLevelAnalyzer {
     return isMutedFromCallback || hasDisabledTracks;
   }
 }
+// src/core/config/config-constants.ts
+import { QUALITY_HIGH } from "mediabunny";
+
 // src/core/processor/format-codec-mapper.ts
 var FORMAT_DEFAULT_CODECS = {
   mp4: "aac",
@@ -149,13 +176,11 @@ var DEFAULT_BACKEND_URL = "https://api.vidtreo.com";
 var DEFAULT_TRANSCODE_CONFIG = Object.freeze({
   format: "mp4",
   fps: 30,
-  width: 1280,
-  height: 720,
-  bitrate: 500000,
-  audioCodec: undefined,
-  audioBitrate: 128000,
-  preset: "medium",
-  packetCount: 1200
+  width: 1920,
+  height: 1080,
+  bitrate: QUALITY_HIGH,
+  audioCodec: "aac",
+  audioBitrate: 96000
 });
 function getDefaultConfigForFormat(format) {
   return {
@@ -165,23 +190,21 @@ function getDefaultConfigForFormat(format) {
   };
 }
 // src/core/config/preset-mapper.ts
-var BITRATE_MAP = {
-  sd: 500000,
-  hd: 1e6,
-  fhd: 2000000,
-  "4k": 8000000
+import {
+  QUALITY_HIGH as QUALITY_HIGH2,
+  QUALITY_LOW,
+  QUALITY_MEDIUM,
+  QUALITY_VERY_HIGH
+} from "mediabunny";
+var QUALITY_MAP = {
+  sd: QUALITY_LOW,
+  hd: QUALITY_MEDIUM,
+  fhd: QUALITY_HIGH2,
+  "4k": QUALITY_VERY_HIGH
 };
 var AUDIO_BITRATE = 128000;
-var PACKET_COUNT_MAP = {
-  sd: 800,
-  hd: 1200,
-  fhd: 2000,
-  "4k": 4000
-};
-var DEFAULT_FPS = 30;
-var DEFAULT_PRESET = "medium";
 function mapPresetToConfig(preset, maxWidth, maxHeight, format = "mp4") {
-  if (!(preset in BITRATE_MAP)) {
+  if (!(preset in QUALITY_MAP)) {
     throw new Error(`Invalid preset: ${preset}`);
   }
   if (typeof maxWidth !== "number" || maxWidth <= 0) {
@@ -193,13 +216,10 @@ function mapPresetToConfig(preset, maxWidth, maxHeight, format = "mp4") {
   const audioCodec = getDefaultAudioCodecForFormat(format);
   return {
     format,
-    fps: DEFAULT_FPS,
     width: maxWidth,
     height: maxHeight,
-    bitrate: BITRATE_MAP[preset],
+    bitrate: QUALITY_MAP[preset],
     audioCodec,
-    preset: DEFAULT_PRESET,
-    packetCount: PACKET_COUNT_MAP[preset],
     audioBitrate: AUDIO_BITRATE
   };
 }
@@ -311,8 +331,12 @@ class ConfigManager {
       apiKey,
       backendUrl: normalizedBackendUrl
     });
-    this.currentConfig = await this.configService.fetchConfig();
-    this.configFetched = true;
+    this.configService.fetchConfig().then((config) => {
+      this.currentConfig = config;
+      this.configFetched = true;
+    }).catch(() => {
+      this.configFetched = false;
+    });
   }
   async fetchConfig() {
     if (!this.configService) {
@@ -1379,9 +1403,9 @@ class SourceSwitchManager {
 
 // src/core/stream/stream-constants.ts
 var DEFAULT_CAMERA_CONSTRAINTS = Object.freeze({
-  width: { ideal: DEFAULT_TRANSCODE_CONFIG.width },
-  height: { ideal: DEFAULT_TRANSCODE_CONFIG.height },
-  frameRate: { ideal: DEFAULT_TRANSCODE_CONFIG.fps }
+  width: { ideal: DEFAULT_TRANSCODE_CONFIG.width || 1920 },
+  height: { ideal: DEFAULT_TRANSCODE_CONFIG.height || 1080 },
+  frameRate: { ideal: DEFAULT_TRANSCODE_CONFIG.fps || 30 }
 });
 var DEFAULT_STREAM_CONFIG = Object.freeze({
   video: DEFAULT_CAMERA_CONSTRAINTS,
@@ -2647,6 +2671,30 @@ function isScreenCaptureStream(stream) {
   return "displaySurface" in settings || videoTrack.label.toLowerCase().includes("screen") || videoTrack.label.toLowerCase().includes("display");
 }
 
+// src/core/processor/codec-detector.ts
+async function detectBestCodec(width, height, bitrate) {
+  try {
+    const { canEncodeVideo } = await import("mediabunny");
+    if (typeof canEncodeVideo === "function") {
+      const checkOptions = {};
+      if (width !== undefined) {
+        checkOptions.width = width;
+      }
+      if (height !== undefined) {
+        checkOptions.height = height;
+      }
+      if (bitrate !== undefined) {
+        checkOptions.bitrate = bitrate;
+      }
+      const hevcSupported = await canEncodeVideo("hevc", checkOptions);
+      if (hevcSupported) {
+        return "hevc";
+      }
+    }
+  } catch {}
+  return "avc";
+}
+
 // src/core/processor/worker/recorder-worker.code.ts
 var workerCode = `// ../../node_modules/mediabunny/dist/modules/src/misc.js
 /*!
@@ -8366,6 +8414,7 @@ class Quality {
     return Math.round(finalBitrate / 1000) * 1000;
   }
 }
+var QUALITY_HIGH = /* @__PURE__ */ new Quality(2);
 
 // ../../node_modules/mediabunny/dist/modules/src/media-source.js
 /*!
@@ -9731,6 +9780,8 @@ class RecorderWorker {
   baseVideoTimestamp = null;
   frameCount = 0;
   config = null;
+  lastKeyFrameTimestamp = 0;
+  forceNextKeyFrame = false;
   videoProcessingActive = false;
   audioProcessingActive = false;
   isStopping = false;
@@ -9819,54 +9870,50 @@ class RecorderWorker {
     }
     this.sendError(new Error(\`Unknown message type: \${message.type}\`));
   };
-  async handleStart(videoStream, audioStream, config, overlayConfig) {
+  validateConfig(config) {
     requireDefined(config, "Transcode config is required");
-    if (config.width <= 0 || config.height <= 0) {
-      throw new Error("Video dimensions must be greater than zero");
+    if (config.width !== undefined && config.width <= 0) {
+      throw new Error("Video width must be greater than zero");
+    }
+    if (config.height !== undefined && config.height <= 0) {
+      throw new Error("Video height must be greater than zero");
     }
-    if (config.fps <= 0) {
+    if (config.fps !== undefined && config.fps <= 0) {
       throw new Error("Frame rate must be greater than zero");
     }
-    if (config.bitrate <= 0) {
+    if (config.bitrate !== undefined && typeof config.bitrate === "number" && config.bitrate <= 0) {
       throw new Error("Bitrate must be greater than zero");
     }
     if (config.keyFrameInterval <= 0) {
       throw new Error("Key frame interval must be greater than zero");
     }
-    logger.debug("[RecorderWorker] handleStart called", {
-      hasVideoStream: !!videoStream,
-      hasAudioStream: !!audioStream,
-      config: {
-        width: config.width,
-        height: config.height,
-        fps: config.fps,
-        bitrate: config.bitrate
-      },
-      hasOverlayConfig: !!overlayConfig,
-      overlayConfig
-    });
-    this.isStopping = false;
-    this.isFinalized = false;
-    if (this.output) {
-      logger.debug("[RecorderWorker] Cleaning up existing output");
-      await this.cleanup();
+  }
+  validateFormat(format) {
+    if (format !== "mp4") {
+      throw new Error(\`Format \${format} is not yet supported in worker. Only MP4 is currently supported.\`);
     }
+  }
+  initializeRecordingState(config) {
     this.config = config;
-    this.frameRate = config.fps;
+    this.frameRate = config.fps || 30;
     this.isPaused = false;
     this.isMuted = false;
     this.lastVideoTimestamp = 0;
     this.lastAudioTimestamp = 0;
     this.baseVideoTimestamp = null;
     this.frameCount = 0;
+    this.lastKeyFrameTimestamp = 0;
+    this.forceNextKeyFrame = false;
     this.pausedDuration = 0;
     this.pauseStartedAt = null;
-    this.overlayConfig = overlayConfig ? { enabled: overlayConfig.enabled, text: overlayConfig.text } : null;
     this.overlayCanvas = null;
     this.hiddenIntervals = [];
     this.currentHiddenIntervalStart = null;
-    this.recordingStartTime = overlayConfig?.recordingStartTime !== undefined ? overlayConfig.recordingStartTime / 1000 : performance.now() / 1000;
     this.pendingVisibilityUpdates = [];
+  }
+  setupOverlayConfig(overlayConfig) {
+    this.overlayConfig = overlayConfig ? { enabled: overlayConfig.enabled, text: overlayConfig.text } : null;
+    this.recordingStartTime = overlayConfig?.recordingStartTime !== undefined ? overlayConfig.recordingStartTime / 1000 : performance.now() / 1000;
     const logData = {
       hasOverlayConfig: !!this.overlayConfig,
       overlayEnabled: this.overlayConfig?.enabled,
@@ -9874,15 +9921,13 @@ class RecorderWorker {
       recordingStartTime: this.recordingStartTime
     };
     logger.debug("[RecorderWorker] Overlay config initialized", logData);
+  }
+  createOutput() {
     const writable = new WritableStream({
       write: (chunk) => {
         this.sendChunk(chunk.data, chunk.position);
       }
     });
-    const format = config.format || "mp4";
-    if (format !== "mp4") {
-      throw new Error(\`Format \${format} is not yet supported in worker. Only MP4 is currently supported.\`);
-    }
     this.output = new Output({
       format: new Mp4OutputFormat({
         fastStart: "fragmented"
@@ -9892,27 +9937,75 @@ class RecorderWorker {
         chunkSize: CHUNK_SIZE
       })
     });
-    this.videoSource = new VideoSampleSource({
+  }
+  createVideoSource(config) {
+    const fps = config.fps || 30;
+    const keyFrameIntervalSeconds = config.keyFrameInterval / fps;
+    const videoSourceOptions = {
       codec: config.codec,
-      bitrate: config.bitrate,
-      sizeChangeBehavior: "passThrough"
-    });
-    this.output.addVideoTrack(this.videoSource);
-    if (videoStream) {
-      this.setupVideoProcessing(videoStream);
+      sizeChangeBehavior: "passThrough",
+      bitrateMode: "variable",
+      latencyMode: "quality",
+      contentHint: "detail",
+      hardwareAcceleration: "prefer-hardware",
+      keyFrameInterval: keyFrameIntervalSeconds,
+      bitrate: config.bitrate ?? QUALITY_HIGH
+    };
+    this.videoSource = new VideoSampleSource(videoSourceOptions);
+    const output = requireNonNull(this.output, "Output must be initialized before adding video track");
+    const trackOptions = {};
+    if (fps !== undefined) {
+      trackOptions.frameRate = fps;
     }
+    output.addVideoTrack(this.videoSource, trackOptions);
+  }
+  setupAudioSource(audioStream, config) {
     if (audioStream && config.audioBitrate && config.audioCodec) {
       if (config.audioBitrate <= 0) {
         throw new Error("Audio bitrate must be greater than zero");
       }
       this.audioSource = new AudioSampleSource({
         codec: config.audioCodec,
-        bitrate: config.audioBitrate
+        bitrate: config.audioBitrate,
+        bitrateMode: "variable"
       });
-      this.output.addAudioTrack(this.audioSource);
+      const output = requireNonNull(this.output, "Output must be initialized before adding audio track");
+      output.addAudioTrack(this.audioSource);
       this.setupAudioProcessing(audioStream);
     }
-    await this.output.start();
+  }
+  async handleStart(videoStream, audioStream, config, overlayConfig) {
+    this.validateConfig(config);
+    logger.debug("[RecorderWorker] handleStart called", {
+      hasVideoStream: !!videoStream,
+      hasAudioStream: !!audioStream,
+      config: {
+        width: config.width,
+        height: config.height,
+        fps: config.fps,
+        bitrate: config.bitrate
+      },
+      hasOverlayConfig: !!overlayConfig,
+      overlayConfig
+    });
+    this.isStopping = false;
+    this.isFinalized = false;
+    if (this.output) {
+      logger.debug("[RecorderWorker] Cleaning up existing output");
+      await this.cleanup();
+    }
+    this.initializeRecordingState(config);
+    this.setupOverlayConfig(overlayConfig);
+    const format = config.format || "mp4";
+    this.validateFormat(format);
+    this.createOutput();
+    this.createVideoSource(config);
+    if (videoStream) {
+      this.setupVideoProcessing(videoStream);
+    }
+    this.setupAudioSource(audioStream, config);
+    const output = requireNonNull(this.output, "Output must be initialized before starting");
+    await output.start();
     this.startBufferUpdates();
     this.sendReady();
     this.sendStateChange("recording");
@@ -10157,8 +10250,6 @@ class RecorderWorker {
         }
       }
     }
-    const keyFrameInterval = config.keyFrameInterval > 0 ? config.keyFrameInterval : 5;
-    const isKeyFrame = this.frameCount % keyFrameInterval === 0;
     const maxLead = 0.05;
     const maxLag = 0.1;
     const targetAudio = this.lastAudioTimestamp;
@@ -10170,6 +10261,10 @@ class RecorderWorker {
     }
     const monotonicTimestamp = this.lastVideoTimestamp + frameDuration;
     const finalTimestamp = adjustedTimestamp >= monotonicTimestamp ? adjustedTimestamp : monotonicTimestamp;
+    const keyFrameIntervalFrames = config.keyFrameInterval > 0 ? config.keyFrameInterval : 5;
+    const keyFrameIntervalSeconds = keyFrameIntervalFrames / this.frameRate;
+    const timeSinceLastKeyFrame = finalTimestamp - this.lastKeyFrameTimestamp;
+    const isKeyFrame = this.forceNextKeyFrame || timeSinceLastKeyFrame >= keyFrameIntervalSeconds || this.frameCount % keyFrameIntervalFrames === 0;
     this.driftOffset *= 0.5;
     const sample = new VideoSample(frameToProcess, {
       timestamp: finalTimestamp,
@@ -10184,6 +10279,10 @@ class RecorderWorker {
     if (!addError) {
       this.frameCount += 1;
       this.lastVideoTimestamp = finalTimestamp;
+      if (isKeyFrame) {
+        this.lastKeyFrameTimestamp = finalTimestamp;
+        this.forceNextKeyFrame = false;
+      }
       if (this.frameCount % 90 === 0 && this.audioProcessingActive) {
         const avDrift = this.lastAudioTimestamp - this.lastVideoTimestamp;
         logger.debug("[RecorderWorker] AV drift metrics", {
@@ -10460,6 +10559,7 @@ class RecorderWorker {
     const previousVideoTimestamp = this.lastVideoTimestamp;
     this.lastVideoTimestamp = continuationTimestamp;
     this.frameCount = 0;
+    this.forceNextKeyFrame = true;
     logger.debug("[RecorderWorker] handleSwitchSource - preserving baseVideoTimestamp", {
       continuationTimestamp,
       lastVideoTimestamp: this.lastVideoTimestamp,
@@ -10512,6 +10612,8 @@ class RecorderWorker {
     this.lastAudioTimestamp = 0;
     this.baseVideoTimestamp = null;
     this.frameCount = 0;
+    this.lastKeyFrameTimestamp = 0;
+    this.forceNextKeyFrame = false;
     this.totalSize = 0;
     this.pausedDuration = 0;
     this.pauseStartedAt = null;
@@ -10566,7 +10668,6 @@ new RecorderWorker;
 
 // src/core/processor/worker-processor.ts
 var KEY_FRAME_INTERVAL = 5;
-var H264_CODEC = "avc";
 var workerBlobUrl = null;
 function getWorkerUrl() {
   if (workerBlobUrl) {
@@ -10687,20 +10788,21 @@ class WorkerProcessor {
     const format = config.format || "mp4";
     const audioCodec = config.audioCodec || getDefaultAudioCodecForFormat(format);
     const isScreenCapture = isScreenCaptureStream(stream);
-    const targetFps = config.fps;
+    const codec = config.codec || await detectBestCodec(config.width, config.height, config.bitrate);
     logger.debug("[WorkerProcessor] Starting processing", {
       isScreenCapture,
-      targetFps,
-      originalFps: config.fps
+      fps: config.fps,
+      codec,
+      bitrate: config.bitrate
     });
     const workerConfig = {
       width: config.width,
       height: config.height,
-      fps: targetFps,
+      fps: config.fps,
       bitrate: config.bitrate,
       audioCodec,
       audioBitrate: config.audioBitrate,
-      codec: H264_CODEC,
+      codec,
       keyFrameInterval: KEY_FRAME_INTERVAL,
       format
     };
@@ -11797,13 +11899,24 @@ function getMimeTypeForFormat(format) {
 function createConversionOptions(config) {
   const audioCodec = getAudioCodecForFormat(config.format, config.audioCodec);
   const video = {
-    width: config.width,
-    height: config.height,
     fit: "contain",
-    frameRate: config.fps,
-    bitrate: config.bitrate,
     forceTranscode: true
   };
+  if (config.width !== undefined) {
+    video.width = config.width;
+  }
+  if (config.height !== undefined) {
+    video.height = config.height;
+  }
+  if (config.fps !== undefined) {
+    video.frameRate = config.fps;
+  }
+  if (config.bitrate !== undefined) {
+    video.bitrate = config.bitrate;
+  }
+  if (config.codec !== undefined) {
+    video.codec = config.codec;
+  }
   const audio = {
     codec: audioCodec,
     forceTranscode: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vidtreo/recorder",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "type": "module",
   "description": "Vidtreo SDK for browser-based video recording and transcoding. Features include camera/screen recording, real-time MP4 transcoding, audio level analysis, mute/pause controls, source switching, device selection, and automatic backend uploads. Similar to Ziggeo and Addpipe, Vidtreo provides enterprise-grade video processing capabilities for web applications.",
   "main": "./dist/index.js",