@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/peer/RtpPacket.d.ts

@@ -0,0 +1,112 @@
+import { RtpPacket as EngineRtpPacket } from '../lib/rtp/rtp/rtp.js';
+/**
+ * The fields of an {@link RtpPacket}.
+ */
+export interface RtpPacketInit {
+    /**
+     * The payload type: the codec of the payload, as the description numbers it.
+     */
+    payloadType: number;
+    /**
+     * The sequence number, from 0 to 65535, one more for each packet.
+     */
+    sequenceNumber: number;
+    /**
+     * The timestamp, in the units of the clock rate of the codec (90000 per second for the video, 48000 for Opus).
+     */
+    timestamp: number;
+    /**
+     * The synchronization source: the id of the stream of packets.
+     * @default 0
+     */
+    ssrc?: number;
+    /**
+     * The marker: set on the last packet of a video frame.
+     * @default false
+     */
+    marker?: boolean;
+    /**
+     * The payload: a piece of encoded audio or video.
+     */
+    payload: Uint8Array;
+}
+/**
+ * An RTP packet: a piece of encoded audio or video, with the fields of its header the applications use. The packets of
+ * a received {@link MediaTrack} come as these (its `rtp` event); a track to send takes these or the bytes of RTP
+ * packets (`writeRtp()`), such as the ones an encoder like ffmpeg or GStreamer sends to a UDP port.
+ * @example
+ * ```typescript
+ * import {RtpPacket} from '@lakutata/webrtc'
+ *
+ * declare const datagram: Buffer
+ * //A packet read from the bytes an encoder sent
+ * const packet: RtpPacket = RtpPacket.parse(datagram)
+ * console.log(packet.payloadType, packet.sequenceNumber, packet.marker)
+ * ```
+ */
+export declare class RtpPacket {
+    /**
+     * The payload type: the codec of the payload, as the description numbers it.
+     */
+    payloadType: number;
+    /**
+     * The sequence number, from 0 to 65535, one more for each packet.
+     */
+    sequenceNumber: number;
+    /**
+     * The timestamp, in the units of the clock rate of the codec.
+     */
+    timestamp: number;
+    /**
+     * The synchronization source: the id of the stream of packets.
+     */
+    ssrc: number;
+    /**
+     * The marker: set on the last packet of a video frame.
+     */
+    marker: boolean;
+    /**
+     * The payload: a piece of encoded audio or video.
+     */
+    payload: Buffer;
+    /**
+     * Create a packet.
+     * @param init The fields of the packet.
+     */
+    constructor(init: RtpPacketInit);
+    /**
+     * Read a packet from its bytes (its header extensions and contributing sources are left out).
+     * @param data The bytes of an RTP packet.
+     * @returns The packet.
+     * @example
+     * ```typescript
+     * import {RtpPacket} from '@lakutata/webrtc'
+     *
+     * declare const datagram: Buffer
+     * const packet: RtpPacket = RtpPacket.parse(datagram)
+     * ```
+     */
+    static parse(data: Uint8Array): RtpPacket;
+    /**
+     * The bytes of the packet.
+     * @returns The bytes.
+     * @example
+     * ```typescript
+     * import {RtpPacket} from '@lakutata/webrtc'
+     *
+     * const packet: RtpPacket = new RtpPacket({payloadType: 96, sequenceNumber: 1, timestamp: 3000, payload: Buffer.from([0x10])})
+     * const bytes: Buffer = packet.toBuffer()
+     * ```
+     */
+    toBuffer(): Buffer;
+}
+/**
+ * The packet of a packet of the engine
+ * @param packet
+ */
+export declare function rtpPacketOf(packet: EngineRtpPacket): RtpPacket;
+/**
+ * The packet of the engine of a packet
+ * @param packet
+ */
+export declare function enginePacketOf(packet: RtpPacket): EngineRtpPacket;

