ringcentral-softphone 1.3.2 → 1.3.3

package/dist/call-session/index.js

@@ -0,0 +1,244 @@
+import { Buffer } from "node:buffer";
+import dgram from "node:dgram";
+import EventEmitter from "node:events";
+import waitFor from "wait-for-async";
+import { RtpHeader, RtpPacket, SrtpSession } from "werift-rtp";
+import DTMF from "../dtmf.js";
+import {
+  RequestMessage,
+  ResponseMessage
+} from "../sip-message/index.js";
+import { branch, extractAddress, localKey, randomInt } from "../utils.js";
+import Streamer from "./streamer.js";
+class CallSession extends EventEmitter {
+  softphone;
+  sipMessage;
+  socket;
+  localPeer;
+  remotePeer;
+  remoteIP;
+  remotePort;
+  disposed = false;
+  srtpSession;
+  encoder;
+  decoder;
+  sdp;
+  // for audio streaming
+  ssrc = randomInt();
+  sequenceNumber = randomInt();
+  timestamp = randomInt();
+  constructor(softphone, sipMessage) {
+    super();
+    this.softphone = softphone;
+    this.encoder = softphone.codec.createEncoder();
+    this.decoder = softphone.codec.createDecoder();
+    this.sipMessage = sipMessage;
+    if (this.sipMessage.body.length > 0) {
+      this.remoteIP = this.sipMessage.body.match(/c=IN IP4 ([\d.]+)/)[1];
+      this.remotePort = parseInt(
+        this.sipMessage.body.match(/m=audio (\d+) /)[1],
+        10
+      );
+    }
+  }
+  set remoteKey(key) {
+    const localKeyBuffer = Buffer.from(localKey, "base64");
+    const remoteKeyBuffer = Buffer.from(key, "base64");
+    this.srtpSession = new SrtpSession({
+      profile: 1,
+      keys: {
+        localMasterKey: localKeyBuffer.subarray(0, 16),
+        localMasterSalt: localKeyBuffer.subarray(16, 30),
+        remoteMasterKey: remoteKeyBuffer.subarray(0, 16),
+        remoteMasterSalt: remoteKeyBuffer.subarray(16, 30)
+      }
+    });
+  }
+  get callId() {
+    return this.sipMessage.getHeader("Call-ID");
+  }
+  send(data) {
+    this.socket.send(data, this.remotePort, this.remoteIP);
+  }
+  async hangup() {
+    const requestMessage = new RequestMessage(
+      `BYE sip:${this.softphone.sipInfo.domain} SIP/2.0`,
+      {
+        "Call-ID": this.callId,
+        From: this.localPeer,
+        To: this.remotePeer,
+        Via: `SIP/2.0/TLS ${this.softphone.fakeDomain};branch=${branch()}`
+      }
+    );
+    await this.softphone.send(requestMessage);
+  }
+  sendDTMF(char) {
+    const payloads = DTMF.charToPayloads(char);
+    const timestamp = this.timestamp;
+    let first = true;
+    for (const payload of payloads) {
+      const rtpHeader = new RtpHeader({
+        version: 2,
+        padding: false,
+        paddingSize: 0,
+        extension: false,
+        marker: first,
+        payloadOffset: 12,
+        payloadType: 101,
+        sequenceNumber: this.sequenceNumber,
+        timestamp,
+        ssrc: this.ssrc,
+        csrcLength: 0,
+        csrc: [],
+        extensionProfile: 48862,
+        extensionLength: void 0,
+        extensions: []
+      });
+      const rtpPacket = new RtpPacket(rtpHeader, payload);
+      this.send(this.srtpSession.encrypt(rtpPacket.payload, rtpPacket.header));
+      this.sequenceNumber = (this.sequenceNumber + 1) % 65536;
+      first = false;
+    }
+    this.timestamp += 800;
+  }
+  async sendDTMFs(s, delay = 500) {
+    for (const c of s) {
+      this.sendDTMF(c);
+      await waitFor({ interval: delay });
+    }
+  }
+  // buffer is the content of a audio file, it is supposed to be uncompressed PCM data
+  // The audio should be playable by command: play -t raw -b 16 -r 16000 -e signed-integer test.wav
+  streamAudio(input) {
+    const streamer = new Streamer(this, input);
+    streamer.start();
+    return streamer;
+  }
+  // send a single rtp packet
+  sendPacket(rtpPacket) {
+    if (this.disposed) {
+      return;
+    }
+    this.send(this.srtpSession.encrypt(rtpPacket.payload, rtpPacket.header));
+  }
+  startLocalServices() {
+    this.socket = dgram.createSocket("udp4");
+    this.socket.on("message", (message) => {
+      const rtpPacket = RtpPacket.deSerialize(
+        this.srtpSession.decrypt(message)
+      );
+      this.emit("rtpPacket", rtpPacket);
+      if (rtpPacket.header.payloadType === 101) {
+        this.emit("dtmfPacket", rtpPacket);
+        const char = DTMF.payloadToChar(rtpPacket.payload);
+        if (char) {
+          this.emit("dtmf", char);
+        }
+      } else if (rtpPacket.header.payloadType === this.softphone.codec.id) {
+        if (rtpPacket.payload.length === 4 && rtpPacket.payload[0] >= 0 && rtpPacket.payload[0] < 12 && rtpPacket.payload[1] === 138 && rtpPacket.payload[2] === 3 && rtpPacket.payload[3] === 192) {
+          return;
+        }
+        try {
+          rtpPacket.payload = this.decoder.decode(rtpPacket.payload);
+          this.emit("audioPacket", rtpPacket);
+        } catch {
+          console.error("Audio packet decode failed", rtpPacket);
+        }
+      }
+    });
+    this.socket.bind();
+    this.send("hello");
+    const byeHandler = (inboundMessage) => {
+      if (inboundMessage.getHeader("Call-ID") !== this.callId) {
+        return;
+      }
+      if (inboundMessage.headers.CSeq.endsWith(" BYE")) {
+        this.softphone.off("message", byeHandler);
+        this.dispose();
+      }
+    };
+    this.softphone.on("message", byeHandler);
+  }
+  dispose() {
+    this.disposed = true;
+    this.emit("disposed");
+    this.removeAllListeners();
+    this.socket?.removeAllListeners();
+    this.socket?.close();
+  }
+  async transfer(transferTo) {
+    const requestMessage = new RequestMessage(
+      `REFER sip:${this.softphone.sipInfo.username}@${this.softphone.sipInfo.outboundProxy};transport=tls SIP/2.0`,
+      {
+        Via: `SIP/2.0/TLS ${this.softphone.client.localAddress}:${this.softphone.client.localPort};rport;branch=${branch()};alias`,
+        "Max-Forwards": 70,
+        From: this.localPeer,
+        To: this.remotePeer,
+        Contact: `<sip:${this.softphone.sipInfo.username}@${this.softphone.client.localAddress}:${this.softphone.client.localPort};transport=TLS;ob>`,
+        "Call-ID": this.callId,
+        Event: "refer",
+        Expires: 600,
+        Supported: "replaces, 100rel, timer, norefersub",
+        Accept: "message/sipfrag;version=2.0",
+        "Allow-Events": "presence, message-summary, refer",
+        "Refer-To": `sip:${transferTo}@${this.softphone.sipInfo.domain}`,
+        "Referred-By": `<sip:${this.softphone.sipInfo.username}@${this.softphone.sipInfo.domain}>`
+      }
+    );
+    await this.softphone.send(requestMessage);
+    return new Promise((resolve) => {
+      const notifyHandler = (inboundMessage) => {
+        if (!inboundMessage.subject.startsWith("NOTIFY ")) {
+          return;
+        }
+        const responseMessage = new ResponseMessage(inboundMessage, 200);
+        this.softphone.send(responseMessage);
+        if (inboundMessage.body.trim() === "SIP/2.0 200 OK") {
+          this.softphone.off("message", notifyHandler);
+          resolve();
+        }
+      };
+      this.softphone.on("message", notifyHandler);
+    });
+  }
+  async toggleReceive(toReceive) {
+    let newSDP = this.sdp;
+    if (!toReceive) {
+      newSDP = newSDP.replace(/a=sendrecv/, "a=sendonly");
+    }
+    const requestMessage = new RequestMessage(
+      `INVITE ${extractAddress(this.remotePeer)} SIP/2.0`,
+      {
+        "Call-Id": this.callId,
+        From: this.localPeer,
+        To: this.remotePeer,
+        Via: `SIP/2.0/TLS ${this.softphone.client.localAddress}:${this.softphone.client.localPort};rport;branch=${branch()};alias`,
+        "Content-Type": "application/sdp",
+        Contact: ` <sip:${this.softphone.sipInfo.username}@${this.softphone.client.localAddress}:${this.softphone.client.localPort};transport=TLS;ob>`
+      },
+      newSDP
+    );
+    const replyMessage = await this.softphone.send(requestMessage, true);
+    const ackMessage = new RequestMessage(
+      `ACK ${extractAddress(this.remotePeer)} SIP/2.0`,
+      {
+        "Call-Id": this.callId,
+        From: this.localPeer,
+        To: this.remotePeer,
+        Via: replyMessage.headers.Via,
+        CSeq: replyMessage.headers.CSeq.replace(" INVITE", " ACK")
+      }
+    );
+    await this.softphone.send(ackMessage);
+  }
+  async hold() {
+    return this.toggleReceive(false);
+  }
+  async unhold() {
+    return this.toggleReceive(true);
+  }
+}
+var call_session_default = CallSession;
+export {
+  call_session_default as default
+};

