node-datachannel 0.1.14-dev → 0.2.2

package/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.15)
 cmake_policy(SET CMP0091 NEW)
-project(node_datachannel VERSION 0.1.14)
+project(node_datachannel VERSION 0.2.2)
 
 include_directories(${CMAKE_JS_INC})
 
@@ -27,10 +27,10 @@ include(FetchContent)
 FetchContent_Declare(
     libdatachannel
     GIT_REPOSITORY https://github.com/paullouisageneau/libdatachannel.git
-    GIT_TAG "v0.16.0"
+    GIT_TAG "v0.16.4"
 )
 
-option(NO_MEDIA "Disable media transport support in libdatachannel" ON)
+option(NO_MEDIA "Disable media transport support in libdatachannel" OFF)
 option(NO_WEBSOCKET "Disable WebSocket support in libdatachannel" ON)
 
 FetchContent_GetProperties(libdatachannel)
@@ -42,6 +42,11 @@ endif()
 
 add_library(${PROJECT_NAME} SHARED
     src/rtc-wrapper.cpp
+    src/media-direction.cpp
+    src/media-rtcpreceivingsession-wrapper.cpp
+    src/media-track-wrapper.cpp
+    src/media-audio-wrapper.cpp
+    src/media-video-wrapper.cpp
     src/data-channel-wrapper.cpp
     src/peer-connection-wrapper.cpp
     src/thread-safe-callback.cpp

package/README.md

@@ -1,60 +1,34 @@
-# node-datachannel - libdatachannel node bindings
+# Easy to use WebRTC data channels and media transport
 
 ![Build CI](https://github.com/murat-dogan/node-datachannel/workflows/Build%20CI/badge.svg)
 
+- Easy to use
+- Lightweight
+  - No need to deal with WebRTC stack!
+  - Small binary sizes
+- Has Prebuilt binaries (Linux,Windows,ARM)
+- Type infos for Typescript
+
 > "libdatachannel is a standalone implementation of WebRTC Data Channels, WebRTC Media Transport, and WebSockets in C++17 with C bindings for POSIX platforms (including GNU/Linux, Android, and Apple macOS) and Microsoft Windows. It enables direct connectivity between native applications and web browsers without the pain of importing the entire WebRTC stack. "
 
-NodeJS bindings for [libdatachannel](https://github.com/paullouisageneau/libdatachannel) library.
+
+This project is NodeJS bindings for [libdatachannel](https://github.com/paullouisageneau/libdatachannel) library.
 
 Please check [libdatachannel](https://github.com/paullouisageneau/libdatachannel) for Compatibility & WebRTC details.
 
-## Examples
+## Example Usage
 ```js
 const nodeDataChannel = require('node-datachannel');
 
 // Log Level
 nodeDataChannel.initLogger("Debug");
 
-// SCTP Settings ( use of nodeDataChannel.setSctpSettings() )
-// export interface SctpSettings {
-//     recvBufferSize?: number;
-//     sendBufferSize?: number;
-//     maxChunksOnQueue?: number;
-//     initialCongestionWindow?: number;
-//     congestionControlModule?: number;
-//     delayedSackTime?: number;
-// }
-
 let dc1 = null;
 let dc2 = null;
 
-// Config options
-// export interface RtcConfig {
-//     iceServers: string[];
-//     proxyServer?: ProxyServer;
-//     enableIceTcp?: boolean;
-//     portRangeBegin?: number;
-//     portRangeEnd?: number;
-//     maxMessageSize?: number;
-//     iceTransportPolicy?: TransportPolicy;
-// }
-
-// "iceServers" option is an array of stun/turn server urls
-// Examples;
-// STUN Server Example          : stun:stun.l.google.com:19302
-// TURN Server Example          : turn:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT
-// TURN Server Example (TCP)    : turn:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT?transport=tcp
-// TURN Server Example (TLS)    : turns:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT
-
 let peer1 = new nodeDataChannel.PeerConnection("Peer1", { iceServers: ["stun:stun.l.google.com:19302"] });
 
 // Set Callbacks
-peer1.onStateChange((state) => {
-    console.log("Peer1 State:", state);
-});
-peer1.onGatheringStateChange((state) => {
-    console.log("Peer1 GatheringState:", state);
-});
 peer1.onLocalDescription((sdp, type) => {
     console.log("Peer1 SDP:", sdp, " Type:", type);
     peer2.setRemoteDescription(sdp, type);
@@ -67,12 +41,6 @@ peer1.onLocalCandidate((candidate, mid) => {
 let peer2 = new nodeDataChannel.PeerConnection("Peer2", { iceServers: ["stun:stun.l.google.com:19302"] });
 
 // Set Callbacks
-peer2.onStateChange((state) => {
-    console.log("Peer2 State:", state);
-});
-peer2.onGatheringStateChange((state) => {
-    console.log("Peer2 GatheringState:", state);
-});
 peer2.onLocalDescription((sdp, type) => {
     console.log("Peer2 SDP:", sdp, " Type:", type);
     peer1.setRemoteDescription(sdp, type);
@@ -90,27 +58,12 @@ peer2.onDataChannel((dc) => {
     dc2.sendMessage("Hello From Peer2");
 });
 
-// DataChannel Options
-// export interface DataChannelInitConfig {
-//     protocol?: string;
-//     negotiated?: boolean;
-//     id?: number;
-//     ordered?: boolean;
-//     maxPacketLifeTime?: number;
-//     maxRetransmits?: number;
-//
-//     // Deprecated, use ordered, maxPacketLifeTime, and maxRetransmits
-//     reliability?: {
-//         type?: ReliabilityType;
-//         unordered?: boolean;
-//         rexmit?: number;
-//     }
-// }
 dc1 = peer1.createDataChannel("test");
+
 dc1.onOpen(() => {
     dc1.sendMessage("Hello from Peer1");
-    // Binary message: Use sendMessageBinary(Buffer)
 });
+
 dc1.onMessage((msg) => {
     console.log('Peer1 Received Msg:', msg);
 });
@@ -120,13 +73,12 @@ setTimeout(() => {
     dc2.close();
     peer1.close();
     peer2.close();
-    dc1 = null;
-    dc2 = null;
-    peer1 = null;
-    peer2 = null;
     nodeDataChannel.cleanup();
 }, 10 * 1000);
 ```
+
+> Please check examples/media folder for media usage example
+
 ## Install
 
 Prebuilt binaries are available (Node Version >= 10);
@@ -138,6 +90,219 @@ Prebuilt binaries are available (Node Version >= 10);
 > npm install node-datachannel --save
 ```
 
+## API
+
+###  PeerConnection Class
+
+**Constructor**
+
+let pc = new PeerConnection(peerName[,options])
+- peerName `<string>` Peer name to use for logs etc..
+- options `<Object>` WebRTC Config Options
+```
+export interface RtcConfig {
+    iceServers: (string | IceServer)[];
+    proxyServer?: ProxyServer;
+    enableIceTcp?: boolean;
+    portRangeBegin?: number;
+    portRangeEnd?: number;
+    maxMessageSize?: number;
+    iceTransportPolicy?: TransportPolicy;
+}
+
+export const enum RelayType {
+    TurnUdp = 'TurnUdp',
+    TurnTcp = 'TurnTcp',
+    TurnTls = 'TurnTls'
+}
+
+export interface IceServer {
+    hostname: string;
+    port: Number;
+    username?: string;
+    password?: string;
+    relayType?: RelayType;
+}
+
+export type TransportPolicy = 'all' | 'relay';
+
+"iceServers" option is an array of stun/turn server urls
+Examples;
+STUN Server Example          : stun:stun.l.google.com:19302
+TURN Server Example          : turn:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT
+TURN Server Example (TCP)    : turn:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT?transport=tcp
+TURN Server Example (TLS)    : turns:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT
+
+```
+
+**close: () => void**
+
+Close Peer Connection
+
+**setRemoteDescription: (sdp: string, type: DescriptionType) => void**
+
+Set Remote Description
+```
+export const enum DescriptionType {
+    Unspec = 'Unspec',
+    Offer = 'Offer',
+    Answer = 'Answer'
+}
+```
+
+**addRemoteCandidate: (candidate: string, mid: string) => void**
+
+Add remote candidate info
+
+**createDataChannel: (label: string, config?: DataChannelInitConfig) => DataChannel**
+
+Create new data-channel
+* label `<string>` Data channel name
+* config `<Object>` Data channel options
+```
+export interface DataChannelInitConfig {
+    protocol?: string;
+    negotiated?: boolean;
+    id?: number;
+    ordered?: boolean;
+    maxPacketLifeTime?: number;
+    maxRetransmits?: number;
+
+    // Deprecated, use ordered, maxPacketLifeTime, and maxRetransmits
+    reliability?: {
+        type?: ReliabilityType;
+        unordered?: boolean;
+        rexmit?: number;
+    }
+}
+
+export const enum ReliabilityType {
+    Reliable = 0, Rexmit = 1, Timed = 2
+}
+```
+**state: () => string**
+
+Get current state
+
+**signalingState: () => string**
+
+Get current signaling state
+
+**gatheringState: () => string**
+
+Get current gathering state
+
+**onLocalDescription: (cb: (sdp: string, type: DescriptionType) => void) => void**
+
+Local Description Callback
+```
+export const enum DescriptionType {
+    Unspec = 'Unspec',
+    Offer = 'Offer',
+    Answer = 'Answer'
+}
+```
+
+**onLocalCandidate: (cb: (candidate: string, mid: string) => void) => void**
+
+Local Candidate Callback
+
+**onStateChange: (cb: (state: string) => void) => void**
+
+State Change Callback
+
+**onSignalingStateChange: (state: (sdp: string) => void) => void**
+
+Signaling State Change Callback
+
+**onGatheringStateChange: (state: (sdp: string) => void) => void**
+
+Gathering State Change Callback
+
+**onDataChannel: (cb: (dc: DataChannel) => void) => void**
+
+New Data Channel Callback
+
+**bytesSent: () => number**
+
+Get bytes sent stat
+
+**bytesReceived: () => number**
+
+Get bytes received stat
+
+**rtt: () => number**
+
+Get rtt stat
+
+**getSelectedCandidatePair: () => { local: SelectedCandidateInfo, remote: SelectedCandidateInfo }**
+
+Get info about selected candidate pair
+```
+export interface SelectedCandidateInfo {
+    address: string;
+    port: number;
+    type: string;
+    transportType: string;
+}
+```
+
+###  DataChannel Class
+
+> You can create a new Datachannel instance by calling `PeerConnection.createDataChannel` function.
+
+**close: () => void**
+
+Close data channel
+
+**getLabel: () => string**
+
+Get label of data-channel
+
+**sendMessage: (msg: string) => boolean**
+
+Send Message as string
+
+**sendMessageBinary: (buffer: Buffer) => boolean**
+
+Send Message as binary
+
+**isOpen: () => boolean**
+
+Query data-channel
+
+**bufferedAmount: () => Number**
+
+Get current buffered amount level
+
+**maxMessageSize: () => Number**
+
+Get max message size of the data-channel, that could be sent
+
+**setBufferedAmountLowThreshold: (newSize: Number) => void**
+
+Set buffer level of the `onBufferedAmountLow` callback
+
+**onOpen: (cb: () => void) => void**
+
+Open callback
+
+**onClosed: (cb: () => void) => void**
+
+Closed callback
+
+**onError: (cb: (err: string) => void) => void**
+
+Error callback
+
+**onBufferedAmountLow: (cb: () => void) => void**
+
+Buffer level low callback
+
+**onMessage: (cb: (msg: string | Buffer) => void) => void**
+
+New Message callback
+
 ## Build
 
 ### Requirements

package/examples/README.md

@@ -1,6 +1,6 @@
 # Examples
 
-## client-server
+# client-server
  * You can use client-server example project to test WebRTC Data Channels with WebSocket signaling.
  * It uses same logic of [libdatachannel/examples/client](https://github.com/paullouisageneau/libdatachannel/tree/master/examples) project.
  * Contains an equivalent implementation for a node.js signaling server
@@ -18,4 +18,4 @@
   * node client.js
   * Enter answerer ID
 
-  > You can also use [libdatachannel/examples/client](https://github.com/paullouisageneau/libdatachannel/tree/master/examples) project's client & signaling server
+  > You can also use [libdatachannel/examples/client](https://github.com/paullouisageneau/libdatachannel/tree/master/examples) project's client & signaling server

package/examples/media/README.md

@@ -0,0 +1,22 @@
+# Examples
+
+# media
+
+## Example Webcam from Browser to Port 5000
+This is an example copy/paste demo to send your webcam from your browser and out port 5000 through the demo application.
+
+## How to use
+Open main.html in your browser (you must open it either as HTTPS or as a domain of http://localhost).
+
+Start the application and copy it's offer into the text box of the web page.
+
+Copy the answer of the webpage back into the application.
+
+You will now see RTP traffic on `localhost:5000` of the computer that the application is running on.
+
+Use the following gstreamer demo pipeline to display the traffic
+(you might need to wave your hand in front of your camera to force an I-frame).
+
+```
+$ gst-launch-1.0 udpsrc address=127.0.0.1 port=5000 caps="application/x-rtp" ! queue ! rtph264depay ! video/x-h264,stream-format=byte-stream ! queue ! avdec_h264 ! queue ! autovideosink
+```

package/examples/media/main.html

@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>libdatachannel media example</title>
+</head>
+<body>
+
+<p>Please enter the offer provided to you by the application: </p>
+<textarea cols="50" rows="50"></textarea>
+<button>Submit</button>
+
+<script>
+    document.querySelector('button').addEventListener('click',  async () => {
+        let offer = JSON.parse(document.querySelector('textarea').value);
+        rtc = new RTCPeerConnection({
+            // Recommended for libdatachannel
+            bundlePolicy: "max-bundle",
+        });
+
+        rtc.onicegatheringstatechange = (state) => {
+            if (rtc.iceGatheringState === 'complete') {
+                // We only want to provide an answer once all of our candidates have been added to the SDP.
+                let answer = rtc.localDescription;
+                document.querySelector('textarea').value = JSON.stringify({"type": answer.type, sdp: answer.sdp});
+                document.querySelector('p').value = 'Please paste the answer in the application.';
+                alert('Please paste the answer in the application.');
+            }
+        }
+        await rtc.setRemoteDescription(offer);
+
+        let media = await navigator.mediaDevices.getUserMedia({
+            video: {
+                width: 1280,
+                height: 720
+            }
+        });
+        media.getTracks().forEach(track => rtc.addTrack(track, media));
+        let answer = await rtc.createAnswer();
+        await rtc.setLocalDescription(answer);
+    })
+</script>
+
+</body>
+</html>

package/examples/media/media.js

@@ -0,0 +1,55 @@
+const nodeDataChannel = require('../../lib/index');
+const readline = require("readline");
+var dgram = require('dgram');
+
+var client = dgram.createSocket('udp4');
+
+// Read Line Interface
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+// Init Logger
+nodeDataChannel.initLogger('Debug');
+
+let peerConnection = new nodeDataChannel.PeerConnection('pc', { iceServers: [] });
+
+peerConnection.onStateChange((state) => {
+    console.log('State: ', state);
+});
+peerConnection.onGatheringStateChange((state) => {
+    // console.log('GatheringState: ', state);
+
+    if(state == 'complete'){
+        let desc = peerConnection.localDescription();
+        console.log('');
+        console.log('## Please copy the offer below to the web page:');
+        console.log(JSON.stringify(desc));
+        console.log('\n\n');
+        console.log('## Expect RTP video traffic on localhost:5000');
+        rl.question('## Please copy/paste the answer provided by the browser: \n', (sdp) => {
+            let sdpObj = JSON.parse(sdp);
+            peerConnection.setRemoteDescription(sdpObj.sdp, sdpObj.type);
+            console.log(track.isOpen())
+            rl.close();
+    
+        });
+    }
+});
+
+let video = new nodeDataChannel.Video('video','RecvOnly');
+video.addH264Codec(96);
+video.setBitrate(3000);
+
+let track = peerConnection.addTrack(video);
+let session = new nodeDataChannel.RtcpReceivingSession();
+
+track.setMediaHandler(session);
+track.onMessage((msg)=>{
+    client.send(msg,5000,'127.0.0.1',(err,n)=>{
+        if(err) console.log(err,n);
+    });
+});
+
+peerConnection.setLocalDescription();

package/lib/index.d.ts

@@ -57,7 +57,9 @@ export interface RtcConfig {
 export const enum DescriptionType {
     Unspec = 'Unspec',
     Offer = 'Offer',
-    Answer = 'Answer'
+    Answer = 'Answer',
+    Pranswer = 'Pranswer',
+    Rollback = 'Rollback'
 }
 
 export const enum ReliabilityType {
@@ -87,6 +89,94 @@ export interface SelectedCandidateInfo {
     transportType: string;
 }
 
+// Must be same as rtc enum class Direction
+export enum Direction {
+    SendOnly = 'SendOnly',
+    RecvOnly = 'RecvOnly',
+    SendRecv = 'SendRecv',
+    Inactive = 'Inactive',
+    Unknown = 'Unknown'
+}
+
+export class RtcpReceivingSession {
+    requestBitrate: (bitRate: Number) => void;
+    requestKeyframe: () => boolean;
+}
+
+export class Audio {
+    constructor(mid: string, dir: Direction);
+    addAudioCodec: (payloadType: Number, codec: string, profile?: string) => void;
+    addOpusCodec: (payloadType: Number, profile?: string) => string;
+
+    direction: () => Direction;
+    generateSdp: (eol: string, addr: string, port: string) => string;
+    mid: () => string;
+    setDirection: (dir: Direction) => void;
+    description: () => string;
+    removeFormat: (fmt: string) => void;
+    addSSRC: (ssrc: Number, name?: string, msid?: string, trackID?: string) => void;
+    removeSSRC: (ssrc: Number) => void;
+    replaceSSRC: (oldSsrc: Number, ssrc: Number, name?: string, msid?: string, trackID?: string) => void;
+    hasSSRC: (ssrc: Number) => boolean;
+    getSSRCs: () => Number[];
+    getCNameForSsrc: (ssrc: Number) => string;
+    setBitrate: (bitRate: Number) => void;
+    getBitrate: () => Number;
+    hasPayloadType: (payloadType: Number) => boolean;
+    addRTXCodec: (payloadType: Number, originalPayloadType: Number, clockRate: Number) => void;
+    addRTPMap: () => void;
+    parseSdpLine: (line: string) => void;
+}
+
+export class Video {
+    constructor(mid: string, dir: Direction);
+    addVideoCodec: (payloadType: Number, codec: string, profile?: string) => void;
+    addH264Codec: (payloadType: Number, profile?: string) => void;
+    addVP8Codec: (payloadType: Number) => void;
+    addVP9Codec: (payloadType: Number) => void;
+
+    direction: () => Direction;
+    generateSdp: (eol: string, addr: string, port: string) => string;
+    mid: () => string;
+    setDirection: (dir: Direction) => void;
+    description: () => string;
+    removeFormat: (fmt: string) => void;
+    addSSRC: (ssrc: Number, name?: string, msid?: string, trackID?: string) => void;
+    removeSSRC: (ssrc: Number) => void;
+    replaceSSRC: (oldSsrc: Number, ssrc: Number, name?: string, msid?: string, trackID?: string) => void;
+    hasSSRC: (ssrc: Number) => boolean;
+    getSSRCs: () => Number[];
+    getCNameForSsrc: (ssrc: Number) => string;
+    setBitrate: (bitRate: Number) => void;
+    getBitrate: () => Number;
+    hasPayloadType: (payloadType: Number) => boolean;
+    addRTXCodec: (payloadType: Number, originalPayloadType: Number, clockRate: Number) => void;
+    addRTPMap: () => void;
+    parseSdpLine: (line: string) => void;
+}
+
+export class Track {
+    direction: () => Direction;
+    mid: () => string;
+    close: () => void;
+    sendMessage: (msg: string) => boolean;
+    sendMessageBinary: (buffer: Buffer) => boolean;
+    isOpen: () => boolean;
+    isClosed: () => boolean;
+    availableAmount: () => Number;
+    bufferedAmount: () => Number;
+    maxMessageSize: () => Number;
+    setBufferedAmountLowThreshold: (newSize: Number) => void;
+    requestKeyframe: () => boolean;
+    setMediaHandler: (handler: RtcpReceivingSession) => void
+    onOpen: (cb: () => void) => void;
+    onClosed: (cb: () => void) => void;
+    onError: (cb: (err: string) => void) => void;
+    onAvailable: (cb: () => void) => void;
+    onBufferedAmountLow: (cb: () => void) => void;
+    onMessage: (cb: (msg: string | Buffer) => void) => void;
+}
+
 export class DataChannel {
     close: () => void;
     getLabel: () => string;
@@ -108,14 +198,23 @@ export class DataChannel {
 export class PeerConnection {
     constructor(peerName: string, config: RtcConfig);
     close: () => void;
+    setLocalDescription: (type: DescriptionType) => void;
     setRemoteDescription: (sdp: string, type: DescriptionType) => void;
+    localDescription: () => { type: string, sdp: string };
     addRemoteCandidate: (candidate: string, mid: string) => void;
     createDataChannel: (label: string, config?: DataChannelInitConfig) => DataChannel;
+    addTrack: (media: Video | Audio) => Track;
+    hasMedia: () => boolean;
+    state: () => string;
+    signalingState: () => string;
+    gatheringState: () => string;
     onLocalDescription: (cb: (sdp: string, type: DescriptionType) => void) => void;
     onLocalCandidate: (cb: (candidate: string, mid: string) => void) => void;
     onStateChange: (cb: (state: string) => void) => void;
+    onSignalingStateChange: (state: (sdp: string) => void) => void;
     onGatheringStateChange: (state: (sdp: string) => void) => void;
     onDataChannel: (cb: (dc: DataChannel) => void) => void;
+    onTrack: () => Track;
     bytesSent: () => number;
     bytesReceived: () => number;
     rtt: () => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-datachannel",
-  "version": "0.1.14-dev",
+  "version": "0.2.2",
   "description": "libdatachannel node bindings",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -22,7 +22,12 @@
     "url": "git+https://github.com/murat-dogan/node-datachannel.git"
   },
   "keywords": [
-    "libdatachannel"
+    "libdatachannel",
+    "webrtc",
+    "p2p",
+    "peer-to-peer",
+    "datachannel",
+    "data channel"
   ],
   "contributors": [
     {
@@ -34,7 +39,7 @@
       "url": "https://github.com/paullouisageneau"
     }
   ],
-  "license": "GPL-2.0-or-later",
+  "license": "LGPL",
   "gypfile": true,
   "bugs": {
     "url": "https://github.com/murat-dogan/node-datachannel/issues"