@besovideo/webrtc-player 0.10.43 → 0.10.44

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

@@ -2,7 +2,7 @@ import {
   __async,
   init_define_processenv,
   init_jsx_shim
-} from "./chunk-7BKM3LDB.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-7BKM3LDB.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.43", PROJECT_NAMESPACE: "bvplayer", SH_LIB_BUILD_TIME: "2026-09-04 14:49:37" };
+    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.43", PROJECT_NAMESPACE: "bvplayer", SH_LIB_BUILD_TIME: "2026-09-04 14:49:37" };
+      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

package/dist/main.es.js

@@ -27,7 +27,7 @@ import {
   logger_default,
   t,
   util_default
-} from "./chunk-7BKM3LDB.js";
+} from "./chunk-7SHCWKP3.js";
 
 // node_modules/.pnpm/ts-ebml@3.0.2/node_modules/ts-ebml/dist/EBML.min.js
 var require_EBML_min = __commonJS({
@@ -29833,7 +29833,7 @@ init_define_processenv();
 init_jsx_shim();
 var bvMediaPromise;
 function loadBvMedia() {
-  bvMediaPromise != null ? bvMediaPromise : bvMediaPromise = import("./bvmedia-7YQE7SZM.js").then(
+  bvMediaPromise != null ? bvMediaPromise : bvMediaPromise = import("./bvmedia-7JPROY4X.js").then(
     (module) => module.default
   );
   return bvMediaPromise;
@@ -31858,6 +31858,182 @@ var DialogManager = class {
 // 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 i2 = 2; i2 < sps.length; i2++) {
+    if (i2 >= 4 && sps[i2] === 3 && sps[i2 - 1] === 0 && sps[i2 - 2] === 0)
+      continue;
+    rbsp.push(sps[i2]);
+  }
+  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 i2 = 0; i2 < count; i2++, 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 i2 = 0; i2 < subLayers; i2++) {
+    subProfiles.push(read2(1));
+    subLevels.push(read2(1));
+  }
+  if (subLayers)
+    read2((8 - subLayers) * 2);
+  for (let i2 = 0; i2 < subLayers; i2++) {
+    if (subProfiles[i2]) {
+      read2(32);
+      read2(32);
+      read2(24);
+    }
+    if (subLevels[i2])
+      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 sets = [vps, sps, pps];
+  if (sets.some((set2) => set2.length < 2 || set2.length > 65535))
+    throw new Error("Invalid HEVC parameter set length");
+  const result = new Uint8Array(23 + sets.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;
+  sets.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, b) => b ? gcd(b, a % b) : 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 x = Math.PI * distance * cutoff;
+        const sinc = Math.abs(x) < 1e-12 ? 1 : Math.sin(x) / x;
+        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, b) => a + b, 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 i2 = 0; i2 < weights.length; i2++) {
+          const frame = center - this.radius + 1 + i2;
+          if (frame >= 0 && frame < this.inputFrames)
+            value += this.buffer[(frame - this.bufferStart) * this.channels + channel] * weights[i2];
+        }
+        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 = [];
@@ -31918,32 +32094,21 @@ var alawToS16 = (sample) => {
   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 output = 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++) {
-      output[frame * channels + channel] = input[lower * channels + channel] * (1 - mix) + input[upper * channels + channel] * mix;
-    }
-  }
-  return output;
-}
 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)
@@ -31951,6 +32116,45 @@ var BvrtcRecorder = class {
       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)
@@ -31958,13 +32162,19 @@ var BvrtcRecorder = class {
         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) }
       });
     };
@@ -31980,77 +32190,115 @@ var BvrtcRecorder = class {
       }
       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: (error) => console.error("BVRTC AAC encoder error", error)
-    });
-    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: (error) => console.error("BVRTC AAC encoder error", error)
+        });
+        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) {
@@ -32059,37 +32307,69 @@ var BvrtcRecorder = class {
       const decoded = new Int16Array(encoded.byteLength);
       for (let i2 = 0; i2 < encoded.byteLength; i2++)
         decoded[i2] = alawToS16(encoded[i2]);
-      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);
@@ -33189,7 +33469,8 @@ function CreateCallConnectionManager(params) {
         processHandle.reg(() => __async(this, null, function* () {
           yield callApis.avCall(
             __spreadProps(__spreadValues({}, callInfo), {
-              id: remoteUserId,
+              // 接通前尚未返回远端 ID，取消呼叫时保留原始设备目标。
+              id: remoteUserId || callInfo.id,
               status: 6 /* END */
             }),
             token

package/dist/types/utils/bvrtcRecord.d.ts

@@ -4,6 +4,13 @@ export interface IBvrtcPacket {
     flags: number;
     data: ArrayBuffer;
 }
+export interface IBvrtcPcmPacket {
+    pts: number;
+    data: ArrayBuffer;
+    channels: number;
+    sampleRate: number;
+    format: string;
+}
 interface IBvrtcPlayer {
     getVideoInfo(): {
         codec?: string;
@@ -17,6 +24,7 @@ interface IBvrtcPlayer {
     };
     setVideoCallback(callback: ((packet: IBvrtcPacket) => void) | null): Promise<void>;
     setAudioCallback(callback: ((packet: IBvrtcPacket) => void) | null): Promise<void>;
+    setDecodedAudioCallback?(callback: ((packet: IBvrtcPcmPacket) => void) | null): Promise<void>;
 }
 export declare class BvrtcRecorder {
     private player;
@@ -29,18 +37,34 @@ export declare class BvrtcRecorder {
     private lastAudioPts?;
     private sps?;
     private pps?;
+    private vps?;
+    private hevc;
+    private videoStarted;
     private pendingAudio;
     private transcodeAlaw;
+    private transcodePcm;
+    private pendingPcmAudio;
+    private nextPcmPts?;
+    private pcmResampler?;
+    private pcmChannels;
+    private recordingClockStart;
+    private videoClockOffset;
+    private pcmClockStart?;
+    private pcmClockOffset;
     private audioEncoder?;
     private stopped;
     constructor(player: IBvrtcPlayer, fileName: string);
     start(): Promise<void>;
     private createMuxer;
-    private createAlawEncoder;
+    private createAudioEncoder;
     private normalizePts;
     private onVideo;
     private addAudio;
     private onAudio;
+    private encodePcm;
+    private writePcm;
+    private addPcmAudio;
+    private onPcmAudio;
     stop(onRecordInfo?: IOnMediaRecordHandle): Promise<void>;
 }
 export {};

package/dist/types/utils/hevcRecord.d.ts

@@ -0,0 +1 @@
+export declare function hevcDecoderConfig(vps: Uint8Array, sps: Uint8Array, pps: Uint8Array): Uint8Array;

package/dist/types/utils/pcmResampler.d.ts

@@ -0,0 +1,16 @@
+export declare class PcmResampler {
+    private inputRate;
+    private outputRate;
+    private channels;
+    private readonly radius;
+    private buffer;
+    private bufferStart;
+    private inputFrames;
+    private outputFrames;
+    private readonly phases;
+    constructor(inputRate: number, outputRate: number, channels: number);
+    get pendingSeconds(): number;
+    process(input: Int16Array): Int16Array;
+    flush(): Int16Array;
+    private render;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@besovideo/webrtc-player",
-  "version": "0.10.43",
+  "version": "0.10.44",
   "description": "@besovideo/webrtc-player desc",
   "type": "module",
   "types": "./dist/types/main.d.ts",