package/dist/call-session/outbound.cjs

@@ -0,0 +1,100 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var outbound_exports = {};
+__export(outbound_exports, {
+  default: () => outbound_default
+});
+module.exports = __toCommonJS(outbound_exports);
+var import_sip_message = require("../sip-message/index.js");
+var import_utils = require("../utils.js");
+var import_index = __toESM(require("./index.js"), 1);
+class OutboundCallSession extends import_index.default {
+  constructor(softphone, answerMessage) {
+    super(softphone, answerMessage);
+    this.localPeer = answerMessage.headers.From;
+    this.remotePeer = answerMessage.headers.To;
+    this.remoteKey = answerMessage.body.match(
+      /AES_CM_128_HMAC_SHA1_80 inline:([\w+/]+)/
+    )[1];
+    this.init();
+  }
+  init() {
+    const answerHandler = (message) => {
+      if (message.headers.CSeq !== this.sipMessage.headers.CSeq) {
+        return;
+      }
+      if (message.subject.startsWith("SIP/2.0 486")) {
+        this.softphone.off("message", answerHandler);
+        this.emit("busy");
+        this.dispose();
+        return;
+      }
+      if (message.subject.startsWith("SIP/2.0 200")) {
+        this.softphone.off("message", answerHandler);
+        this.emit("answered");
+        const ackMessage = new import_sip_message.RequestMessage(
+          `ACK ${(0, import_utils.extractAddress)(this.remotePeer)} SIP/2.0`,
+          {
+            "Call-ID": this.callId,
+            From: this.localPeer,
+            To: this.remotePeer,
+            Via: this.sipMessage.headers.Via,
+            CSeq: this.sipMessage.headers.CSeq.replace(" INVITE", " ACK")
+          }
+        );
+        this.softphone.send(ackMessage);
+      }
+    };
+    this.softphone.on("message", answerHandler);
+    this.once("answered", () => this.startLocalServices());
+  }
+  async cancel() {
+    const requestMessage = new import_sip_message.RequestMessage(
+      `CANCEL ${(0, import_utils.extractAddress)(this.remotePeer)} SIP/2.0`,
+      {
+        "Call-ID": this.callId,
+        From: this.localPeer,
+        To: (0, import_utils.withoutTag)(this.remotePeer),
+        Via: this.sipMessage.headers.Via,
+        CSeq: this.sipMessage.headers.CSeq.replace(" INVITE", " CANCEL")
+      }
+    );
+    await this.softphone.send(requestMessage);
+  }
+  get sessionId() {
+    const header = this.sipMessage.headers["p-rc-api-ids"];
+    const match = header.match(/party-id=([^;]+);session-id=([^;]+)/);
+    return match[2];
+  }
+  get partyId() {
+    const header = this.sipMessage.headers["p-rc-api-ids"];
+    const match = header.match(/party-id=([^;]+);session-id=([^;]+)/);
+    return match[1];
+  }
+}
+var outbound_default = OutboundCallSession;

