Comment le contrôle de la bande passante dans WebRTC appel vidéo?

Je suis en train de développer un Appel Vidéo/application de Visioconférence utilisant WebRTC et node.js.
Maintenant il n'y a pas d'installations pour le contrôle de la bande passante pendant pendant l'appel vidéo. Est-il possible de contrôler et de réduire la bande passante.
(comme je veux faire tout mon application web pour travailler sur 150 kbit /s alors que la vidéo-conférence).

Toutes les suggestions sont grandement appréciés.
Merci à l'avance.

WebRTC est un peer to peer technologie où le serveur vient négocie l'introduction entre les utilisateurs. Pourriez-vous clarifier ce que/dont la bande passante que vous souhaitez limiter?

OriginalL'auteur user2413226 | 2013-05-23

Essayer cette démo. Vous pouvez injecter de la bande passante attributs (b=AS) dans les descriptions des sessions:

audioBandwidth = 50;
videoBandwidth = 256;
function setBandwidth(sdp) {
    sdp = sdp.replace(/a=mid:audio\r\n/g, 'a=mid:audio\r\nb=AS:' + audioBandwidth + '\r\n');
    sdp = sdp.replace(/a=mid:video\r\n/g, 'a=mid:video\r\nb=AS:' + videoBandwidth + '\r\n');
    return sdp;
}


//----------------------------------------------------------

peer.createOffer(function (sessionDescription) {
        sessionDescription.sdp = setBandwidth(sessionDescription.sdp);
        peer.setLocalDescription(sessionDescription);
    }, null, constraints);

peer.createAnswer(function (sessionDescription) {
        sessionDescription.sdp = setBandwidth(sessionDescription.sdp);
        peer.setLocalDescription(sessionDescription);
    }, null, constraints);

b=AS est déjà présent dans la sdp pour data m-line; sa valeur par défaut est 50.

Mis à jour au 23 Septembre 2015

Ici est une bibliothèque qui fournit un contrôle complet sur les deux pistes audio/vidéo' les débits:

//here is how to use it
var bandwidth = {
    screen: 300, //300kbits minimum
    audio: 50,   //50kbits  minimum
    video: 256   //256kbits (both min-max)
};
var isScreenSharing = false;

sdp = BandwidthHandler.setApplicationSpecificBandwidth(sdp, bandwidth, isScreenSharing);
sdp = BandwidthHandler.setVideoBitrates(sdp, {
    min: bandwidth.video,
    max: bandwidth.video
});
sdp = BandwidthHandler.setOpusAttributes(sdp);

Voici le code de la bibliothèque. Il est assez grand, mais il fonctionne!

