@besovideo/webrtc-player 0.10.42 → 0.10.44

package/dist/{bvmedia-7ZJI3VSG.js → bvmedia-7JPROY4X.js}

@@ -2,7 +2,7 @@ import {
   __async,
   init_define_processenv,
   init_jsx_shim
-} from "./chunk-26DTQELB.js";
+} from "./chunk-7SHCWKP3.js";
 
 // src/lib/bvmedia/index.ts
 init_define_processenv();
@@ -1028,7 +1028,21 @@ var BVMedia = class {
       this.webcodecPlayer.decodeAudio(packet.data, packet.pts);
     }
   }
+  // Recording subscribes independently of playback volume and onaudioData.
+  setDecodedAudioCallback(callback) {
+    this.onDecodedAudioCallback = callback;
+    return Promise.resolve();
+  }
   _OnAudioData(frame) {
+    var _a;
+    (_a = this.onDecodedAudioCallback) == null ? void 0 : _a.call(this, {
+      pts: frame.pts / 1e3,
+      // decoded PCM uses milliseconds; recording uses seconds
+      data: frame.data,
+      channels: this.audioInfo.channels,
+      sampleRate: this.audioInfo.sampleRate,
+      format: this.audioInfo.encoding
+    });
     if (this.audioPlayer) {
       let numberOfFrames = frame.len / this.audioInfo.channels / this.audioPlayer.getNumofSamples(this.audioInfo.encoding);
       let ar = new Uint8Array(frame.data);

package/dist/{chunk-26DTQELB.js → chunk-7SHCWKP3.js}

@@ -119,7 +119,7 @@ var __async = (__this, __arguments, generator) => {
 var define_processenv_default;
 var init_define_processenv = __esm({
   "<define:processenv>"() {
-    define_processenv_default = { NODE_ENV: "production", SH_LIB_NAME: "@besovideo/webrtc-player", SH_LIB_VERSION: "0.10.42", PROJECT_NAMESPACE: "bvplayer", SH_LIB_BUILD_TIME: "2026-08-28 17:40:57" };
+    define_processenv_default = { NODE_ENV: "production", SH_LIB_NAME: "@besovideo/webrtc-player", SH_LIB_VERSION: "0.10.44", PROJECT_NAMESPACE: "bvplayer", SH_LIB_BUILD_TIME: "2026-09-10 18:05:58" };
   }
 });
 

package/dist/main.browser.js

@@ -125,7 +125,7 @@ var bvPlayerCore = (() => {
   var define_processenv_default;
   var init_define_processenv = __esm({
     "<define:processenv>"() {
-      define_processenv_default = { NODE_ENV: "production", SH_LIB_NAME: "@besovideo/webrtc-player", SH_LIB_VERSION: "0.10.42", PROJECT_NAMESPACE: "bvplayer", SH_LIB_BUILD_TIME: "2026-08-28 17:40:57" };
+      define_processenv_default = { NODE_ENV: "production", SH_LIB_NAME: "@besovideo/webrtc-player", SH_LIB_VERSION: "0.10.44", PROJECT_NAMESPACE: "bvplayer", SH_LIB_BUILD_TIME: "2026-09-10 18:05:58" };
     }
   });
 
@@ -14840,7 +14840,21 @@ CustomVideoTrackGeneratorWorker();`;
             this.webcodecPlayer.decodeAudio(packet.data, packet.pts);
           }
         }
+        // Recording subscribes independently of playback volume and onaudioData.
+        setDecodedAudioCallback(callback) {
+          this.onDecodedAudioCallback = callback;
+          return Promise.resolve();
+        }
         _OnAudioData(frame) {
+          var _a;
+          (_a = this.onDecodedAudioCallback) == null ? void 0 : _a.call(this, {
+            pts: frame.pts / 1e3,
+            // decoded PCM uses milliseconds; recording uses seconds
+            data: frame.data,
+            channels: this.audioInfo.channels,
+            sampleRate: this.audioInfo.sampleRate,
+            format: this.audioInfo.encoding
+          });
           if (this.audioPlayer) {
             let numberOfFrames = frame.len / this.audioInfo.channels / this.audioPlayer.getNumofSamples(this.audioInfo.encoding);
             let ar = new Uint8Array(frame.data);
@@ -37325,6 +37339,182 @@ ${event.candidate ? event.candidate.candidate : "(null)"}`
   // src/utils/bvrtcRecord.ts
   init_define_processenv();
   init_jsx_shim();
+
+  // src/utils/hevcRecord.ts
+  init_define_processenv();
+  init_jsx_shim();
+  function hevcDecoderConfig(vps, sps, pps) {
+    const rbsp = [];
+    for (let i3 = 2; i3 < sps.length; i3++) {
+      if (i3 >= 4 && sps[i3] === 3 && sps[i3 - 1] === 0 && sps[i3 - 2] === 0)
+        continue;
+      rbsp.push(sps[i3]);
+    }
+    let offset2 = 0;
+    const read2 = (count) => {
+      if (offset2 + count > rbsp.length * 8)
+        throw new Error("Invalid HEVC SPS in BVRTC callback");
+      let value = 0;
+      for (let i3 = 0; i3 < count; i3++, offset2++)
+        value = value * 2 + (rbsp[offset2 >> 3] >> 7 - (offset2 & 7) & 1);
+      return value;
+    };
+    const ue = () => {
+      let zeros = 0;
+      while (read2(1) === 0) {
+        if (++zeros > 31)
+          throw new Error("Invalid HEVC SPS Exp-Golomb value");
+      }
+      return __pow(2, zeros) - 1 + read2(zeros);
+    };
+    read2(4);
+    const subLayers = read2(3);
+    const temporalNested = read2(1);
+    const profileTierLevel = Uint8Array.from({ length: 12 }, () => read2(8));
+    const subProfiles = [];
+    const subLevels = [];
+    for (let i3 = 0; i3 < subLayers; i3++) {
+      subProfiles.push(read2(1));
+      subLevels.push(read2(1));
+    }
+    if (subLayers)
+      read2((8 - subLayers) * 2);
+    for (let i3 = 0; i3 < subLayers; i3++) {
+      if (subProfiles[i3]) {
+        read2(32);
+        read2(32);
+        read2(24);
+      }
+      if (subLevels[i3])
+        read2(8);
+    }
+    ue();
+    const chromaFormat = ue();
+    if (chromaFormat === 3)
+      read2(1);
+    ue();
+    ue();
+    if (read2(1)) {
+      ue();
+      ue();
+      ue();
+      ue();
+    }
+    const bitDepthLuma = ue();
+    const bitDepthChroma = ue();
+    if (chromaFormat > 3 || bitDepthLuma > 7 || bitDepthChroma > 7)
+      throw new Error("Invalid HEVC SPS format");
+    const sets2 = [vps, sps, pps];
+    if (sets2.some((set2) => set2.length < 2 || set2.length > 65535))
+      throw new Error("Invalid HEVC parameter set length");
+    const result = new Uint8Array(23 + sets2.reduce((size, set2) => size + 5 + set2.length, 0));
+    result[0] = 1;
+    result.set(profileTierLevel, 1);
+    result.set([
+      240,
+      0,
+      252,
+      252 | chromaFormat,
+      248 | bitDepthLuma,
+      248 | bitDepthChroma,
+      0,
+      0,
+      subLayers + 1 << 3 | temporalNested << 2 | 3,
+      3
+    ], 13);
+    let position = 23;
+    sets2.forEach((set2, index) => {
+      result[position++] = 128 | 32 + index;
+      new DataView(result.buffer).setUint16(position, 1);
+      position += 2;
+      new DataView(result.buffer).setUint16(position, set2.length);
+      position += 2;
+      result.set(set2, position);
+      position += set2.length;
+    });
+    return result;
+  }
+
+  // src/utils/pcmResampler.ts
+  init_define_processenv();
+  init_jsx_shim();
+  var PcmResampler = class {
+    constructor(inputRate, outputRate, channels) {
+      this.inputRate = inputRate;
+      this.outputRate = outputRate;
+      this.channels = channels;
+      this.radius = 32;
+      this.buffer = new Int16Array(0);
+      this.bufferStart = 0;
+      this.inputFrames = 0;
+      this.outputFrames = 0;
+      this.phases = [];
+      if (!Number.isInteger(inputRate) || inputRate <= 0 || !Number.isInteger(outputRate) || outputRate <= 0 || !Number.isInteger(channels) || channels <= 0)
+        throw new Error("Invalid PCM resampler format");
+      const gcd = (a, b2) => b2 ? gcd(b2, a % b2) : a;
+      const count = outputRate / gcd(inputRate, outputRate);
+      const cutoff = Math.min(1, outputRate / inputRate);
+      for (let phase = 0; phase < count; phase++) {
+        const fraction = phase * inputRate % outputRate / outputRate;
+        const weights = [];
+        for (let tap = -this.radius + 1; tap <= this.radius; tap++) {
+          const distance = fraction - tap;
+          const x2 = Math.PI * distance * cutoff;
+          const sinc = Math.abs(x2) < 1e-12 ? 1 : Math.sin(x2) / x2;
+          const window2 = Math.abs(distance) >= this.radius ? 0 : 0.42 + 0.5 * Math.cos(Math.PI * distance / this.radius) + 0.08 * Math.cos(2 * Math.PI * distance / this.radius);
+          weights.push(cutoff * sinc * window2);
+        }
+        const sum = weights.reduce((a, b2) => a + b2, 0);
+        this.phases.push(weights.map((weight) => weight / sum));
+      }
+    }
+    get pendingSeconds() {
+      return this.inputFrames / this.inputRate - this.outputFrames / this.outputRate;
+    }
+    process(input) {
+      if (input.length % this.channels)
+        throw new Error("Incomplete interleaved PCM frame");
+      if (this.inputRate === this.outputRate)
+        return input;
+      const merged = new Int16Array(this.buffer.length + input.length);
+      merged.set(this.buffer);
+      merged.set(input, this.buffer.length);
+      this.buffer = merged;
+      this.inputFrames += input.length / this.channels;
+      return this.render(false);
+    }
+    flush() {
+      return this.inputRate === this.outputRate ? new Int16Array(0) : this.render(true);
+    }
+    render(final) {
+      const limit = Math.round(this.inputFrames * this.outputRate / this.inputRate);
+      const result = [];
+      while (this.outputFrames < limit) {
+        const center = Math.floor(this.outputFrames * this.inputRate / this.outputRate);
+        if (!final && center + this.radius >= this.inputFrames)
+          break;
+        const weights = this.phases[this.outputFrames % this.phases.length];
+        for (let channel = 0; channel < this.channels; channel++) {
+          let value = 0;
+          for (let i3 = 0; i3 < weights.length; i3++) {
+            const frame = center - this.radius + 1 + i3;
+            if (frame >= 0 && frame < this.inputFrames)
+              value += this.buffer[(frame - this.bufferStart) * this.channels + channel] * weights[i3];
+          }
+          result.push(Math.max(-32768, Math.min(32767, Math.round(value))));
+        }
+        this.outputFrames++;
+      }
+      const keepFrom = Math.max(0, Math.floor(this.outputFrames * this.inputRate / this.outputRate) - this.radius);
+      if (keepFrom > this.bufferStart) {
+        this.buffer = this.buffer.slice((keepFrom - this.bufferStart) * this.channels);
+        this.bufferStart = keepFrom;
+      }
+      return Int16Array.from(result);
+    }
+  };
+
+  // src/utils/bvrtcRecord.ts
   var startCodeLength = (data, offset2) => data[offset2] === 0 && data[offset2 + 1] === 0 && (data[offset2 + 2] === 1 ? 3 : data[offset2 + 2] === 0 && data[offset2 + 3] === 1 ? 4 : 0);
   function splitAnnexB(data) {
     const units = [];
@@ -37385,32 +37575,21 @@ ${event.candidate ? event.candidate.candidate : "(null)"}`
     return value & 128 ? pcm : -pcm;
   };
   var AAC_SAMPLE_RATE = 48e3;
-  function resampleS16(input, channels, inputRate) {
-    if (inputRate === AAC_SAMPLE_RATE)
-      return input;
-    const inputFrames = Math.floor(input.length / channels);
-    if (!inputFrames)
-      return input;
-    const outputFrames = Math.round(inputFrames * AAC_SAMPLE_RATE / inputRate);
-    const output2 = new Int16Array(outputFrames * channels);
-    for (let frame = 0; frame < outputFrames; frame++) {
-      const sourcePosition = frame * inputRate / AAC_SAMPLE_RATE;
-      const lower = Math.floor(sourcePosition);
-      const upper = Math.min(lower + 1, inputFrames - 1);
-      const mix = sourcePosition - lower;
-      for (let channel = 0; channel < channels; channel++) {
-        output2[frame * channels + channel] = input[lower * channels + channel] * (1 - mix) + input[upper * channels + channel] * mix;
-      }
-    }
-    return output2;
-  }
   var BvrtcRecorder = class {
     constructor(player, fileName) {
       this.player = player;
       this.fileName = fileName;
       this.startedAt = 0;
+      this.hevc = false;
+      this.videoStarted = false;
       this.pendingAudio = [];
       this.transcodeAlaw = false;
+      this.transcodePcm = false;
+      this.pendingPcmAudio = [];
+      this.pcmChannels = 1;
+      this.recordingClockStart = 0;
+      this.videoClockOffset = 0;
+      this.pcmClockOffset = 0;
       this.stopped = false;
       this.onVideo = (packet) => {
         if (this.stopped)
@@ -37418,6 +37597,45 @@ ${event.candidate ? event.candidate.candidate : "(null)"}`
         const units = splitAnnexB(new Uint8Array(packet.data));
         if (!units.length)
           return;
+        const hasPicture = units.some((unit) => this.hevc ? (unit[0] >> 1 & 63) < 32 : (unit[0] & 31) >= 1 && (unit[0] & 31) <= 5);
+        if (this.transcodePcm && this.firstPts === void 0 && hasPicture) {
+          this.videoClockOffset = (performance.now() - this.recordingClockStart) * 1e3;
+          this.normalizePts(packet.pts);
+        }
+        if (this.hevc) {
+          for (const unit of units) {
+            const type = unit[0] >> 1 & 63;
+            if (type === 32)
+              this.vps = unit;
+            if (type === 33)
+              this.sps = unit;
+            if (type === 34)
+              this.pps = unit;
+          }
+          const sampleUnits = units.filter((unit) => {
+            const type = unit[0] >> 1 & 63;
+            return type < 32 || type > 34;
+          });
+          if (!sampleUnits.some((unit) => (unit[0] >> 1 & 63) < 32))
+            return;
+          const key2 = sampleUnits.some((unit) => {
+            const type = unit[0] >> 1 & 63;
+            return type >= 16 && type <= 21;
+          });
+          if (!this.videoStarted && !key2)
+            return;
+          this.createMuxer();
+          if (!this.muxer)
+            return;
+          this.videoStarted = true;
+          const pts2 = this.normalizePts(packet.pts);
+          const duration2 = this.lastVideoPts === void 0 ? 0 : Math.max(0, pts2 - this.lastVideoPts);
+          this.lastVideoPts = pts2;
+          this.muxer.addVideoChunkRaw(avcSample(sampleUnits), key2 ? "key" : "delta", pts2, duration2, {
+            decoderConfig: { codec: "hvc1", description: hevcDecoderConfig(this.vps, this.sps, this.pps) }
+          });
+          return;
+        }
         for (const unit of units) {
           const type = unit[0] & 31;
           if (type === 7)
@@ -37425,13 +37643,19 @@ ${event.candidate ? event.candidate.candidate : "(null)"}`
           if (type === 8)
             this.pps = unit;
         }
+        if (!units.some((unit) => (unit[0] & 31) >= 1 && (unit[0] & 31) <= 5))
+          return;
+        const key = units.some((unit) => (unit[0] & 31) === 5);
+        if (!this.videoStarted && !key)
+          return;
         this.createMuxer();
         if (!this.muxer)
           return;
+        this.videoStarted = true;
         const pts = this.normalizePts(packet.pts);
         const duration = this.lastVideoPts === void 0 ? 0 : Math.max(0, pts - this.lastVideoPts);
         this.lastVideoPts = pts;
-        this.muxer.addVideoChunkRaw(avcSample(units), packet.flags & 1 ? "key" : "delta", pts, duration, {
+        this.muxer.addVideoChunkRaw(avcSample(units), key ? "key" : "delta", pts, duration, {
           decoderConfig: { codec: "avc1", description: avcDecoderConfig(this.sps, this.pps) }
         });
       };
@@ -37447,77 +37671,115 @@ ${event.candidate ? event.candidate.candidate : "(null)"}`
         }
         this.addAudio(packet);
       };
+      this.onPcmAudio = (packet) => {
+        if (this.stopped)
+          return;
+        if (this.pcmClockStart === void 0) {
+          this.pcmClockStart = packet.pts;
+          this.pcmClockOffset = (performance.now() - this.recordingClockStart) * 1e3;
+        }
+        if (!this.muxer) {
+          this.pendingPcmAudio.push(packet);
+          return;
+        }
+        this.addPcmAudio(packet);
+      };
     }
     start() {
       return __async(this, null, function* () {
-        var _a, _b;
+        var _a, _b, _c;
         const videoCodec = (_a = this.player.getVideoInfo().codec) == null ? void 0 : _a.toLowerCase();
         const audioCodec = (_b = this.player.getAudioInfo().codec) == null ? void 0 : _b.toLowerCase();
-        if (videoCodec && videoCodec !== "none" && !/(h264|avc)/.test(videoCodec))
+        this.hevc = /^(hevc|h265|h\.265|hvc1|hev1)$/.test(videoCodec || "");
+        if (videoCodec && videoCodec !== "none" && !/(h264|avc)/.test(videoCodec) && !this.hevc)
           throw new Error(`BVRTC passthrough recording does not support video codec: ${videoCodec}`);
-        if (audioCodec && audioCodec !== "aac" && audioCodec !== "pcm_alaw")
+        this.transcodePcm = /^(adpcm_)?g726(le)?$/.test(audioCodec || "");
+        if (audioCodec && audioCodec !== "aac" && audioCodec !== "pcm_alaw" && !this.transcodePcm)
           throw new Error(`BVRTC passthrough recording does not support audio codec: ${audioCodec}`);
         this.transcodeAlaw = audioCodec === "pcm_alaw";
-        if (this.transcodeAlaw && !globalThis.AudioEncoder) {
-          throw new Error("This browser does not support WebCodecs AAC audio encoding required for pcm_alaw MP4 recording");
+        if (this.transcodeAlaw || this.transcodePcm) {
+          if (!(yield this.createAudioEncoder())) {
+            this.transcodeAlaw = false;
+            this.transcodePcm = false;
+          }
+        }
+        if (this.transcodePcm && !this.player.setDecodedAudioCallback) {
+          (_c = this.audioEncoder) == null ? void 0 : _c.close();
+          throw new Error("BVRTC G.726 recording requires decoded PCM audio callbacks");
         }
         this.startedAt = Date.now();
+        this.recordingClockStart = performance.now();
         if (videoCodec === "none")
           this.createMuxer();
         yield Promise.all([
           this.player.setVideoCallback(this.onVideo),
-          this.player.setAudioCallback(this.onAudio)
+          this.transcodePcm ? this.player.setDecodedAudioCallback(this.onPcmAudio) : this.player.setAudioCallback(this.onAudio)
         ]);
       });
     }
     createMuxer() {
       var _a, _b;
       const hasVideo = ((_a = this.player.getVideoInfo().codec) == null ? void 0 : _a.toLowerCase()) !== "none";
-      if (this.muxer || hasVideo && (!this.sps || !this.pps))
+      if (this.muxer || hasVideo && (!this.sps || !this.pps || this.hevc && !this.vps))
         return;
       const video = this.player.getVideoInfo();
       const audio = this.player.getAudioInfo();
       this.target = new ArrayBufferTarget2();
       this.muxer = new Muxer2({
         target: this.target,
-        video: hasVideo ? { codec: "avc", width: video.width || 1, height: video.height || 1 } : void 0,
-        audio: ((_b = audio.codec) == null ? void 0 : _b.toLowerCase()) === "aac" || this.transcodeAlaw ? { codec: "aac", numberOfChannels: audio.channels || 1, sampleRate: this.transcodeAlaw ? AAC_SAMPLE_RATE : audio.sampleRate || 8e3 } : void 0,
+        video: hasVideo ? { codec: this.hevc ? "hevc" : "avc", width: video.width || 1, height: video.height || 1 } : void 0,
+        audio: ((_b = audio.codec) == null ? void 0 : _b.toLowerCase()) === "aac" || this.transcodeAlaw || this.transcodePcm ? { codec: "aac", numberOfChannels: audio.channels || 1, sampleRate: this.transcodeAlaw || this.transcodePcm ? AAC_SAMPLE_RATE : audio.sampleRate || 8e3 } : void 0,
         fastStart: "in-memory",
         firstTimestampBehavior: "cross-track-offset"
       });
-      if (this.transcodeAlaw)
-        this.createAlawEncoder();
       for (const packet of this.pendingAudio.splice(0))
         this.addAudio(packet);
+      for (const packet of this.pendingPcmAudio.splice(0))
+        this.addPcmAudio(packet);
     }
-    createAlawEncoder() {
-      if (this.audioEncoder || !this.muxer)
-        return;
-      const audio = this.player.getAudioInfo();
-      const Encoder3 = globalThis.AudioEncoder;
-      this.audioEncoder = new Encoder3({
-        output: (chunk, meta) => {
-          var _a;
-          return (_a = this.muxer) == null ? void 0 : _a.addAudioChunk(chunk, meta);
-        },
-        error: (error2) => console.error("BVRTC AAC encoder error", error2)
-      });
-      this.audioEncoder.configure({
-        codec: "mp4a.40.2",
-        sampleRate: AAC_SAMPLE_RATE,
-        numberOfChannels: audio.channels || 1,
-        // Chromium's AAC WebCodecs implementation currently accepts 96 kbps+
-        // only (even for 8 kHz G.711 input).
-        bitrate: 96e3
+    createAudioEncoder() {
+      return __async(this, null, function* () {
+        var _a, _b;
+        const audio = this.player.getAudioInfo();
+        const Encoder3 = globalThis.AudioEncoder;
+        if (!Encoder3 || !globalThis.AudioData)
+          return false;
+        const config = {
+          codec: "mp4a.40.2",
+          sampleRate: AAC_SAMPLE_RATE,
+          numberOfChannels: audio.channels || 1,
+          // Chromium's AAC WebCodecs implementation currently accepts 96 kbps+
+          // only (even for 8 kHz G.711 input).
+          bitrate: 96e3
+        };
+        try {
+          if (!(yield Encoder3.isConfigSupported(config)).supported)
+            return false;
+          this.audioEncoder = new Encoder3({
+            output: (chunk, meta) => {
+              var _a2;
+              return (_a2 = this.muxer) == null ? void 0 : _a2.addAudioChunk(chunk, meta);
+            },
+            error: (error2) => console.error("BVRTC AAC encoder error", error2)
+          });
+          this.audioEncoder.configure(config);
+          return true;
+        } catch (e) {
+          if (((_a = this.audioEncoder) == null ? void 0 : _a.state) !== "closed")
+            (_b = this.audioEncoder) == null ? void 0 : _b.close();
+          this.audioEncoder = void 0;
+          return false;
+        }
       });
     }
     normalizePts(pts) {
       var _a;
+      pts = pts >= 1e11 ? pts / 1e3 : pts;
       (_a = this.firstPts) != null ? _a : this.firstPts = pts;
-      return Math.max(0, (pts - this.firstPts) * 1e3);
+      return Math.max(0, Math.round((pts - this.firstPts) * 1e6 + this.videoClockOffset));
     }
     addAudio(packet) {
-      var _a, _b;
+      var _a;
       if (!this.muxer)
         return;
       if (this.transcodeAlaw) {
@@ -37526,37 +37788,69 @@ ${event.candidate ? event.candidate.candidate : "(null)"}`
         const decoded = new Int16Array(encoded.byteLength);
         for (let i3 = 0; i3 < encoded.byteLength; i3++)
           decoded[i3] = alawToS16(encoded[i3]);
-        const channels = audio.channels || 1;
-        const pcm = resampleS16(decoded, channels, audio.sampleRate || 8e3);
-        const AudioDataCtor = globalThis.AudioData;
-        const frame = new AudioDataCtor({ format: "s16", sampleRate: AAC_SAMPLE_RATE, numberOfFrames: pcm.length / channels, numberOfChannels: channels, timestamp: this.normalizePts(packet.pts), data: pcm });
-        (_a = this.audioEncoder) == null ? void 0 : _a.encode(frame);
-        frame.close();
+        this.encodePcm(decoded, audio.channels || 1, audio.sampleRate || 8e3, packet.pts);
         return;
       }
-      if (((_b = this.player.getAudioInfo().codec) == null ? void 0 : _b.toLowerCase()) !== "aac")
+      if (((_a = this.player.getAudioInfo().codec) == null ? void 0 : _a.toLowerCase()) !== "aac")
         return;
-      const pts = this.normalizePts(packet.pts);
-      const duration = this.lastAudioPts === void 0 ? 0 : Math.max(0, pts - this.lastAudioPts);
+      const duration = 1024 * 1e6 / (this.player.getAudioInfo().sampleRate || 8e3);
+      const sourcePts = this.normalizePts(packet.pts);
+      const pts = this.lastAudioPts === void 0 ? sourcePts : Math.max(sourcePts, this.lastAudioPts + duration);
       this.lastAudioPts = pts;
       this.muxer.addAudioChunkRaw(stripAdts(new Uint8Array(packet.data)), "key", pts, duration);
     }
+    encodePcm(decoded, channels, sampleRate, sourcePts, normalizedPts = this.normalizePts(sourcePts)) {
+      var _a;
+      (_a = this.pcmResampler) != null ? _a : this.pcmResampler = new PcmResampler(sampleRate, AAC_SAMPLE_RATE, channels);
+      this.pcmChannels = channels;
+      const pendingSeconds = this.pcmResampler.pendingSeconds;
+      const pcm = this.pcmResampler.process(decoded);
+      this.writePcm(pcm, channels, normalizedPts - pendingSeconds * 1e6);
+    }
+    writePcm(pcm, channels, normalizedPts) {
+      var _a;
+      const numberOfFrames = pcm.length / channels;
+      if (!numberOfFrames)
+        return;
+      const timestamp = Math.max(normalizedPts, (_a = this.nextPcmPts) != null ? _a : 0);
+      this.nextPcmPts = timestamp + numberOfFrames * 1e6 / AAC_SAMPLE_RATE;
+      const AudioDataCtor = globalThis.AudioData;
+      const frame = new AudioDataCtor({ format: "s16", sampleRate: AAC_SAMPLE_RATE, numberOfFrames, numberOfChannels: channels, timestamp: Math.round(timestamp), data: pcm });
+      try {
+        this.audioEncoder.encode(frame);
+      } finally {
+        frame.close();
+      }
+    }
+    addPcmAudio(packet) {
+      if (packet.format !== "s16")
+        throw new Error(`Unsupported BVRTC decoded PCM format: ${packet.format}`);
+      const timestamp = (packet.pts - this.pcmClockStart) * 1e6 + this.pcmClockOffset;
+      this.encodePcm(new Int16Array(packet.data), packet.channels, packet.sampleRate, packet.pts, timestamp);
+    }
     stop(onRecordInfo) {
       return __async(this, null, function* () {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         if (this.stopped)
           return;
         this.stopped = true;
         const disableCallbacks = Promise.allSettled([
           this.player.setVideoCallback(null),
-          this.player.setAudioCallback(null)
+          this.transcodePcm ? this.player.setDecodedAudioCallback(null) : this.player.setAudioCallback(null)
         ]);
         const endTime = Date.now();
-        if (!this.muxer || !this.target)
+        this.pendingAudio = [];
+        this.pendingPcmAudio = [];
+        if (!this.muxer || !this.target) {
+          (_a = this.audioEncoder) == null ? void 0 : _a.close();
+          yield disableCallbacks;
           return;
-        yield (_a = this.audioEncoder) == null ? void 0 : _a.flush();
-        (_b = this.audioEncoder) == null ? void 0 : _b.close();
-        (_c = this.muxer) == null ? void 0 : _c.finalize();
+        }
+        if (this.pcmResampler)
+          this.writePcm(this.pcmResampler.flush(), this.pcmChannels, (_b = this.nextPcmPts) != null ? _b : 0);
+        yield (_c = this.audioEncoder) == null ? void 0 : _c.flush();
+        (_d = this.audioEncoder) == null ? void 0 : _d.close();
+        (_e = this.muxer) == null ? void 0 : _e.finalize();
         const blob = new Blob([this.target.buffer], { type: "video/mp4" });
         const suffix = "mp4";
         const download2 = (name) => file_default.downLoadBlob(blob, name || this.fileName, suffix);
@@ -38656,7 +38950,8 @@ ${event.candidate ? event.candidate.candidate : "(null)"}`
           processHandle.reg(() => __async(this, null, function* () {
             yield callApis.avCall(
               __spreadProps(__spreadValues({}, callInfo), {
-                id: remoteUserId,
+                // 接通前尚未返回远端 ID，取消呼叫时保留原始设备目标。
+                id: remoteUserId || callInfo.id,
                 status: 6 /* END */
               }),
               token
@@ -39090,7 +39385,7 @@ ${event.candidate ? event.candidate.candidate : "(null)"}`
     return {
       open(openParams, sinks) {
         return __async(this, null, function* () {
-          var _a2, _b, _c, _d, _e;
+          var _a2, _b, _c, _d, _e, _f;
           const rc = {
             code: "SUCCESS"
           };
@@ -39106,11 +39401,18 @@ ${event.candidate ? event.candidate.candidate : "(null)"}`
             const mediaOpenError = t("huo-qu-ben-di-mei-ti-shi-bai");
             SetCode(rc, "GET_MEDIA_ERROR", mediaOpenError);
             const hasVideo = !!(openParams.beCall && openParams.beCall.callData.videoCall) || !!((_a2 = openParams.call) == null ? void 0 : _a2.videoCall) || ((_c = (_b = openParams.call) == null ? void 0 : _b.displayMedia) == null ? void 0 : _c.video);
-            let mediaStream = null;
+            let mediaStream = ((_d = openParams.call) == null ? void 0 : _d.mediaStream) || null;
+            let mediaInactiveHandler;
             try {
-              if ((_d = openParams.call) == null ? void 0 : _d.displayMedia) {
+              if (mediaStream) {
+                mediaInactiveHandler = () => {
+                  var _a3, _b2;
+                  (_b2 = (_a3 = openParams.call) == null ? void 0 : _a3.onMediaInactive) == null ? void 0 : _b2.call(_a3);
+                };
+                mediaStream.addEventListener("inactive", mediaInactiveHandler);
+              } else if ((_e = openParams.call) == null ? void 0 : _e.displayMedia) {
                 mediaStream = yield navigator.mediaDevices.getDisplayMedia({
-                  video: (_e = openParams.call) == null ? void 0 : _e.displayMedia.video,
+                  video: (_f = openParams.call) == null ? void 0 : _f.displayMedia.video,
                   audio: !!openParams.call.displayMedia.audio
                 });
                 mediaStream.addEventListener("inactive", () => {
@@ -39189,6 +39491,9 @@ ${event.candidate ? event.candidate.candidate : "(null)"}`
             }
             releaseHandle.regRelease(() => __async(this, null, function* () {
               var _a3;
+              if (mediaInactiveHandler && mediaStream) {
+                mediaStream.removeEventListener("inactive", mediaInactiveHandler);
+              }
               if ((_a3 = openParams.call) == null ? void 0 : _a3.displayMedia) {
                 delete openParams.call.displayMedia.onInactive;
               }
@@ -39274,7 +39579,7 @@ a=fmtp:${pt} x-google-start-bitrate=${bitrate}`
                 );
                 const { promise: waitPCConnected, resolve: resolvePCConnected } = Promise.withResolvers();
                 const onPcStateChange = () => {
-                  var _a3, _b2, _c2, _d2, _e2, _f;
+                  var _a3, _b2, _c2, _d2, _e2, _f2;
                   if (pc.connectionState === "connected") {
                     if (pushResult.code == "WAIT_PEER_CONNECTED_ERROR") {
                       resolvePCConnected();
@@ -39290,7 +39595,7 @@ a=fmtp:${pt} x-google-start-bitrate=${bitrate}`
                   if (pc.connectionState === "failed") {
                     if ((_d2 = openParams.events) == null ? void 0 : _d2.onClose) {
                       ((_e2 = openParams.events) == null ? void 0 : _e2.onClose) && openParams.events.onClose();
-                      (_f = openParams.events) == null ? true : delete _f.onClose;
+                      (_f2 = openParams.events) == null ? true : delete _f2.onClose;
                     }
                     if (pushResult.close) {
                       pushResult.close();
@@ -40432,6 +40737,8 @@ a=fmtp:${pt} x-google-start-bitrate=${bitrate}`
         call: {
           videoCall: !!params.video,
           name: "",
+          mediaStream: params.mediaStream,
+          onMediaInactive: params.onMediaInactive,
           displayMedia: params.displayMedia
         },
         events: {