RTCEngine-server/mediabench.ts at master · RTCEngine/RTCEngine-server · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124


import fetch from 'node-fetch'

const ip = require('ip')

const MediaServer = require('medooze-media-server')
const SemanticSDP = require('semantic-sdp')
const SDPInfo = SemanticSDP.SDPInfo

const yargs = require('yargs')

const localhost = ip.address()

MediaServer.enableDebug(true)
MediaServer.enableUltraDebug(true)

const argv = yargs
    .usage('Usage: ts-node $0 -s streamname -e 127.0.0.1 -m 127.0.0.1:6000')
    .help('help').alias('help','h')
    .default({
        medianode:'127.0.0.1:6000',
        endpoint: localhost,
        count: 200
    })
    .options({
        medianode: {
            alias: 'm',
            description: 'medianode to use, default 127.0.0.1:6000',
            requiresArg: true,
        },
        endpoint: {
            alias: 'e',
            description: 'endpoint to use, default 127.0.0.1',
            requiresArg: true,
        },
        stream: {
            alias: 's',
            description: 'stream to subscribe',
            requiresArg: true,
            required: true
        },
        count: {
            alias: 'c',
            description: 'stream count to bench',
            requiresArg: true
        }
    }).argv


const capabilities = {
    audio: {
        codecs: ['opus'],
        extensions: [
            'urn:ietf:params:rtp-hdrext:ssrc-audio-level',
            'urn:ietf:params:rtp-hdrext:sdes:mid'
        ]
    },
    video: {
        codecs: ['h264'],
        rtx: true,
        rtcpfbs: [
            { 'id': 'transport-cc' },
            { "id": "ccm", "params": ["fir"] },
            { "id": "nack" },
            { "id": "nack", "params": ["pli"] }
        ],
        extensions: [
            'http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time',
            'http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01',
            'urn:ietf:params:rtp-hdrext:sdes:mid'
        ]
    }
}

const startBench = async (streamId:string, endpoint:string, medianode:string, count:number) => {

    const benchEndpoints = new Map<number,boolean>()

    for (let i=1; i <= count; i++) {

        const relayEndpoint = MediaServer.createEndpoint(endpoint)

        const relayOffer = relayEndpoint.createOffer(capabilities)

        const response = await fetch('http://' + medianode + '/api/play', {
            method: 'post',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                streamId: streamId,
                sdp: relayOffer.toString()
            })
        })

        const ret = await response.json()

        const answerStr = ret.d.sdp

        const relayAnswer = SDPInfo.process(answerStr)

        const relayTransport = relayEndpoint.createTransport(relayAnswer, relayOffer, {disableSTUNKeepAlive: true})

        relayTransport.on('dtlsstate', (state) => {

            if (state === 'connected') {
                benchEndpoints.set(i,true)
                let connected = benchEndpoints.size
                console.log(`transport ${i} connect,  ${connected} connected`)
            }
        })

        relayTransport.setLocalProperties(relayOffer)
        relayTransport.setRemoteProperties(relayAnswer)

        const streamInfo = relayAnswer.getFirstStream()
        const incoming = relayTransport.createIncomingStream(streamInfo)
    }
}

if (argv.stream && argv.endpoint && argv.medianode) {

    startBench(argv.stream, argv.endpoint, argv.medianode, argv.count)
}