Skip to main content

API & Config

Create instance​

var engine = new P2PEngineShaka(player, {p2pConfig: [opts]}, shaka = window.shaka);​

Create a new P2PEngineShaka instance, player is an instance of Shaka Player .

If opts is specified, then the default options (shown below) will be overridden.

FieldTypeDefaultDescription
logLevelstring|boolean'error'Print log level(warn, error, none，false=none, true=warn).
tokenstringundefinedToken is used to summarize and display multi domain name data on the console. In addition, token is required while customizing channelId.
trackerZonestring'eu'The country code name of the tracker server address('eu', 'hk', 'us').
memoryCacheLimitObject{"pc": 400 1024 1024, "mobile": 100 1024 1024}The max size of binary data that can be stored in the cache.
useDiskCachebooleantrueUse IndexedDB to cache data for VOD streaming.
diskCacheLimitObject{"pc": 1500 1024 1024, "mobile": 1000 1024 1024}The max size of binary data that can be stored in the disk cache.
p2pEnabledbooleantrueEnable or disable p2p engine.
webRTCConfigObject{}A Configuration dictionary providing options to configure WebRTC connections.
useHttpRangebooleantrueUse HTTP ranges requests where it is possible. Allows to continue (and not start over) aborted P2P downloads over HTTP.
sharePlaylistbooleanfalseAllow the P2P transmission of m3u8 file.
showSloganbooleanfalseDisplay slogan of cdnbye on console.
prefetchOnlybooleanfalseOnly use prefetch strategy in p2p downloading(Only for HLS).

P2PEngineShaka API​

P2PEngineShaka.version (static method)​

Get the version of P2PEngineShaka.

P2PEngineShaka.protocolVersion (static method)​

Get the version of P2P protocol.

P2PEngineShaka.isSupported() (static method)​

Returns true if WebRTC data channel is supported by the browser.

engine.enableP2P()​

Resume P2P if it has been stopped.

engine.disableP2P()​

Disable engine to stop p2p and free used resources.

engine.destroy()​

Stop p2p and free used resources.

P2PEngineShaka Events​

engine.on('peerId', function (peerId) {})​

Emitted when the peer Id of this client is obtained from server.

engine.on('peers', function (peers) {})​

Emitted when successfully connected with new peer.

engine.on('stats', function (stats) {})​

Emitted when data is downloaded/uploaded.
stats.totalHTTPDownloaded: total data downloaded by HTTP(KB).
stats.totalP2PDownloaded: total data downloaded by P2P(KB).
stats.totalP2PUploaded: total data uploaded by P2P(KB).
stats.p2pDownloadSpeed: p2p download speed(KB/s).

engine.on('serverConnected', function (connected) {})​

Emitted when websocket is opened/closed.

engine.on('exception', function (e) {})​

Emitted when exception occured.
e.code: Exception identifier（TRACKER_EXPT SIGNAL_EXPT）
e.message: Exception message
e.stack: Exception stack

Get p2p information from p2pConfig​

p2pConfig: {
    getStats: function (totalP2PDownloaded, totalP2PUploaded, totalHTTPDownloaded, p2pDownloadSpeed) {
        // get the downloading statistics
    },
    getPeerId: function (peerId) {
        // get peer Id
    },
    getPeersInfo: function (peers) {
        // get peers information
    },
    onHttpDownloaded: function (traffic) {
        // listen to http downloaded traffic
    },
    onP2pDownloaded: function (traffic, speed) {
        // listen to p2p downloaded traffic
    },
    onP2pUploaded: function (traffic) {
        // listen to p2p uploaded traffic
    },
}
note

The unit of download and upload is KB. The unit of download speed is KB/s.

Advanced Usage​

Dynamic M3u8/mpd Path Support​

Some m3u8/mpd urls play the same live/vod but have different paths on them. For example, example.com/clientId1/streamId.mpd and example.com/clientId2/streamId.mpd. In this case, you can format a common channelId for them.

// Set token in p2pConfig before setting channelId!
p2pConfig: {
    token: YOUR_TOKEN,
    channelId: function (mpdUrl) {
        const videoId = extractVideoIdFromUrl(mpdUrl);   // make a channelId by removing the different part which is defined by yourself
        return videoId;
    }
    // channelId: VIDEO_ID       // for fixed channel id
}

Dynamic Segment Path Support​

Like dynamic mpd path, you should format a common segmentId for the same segment file. You can override the segment ID like this:

p2pConfig: {
    /*
        segmentUrl: The url of segment
        range: The byte range of segment
     */
    segmentId: function (segmentUrl, range) {
        const segId = extractSegmentIdFromUrl(segmentUrl, range);
        return segId;
    }
}

Use Your Own STUN or TURN Server​

STUN (Session Traversal Utilities for NAT) allows clients to discover their public IP address and the type of NAT they are behind. This information is used to establish the media connection. Although there are default STUN servers in this SDK, you can replace them with your own via P2PConfig. TURN (Traversal Using Relays around NAT) server is used to relay traffic if direct connection fails. You can config your TURN server in the same way as STUN.

p2pConfig: {
    webRTCConfig: {
       iceServers: [
           { urls: YOUR_STUN_OR_TURN_SERVER }
       ]
    }
}

Allow Http Range Request​

If http range request is activated, we are able to get chunks of data from peer and then complete the segments by getting other chunks from the CDN, thus, reducing your CDN bandwidth. Besides, the code below is needed：

p2pConfig: {
    useHttpRange: true,
}

How to Check Segment Validity​

Sometimes we need to prevent a peer from sending a fake segment (such as the bittorrent with a hash function). CDNBye provides a validation callback with buffer of the downloaded segment, developer should implement the actual validator. For example, you can create a program that generates hashes for the segments and stores them in a specific file or injects into m3u8 playlist files the hashes information. If the callback returns false, then the segment is not valid.

p2pConfig: {
   validateSegment: function (segId, buffer) {
       var hash = hashFile.getHash(segId);
       return hash === md5(buffer);
   }
}