package/dist/cjs/peer/RtpPacket.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RtpPacket = void 0;
+exports.rtpPacketOf = rtpPacketOf;
+exports.enginePacketOf = enginePacketOf;
+const rtp_js_1 = require("../lib/rtp/rtp/rtp.js");
+/**
+ * An RTP packet: a piece of encoded audio or video, with the fields of its header the applications use. The packets of
+ * a received {@link MediaTrack} come as these (its `rtp` event); a track to send takes these or the bytes of RTP
+ * packets (`writeRtp()`), such as the ones an encoder like ffmpeg or GStreamer sends to a UDP port.
+ * @example
+ * ```typescript
+ * import {RtpPacket} from '@lakutata/webrtc'
+ *
+ * declare const datagram: Buffer
+ * //A packet read from the bytes an encoder sent
+ * const packet: RtpPacket = RtpPacket.parse(datagram)
+ * console.log(packet.payloadType, packet.sequenceNumber, packet.marker)
+ * ```
+ */
+class RtpPacket {
+    /**
+     * Create a packet.
+     * @param init The fields of the packet.
+     */
+    constructor(init) {
+        this.payloadType = init.payloadType;
+        this.sequenceNumber = init.sequenceNumber;
+        this.timestamp = init.timestamp;
+        this.ssrc = init.ssrc ?? 0;
+        this.marker = init.marker ?? false;
+        this.payload = Buffer.isBuffer(init.payload) ? init.payload : Buffer.from(init.payload.buffer, init.payload.byteOffset, init.payload.byteLength);
+    }
+    /**
+     * Read a packet from its bytes (its header extensions and contributing sources are left out).
+     * @param data The bytes of an RTP packet.
+     * @returns The packet.
+     * @example
+     * ```typescript
+     * import {RtpPacket} from '@lakutata/webrtc'
+     *
+     * declare const datagram: Buffer
+     * const packet: RtpPacket = RtpPacket.parse(datagram)
+     * ```
+     */
+    static parse(data) {
+        return rtpPacketOf(rtp_js_1.RtpPacket.deSerialize(Buffer.isBuffer(data) ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength)));
+    }
+    /**
+     * The bytes of the packet.
+     * @returns The bytes.
+     * @example
+     * ```typescript
+     * import {RtpPacket} from '@lakutata/webrtc'
+     *
+     * const packet: RtpPacket = new RtpPacket({payloadType: 96, sequenceNumber: 1, timestamp: 3000, payload: Buffer.from([0x10])})
+     * const bytes: Buffer = packet.toBuffer()
+     * ```
+     */
+    toBuffer() {
+        return enginePacketOf(this).serialize();
+    }
+}
+exports.RtpPacket = RtpPacket;
+/**
+ * The packet of a packet of the engine
+ * @param packet
+ */
+function rtpPacketOf(packet) {
+    const { header } = packet;
+    return new RtpPacket({
+        payloadType: header.payloadType,
+        sequenceNumber: header.sequenceNumber,
+        timestamp: header.timestamp,
+        ssrc: header.ssrc,
+        marker: header.marker,
+        payload: packet.payload
+    });
+}
+/**
+ * The packet of the engine of a packet
+ * @param packet
+ */
+function enginePacketOf(packet) {
+    return new rtp_js_1.RtpPacket(new rtp_js_1.RtpHeader({
+        payloadType: packet.payloadType,
+        sequenceNumber: packet.sequenceNumber,
+        timestamp: packet.timestamp,
+        ssrc: packet.ssrc,
+        marker: packet.marker
+    }), packet.payload);
+}

package/dist/cjs/peer/RtpTransceiver.d.ts