package/dist/call-session/outbound.js

@@ -0,0 +1,71 @@
+import { RequestMessage } from "../sip-message/index.js";
+import { extractAddress, withoutTag } from "../utils.js";
+import CallSession from "./index.js";
+class OutboundCallSession extends CallSession {
+  constructor(softphone, answerMessage) {
+    super(softphone, answerMessage);
+    this.localPeer = answerMessage.headers.From;
+    this.remotePeer = answerMessage.headers.To;
+    this.remoteKey = answerMessage.body.match(
+      /AES_CM_128_HMAC_SHA1_80 inline:([\w+/]+)/
+    )[1];
+    this.init();
+  }
+  init() {
+    const answerHandler = (message) => {
+      if (message.headers.CSeq !== this.sipMessage.headers.CSeq) {
+        return;
+      }
+      if (message.subject.startsWith("SIP/2.0 486")) {
+        this.softphone.off("message", answerHandler);
+        this.emit("busy");
+        this.dispose();
+        return;
+      }
+      if (message.subject.startsWith("SIP/2.0 200")) {
+        this.softphone.off("message", answerHandler);
+        this.emit("answered");
+        const ackMessage = new RequestMessage(
+          `ACK ${extractAddress(this.remotePeer)} SIP/2.0`,
+          {
+            "Call-ID": this.callId,
+            From: this.localPeer,
+            To: this.remotePeer,
+            Via: this.sipMessage.headers.Via,
+            CSeq: this.sipMessage.headers.CSeq.replace(" INVITE", " ACK")
+          }
+        );
+        this.softphone.send(ackMessage);
+      }
+    };
+    this.softphone.on("message", answerHandler);
+    this.once("answered", () => this.startLocalServices());
+  }
+  async cancel() {
+    const requestMessage = new RequestMessage(
+      `CANCEL ${extractAddress(this.remotePeer)} SIP/2.0`,
+      {
+        "Call-ID": this.callId,
+        From: this.localPeer,
+        To: withoutTag(this.remotePeer),
+        Via: this.sipMessage.headers.Via,
+        CSeq: this.sipMessage.headers.CSeq.replace(" INVITE", " CANCEL")
+      }
+    );
+    await this.softphone.send(requestMessage);
+  }
+  get sessionId() {
+    const header = this.sipMessage.headers["p-rc-api-ids"];
+    const match = header.match(/party-id=([^;]+);session-id=([^;]+)/);
+    return match[2];
+  }
+  get partyId() {
+    const header = this.sipMessage.headers["p-rc-api-ids"];
+    const match = header.match(/party-id=([^;]+);session-id=([^;]+)/);
+    return match[1];
+  }
+}
+var outbound_default = OutboundCallSession;
+export {
+  outbound_default as default
+};

