Files
Testing/html5-chat1/js/mediasoup/mediasoupLib2.js
sean 0e8a8b3028
Some checks failed
deploy-testing / deploy (push) Has been cancelled
Initial testing snapshot
2026-11-17 16:15:01 -05:00

613 lines
21 KiB
JavaScript

'use strict';
// These are the main parameters.
// We can save a lot of bandwidth by constraining the dimensions.
// Note that this doesn't work so well on some iOS, so we handle
// that by reissuing a getUserMedia without the dimensions below.
var VIDEO_CONSTRAINTS = {facingMode: 'user', width: 320, height: 240};
// In case you need them. See the MediaSoup client API.
var TRANSPORT_OPTIONS = {};
// We start off without publishing enabled.
var publishing = false;
// The session counter, so we can send multiple requests to the server.
var lastSession = 0;
var webrtcPublished;
var socketMediaSoup = {}
// The getUserMedia() stream of the publisher.
var gumStream;
// Mapping of a session (multiple sessions for one socketMediaSoup.io socketMediaSoup) to
// a MediaSoup client Rooms.
var roomsMS = {};
// A list of all the producers we create for the publisher.
var producers = [];
// The session corresponding to the current publisher, if any.
var pubsession;
// Whether the publisher is muted.
var pubmuted = false;
// The current request id (monotonically increasing), to map messages
// to their callbacks.
var reqid = 0;
// Map of request id to success callback (which takes a parameter indicating
// the response.
var pending = {};
// Map of request id to error callback (which takes a parameter indicating
// the error type).
var errors = {};
// A shorthand for the MediaSoup client.
var ms = window.mediasoupClient;
if (!ms.isDeviceSupported()) {
// Too bad.
// Maybe try upgrading your mediasoup-client.js (but make sure it is still v2!)
alert('Sorry, Mediasoup is not supported on this device');
}
var remoteFeeds = new Map();
var myStreamid;
function connectMS(SOCKETIO_SERVER, _streamid) {
myStreamid = _streamid;
// Connect to the socketMediaSoup.io pubsub server (../server.js), and update status.
if (socketMediaSoup.connected) {
socketMediaSoup.close();
}
socketMediaSoup = io.connect(SOCKETIO_SERVER);
socketMediaSoup.on('connect', function conn() {
console.log('mediaSoupConnected');
var event = new Event('mediaSoupReady');
document.dispatchEvent(event);
});
socketMediaSoup.on('disconnect', function disco(reason) {
console.log('mediaSoupDiscConnected');
});
socketMediaSoup.on('ms', function recv(obj) {
console.log('recv', obj);
switch (obj.type) {
case 'MS_RESPONSE':
{
// It was a response from the mediasoup server.
// Look up our success callback.
var cb = pending[obj.meta.id];
// Release the callback/errback maps for this request id.
delete pending[obj.meta.id];
delete errors[obj.meta.id];
if (cb) {
// If there was a callback, call it with MediaSoup's payload.
cb(obj.payload);
}
break
}
case 'MS_ERROR':
{
// It was an error from the mediasoup server.
// Look up our error callback.
var errb = errors[obj.meta.id];
// Release the callback/errback maps for this request id.
delete pending[obj.meta.id];
delete errors[obj.meta.id];
if (errb) {
// If there was an errback, call it with MediaSoup's error.
errb(obj.payload);
}
break;
}
case 'MS_NOTIFY':
{
// It was a notification.
// The only target for client notifications is the Room
// corresponding to this session.
var room = roomsMS[obj.meta.session];
if (room) {
// Receive the notification with MediaSoup's payload.
room.receiveNotification(obj.payload);
}
break;
}
// FIXME: Maybe do something to log unknown protocol.
}
});
}
// Helper function to send objects via socketMediaSoup.io.
function sendMS(obj) {
//console.log('send:', obj);
// We always use the 'ms' message type to send to the pubsub server.
socketMediaSoup.emit('ms', obj);
}
// Handle the 'ms' socketMediaSoup.io messages.
function publishOwnFeed(_streamid) {
myStreamid = _streamid;
if (pubsession) {
// We can just delete the room, since our MS_STOP message will
// properly be handled by MediaSoup and clean up the rest of the client.
delete roomsMS[pubsession];
// Don't expect an error or response.
sendMS({type: 'MS_STOP', payload: {}, meta: {id: ++reqid, session: pubsession}});
}
// Mark us as not currently publishing.
pubsession = undefined;
if (publishing) {
stopPublish();
} else {
startPublish();
}
}
function stopStream(streamid) {
// We can just delete the Room, since MediaSoup client will clean up after the MS_STOP.
var session = remoteFeeds.get(streamid);
if (session) {
delete roomsMS[session];
// Don't expect an error or response.
sendMS({type: 'MS_STOP', payload: {}, meta: {id: ++reqid, session: session}});
}
}
// Do the actions needed for the isMuted setting.
function mute(isMuted) {
console.log('Applying mute', isMuted);
// Loop over all the publisher's producers.
for (var producer of producers) {
if (producer.kind !== 'audio') {
// Only pause/resume the audio producers.
continue;
}
if (isMuted) {
// Mute by pausing the audio producer.
producer.pause();
} else {
// Unmute by resuming the audio producer.
producer.resume();
}
}
}
// This is a timeout needed on some platforms to
// properly do an action only when a stream has become
// active.
var streamActiveTimeout = {};
// Do an action when stream is active.
function whenStreamIsActive(getStream, callback) {
// Call the getter function to obtain the target stream.
var stream = getStream();
if (!stream) {
// If the stream is no longer present, just return.
return;
}
// Get the stream's id.
var id = stream.id;
if (stream.active) {
// It's active, so call the callback.
callback();
}
else if ('onactive' in stream) {
// We can set an active handler.
stream.onactive = maybeCallback;
}
else if (!streamActiveTimeout[id]) {
// Some platforms, like Safari, don't support
// onactive, so we need to keep retrying after timeout.
// We aren't waiting for this stream yet,
// so try setting a timeout.
maybeCallback();
}
function maybeCallback() {
delete streamActiveTimeout[id];
var stream = getStream();
if (!stream || stream.id !== id) {
// Not present anymore, or ID doesn't match
// the one we were called with.
return;
}
if (stream.onactive === maybeCallback) {
// Remove the onactive handler.
stream.onactive = null;
}
if (!stream.active) {
// Safari needs a timeout to try again.
// console.log('try again');
streamActiveTimeout[id] = setTimeout(maybeCallback, 500);
return;
}
// The stream is active, so callback.
callback();
}
}
// Set a stream as the video tag's source.
function setVideoSource(video, stream) {
if (!stream) {
// No stream, so remove it from the video tag...
if (video) {
// ... if there is one.
try {
video.removeAttribute('src');
// srcObject is not always available.
video.srcObject = null;
} catch (e) {
}
// Load the video to stop playback.
video.load();
}
return;
}
// We can only set a new source when the stream becomes active.
whenStreamIsActive(function getStream() {
return stream;
}, setSrc);
function setSrc() {
console.log('adding active playback stream');
try {
video.srcObject = stream;
}
catch (e) {
// Some platforms don't support srcObject,
// so we need to create a URL and set it instead.
var url = (window.URL || window.webkitURL);
video.src = url ? url.createObjectURL(stream) : stream;
}
$(video).prop("controls", true);//yarek
//video.setAttribute('controls', true);
}
}
// This starts a new client for:
// kind: publish | subscribe
// session: an identifier for the specific session within the socketMediaSoup.io connection
// streamid: the name used to correlate publishers with subscribers
function pubsub(kind, session, streamid) {
// We return a promise that resolves with a {room, peers} object on success
// rejects on error.
return new Promise(function executor(resolve, reject) {
// Issue the MS_START request for a new request id.
pending[++reqid] = onPubsub;
errors[reqid] = reject;
sendMS({type: 'MS_START', payload: {kind, streamid}, meta: {id: reqid, session}});
function onPubsub(payload) {
// We received the response to MS_START.
// Create a new MediaSoup client room for this session.
var room = roomsMS[session] = new ms.Room({
requestTimeout: 8000, // milliseconds timeout
transportOptions: TRANSPORT_OPTIONS, // any special options
});
// Hook up the room's requests to this socketMediaSoup.io session.
room.on('request', function onRequest(request, callback, errback) {
// Create a new request, and set the callback
pending[++reqid] = callback;
// and error callback.
errors[reqid] = errback;
// Then send the request to the pubsub serverr.
sendMS({type: 'MS_SEND', payload: request, meta: {id: reqid, session}})
});
// Hook up the room's notifications to this socketMediaSoup.io sessione
room.on('notify', function onNotification(notification) {
// Create a new notification (with no callbacks).
sendMS({type: 'MS_SEND', payload: notification, meta: {notification: true, session}});
});
// Generate a random peerName, or "publisher" if we are the publisher.
var peerName = kind === 'publish' ? 'publisher' : '' + Math.random();
// Issue the join request via the MediaSoup client API, since it's all wired up.
room.join(peerName)
.then(function onJoin(peers) {
// We got the response, which are the peers, so resolve the pubsub promise.
resolve({room, peers});
})
// Join failures result in rejecting the pubsub promise.
.catch(reject);
}
});
}
// Create the click handler for the start subscribing button.
function playStream(streamid, $video) {
// Start a new session.
var session = ++lastSession;
var video = $video;
// Start a pubsub session for that stream.
pubsub('subscribe', session, streamid)
.then(function onSubscribe(ps) {
// We got a pubsub response, consisting of a Room and Peers.
var room = ps.room;
// Create a new transport we will use to receive from this publisher.
var transport = room.createTransport('recv');
// The server will only send us a single publisher.
// Stream it if it is new...
room.on('newpeer', function newPeer(peer) {
console.log('New peer detected:', peer.name);
setVideoSource(video[0], startRecvStream(peer));
});
// ... or if it already exists.
if (ps.peers[0]) {
console.log('Existing peer detected:', ps.peers[0].name);
setVideoSource(video[0], startRecvStream(ps.peers[0]));
} else {
// Let them know that nobody is publishing yet.
// This color is just a little gray to distinguish from black.
}
// Helper to start receiving a stream from a peer.
function startRecvStream(peer) {
var stream = new MediaStream();
// Add consumers that are added later...
peer.on('newconsumer', addConsumer);
peer.on('closed', function closedPeer() {
// Reset the video source when close.d
setVideoSource(video);
});
// ... as well as adding the consumers that were already present.
for (var i = 0; i < peer.consumers.length; i++) {
addConsumer(peer.consumers[i]);
}
// Helper to add a consumer to the stream.
function addConsumer(consumer) {
if (!consumer.supported) {
// Cannot stream this media.
console.log('consumer', consumer.id, 'not supported');
return;
}
// Receive the consumer on our transport.
consumer.receive(transport)
.then(function receiveTrack(track) {
// We got a new track, so add it to the stream.
console.log('consuming', track.id);
remoteFeeds.set(streamid, session);
stream.addTrack(track);
// We have to reset the video source to make
// sure the track is added on all platforms.
setVideoSource(video, stream);
// On the close of the track...
consumer.on('close', function closeConsumer() {
// ... remove the old track.
console.log('removing the old track', track.id);
stream.removeTrack(track);
// Reset the video source to make the
// track stop playing on all platforms.
setVideoSource(video, stream);
});
})
.catch(function onError(e) {
// We got an error, so log it.
console.log('Cannot add track', e);
});
}
// Return the stream we created.
return stream;
}
})
.catch(function onError(e) {
// An error in the pubsub protocol.
alert('Cannot subscribe to streamid ' + streamid + ': ' + e);
});
}
// Begin the publishing process.
function startPublish() {
// We're starting.
webrtcPublished = jQuery.Deferred();
publishing = true;
if (!gumStream) {
// Need to getUserMedia.
var constraints = {};
constraints.audio = true;
constraints.video = VIDEO_CONSTRAINTS;
navigator.mediaDevices.getUserMedia(constraints)
.catch(function firstErrorCallback(e) {
// Needed on some iOS Safaris, which reject our
// video constraints.
// Delete the dimensions and try again.
// FIXME: Maybe fps will also cause problems?
delete constraints.video.width;
delete constraints.video.height;
return navigator.mediaDevices.getUserMedia(constraints);
})
.then(function successCallback(stream) {
// We got the media, so track it.
gumStream = stream;
// Apply the mute setting.
mute(pubmuted);
// When the gumStream is ready, go on to activate it.
whenStreamIsActive(function getGumStream() {
webrtcPublished.resolve(true);
return gumStream;
}, onGumActive);
})
.catch(function errorCallback(e) {
// Let the user know we failed.
webrtcPublished.resolve(false);
//alert('Error getting media (error code ' + e + ')');
bootbox.alert("Cannot access webcam");
//alert('Cannot publish to streamid ' + streamid + ': ' + e);
jQuery.event.trigger({
type: 'doNotGetMyStreamId',
});
});
}
else {
// We already have the user media, so go on to activate it.
whenStreamIsActive(function getGumStream() {
return gumStream;
}, onGumActive);
}
function onGumActive() {
console.log('adding active getUserMedia stream');
// Change the background to let them know it is captured.
// Get ready to handle the start of the video stream.
myVideo.onplay = onPlay;
// Set the video source.
setVideoSource(myVideo, gumStream);
function onPlay() {
// We're ready, so remove the callback.
myVideo.onplay = null;
// Now that we have something to show, begin streaming.
// Wait a little bit, so the video starts playing on Chrome.
setTimeout(doPublish, 500);
function doPublish() {
// FIXME: Again, you may want a different way to get a streamid
// for the publisher.
var streamid = myStreamid
if (streamid === null) {
return;
}
//streamid = streamid.trim().toLowerCase();
// Keep note of the new publisher's session.
pubsession = ++lastSession;
// Tell them we can stop.
// Begin the pubsub client for this session and streamid.
pubsub('publish', pubsession, streamid)
.then(function onPublish(ps) {
// Get our MediaSoup client Room.
var room = ps.room;
// Create a transport for sending the stream.
var transport = room.createTransport('send');
// Send it now.
startSendStream(gumStream);
function startSendStream(stream) {
// Start connections when our stream is ready.
whenStreamIsActive(function getStream() {
return stream;
}, doConnects);
function doConnects() {
if (!stream) {
// No stream, so ignore.
return;
}
// Produce all the tracks from our stream.
for (var track of
stream.getTracks()
)
{
console.log('producing', track.id);
// Create a producer for the track.
var producer = room.createProducer(track);
// Register it with our producer list for this publisher.
producers.push(producer);
jQuery.event.trigger({
type: 'getMyStreamId',
id: myStreamid
});
// Send the producer on the transport.
producer.send(transport);
}
}
}
})
.catch(function onError(e) {
// Error with the pubsub client.
bootbox.alert("Cannot access webcam");
//alert('Cannot publish to streamid ' + streamid + ': ' + e);
jQuery.event.trigger({
type: 'doNotGetMyStreamId',
});
});
}
}
}
}
// Just stop publishing the stream.
function stopPublish() {
if (typeof myVideo=='undefined') {
return;
}
// We're stopping.
publishing = false;
// Stop playing our video.
setVideoSource(myVideo);
// Close all of the publisher's producers.
while (producers[0]) {
producers[0].close();
producers.shift();
}
// Close the user media stream.
var stream = gumStream;
gumStream = undefined;
if (!stream) {
// No user stream, just return.
return;
}
if (stream.stop) {
// There's a stop method, so use it.
stream.stop();
} else if (stream.getTracks) {
// We need to stop each of the tracks individually.
for (var track of stream.getTracks())
{
track.stop();
}
}
}