//BandwidthHandler.js
var BandwidthHandler = (function() {
function setBAS(sdp, bandwidth, isScreen) {
if (!!navigator.mozGetUserMedia || !bandwidth) {
return sdp;
}
if (isScreen) {
if (!bandwidth.screen) {
console.warn('It seems that you are not using bandwidth for screen. Screen sharing is expected to fail.');
} else if (bandwidth.screen < 300) {
console.warn('It seems that you are using wrong bandwidth value for screen. Screen sharing is expected to fail.');
}
}
//if screen; must use at least 300kbs
if (bandwidth.screen && isScreen) {
sdp = sdp.replace(/b=AS([^\r\n]+\r\n)/g, '');
sdp = sdp.replace(/a=mid:video\r\n/g, 'a=mid:video\r\nb=AS:' + bandwidth.screen + '\r\n');
}
//remove existing bandwidth lines
if (bandwidth.audio || bandwidth.video || bandwidth.data) {
sdp = sdp.replace(/b=AS([^\r\n]+\r\n)/g, '');
}
if (bandwidth.audio) {
sdp = sdp.replace(/a=mid:audio\r\n/g, 'a=mid:audio\r\nb=AS:' + bandwidth.audio + '\r\n');
}
if (bandwidth.video) {
sdp = sdp.replace(/a=mid:video\r\n/g, 'a=mid:video\r\nb=AS:' + (isScreen ? bandwidth.screen : bandwidth.video) + '\r\n');
}
return sdp;
}
//Find the line in sdpLines that starts with |prefix|, and, if specified,
//contains |substr| (case-insensitive search).
function findLine(sdpLines, prefix, substr) {
return findLineInRange(sdpLines, 0, -1, prefix, substr);
}
//Find the line in sdpLines[startLine...endLine - 1] that starts with |prefix|
//and, if specified, contains |substr| (case-insensitive search).
function findLineInRange(sdpLines, startLine, endLine, prefix, substr) {
var realEndLine = endLine !== -1 ? endLine : sdpLines.length;
for (var i = startLine; i < realEndLine; ++i) {
if (sdpLines[i].indexOf(prefix) === 0) {
if (!substr ||
sdpLines[i].toLowerCase().indexOf(substr.toLowerCase()) !== -1) {
return i;
}
}
}
return null;
}
//Gets the codec payload type from an a=rtpmap:X line.
function getCodecPayloadType(sdpLine) {
var pattern = new RegExp('a=rtpmap:(\\d+) \\w+\\/\\d+');
var result = sdpLine.match(pattern);
return (result && result.length === 2) ? result[1] : null;
}
function setVideoBitrates(sdp, params) {
params = params || {};
var xgoogle_min_bitrate = params.min;
var xgoogle_max_bitrate = params.max;
var sdpLines = sdp.split('\r\n');
//VP8
var vp8Index = findLine(sdpLines, 'a=rtpmap', 'VP8/90000');
var vp8Payload;
if (vp8Index) {
vp8Payload = getCodecPayloadType(sdpLines[vp8Index]);
}
if (!vp8Payload) {
return sdp;
}
var rtxIndex = findLine(sdpLines, 'a=rtpmap', 'rtx/90000');
var rtxPayload;
if (rtxIndex) {
rtxPayload = getCodecPayloadType(sdpLines[rtxIndex]);
}
if (!rtxIndex) {
return sdp;
}
var rtxFmtpLineIndex = findLine(sdpLines, 'a=fmtp:' + rtxPayload.toString());
if (rtxFmtpLineIndex !== null) {
var appendrtxNext = '\r\n';
appendrtxNext += 'a=fmtp:' + vp8Payload + ' x-google-min-bitrate=' + (xgoogle_min_bitrate || '228') + '; x-google-max-bitrate=' + (xgoogle_max_bitrate || '228');
sdpLines[rtxFmtpLineIndex] = sdpLines[rtxFmtpLineIndex].concat(appendrtxNext);
sdp = sdpLines.join('\r\n');
}
return sdp;
}
function setOpusAttributes(sdp, params) {
params = params || {};
var sdpLines = sdp.split('\r\n');
//Opus
var opusIndex = findLine(sdpLines, 'a=rtpmap', 'opus/48000');
var opusPayload;
if (opusIndex) {
opusPayload = getCodecPayloadType(sdpLines[opusIndex]);
}
if (!opusPayload) {
return sdp;
}
var opusFmtpLineIndex = findLine(sdpLines, 'a=fmtp:' + opusPayload.toString());
if (opusFmtpLineIndex === null) {
return sdp;
}
var appendOpusNext = '';
appendOpusNext += '; stereo=' + (typeof params.stereo != 'undefined' ? params.stereo : '1');
appendOpusNext += '; sprop-stereo=' + (typeof params['sprop-stereo'] != 'undefined' ? params['sprop-stereo'] : '1');
if (typeof params.maxaveragebitrate != 'undefined') {
appendOpusNext += '; maxaveragebitrate=' + (params.maxaveragebitrate || 128 * 1024 * 8);
}
if (typeof params.maxplaybackrate != 'undefined') {
appendOpusNext += '; maxplaybackrate=' + (params.maxplaybackrate || 128 * 1024 * 8);
}
if (typeof params.cbr != 'undefined') {
appendOpusNext += '; cbr=' + (typeof params.cbr != 'undefined' ? params.cbr : '1');
}
if (typeof params.useinbandfec != 'undefined') {
appendOpusNext += '; useinbandfec=' + params.useinbandfec;
}
if (typeof params.usedtx != 'undefined') {
appendOpusNext += '; usedtx=' + params.usedtx;
}
if (typeof params.maxptime != 'undefined') {
appendOpusNext += '\r\na=maxptime:' + params.maxptime;
}
sdpLines[opusFmtpLineIndex] = sdpLines[opusFmtpLineIndex].concat(appendOpusNext);
sdp = sdpLines.join('\r\n');
return sdp;
}
return {
setApplicationSpecificBandwidth: function(sdp, bandwidth, isScreen) {
return setBAS(sdp, bandwidth, isScreen);
},
setVideoBitrates: function(sdp, params) {
return setVideoBitrates(sdp, params);
},
setOpusAttributes: function(sdp, params) {
return setOpusAttributes(sdp, params);
}
};
})();