package/dist/call-session/streamer.cjs

@@ -0,0 +1,112 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var streamer_exports = {};
+__export(streamer_exports, {
+  default: () => streamer_default
+});
+module.exports = __toCommonJS(streamer_exports);
+var import_node_buffer = require("node:buffer");
+var import_node_events = __toESM(require("node:events"), 1);
+var import_werift_rtp = require("werift-rtp");
+class Streamer extends import_node_events.default {
+  paused = false;
+  callSession;
+  buffer;
+  originalBuffer;
+  constructor(callSesstion, buffer) {
+    super();
+    this.callSession = callSesstion;
+    this.buffer = buffer;
+    this.originalBuffer = buffer;
+  }
+  start() {
+    this.buffer = this.originalBuffer;
+    this.paused = false;
+    this.sendPacket();
+  }
+  stop() {
+    this.buffer = import_node_buffer.Buffer.alloc(0);
+  }
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+    this.sendPacket();
+  }
+  get finished() {
+    return this.callSession.disposed || this.buffer.length < this.callSession.softphone.codec.packetSize;
+  }
+  sendPacket() {
+    if (!this.paused && !this.finished) {
+      const temp = this.callSession.encoder.encode(
+        this.buffer.subarray(0, this.callSession.softphone.codec.packetSize)
+      );
+      const rtpPacket = new import_werift_rtp.RtpPacket(
+        new import_werift_rtp.RtpHeader({
+          version: 2,
+          padding: false,
+          paddingSize: 0,
+          extension: false,
+          marker: false,
+          payloadOffset: 12,
+          payloadType: this.callSession.softphone.codec.id,
+          sequenceNumber: this.callSession.sequenceNumber,
+          timestamp: this.callSession.timestamp,
+          ssrc: this.callSession.ssrc,
+          csrcLength: 0,
+          csrc: [],
+          extensionProfile: 48862,
+          extensionLength: void 0,
+          extensions: []
+        }),
+        temp
+      );
+      this.callSession.send(
+        this.callSession.srtpSession.encrypt(
+          rtpPacket.payload,
+          rtpPacket.header
+        )
+      );
+      this.callSession.sequenceNumber += 1;
+      if (this.callSession.sequenceNumber > 65535) {
+        this.callSession.sequenceNumber = 0;
+      }
+      this.callSession.timestamp += this.callSession.softphone.codec.timestampInterval;
+      this.buffer = this.buffer.subarray(
+        this.callSession.softphone.codec.packetSize
+      );
+      if (this.finished) {
+        this.emit("finished");
+      } else {
+        setTimeout(() => this.sendPacket(), 20);
+      }
+    }
+  }
+}
+var streamer_default = Streamer;

package/dist/call-session/streamer.js