@@ -0,0 +1,167 @@
+import type { RTCRtpReceiver } from '../lib/peer/media/rtpReceiver.js';
+import type { RTCRtpSender } from '../lib/peer/media/rtpSender.js';
+import type { RTCRtpTransceiver } from '../lib/peer/media/rtpTransceiver.js';
+import { type MediaKind, MediaTrack } from './MediaTrack.js';
+/**
+ * The direction of a {@link RtpTransceiver}: `sendrecv`, `sendonly`, `recvonly` or `inactive`.
+ */
+export type RtpTransceiverDirection = 'sendrecv' | 'sendonly' | 'recvonly' | 'inactive';
+/**
+ * The sending side of a {@link RtpTransceiver}, as `RTCRtpSender`: the track it sends.
+ * @example
+ * ```typescript
+ * import {MediaTrack, type PeerConnection, type RtpSender} from '@lakutata/webrtc'
+ *
+ * declare const connection: PeerConnection
+ * const sender: RtpSender = connection.addTrack(new MediaTrack('audio', {codec: 'audio/opus'}))
+ * //Send another source, without negotiating again
+ * await sender.replaceTrack(new MediaTrack('audio', {codec: 'audio/opus'}))
+ * ```
+ */
+export declare class RtpSender {
+    #private;
+    /**
+     * Wrap a sender of the engine
+     * @param sender
+     * @internal
+     */
+    constructor(sender: RTCRtpSender);
+    /**
+     * The track sent; `null` when none.
+     */
+    get track(): MediaTrack | null;
+    /**
+     * Send another track, of any codec negotiated (the other peer accepts each of them), without negotiating again;
+     * `null` stops sending.
+     * @param track The track, or `null`.
+     * @returns Resolves once replaced.
+     * @throws {DOMException} When the codec of the track is none of the ones negotiated (`InvalidModificationError`).
+     * @example
+     * ```typescript
+     * import type {MediaTrack, RtpSender} from '@lakutata/webrtc'
+     *
+     * declare const sender: RtpSender
+     * declare const backup: MediaTrack
+     * await sender.replaceTrack(backup)
+     * ```
+     */
+    replaceTrack(track: MediaTrack | null): Promise<void>;
+    /**
+     * Change the streams the track sent belongs to, as `RTCRtpSender.setStreams()`: the other peer groups the tracks of
+     * a stream. A new negotiation is needed.
+     * @param streamIds The ids of the streams.
+     * @example
+     * ```typescript
+     * import type {RtpSender} from '@lakutata/webrtc'
+     *
+     * declare const sender: RtpSender
+     * sender.setStreams('screen')
+     * ```
+     */
+    setStreams(...streamIds: string[]): void;
+}
+/**
+ * The receiving side of a {@link RtpTransceiver}, as `RTCRtpReceiver`: the track it receives.
+ * @example
+ * ```typescript
+ * import type {MediaTrack, PeerConnection, RtpReceiver} from '@lakutata/webrtc'
+ *
+ * declare const connection: PeerConnection
+ * const tracks: MediaTrack[] = connection.getReceivers().map((receiver: RtpReceiver): MediaTrack => receiver.track)
+ * ```
+ */
+export declare class RtpReceiver {
+    #private;
+    /**
+     * Wrap a receiver of the engine
+     * @param receiver
+     * @internal
+     */
+    constructor(receiver: RTCRtpReceiver);
+    /**
+     * The track received.
+     */
+    get track(): MediaTrack;
+}
+/**
+ * An audio or video line of a {@link PeerConnection}, as `RTCRtpTransceiver`: a sender and a receiver, and the
+ * direction the media goes. `addTrack()` creates one (or reuses one the other peer offered), `addTransceiver()` creates
+ * one of a given direction: `recvonly` to receive without sending.
+ * @example
+ * ```typescript
+ * import type {PeerConnection, RtpTransceiver} from '@lakutata/webrtc'
+ *
+ * declare const connection: PeerConnection
+ * //Receive the video of the other peer, send none
+ * const transceiver: RtpTransceiver = connection.addTransceiver('video', {direction: 'recvonly'})
+ * ```
+ */
+export declare class RtpTransceiver {
+    #private;
+    /**
+     * Wrap a transceiver of the engine
+     * @param transceiver
+     * @internal
+     */
+    constructor(transceiver: RTCRtpTransceiver);
+    /**
+     * The media id of its line in the description; `null` until negotiated.
+     */
+    get mid(): string | null;
+    /**
+     * `audio` or `video`.
+     */
+    get kind(): MediaKind;
+    /**
+     * The direction wanted; changing it makes the connection negotiate.
+     */
+    get direction(): RtpTransceiverDirection;
+    /**
+     * Change the direction wanted.
+     * @param direction The direction.
+     */
+    set direction(direction: RtpTransceiverDirection);
+    /**
+     * The direction negotiated, `stopped` once stopped; `null` until negotiated.
+     */
+    get currentDirection(): RtpTransceiverDirection | 'stopped' | null;
+    /**
+     * The sending side.
+     */
+    get sender(): RtpSender;
+    /**
+     * The receiving side.
+     */
+    get receiver(): RtpReceiver;
+    /**
+     * Stop the transceiver: it sends and receives no more, and the connection negotiates.
+     * @example
+     * ```typescript
+     * import type {RtpTransceiver} from '@lakutata/webrtc'
+     *
+     * declare const transceiver: RtpTransceiver
+     * transceiver.stop()
+     * ```
+     */
+    stop(): void;
+}
+/**
+ * The sender of a sender of the engine, created once
+ * @param sender
+ */
+export declare function senderOf(sender: RTCRtpSender): RtpSender;
+/**
+ * The sender of the engine of a sender
+ * @param sender
+ */
+export declare function engineSenderOf(sender: RtpSender): RTCRtpSender;
+/**
+ * The receiver of a receiver of the engine, created once
+ * @param receiver
+ */
+export declare function receiverOf(receiver: RTCRtpReceiver): RtpReceiver;
+/**
+ * The transceiver of a transceiver of the engine, created once
+ * @param transceiver
+ */
+export declare function transceiverOf(transceiver: RTCRtpTransceiver): RtpTransceiver;