Voici comment définir l'avance opus bitrate paramètres:

sdp = BandwidthHandler.setOpusAttributes(sdp, {
'stereo': 0, //to disable stereo (to force mono audio)
'sprop-stereo': 1,
'maxaveragebitrate': 500 * 1024 * 8, //500 kbits
'maxplaybackrate': 500 * 1024 * 8, //500 kbits
'cbr': 0, //disable cbr
'useinbandfec': 1, //use inband fec
'usedtx': 1, //use dtx
'maxptime': 3
});

Vous avez donné votre réponse depuis plus d'un an, est-ce encore du travail? J'ai essayé de le faire fonctionner sans succès. Plutôt que d'utiliser la bibliothèque sur le lien, je suis en utilisant simplement le code que vous avez posté.
Il travaille toujours en chrome pour le "vidéo-pistes". b=COMME pour l'audio-pistes a des bugs connus en chrome qui est fixé en Chrome-39. Pour google chrome 38 et plus tôt [pour l'audio-titres], vous pouvez modifier SDP pour "maxaveragebitrate" au lieu de cela, comme vous pouvez voir quelques extraits de ici.
Merci pour la réponse. Quelle méthode utilisez-vous pour vérifier la limitation de la bande passante? Mes tests ont montré aucun changement. Quelles sont les valeurs valides pour la bande passante? Aller au-dessous de 30, je semble perdre de la vidéo entièrement. Merci encore.
Cette webrtc-pedia page énuméré quelques min/max valeurs de bitrate pour VP8 et Opus codecs. BTW, il n'est pas facile de contrôler la bande passante disponible. Ref-1 / Ref-2. BTW, 20kbits est le minimum de la bande passante prise en charge pour VP8, et 30kbits est minimum pour l'Opus.
Il est également possible de limiter la bande passante de la distance de la description et donc à la force par les pairs à la baisse ses bandes passantes? Mon cas d'utilisation: Si je communique avec les anciens appareils tels que l'iPad 3, je ne peux utiliser 240p et une cadence de 10. Sinon, la connexion sera moche. Mais je ne veux pas d'installation de l'ensemble de la getUserMedia() chose de nouveau, car il serait la cause de Firefox pour demander la permission de nouveau.

OriginalL'auteur Muaz Khan

5

Ne sais pas si cela aide, mais vous pouvez limiter la résolution de la vidéo à partir de getUserMedia avec des contraintes: voir démo à simpl.info/getusermedia/constraints/.

Est-il possible de changer la résolution de la vidéo dans le milieu de la conversation. PS: j'ai kurento de l'installation si cela aide. Si je suis à la recherche de la SFU solution au lieu de MCU

OriginalL'auteur Sam Dutton
-1

Vous devez également être en mesure d'utiliser des contraintes de bande passante sur le flux (voir cette démo), mais il ne semble pas y avoir de travail, même dans les dernières canaries (29.0.1529.3).

Il est parfois question de la SDP, l'approche basée sur les discuter de webrtc liste de diffusion, qui se lie à WebRTC bug 1846.

OriginalL'auteur tom
-5

WebRTC est pour la communication entre pairs, vous ne pouvez pas contrôler la largeur de bande dans l'appel vidéo.

Dans google chrome, il y a de ces propriétés sur un élément vidéo:
```
webkitVideoDecodedByteCount: 0
webkitAudioDecodedByteCount: 0
```
Ils sont utiles pour savoir en combien de temps le client est capable de décoder de la vidéo. Comme la vidéo, vous souhaitez garder une trace de la delta montant de ces octets qui vous donne des octets/s, le client est le traitement de la vidéo.(Fil)

vous devez utiliser Réseau d'Information de l'API de connaître la bande passante ( il est encore en cours d'exécution).

OriginalL'auteur Konga Raju

Vous devez vous connecter pour publier un commentaire.