@@ -0,0 +1,83 @@
+import { Buffer } from "node:buffer";
+import EventEmitter from "node:events";
+import { RtpHeader, RtpPacket } from "werift-rtp";
+class Streamer extends EventEmitter {
+  paused = false;
+  callSession;
+  buffer;
+  originalBuffer;
+  constructor(callSesstion, buffer) {
+    super();
+    this.callSession = callSesstion;
+    this.buffer = buffer;
+    this.originalBuffer = buffer;
+  }
+  start() {
+    this.buffer = this.originalBuffer;
+    this.paused = false;
+    this.sendPacket();
+  }
+  stop() {
+    this.buffer = Buffer.alloc(0);
+  }
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+    this.sendPacket();
+  }
+  get finished() {
+    return this.callSession.disposed || this.buffer.length < this.callSession.softphone.codec.packetSize;
+  }
+  sendPacket() {
+    if (!this.paused && !this.finished) {
+      const temp = this.callSession.encoder.encode(
+        this.buffer.subarray(0, this.callSession.softphone.codec.packetSize)
+      );
+      const rtpPacket = new RtpPacket(
+        new RtpHeader({
+          version: 2,
+          padding: false,
+          paddingSize: 0,
+          extension: false,
+          marker: false,
+          payloadOffset: 12,
+          payloadType: this.callSession.softphone.codec.id,
+          sequenceNumber: this.callSession.sequenceNumber,
+          timestamp: this.callSession.timestamp,
+          ssrc: this.callSession.ssrc,
+          csrcLength: 0,
+          csrc: [],
+          extensionProfile: 48862,
+          extensionLength: void 0,
+          extensions: []
+        }),
+        temp
+      );
+      this.callSession.send(
+        this.callSession.srtpSession.encrypt(
+          rtpPacket.payload,
+          rtpPacket.header
+        )
+      );
+      this.callSession.sequenceNumber += 1;
+      if (this.callSession.sequenceNumber > 65535) {
+        this.callSession.sequenceNumber = 0;
+      }
+      this.callSession.timestamp += this.callSession.softphone.codec.timestampInterval;
+      this.buffer = this.buffer.subarray(
+        this.callSession.softphone.codec.packetSize
+      );
+      if (this.finished) {
+        this.emit("finished");
+      } else {
+        setTimeout(() => this.sendPacket(), 20);
+      }
+    }
+  }
+}
+var streamer_default = Streamer;
+export {
+  streamer_default as default
+};

package/dist/codec.cjs

@@ -0,0 +1,85 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var codec_exports = {};
+__export(codec_exports, {
+  default: () => codec_default
+});
+module.exports = __toCommonJS(codec_exports);
+var import_node_buffer = require("node:buffer");
+var import_opus = require("@evan/opus");
+class Codec {
+  id;
+  name;
+  packetSize;
+  timestampInterval;
+  createEncoder;
+  createDecoder;
+  constructor(name) {
+    this.name = name;
+    switch (name) {
+      case "OPUS/16000": {
+        this.createEncoder = () => {
+          const encoder = new import_opus.Encoder({ channels: 1, sample_rate: 16e3 });
+          return { encode: (pcm) => import_node_buffer.Buffer.from(encoder.encode(pcm)) };
+        };
+        this.createDecoder = () => {
+          const decoder = new import_opus.Decoder({ channels: 1, sample_rate: 16e3 });
+          return {
+            decode: (opus) => import_node_buffer.Buffer.from(decoder.decode(opus))
+          };
+        };
+        this.id = 109;
+        this.packetSize = 640;
+        this.timestampInterval = 320;
+        break;
+      }
+      case "OPUS/48000/2": {
+        this.createEncoder = () => {
+          const encoder = new import_opus.Encoder({ channels: 2, sample_rate: 48e3 });
+          return { encode: (pcm) => import_node_buffer.Buffer.from(encoder.encode(pcm)) };
+        };
+        this.createDecoder = () => {
+          const decoder = new import_opus.Decoder({ channels: 2, sample_rate: 48e3 });
+          return {
+            decode: (opus) => import_node_buffer.Buffer.from(decoder.decode(opus))
+          };
+        };
+        this.id = 111;
+        this.packetSize = 3840;
+        this.timestampInterval = 960;
+        break;
+      }
+      case "PCMU/8000": {
+        this.createEncoder = () => {
+          return { encode: (pcm) => pcm };
+        };
+        this.createDecoder = () => {
+          return { decode: (audio) => audio };
+        };
+        this.id = 0;
+        this.packetSize = 160;
+        this.timestampInterval = 160;
+        break;
+      }
+      default: {
+        throw new Error(`unsupported codec: ${name}`);
+      }
+    }
+  }
+}
+var codec_default = Codec;