package/dist/cjs/peer/RtpTransceiver.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RtpTransceiver = exports.RtpReceiver = exports.RtpSender = void 0;
+exports.senderOf = senderOf;
+exports.engineSenderOf = engineSenderOf;
+exports.receiverOf = receiverOf;
+exports.transceiverOf = transceiverOf;
+const track_js_1 = require("../lib/peer/media/track.js");
+const MediaTrack_js_1 = require("./MediaTrack.js");
+/**
+ * The senders of the engine of the senders
+ */
+const engineSenders = new WeakMap();
+/**
+ * The sending side of a {@link RtpTransceiver}, as `RTCRtpSender`: the track it sends.
+ * @example
+ * ```typescript
+ * import {MediaTrack, type PeerConnection, type RtpSender} from '@lakutata/webrtc'
+ *
+ * declare const connection: PeerConnection
+ * const sender: RtpSender = connection.addTrack(new MediaTrack('audio', {codec: 'audio/opus'}))
+ * //Send another source, without negotiating again
+ * await sender.replaceTrack(new MediaTrack('audio', {codec: 'audio/opus'}))
+ * ```
+ */
+class RtpSender {
+    #sender;
+    /**
+     * Wrap a sender of the engine
+     * @param sender
+     * @internal
+     */
+    constructor(sender) {
+        this.#sender = sender;
+        engineSenders.set(this, sender);
+    }
+    /**
+     * The track sent; `null` when none.
+     */
+    get track() {
+        return this.#sender.track ? (0, MediaTrack_js_1.trackOf)(this.#sender.track) : null;
+    }
+    /**
+     * Send another track, of any codec negotiated (the other peer accepts each of them), without negotiating again;
+     * `null` stops sending.
+     * @param track The track, or `null`.
+     * @returns Resolves once replaced.
+     * @throws {DOMException} When the codec of the track is none of the ones negotiated (`InvalidModificationError`).
+     * @example
+     * ```typescript
+     * import type {MediaTrack, RtpSender} from '@lakutata/webrtc'
+     *
+     * declare const sender: RtpSender
+     * declare const backup: MediaTrack
+     * await sender.replaceTrack(backup)
+     * ```
+     */
+    async replaceTrack(track) {
+        await this.#sender.replaceTrack(track ? (0, MediaTrack_js_1.engineTrackOf)(track) : null);
+    }
+    /**
+     * Change the streams the track sent belongs to, as `RTCRtpSender.setStreams()`: the other peer groups the tracks of
+     * a stream. A new negotiation is needed.
+     * @param streamIds The ids of the streams.
+     * @example
+     * ```typescript
+     * import type {RtpSender} from '@lakutata/webrtc'
+     *
+     * declare const sender: RtpSender
+     * sender.setStreams('screen')
+     * ```
+     */
+    setStreams(...streamIds) {
+        this.#sender.setStreams(streamIds.map((id) => new track_js_1.MediaStream({ id: id })));
+    }
+}
+exports.RtpSender = RtpSender;
+/**
+ * The receiving side of a {@link RtpTransceiver}, as `RTCRtpReceiver`: the track it receives.
+ * @example
+ * ```typescript
+ * import type {MediaTrack, PeerConnection, RtpReceiver} from '@lakutata/webrtc'
+ *
+ * declare const connection: PeerConnection
+ * const tracks: MediaTrack[] = connection.getReceivers().map((receiver: RtpReceiver): MediaTrack => receiver.track)
+ * ```
+ */
+class RtpReceiver {
+    #receiver;
+    /**
+     * Wrap a receiver of the engine
+     * @param receiver
+     * @internal
+     */
+    constructor(receiver) {
+        this.#receiver = receiver;
+    }
+    /**
+     * The track received.
+     */
+    get track() {
+        return (0, MediaTrack_js_1.trackOf)(this.#receiver.track, this.#receiver);
+    }
+}
+exports.RtpReceiver = RtpReceiver;
+/**
+ * The senders, receivers and transceivers of the ones of the engine
+ */
+const senders = new WeakMap();
+const receivers = new WeakMap();
+const transceivers = new WeakMap();
+/**
+ * An audio or video line of a {@link PeerConnection}, as `RTCRtpTransceiver`: a sender and a receiver, and the
+ * direction the media goes. `addTrack()` creates one (or reuses one the other peer offered), `addTransceiver()` creates
+ * one of a given direction: `recvonly` to receive without sending.
+ * @example
+ * ```typescript
+ * import type {PeerConnection, RtpTransceiver} from '@lakutata/webrtc'
+ *
+ * declare const connection: PeerConnection
+ * //Receive the video of the other peer, send none
+ * const transceiver: RtpTransceiver = connection.addTransceiver('video', {direction: 'recvonly'})
+ * ```
+ */
+class RtpTransceiver {
+    #transceiver;
+    /**
+     * Wrap a transceiver of the engine
+     * @param transceiver
+     * @internal
+     */
+    constructor(transceiver) {
+        this.#transceiver = transceiver;
+    }
+    /**
+     * The media id of its line in the description; `null` until negotiated.
+     */
+    get mid() {
+        return this.#transceiver.mid;
+    }
+    /**
+     * `audio` or `video`.
+     */
+    get kind() {
+        return this.#transceiver.kind;
+    }
+    /**
+     * The direction wanted; changing it makes the connection negotiate.
+     */
+    get direction() {
+        return this.#transceiver.direction;
+    }
+    /**
+     * Change the direction wanted.
+     * @param direction The direction.
+     */
+    set direction(direction) {
+        this.#transceiver.direction = direction;
+    }
+    /**
+     * The direction negotiated, `stopped` once stopped; `null` until negotiated.
+     */
+    get currentDirection() {
+        return this.#transceiver.currentDirection;
+    }
+    /**
+     * The sending side.
+     */
+    get sender() {
+        return senderOf(this.#transceiver.sender);
+    }
+    /**
+     * The receiving side.
+     */
+    get receiver() {
+        return receiverOf(this.#transceiver.receiver);
+    }
+    /**
+     * Stop the transceiver: it sends and receives no more, and the connection negotiates.
+     * @example
+     * ```typescript
+     * import type {RtpTransceiver} from '@lakutata/webrtc'
+     *
+     * declare const transceiver: RtpTransceiver
+     * transceiver.stop()
+     * ```
+     */
+    stop() {
+        this.#transceiver.stop();
+    }
+}
+exports.RtpTransceiver = RtpTransceiver;
+/**
+ * The sender of a sender of the engine, created once
+ * @param sender
+ */
+function senderOf(sender) {
+    let wrapped = senders.get(sender);
+    if (!wrapped) {
+        wrapped = new RtpSender(sender);
+        senders.set(sender, wrapped);
+    }
+    return wrapped;
+}
+/**
+ * The sender of the engine of a sender
+ * @param sender
+ */
+function engineSenderOf(sender) {
+    return engineSenders.get(sender);
+}
+/**
+ * The receiver of a receiver of the engine, created once
+ * @param receiver
+ */
+function receiverOf(receiver) {
+    let wrapped = receivers.get(receiver);
+    if (!wrapped) {
+        wrapped = new RtpReceiver(receiver);
+        receivers.set(receiver, wrapped);
+    }
+    return wrapped;
+}
+/**
+ * The transceiver of a transceiver of the engine, created once
+ * @param transceiver
+ */
+function transceiverOf(transceiver) {
+    let wrapped = transceivers.get(transceiver);
+    if (!wrapped) {
+        wrapped = new RtpTransceiver(transceiver);
+        transceivers.set(transceiver, wrapped);
+    }
+    return wrapped;
+}