| /* |
| * Copyright (C) 2014-2015 Ericsson AB. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| "use strict"; |
| |
| if (typeof(SDP) == "undefined") |
| var SDP = {}; |
| |
| (function () { |
| var regexps = { |
| "vline": "^v=([\\d]+).*$", |
| "oline": "^o=([\\w\\-@\\.]+) ([\\d]+) ([\\d]+) IN (IP[46]) ([\\d\\.a-f\\:]+).*$", |
| "sline": "^s=(.*)$", |
| "tline": "^t=([\\d]+) ([\\d]+).*$", |
| "cline": "^c=IN (IP[46]) ([\\d\\.a-f\\:]+).*$", |
| "msidsemantic": "^a=msid-semantic: *WMS .*$", |
| "mblock": "^m=(audio|video|application) ([\\d]+) ([A-Z/]+)([\\d ]*)$\\r?\\n", |
| "mode": "^a=(sendrecv|sendonly|recvonly|inactive).*$", |
| "mid": "^a=mid:([!#$%&'*+-.\\w]*).*$", |
| "rtpmap": "^a=rtpmap:${type} ([\\w\\-]+)/([\\d]+)/?([\\d]+)?.*$", |
| "fmtp": "^a=fmtp:${type} ([\\w\\-=; ]+).*$", |
| "param": "([\\w\\-]+)=([\\w\\-]+);?", |
| "nack": "^a=rtcp-fb:${type} nack$", |
| "nackpli": "^a=rtcp-fb:${type} nack pli$", |
| "ccmfir": "^a=rtcp-fb:${type} ccm fir$", |
| "ericscream": "^a=rtcp-fb:${type} ericscream$", |
| "rtcp": "^a=rtcp:([\\d]+)( IN (IP[46]) ([\\d\\.a-f\\:]+))?.*$", |
| "rtcpmux": "^a=rtcp-mux.*$", |
| "cname": "^a=ssrc:(\\d+) cname:([\\w+/\\-@\\.\\{\\}]+).*$", |
| "msid": "^a=(ssrc:\\d+ )?msid:([\\w+/\\-=]+) +([\\w+/\\-=]+).*$", |
| "ufrag": "^a=ice-ufrag:([\\w+/]*).*$", |
| "pwd": "^a=ice-pwd:([\\w+/]*).*$", |
| "candidate": "^a=candidate:(\\d+) (\\d) (UDP|TCP) ([\\d\\.]*) ([\\d\\.a-f\\:]*) (\\d*)" + |
| " typ ([a-z]*)( raddr ([\\d\\.a-f\\:]*) rport (\\d*))?" + |
| "( tcptype (active|passive|so))?.*$", |
| "fingerprint": "^a=fingerprint:(sha-1|sha-256) ([A-Fa-f\\d\:]+).*$", |
| "setup": "^a=setup:(actpass|active|passive).*$", |
| "sctpmap": "^a=sctpmap:${port} ([\\w\\-]+)( [\\d]+)?.*$" |
| }; |
| |
| var templates = { |
| "sdp": |
| "v=${version}\r\n" + |
| "o=${username} ${sessionId} ${sessionVersion} ${netType} ${addressType} ${address}\r\n" + |
| "s=${sessionName}\r\n" + |
| "t=${startTime} ${stopTime}\r\n" + |
| "${bundleLine}" + |
| "${msidsemanticLine}", |
| |
| "msidsemantic": "a=msid-semantic:WMS ${mediaStreamIds}\r\n", |
| |
| "mblock": |
| "m=${type} ${port} ${protocol} ${fmt}\r\n" + |
| "c=${netType} ${addressType} ${address}\r\n" + |
| "${rtcpLine}" + |
| "${rtcpMuxLine}" + |
| "${bundleOnlyLine}" + |
| "a=${mode}\r\n" + |
| "${midLine}" + |
| "${rtpMapLines}" + |
| "${fmtpLines}" + |
| "${nackLines}" + |
| "${nackpliLines}" + |
| "${ccmfirLines}" + |
| "${ericScreamLines}" + |
| "${cnameLines}" + |
| "${msidLines}" + |
| "${iceCredentialLines}" + |
| "${candidateLines}" + |
| "${dtlsFingerprintLine}" + |
| "${dtlsSetupLine}" + |
| "${sctpmapLine}", |
| |
| "rtcp": "a=rtcp:${port}${[ ]netType}${[ ]addressType}${[ ]address}\r\n", |
| "rtcpMux": "a=rtcp-mux\r\n", |
| "mid": "a=mid:${mid}\r\n", |
| "bundle": "a=group:BUNDLE ${midsBundle}\r\n", |
| |
| "rtpMap": "a=rtpmap:${type} ${encodingName}/${clockRate}${[/]channels}\r\n", |
| "fmtp": "a=fmtp:${type} ${parameters}\r\n", |
| "nack": "a=rtcp-fb:${type} nack\r\n", |
| "nackpli": "a=rtcp-fb:${type} nack pli\r\n", |
| "ccmfir": "a=rtcp-fb:${type} ccm fir\r\n", |
| "ericscream": "a=rtcp-fb:${type} ericscream\r\n", |
| |
| "cname": "a=ssrc:${ssrc} cname:${cname}\r\n", |
| "msid": "a=msid:${mediaStreamId} ${mediaStreamTrackId}\r\n", |
| |
| "iceCredentials": |
| "a=ice-ufrag:${ufrag}\r\n" + |
| "a=ice-pwd:${password}\r\n", |
| |
| "candidate": |
| "a=candidate:${foundation} ${componentId} ${transport} ${priority} ${address} ${port}" + |
| " typ ${type}${[ raddr ]relatedAddress}${[ rport ]relatedPort}${[ tcptype ]tcpType}\r\n", |
| |
| "dtlsFingerprint": "a=fingerprint:${fingerprintHashFunction} ${fingerprint}\r\n", |
| "dtlsSetup": "a=setup:${setup}\r\n", |
| |
| "sctpmap": "a=sctpmap:${port} ${app}${[ ]streams}\r\n" |
| }; |
| |
| function match(data, pattern, flags, alt) { |
| var r = new RegExp(pattern, flags); |
| return data.match(r) || alt && alt.match(r) || null; |
| } |
| |
| function addDefaults(obj, defaults) { |
| for (var p in defaults) { |
| if (!defaults.hasOwnProperty(p)) |
| continue; |
| if (typeof(obj[p]) == "undefined") |
| obj[p] = defaults[p]; |
| } |
| } |
| |
| function fillTemplate(template, info) { |
| var text = template; |
| for (var p in info) { |
| if (!info.hasOwnProperty(p)) |
| continue; |
| var r = new RegExp("\\${(\\[[^\\]]+\\])?" + p + "(\\[[^\\]]+\\])?}"); |
| text = text.replace(r, function (_, prefix, suffix) { |
| if (!info[p] && info[p] != 0) |
| return ""; |
| prefix = prefix ? prefix.substr(1, prefix.length - 2) : ""; |
| suffix = suffix ? suffix.substr(1, suffix.length - 2) : ""; |
| return prefix + info[p] + suffix; |
| }); |
| } |
| return text; |
| } |
| |
| SDP.parse = function (sdpText) { |
| sdpText = new String(sdpText); |
| var sdpObj = {}; |
| var parts = sdpText.split(new RegExp(regexps.mblock, "m")) || [sdpText]; |
| var sblock = parts.shift(); |
| var version = parseInt((match(sblock, regexps.vline, "m") || [])[1]); |
| if (!isNaN(version)) |
| sdpObj.version = version; |
| var originator = match(sblock, regexps.oline, "m");; |
| if (originator) { |
| sdpObj.originator = { |
| "username": originator[1], |
| "sessionId": originator[2], |
| "sessionVersion": parseInt(originator[3]), |
| "netType": "IN", |
| "addressType": originator[4], |
| "address": originator[5] |
| }; |
| } |
| var sessionName = match(sblock, regexps.sline, "m"); |
| if (sessionName) |
| sdpObj.sessionName = sessionName[1]; |
| var sessionTime = match(sblock, regexps.tline, "m"); |
| if (sessionTime) { |
| sdpObj.startTime = parseInt(sessionTime[1]); |
| sdpObj.stopTime = parseInt(sessionTime[2]); |
| } |
| var hasMediaStreamId = !!match(sblock, regexps.msidsemantic, "m"); |
| sdpObj.mediaDescriptions = []; |
| |
| for (var i = 0; i < parts.length; i += 5) { |
| var mediaDescription = { |
| "type": parts[i], |
| "port": parseInt(parts[i + 1]), |
| "protocol": parts[i + 2], |
| }; |
| var fmt = parts[i + 3].replace(/^[\s\uFEFF\xA0]+/, '') |
| .split(/ +/) |
| .map(function (x) { |
| return parseInt(x); |
| }); |
| var mblock = parts[i + 4]; |
| |
| var connection = match(mblock, regexps.cline, "m", sblock); |
| if (connection) { |
| mediaDescription.netType = "IN"; |
| mediaDescription.addressType = connection[1]; |
| mediaDescription.address = connection[2]; |
| } |
| var mode = match(mblock, regexps.mode, "m", sblock); |
| if (mode) |
| mediaDescription.mode = mode[1]; |
| |
| var mid = match(mblock, regexps.mid, "m", sblock); |
| if (mid) |
| mediaDescription.mid = mid[1]; |
| |
| var payloadTypes = []; |
| if (match(mediaDescription.protocol, "(UDP/TLS)?RTP/S?AVPF?")) { |
| mediaDescription.payloads = []; |
| payloadTypes = fmt; |
| } |
| payloadTypes.forEach(function (payloadType) { |
| var payload = { "type": payloadType }; |
| var rtpmapLine = fillTemplate(regexps.rtpmap, payload); |
| var rtpmap = match(mblock, rtpmapLine, "m"); |
| if (rtpmap) { |
| payload.encodingName = rtpmap[1]; |
| payload.clockRate = parseInt(rtpmap[2]); |
| if (mediaDescription.type == "audio") |
| payload.channels = parseInt(rtpmap[3]) || 1; |
| else if (mediaDescription.type == "video") { |
| var nackLine = fillTemplate(regexps.nack, payload); |
| payload.nack = !!match(mblock, nackLine, "m"); |
| var nackpliLine = fillTemplate(regexps.nackpli, payload); |
| payload.nackpli = !!match(mblock, nackpliLine, "m"); |
| var ccmfirLine = fillTemplate(regexps.ccmfir, payload); |
| payload.ccmfir = !!match(mblock, ccmfirLine, "m"); |
| var ericScreamLine = fillTemplate(regexps.ericscream, payload); |
| payload.ericscream = !!match(mblock, ericScreamLine, "m"); |
| } |
| } else if (payloadType == 0 || payloadType == 8) { |
| payload.encodingName = payloadType == 8 ? "PCMA" : "PCMU"; |
| payload.clockRate = 8000; |
| payload.channels = 1; |
| } |
| var fmtpLine = fillTemplate(regexps.fmtp, payload); |
| var fmtp = match(mblock, fmtpLine, "m"); |
| if (fmtp) { |
| payload.parameters = {}; |
| fmtp[1].replace(new RegExp(regexps.param, "g"), |
| function(_, key, value) { |
| key = key.replace(/-([a-z])/g, function (_, c) { |
| return c.toUpperCase(); |
| }); |
| payload.parameters[key] = isNaN(+value) ? value : +value; |
| }); |
| } |
| mediaDescription.payloads.push(payload); |
| }); |
| |
| var rtcp = match(mblock, regexps.rtcp, "m"); |
| if (rtcp) { |
| mediaDescription.rtcp = { |
| "netType": "IN", |
| "port": parseInt(rtcp[1]) |
| }; |
| if (rtcp[2]) { |
| mediaDescription.rtcp.addressType = rtcp[3]; |
| mediaDescription.rtcp.address = rtcp[4]; |
| } |
| } |
| var rtcpmux = match(mblock, regexps.rtcpmux, "m", sblock); |
| if (rtcpmux) { |
| if (!mediaDescription.rtcp) |
| mediaDescription.rtcp = {}; |
| mediaDescription.rtcp.mux = true; |
| } |
| |
| var cnameLines = match(mblock, regexps.cname, "mg"); |
| if (cnameLines) { |
| mediaDescription.ssrcs = []; |
| cnameLines.forEach(function (line) { |
| var cname = match(line, regexps.cname, "m"); |
| mediaDescription.ssrcs.push(parseInt(cname[1])); |
| if (!mediaDescription.cname) |
| mediaDescription.cname = cname[2]; |
| }); |
| } |
| |
| if (hasMediaStreamId) { |
| var msid = match(mblock, regexps.msid, "m"); |
| if (msid) { |
| mediaDescription.mediaStreamId = msid[2]; |
| mediaDescription.mediaStreamTrackId = msid[3]; |
| } |
| } |
| |
| var ufrag = match(mblock, regexps.ufrag, "m", sblock); |
| var pwd = match(mblock, regexps.pwd, "m", sblock); |
| if (ufrag && pwd) { |
| mediaDescription.ice = { |
| "ufrag": ufrag[1], |
| "password": pwd[1] |
| }; |
| } |
| var candidateLines = match(mblock, regexps.candidate, "mig"); |
| if (candidateLines) { |
| if (!mediaDescription.ice) |
| mediaDescription.ice = {}; |
| mediaDescription.ice.candidates = []; |
| candidateLines.forEach(function (line) { |
| var candidateLine = match(line, regexps.candidate, "mi"); |
| var candidate = { |
| "foundation": candidateLine[1], |
| "componentId": parseInt(candidateLine[2]), |
| "transport": candidateLine[3].toUpperCase(), |
| "priority": parseInt(candidateLine[4]), |
| "address": candidateLine[5], |
| "port": parseInt(candidateLine[6]), |
| "type": candidateLine[7] |
| }; |
| if (candidateLine[9]) |
| candidate.relatedAddress = candidateLine[9]; |
| if (!isNaN(candidateLine[10])) |
| candidate.relatedPort = parseInt(candidateLine[10]); |
| if (candidateLine[12]) |
| candidate.tcpType = candidateLine[12]; |
| else if (candidate.transport == "TCP") { |
| if (candidate.port == 0 || candidate.port == 9) { |
| candidate.tcpType = "active"; |
| candidate.port = 9; |
| } else { |
| return; |
| } |
| } |
| mediaDescription.ice.candidates.push(candidate); |
| }); |
| } |
| |
| var fingerprint = match(mblock, regexps.fingerprint, "mi", sblock); |
| if (fingerprint) { |
| mediaDescription.dtls = { |
| "fingerprintHashFunction": fingerprint[1].toLowerCase(), |
| "fingerprint": fingerprint[2].toUpperCase() |
| }; |
| } |
| var setup = match(mblock, regexps.setup, "m", sblock); |
| if (setup) { |
| if (!mediaDescription.dtls) |
| mediaDescription.dtls = {}; |
| mediaDescription.dtls.setup = setup[1]; |
| } |
| |
| if (mediaDescription.protocol == "DTLS/SCTP") { |
| mediaDescription.sctp = { |
| "port": fmt[0] |
| }; |
| var sctpmapLine = fillTemplate(regexps.sctpmap, mediaDescription.sctp); |
| var sctpmap = match(mblock, sctpmapLine, "m"); |
| if (sctpmap) { |
| mediaDescription.sctp.app = sctpmap[1]; |
| if (sctpmap[2]) |
| mediaDescription.sctp.streams = parseInt(sctpmap[2]); |
| } |
| } |
| |
| sdpObj.mediaDescriptions.push(mediaDescription); |
| } |
| |
| return sdpObj; |
| }; |
| |
| SDP.generate = function (sdpObj) { |
| sdpObj = JSON.parse(JSON.stringify(sdpObj)); |
| addDefaults(sdpObj, { |
| "version": 0, |
| "originator": {}, |
| "sessionName": "-", |
| "startTime": 0, |
| "stopTime": 0, |
| "bundlePolicy": "balanced", |
| "mediaDescriptions": [] |
| }); |
| addDefaults(sdpObj.originator, { |
| "username": "-", |
| "sessionId": "" + Math.floor((Math.random() + +new Date()) * 1e6), |
| "sessionVersion": 1, |
| "netType": "IN", |
| "addressType": "IP4", |
| "address": "127.0.0.1" |
| }); |
| var sdpText = fillTemplate(templates.sdp, sdpObj); |
| sdpText = fillTemplate(sdpText, sdpObj.originator); |
| |
| var midsBundle = []; |
| var mediatypesBundle = []; |
| var msidsemanticLine = ""; |
| var mediaStreamIds = []; |
| sdpObj.mediaDescriptions.forEach(function (mdesc) { |
| if (mdesc.mediaStreamId && mdesc.mediaStreamTrackId |
| && mediaStreamIds.indexOf(mdesc.mediaStreamId) == -1) |
| mediaStreamIds.push(mdesc.mediaStreamId); |
| }); |
| if (mediaStreamIds.length) { |
| var msidsemanticLine = fillTemplate(templates.msidsemantic, |
| { "mediaStreamIds": mediaStreamIds.join(" ") }); |
| } |
| sdpText = fillTemplate(sdpText, { "msidsemanticLine": msidsemanticLine }); |
| |
| sdpObj.mediaDescriptions.forEach(function (mediaDescription) { |
| addDefaults(mediaDescription, { |
| "port": 9, |
| "protocol": "UDP/TLS/RTP/SAVPF", |
| "netType": "IN", |
| "addressType": "IP4", |
| "address": "0.0.0.0", |
| "mode": "sendrecv", |
| "payloads": [], |
| "rtcp": {} |
| }); |
| var mblock = fillTemplate(templates.mblock, mediaDescription); |
| |
| var midBundleInfo = {"midLine": "", "bundleOnlyLine": ""}; |
| if (mediaDescription.mid) { |
| midBundleInfo.midLine = fillTemplate(templates.mid, mediaDescription); |
| if ((sdpObj.bundlePolicy == "balanced" && mediatypesBundle.includes(mediaDescription.type)) || |
| (sdpObj.bundlePolicy == "max-bundle" && mediatypesBundle.length > 0)) |
| midBundleInfo.bundleOnlyLine = "a=bundle-only\r\n"; |
| mediatypesBundle.push(mediaDescription.type) |
| midsBundle.push(mediaDescription.mid); |
| } |
| mblock = fillTemplate(mblock, midBundleInfo); |
| |
| var payloadInfo = {"rtpMapLines": "", "fmtpLines": "", "nackLines": "", |
| "nackpliLines": "", "ccmfirLines": "", "ericScreamLines": ""}; |
| mediaDescription.payloads.forEach(function (payload) { |
| if (payloadInfo.fmt) |
| payloadInfo.fmt += " " + payload.type; |
| else |
| payloadInfo.fmt = payload.type; |
| if (!payload.channels || payload.channels == 1) |
| payload.channels = null; |
| payloadInfo.rtpMapLines += fillTemplate(templates.rtpMap, payload); |
| if (payload.parameters) { |
| var fmtpInfo = { "type": payload.type, "parameters": "" }; |
| for (var p in payload.parameters) { |
| var param = p.replace(/([A-Z])([a-z])/g, function (_, a, b) { |
| return "-" + a.toLowerCase() + b; |
| }); |
| if (fmtpInfo.parameters) |
| fmtpInfo.parameters += ";"; |
| fmtpInfo.parameters += param + "=" + payload.parameters[p]; |
| } |
| payloadInfo.fmtpLines += fillTemplate(templates.fmtp, fmtpInfo); |
| } |
| if (payload.nack) |
| payloadInfo.nackLines += fillTemplate(templates.nack, payload); |
| if (payload.nackpli) |
| payloadInfo.nackpliLines += fillTemplate(templates.nackpli, payload); |
| if (payload.ccmfir) |
| payloadInfo.ccmfirLines += fillTemplate(templates.ccmfir, payload); |
| if (payload.ericscream) |
| payloadInfo.ericScreamLines += fillTemplate(templates.ericscream, payload); |
| }); |
| mblock = fillTemplate(mblock, payloadInfo); |
| |
| var rtcpInfo = {"rtcpLine": "", "rtcpMuxLine": ""}; |
| if (mediaDescription.rtcp.port) { |
| addDefaults(mediaDescription.rtcp, { |
| "netType": "IN", |
| "addressType": "IP4", |
| "address": "" |
| }); |
| if (!mediaDescription.rtcp.address) |
| mediaDescription.rtcp.netType = mediaDescription.rtcp.addressType = ""; |
| rtcpInfo.rtcpLine = fillTemplate(templates.rtcp, mediaDescription.rtcp); |
| } |
| if (mediaDescription.rtcp.mux) |
| rtcpInfo.rtcpMuxLine = templates.rtcpMux; |
| mblock = fillTemplate(mblock, rtcpInfo); |
| |
| var srcAttributeLines = { "cnameLines": "", "msidLines": "" }; |
| var srcAttributes = { |
| "cname": mediaDescription.cname, |
| "mediaStreamId": mediaDescription.mediaStreamId, |
| "mediaStreamTrackId": mediaDescription.mediaStreamTrackId |
| }; |
| if (mediaDescription.cname && mediaDescription.ssrcs) { |
| mediaDescription.ssrcs.forEach(function (ssrc) { |
| srcAttributes.ssrc = ssrc; |
| srcAttributeLines.cnameLines += fillTemplate(templates.cname, srcAttributes); |
| if (mediaDescription.mediaStreamId && mediaDescription.mediaStreamTrackId) |
| srcAttributeLines.msidLines += fillTemplate(templates.msid, srcAttributes); |
| }); |
| } else if (mediaDescription.mediaStreamId && mediaDescription.mediaStreamTrackId) { |
| srcAttributes.ssrc = null; |
| srcAttributeLines.msidLines += fillTemplate(templates.msid, srcAttributes); |
| } |
| mblock = fillTemplate(mblock, srcAttributeLines); |
| |
| var iceInfo = {"iceCredentialLines": "", "candidateLines": ""}; |
| if (mediaDescription.ice) { |
| iceInfo.iceCredentialLines = fillTemplate(templates.iceCredentials, |
| mediaDescription.ice); |
| if (mediaDescription.ice.candidates) { |
| mediaDescription.ice.candidates.forEach(function (candidate) { |
| addDefaults(candidate, { |
| "relatedAddress": null, |
| "relatedPort": null, |
| "tcpType": null |
| }); |
| iceInfo.candidateLines += fillTemplate(templates.candidate, candidate); |
| }); |
| } |
| } |
| mblock = fillTemplate(mblock, iceInfo); |
| |
| var dtlsInfo = { "dtlsFingerprintLine": "", "dtlsSetupLine": "" }; |
| if (mediaDescription.dtls) { |
| if (mediaDescription.dtls.fingerprint) { |
| dtlsInfo.dtlsFingerprintLine = fillTemplate(templates.dtlsFingerprint, |
| mediaDescription.dtls); |
| } |
| addDefaults(mediaDescription.dtls, {"setup": "actpass"}); |
| dtlsInfo.dtlsSetupLine = fillTemplate(templates.dtlsSetup, mediaDescription.dtls); |
| } |
| mblock = fillTemplate(mblock, dtlsInfo); |
| |
| var sctpInfo = {"sctpmapLine": "", "fmt": ""}; |
| if (mediaDescription.sctp) { |
| addDefaults(mediaDescription.sctp, {"streams": null}); |
| sctpInfo.sctpmapLine = fillTemplate(templates.sctpmap, mediaDescription.sctp); |
| sctpInfo.fmt = mediaDescription.sctp.port; |
| } |
| mblock = fillTemplate(mblock, sctpInfo); |
| |
| sdpText += mblock; |
| }); |
| |
| var bundleLine = ""; |
| if (midsBundle.length > 0) |
| bundleLine = fillTemplate(templates.bundle, { "midsBundle": midsBundle.join(" ") }); |
| sdpText = fillTemplate(sdpText, { "bundleLine": bundleLine }); |
| |
| return sdpText; |
| }; |
| |
| SDP.generateCandidateLine = function (candidateObj) { |
| addDefaults(candidateObj, { |
| "relatedAddress": null, |
| "relatedPort": null, |
| "tcpType": null |
| }); |
| |
| return fillTemplate(templates.candidate, candidateObj); |
| }; |
| |
| var expectedProperties = { |
| "session": [ "version", "originator", "sessionName", "startTime", "stopTime" ], |
| "mline": [ "type", "port", "protocol", "mode", "payloads", "rtcp", "dtls", "ice" ], |
| "mlineSubObjects": { |
| "rtcp": [ "mux" ], |
| "ice": [ "ufrag", "password" ], |
| "dtls": [ "setup", "fingerprintHashFunction", "fingerprint" ] |
| } |
| }; |
| |
| function hasAllProperties(object, properties) { |
| var missing = properties.filter(function (property) { |
| return !object.hasOwnProperty(property); |
| }); |
| |
| return !missing.length; |
| } |
| |
| SDP.verifyObject = function (sdpObj) { |
| if (!hasAllProperties(sdpObj, expectedProperties.session)) |
| return false; |
| |
| for (var i = 0; i < sdpObj.mediaDescriptions.length; i++) { |
| var mediaDescription = sdpObj.mediaDescriptions[i]; |
| |
| if (!hasAllProperties(mediaDescription, expectedProperties.mline)) |
| return false; |
| |
| for (var p in expectedProperties.mlineSubObjects) { |
| if (!hasAllProperties(mediaDescription[p], expectedProperties.mlineSubObjects[p])) |
| return false; |
| } |
| } |
| |
| return true; |
| }; |
| |
| })(); |
| |
| function generate(json) { |
| var object = JSON.parse(json); |
| return SDP.generate(object); |
| } |
| |
| function parse(sdp) { |
| var object = SDP.parse(sdp); |
| |
| if (!SDP.verifyObject(object)) |
| return "ParseError"; |
| |
| return JSON.stringify(object); |
| } |
| |
| function generateCandidateLine(json) { |
| var candidate = JSON.parse(json); |
| return SDP.generateCandidateLine(candidate).substr(2); |
| } |
| |
| function parseCandidateLine(candidateLine) { |
| var mdesc = SDP.parse("m=application 0 NONE\r\na=" + candidateLine + "\r\n").mediaDescriptions[0]; |
| if (!mdesc.ice) |
| return "ParseError"; |
| |
| return JSON.stringify(mdesc.ice.candidates[0]); |
| } |
| |
| if (typeof(module) != "undefined" && typeof(exports) != "undefined") |
| module.exports = SDP; |
