0; --i) {
92 |
93 | /* Shift result one left to make room for another bit,
94 | then add the next bit on the stream. */
95 | result = ((result|0) << 1) | (((this.byte|0) >> (8 - (++this.bitpos))) & 0x01);
96 | if ((this.bitpos|0)>=8) {
97 | this.byte = this.src.getUint8(++this.bytepos);
98 | this.bitpos &= 0x7;
99 | }
100 | }
101 |
102 | return result;
103 | }
104 | skipBits(length) {
105 | this.bitpos += (length|0) & 0x7; // %8
106 | this.bytepos += (length|0) >>> 3; // *8
107 | if (this.bitpos > 7) {
108 | this.bitpos &= 0x7;
109 | ++this.bytepos;
110 | }
111 |
112 | if (!this.finished()) {
113 | this.byte = this.src.getUint8(this.bytepos);
114 | return 0;
115 | } else {
116 | return this.bytepos-this.src.byteLength-this.src.bitpos;
117 | }
118 | }
119 |
120 | finished() {
121 | return this.bytepos >= this.src.byteLength;
122 | }
123 | }
--------------------------------------------------------------------------------
/src/client/hls/pes_aac.js:
--------------------------------------------------------------------------------
1 | import {Log} from '../../deps/bp_logger.js';
2 | import {ADTS} from './adts.js';
3 | import {StreamType, PayloadType} from '../../core/defs.js';
4 | import {AACFrame} from '../../core/elementary/AACFrame.js';
5 |
6 | export class AACPES {
7 | constructor() {
8 | this.aacOverFlow = null;
9 | this.lastAacPTS = null;
10 | this.track = {};
11 | this.config = null;
12 | }
13 |
14 | parse(pes) {
15 | let data = pes.data;
16 | let pts = pes.pts;
17 | let startOffset = 0;
18 | let aacOverFlow = this.aacOverFlow;
19 | let lastAacPTS = this.lastAacPTS;
20 | var config, frameDuration, frameIndex, offset, stamp, len;
21 |
22 | if (aacOverFlow) {
23 | var tmp = new Uint8Array(aacOverFlow.byteLength + data.byteLength);
24 | tmp.set(aacOverFlow, 0);
25 | tmp.set(data, aacOverFlow.byteLength);
26 | Log.debug(`AAC: append overflowing ${aacOverFlow.byteLength} bytes to beginning of new PES`);
27 | data = tmp;
28 | }
29 |
30 | // look for ADTS header (0xFFFx)
31 | for (offset = startOffset, len = data.length; offset < len - 1; offset++) {
32 | if ((data[offset] === 0xff) && (data[offset+1] & 0xf0) === 0xf0) {
33 | break;
34 | }
35 | }
36 | // if ADTS header does not start straight from the beginning of the PES payload, raise an error
37 | if (offset) {
38 | var reason, fatal;
39 | if (offset < len - 1) {
40 | reason = `AAC PES did not start with ADTS header,offset:${offset}`;
41 | fatal = false;
42 | } else {
43 | reason = 'no ADTS header found in AAC PES';
44 | fatal = true;
45 | }
46 | Log.error(reason);
47 | if (fatal) {
48 | return;
49 | }
50 | }
51 |
52 | let hdr = null;
53 | let res = {units:[], type: StreamType.AUDIO, pay: PayloadType.AAC};
54 | if (!this.config) {
55 | hdr = ADTS.parseHeaderConfig(data.subarray(offset));
56 | this.config = hdr.config;
57 | res.config = hdr.config;
58 | hdr.config = null;
59 | Log.debug(`parsed codec:${this.config.codec},rate:${this.config.samplerate},nb channel:${this.config.channels}`);
60 | }
61 | frameIndex = 0;
62 | frameDuration = 1024 * 90000 / this.config.samplerate;
63 |
64 | // if last AAC frame is overflowing, we should ensure timestamps are contiguous:
65 | // first sample PTS should be equal to last sample PTS + frameDuration
66 | if(aacOverFlow && lastAacPTS) {
67 | var newPTS = lastAacPTS+frameDuration;
68 | if(Math.abs(newPTS-pts) > 1) {
69 | Log.debug(`AAC: align PTS for overlapping frames by ${Math.round((newPTS-pts)/90)}`);
70 | pts=newPTS;
71 | }
72 | }
73 |
74 | while ((offset + 5) < len) {
75 | if (!hdr) {
76 | hdr = ADTS.parseHeader(data.subarray(offset));
77 | }
78 | if ((hdr.size > 0) && ((offset + hdr.offset + hdr.size) <= len)) {
79 | stamp = pts + frameIndex * frameDuration;
80 | res.units.push(new AACFrame(data.subarray(offset + hdr.offset, offset + hdr.offset + hdr.size), stamp));
81 | offset += hdr.offset + hdr.size;
82 | frameIndex++;
83 | // look for ADTS header (0xFFFx)
84 | for ( ; offset < (len - 1); offset++) {
85 | if ((data[offset] === 0xff) && ((data[offset + 1] & 0xf0) === 0xf0)) {
86 | break;
87 | }
88 | }
89 | } else {
90 | break;
91 | }
92 | hdr = null;
93 | }
94 | if ((offset < len) && (data[offset]==0xff)) { // TODO: check it
95 | aacOverFlow = data.subarray(offset, len);
96 | //logger.log(`AAC: overflow detected:${len-offset}`);
97 | } else {
98 | aacOverFlow = null;
99 | }
100 | this.aacOverFlow = aacOverFlow;
101 | this.lastAacPTS = stamp;
102 |
103 | return res;
104 | }
105 | }
--------------------------------------------------------------------------------
/src/client/hls/id3.js:
--------------------------------------------------------------------------------
1 | /**
2 | * ID3 parser
3 | */
4 | import {getTagged} from '../../deps/bp_logger.js';
5 |
6 | const logger = getTagged('id3');
7 |
8 | class ID3 {
9 |
10 | constructor(data) {
11 | this._hasTimeStamp = false;
12 | var offset = 0, byte1,byte2,byte3,byte4,tagSize,endPos,header,len;
13 | do {
14 | header = this.readUTF(data,offset,3);
15 | offset+=3;
16 | // first check for ID3 header
17 | if (header === 'ID3') {
18 | // skip 24 bits
19 | offset += 3;
20 | // retrieve tag(s) length
21 | byte1 = data[offset++] & 0x7f;
22 | byte2 = data[offset++] & 0x7f;
23 | byte3 = data[offset++] & 0x7f;
24 | byte4 = data[offset++] & 0x7f;
25 | tagSize = (byte1 << 21) + (byte2 << 14) + (byte3 << 7) + byte4;
26 | endPos = offset + tagSize;
27 | //logger.log(`ID3 tag found, size/end: ${tagSize}/${endPos}`);
28 |
29 | // read ID3 tags
30 | this._parseID3Frames(data, offset,endPos);
31 | offset = endPos;
32 | } else if (header === '3DI') {
33 | // http://id3.org/id3v2.4.0-structure chapter 3.4. ID3v2 footer
34 | offset += 7;
35 | logger.log(`3DI footer found, end: ${offset}`);
36 | } else {
37 | offset -= 3;
38 | len = offset;
39 | if (len) {
40 | //logger.log(`ID3 len: ${len}`);
41 | if (!this.hasTimeStamp) {
42 | logger.warn('ID3 tag found, but no timestamp');
43 | }
44 | this._length = len;
45 | this._payload = data.subarray(0,len);
46 | }
47 | return;
48 | }
49 | } while (true);
50 | }
51 |
52 | readUTF(data,start,len) {
53 |
54 | var result = '',offset = start, end = start + len;
55 | do {
56 | result += String.fromCharCode(data[offset++]);
57 | } while(offset < end);
58 | return result;
59 | }
60 |
61 | _parseID3Frames(data,offset,endPos) {
62 | var tagId,tagLen,tagStart,tagFlags,timestamp;
63 | while(offset + 8 <= endPos) {
64 | tagId = this.readUTF(data,offset,4);
65 | offset +=4;
66 |
67 | tagLen = data[offset++] << 24 +
68 | data[offset++] << 16 +
69 | data[offset++] << 8 +
70 | data[offset++];
71 |
72 | tagFlags = data[offset++] << 8 +
73 | data[offset++];
74 |
75 | tagStart = offset;
76 | //logger.log("ID3 tag id:" + tagId);
77 | switch(tagId) {
78 | case 'PRIV':
79 | //logger.log('parse frame:' + Hex.hexDump(data.subarray(offset,endPos)));
80 | // owner should be "com.apple.streaming.transportStreamTimestamp"
81 | if (this.readUTF(data,offset,44) === 'com.apple.streaming.transportStreamTimestamp') {
82 | offset+=44;
83 | // smelling even better ! we found the right descriptor
84 | // skip null character (string end) + 3 first bytes
85 | offset+= 4;
86 |
87 | // timestamp is 33 bit expressed as a big-endian eight-octet number, with the upper 31 bits set to zero.
88 | var pts33Bit = data[offset++] & 0x1;
89 | this._hasTimeStamp = true;
90 |
91 | timestamp = ((data[offset++] << 23) +
92 | (data[offset++] << 15) +
93 | (data[offset++] << 7) +
94 | data[offset++]) /45;
95 |
96 | if (pts33Bit) {
97 | timestamp += 47721858.84; // 2^32 / 90
98 | }
99 | timestamp = Math.round(timestamp);
100 | logger.trace(`ID3 timestamp found: ${timestamp}`);
101 | this._timeStamp = timestamp;
102 | }
103 | break;
104 | default:
105 | break;
106 | }
107 | }
108 | }
109 |
110 | get hasTimeStamp() {
111 | return this._hasTimeStamp;
112 | }
113 |
114 | get timeStamp() {
115 | return this._timeStamp;
116 | }
117 |
118 | get length() {
119 | return this._length;
120 | }
121 |
122 | get payload() {
123 | return this._payload;
124 | }
125 |
126 | }
127 |
128 | export default ID3;
129 |
130 |
--------------------------------------------------------------------------------
/src/client/hls/adts.js:
--------------------------------------------------------------------------------
1 | import {BitArray} from '../../core/util/binary.js';
2 | import {AACParser} from '../../core/parsers/aac.js';
3 |
4 | export class ADTS {
5 |
6 | static parseHeader(data) {
7 | let bits = new BitArray(data);
8 | bits.skipBits(15);
9 | let protectionAbs = bits.readBits(1);
10 | bits.skipBits(14);
11 | let len = bits.readBits(13);
12 | bits.skipBits(11);
13 | let cnt = bits.readBits(2);
14 | if (!protectionAbs) {
15 | bits.skipBits(16);
16 | }
17 | return {size: len-bits.bytepos, frameCount: cnt, offset: bits.bytepos}
18 | }
19 |
20 | static parseHeaderConfig(data) {
21 | let bits = new BitArray(data);
22 | bits.skipBits(15);
23 | let protectionAbs = bits.readBits(1);
24 | let profile = bits.readBits(2) + 1;
25 | let freq = bits.readBits(4);
26 | bits.skipBits(1);
27 | let channels = bits.readBits(3);
28 | bits.skipBits(4);
29 | let len = bits.readBits(13);
30 | bits.skipBits(11);
31 | let cnt = bits.readBits(2);
32 | if (!protectionAbs) {
33 | bits.skipBits(16);
34 | }
35 |
36 | let userAgent = navigator.userAgent.toLowerCase();
37 | let configLen = 4;
38 | let extSamplingIdx;
39 |
40 | // firefox: freq less than 24kHz = AAC SBR (HE-AAC)
41 | if (userAgent.indexOf('firefox') !== -1) {
42 | if (freq >= 6) {
43 | profile = 5;
44 | configLen = 4;
45 | // HE-AAC uses SBR (Spectral Band Replication) , high frequencies are constructed from low frequencies
46 | // there is a factor 2 between frame sample rate and output sample rate
47 | // multiply frequency by 2 (see table below, equivalent to substract 3)
48 | extSamplingIdx = freq - 3;
49 | } else {
50 | profile = 2;
51 | configLen = 2;
52 | extSamplingIdx = freq;
53 | }
54 | // Android : always use AAC
55 | } else if (userAgent.indexOf('android') !== -1) {
56 | profile = 2;
57 | configLen = 2;
58 | extSamplingIdx = freq;
59 | } else {
60 | /* for other browsers (chrome ...)
61 | always force audio type to be HE-AAC SBR, as some browsers do not support audio codec switch properly (like Chrome ...)
62 | */
63 | profile = 5;
64 | configLen = 4;
65 | // if (manifest codec is HE-AAC or HE-AACv2) OR (manifest codec not specified AND frequency less than 24kHz)
66 | if (freq >= 6) {
67 | // HE-AAC uses SBR (Spectral Band Replication) , high frequencies are constructed from low frequencies
68 | // there is a factor 2 between frame sample rate and output sample rate
69 | // multiply frequency by 2 (see table below, equivalent to substract 3)
70 | extSamplingIdx = freq - 3;
71 | } else {
72 | // if (manifest codec is AAC) AND (frequency less than 24kHz OR nb channel is 1) OR (manifest codec not specified and mono audio)
73 | // Chrome fails to play back with AAC LC mono when initialized with HE-AAC. This is not a problem with stereo.
74 | if (channels === 1) {
75 | profile = 2;
76 | configLen = 2;
77 | }
78 | extSamplingIdx = freq;
79 | }
80 | }
81 |
82 |
83 | let config = new Uint8Array(configLen);
84 |
85 | config[0] = profile << 3;
86 | // samplingFrequencyIndex
87 | config[0] |= (freq & 0x0E) >> 1;
88 | config[1] |= (freq & 0x01) << 7;
89 | // channelConfiguration
90 | config[1] |= channels << 3;
91 | if (profile === 5) {
92 | // adtsExtensionSampleingIndex
93 | config[1] |= (extSamplingIdx & 0x0E) >> 1;
94 | config[2] = (extSamplingIdx & 0x01) << 7;
95 | // adtsObjectType (force to 2, chrome is checking that object type is less than 5 ???
96 | // https://chromium.googlesource.com/chromium/src.git/+/master/media/formats/mp4/aac.cc
97 | config[2] |= 2 << 2;
98 | config[3] = 0;
99 | }
100 | return {
101 | config: {
102 | config: config,
103 | codec: `mp4a.40.${profile}`,
104 | samplerate: AACParser.SampleRates[freq],
105 | channels: channels,
106 | },
107 | size: len-bits.bytepos,
108 | frameCount: cnt,
109 | offset: bits.bytepos
110 | };
111 | }
112 | }
--------------------------------------------------------------------------------
/src/core/parsers/m3u8.js:
--------------------------------------------------------------------------------
1 | // adapted from https://github.com/kanongil/node-m3u8parse/blob/master/attrlist.js
2 | class AttrList {
3 |
4 | constructor(attrs) {
5 | if (typeof attrs === 'string') {
6 | attrs = AttrList.parseAttrList(attrs);
7 | }
8 | for(var attr in attrs){
9 | if(attrs.hasOwnProperty(attr)) {
10 | this[attr] = attrs[attr];
11 | }
12 | }
13 | this.attrs = attrs;
14 | }
15 |
16 | decimalInteger(attrName) {
17 | const intValue = parseInt(this[attrName], 10);
18 | if (intValue > Number.MAX_SAFE_INTEGER) {
19 | return Infinity;
20 | }
21 | return intValue;
22 | }
23 |
24 | hexadecimalInteger(attrName) {
25 | if(this[attrName]) {
26 | let stringValue = (this[attrName] || '0x').slice(2);
27 | stringValue = ((stringValue.length & 1) ? '0' : '') + stringValue;
28 |
29 | const value = new Uint8Array(stringValue.length / 2);
30 | for (let i = 0; i < stringValue.length / 2; i++) {
31 | value[i] = parseInt(stringValue.slice(i * 2, i * 2 + 2), 16);
32 | }
33 | return value;
34 | } else {
35 | return null;
36 | }
37 | }
38 |
39 | hexadecimalIntegerAsNumber(attrName) {
40 | const intValue = parseInt(this[attrName], 16);
41 | if (intValue > Number.MAX_SAFE_INTEGER) {
42 | return Infinity;
43 | }
44 | return intValue;
45 | }
46 |
47 | decimalFloatingPoint(attrName) {
48 | return parseFloat(this[attrName]);
49 | }
50 |
51 | enumeratedString(attrName) {
52 | return this[attrName];
53 | }
54 |
55 | decimalResolution(attrName) {
56 | const res = /^(\d+)x(\d+)$/.exec(this[attrName]);
57 | if (res === null) {
58 | return undefined;
59 | }
60 | return {
61 | width: parseInt(res[1], 10),
62 | height: parseInt(res[2], 10)
63 | };
64 | }
65 |
66 | static parseAttrList(input) {
67 | const re = /\s*(.+?)\s*=((?:\".*?\")|.*?)(?:,|$)/g;
68 | var match, attrs = {};
69 | while ((match = re.exec(input)) !== null) {
70 | var value = match[2], quote = '"';
71 |
72 | if (value.indexOf(quote) === 0 &&
73 | value.lastIndexOf(quote) === (value.length-1)) {
74 | value = value.slice(1, -1);
75 | }
76 | attrs[match[1]] = value;
77 | }
78 | return attrs;
79 | }
80 |
81 | }
82 |
83 | export class M3U8Parser {
84 | static get TYPE_CHUNK() {return 0;}
85 | static get TYPE_PLAYLIST() {return 1;}
86 | // TODO: parse master playlists
87 | static parse(playlist, baseUrl='') {
88 | playlist = playlist.replace(/\r/, '').split('\n');
89 | if (playlist.shift().indexOf('#EXTM3U') < 0) {
90 | throw new Error("Bad playlist");
91 | }
92 | let chunkList = [];
93 | let playlistList = [];
94 | let expectedUrl = false;
95 | let cont = {};
96 | let urlType=null;
97 | while (playlist.length) {
98 | let entry = playlist.shift().replace(/\r/, '');
99 | if (expectedUrl) {
100 | if (entry) {
101 | cont.url = entry.startsWith('http')?entry:`${baseUrl}/${entry}`;
102 | switch (urlType) {
103 | case M3U8Parser.TYPE_CHUNK:
104 | chunkList.push(cont);
105 | break;
106 | case M3U8Parser.TYPE_PLAYLIST:
107 | playlistList.push(cont);
108 | break;
109 | }
110 | cont={};
111 | expectedUrl = false;
112 | }
113 | } else {
114 | if (entry.startsWith('#EXTINF')) {
115 | // TODO: it's unsafe
116 | cont.duration = Number(entry.split(':')[1].split(',')[0]);
117 | urlType = M3U8Parser.TYPE_CHUNK;
118 | expectedUrl = true;
119 | } else if (entry.startsWith('#EXT-X-STREAM-INF')){
120 | let props = entry.split(':')[1];
121 | let al = new AttrList(props);
122 | for (let prop in al.attrs) {
123 | cont[prop.toLowerCase()]= al.attrs[prop];
124 | }
125 | urlType = M3U8Parser.TYPE_PLAYLIST;
126 | expectedUrl = true;
127 | }
128 | }
129 | }
130 | return {chunks: chunkList, playlists: playlistList}
131 | }
132 | }
--------------------------------------------------------------------------------
/src/core/remuxer/base.js:
--------------------------------------------------------------------------------
1 | import {getTagged} from '../../deps/bp_logger.js';
2 |
3 | const Log = getTagged('remuxer:base');
4 | let track_id = 1;
5 | export class BaseRemuxer {
6 |
7 | static get MP4_TIMESCALE() { return 90000;}
8 |
9 | // TODO: move to ts parser
10 | // static PTSNormalize(value, reference) {
11 | //
12 | // let offset;
13 | // if (reference === undefined) {
14 | // return value;
15 | // }
16 | // if (reference < value) {
17 | // // - 2^33
18 | // offset = -8589934592;
19 | // } else {
20 | // // + 2^33
21 | // offset = 8589934592;
22 | // }
23 | // /* PTS is 33bit (from 0 to 2^33 -1)
24 | // if diff between value and reference is bigger than half of the amplitude (2^32) then it means that
25 | // PTS looping occured. fill the gap */
26 | // while (Math.abs(value - reference) > 4294967296) {
27 | // value += offset;
28 | // }
29 | // return value;
30 | // }
31 |
32 | static getTrackID() {
33 | return track_id++;
34 | }
35 |
36 | constructor(timescale, scaleFactor, params) {
37 | this.timeOffset = 0;
38 | this.timescale = timescale;
39 | this.scaleFactor = scaleFactor;
40 | this.readyToDecode = false;
41 | this.samples = [];
42 | this.seq = 1;
43 | this.tsAlign = 1;
44 | }
45 |
46 | scaled(timestamp) {
47 | return timestamp / this.scaleFactor;
48 | }
49 |
50 | unscaled(timestamp) {
51 | return timestamp * this.scaleFactor;
52 | }
53 |
54 | remux(unit) {
55 | if (unit) {
56 | this.samples.push({
57 | unit: unit,
58 | pts: unit.pts,
59 | dts: unit.dts
60 | });
61 | return true;
62 | }
63 | return false;
64 | }
65 |
66 | static toMS(timestamp) {
67 | return timestamp/90;
68 | }
69 |
70 | setConfig(config) {
71 |
72 | }
73 |
74 | insertDscontinuity() {
75 | this.samples.push(null);
76 | }
77 |
78 | init(initPTS, initDTS, shouldInitialize=true) {
79 | this.initPTS = Math.min(initPTS, this.samples[0].dts /*- this.unscaled(this.timeOffset)*/);
80 | this.initDTS = Math.min(initDTS, this.samples[0].dts /*- this.unscaled(this.timeOffset)*/);
81 | Log.debug(`Initial pts=${this.initPTS} dts=${this.initDTS} offset=${this.unscaled(this.timeOffset)}`);
82 | this.initialized = shouldInitialize;
83 | }
84 |
85 | flush() {
86 | this.seq++;
87 | this.mp4track.len = 0;
88 | this.mp4track.samples = [];
89 | }
90 |
91 | static dtsSortFunc(a,b) {
92 | return (a.dts-b.dts);
93 | }
94 |
95 | static groupByDts(gop) {
96 | const groupBy = (xs, key) => {
97 | return xs.reduce((rv, x) => {
98 | (rv[x[key]] = rv[x[key]] || []).push(x);
99 | return rv;
100 | }, {});
101 | };
102 | return groupBy(gop, 'dts');
103 | }
104 |
105 | getPayloadBase(sampleFunction, setupSample) {
106 | if (!this.readyToDecode || !this.initialized || !this.samples.length) return null;
107 | this.samples.sort(BaseRemuxer.dtsSortFunc);
108 | return true;
109 | //
110 | // let payload = new Uint8Array(this.mp4track.len);
111 | // let offset = 0;
112 | // let samples=this.mp4track.samples;
113 | // let mp4Sample, lastDTS, pts, dts;
114 | //
115 | // while (this.samples.length) {
116 | // let sample = this.samples.shift();
117 | // if (sample === null) {
118 | // // discontinuity
119 | // this.nextDts = undefined;
120 | // break;
121 | // }
122 | //
123 | // let unit = sample.unit;
124 | //
125 | // pts = Math.round((sample.pts - this.initDTS)/this.tsAlign)*this.tsAlign;
126 | // dts = Math.round((sample.dts - this.initDTS)/this.tsAlign)*this.tsAlign;
127 | // // ensure DTS is not bigger than PTS
128 | // dts = Math.min(pts, dts);
129 | //
130 | // // sampleFunction(pts, dts); // TODO:
131 | //
132 | // // mp4Sample = setupSample(unit, pts, dts); // TODO:
133 | //
134 | // payload.set(unit.getData(), offset);
135 | // offset += unit.getSize();
136 | //
137 | // samples.push(mp4Sample);
138 | // lastDTS = dts;
139 | // }
140 | // if (!samples.length) return null;
141 | //
142 | // // samplesPostFunction(samples); // TODO:
143 | //
144 | // return new Uint8Array(payload.buffer, 0, this.mp4track.len);
145 | }
146 | }
--------------------------------------------------------------------------------
/src/core/remuxer/aac.js:
--------------------------------------------------------------------------------
1 | import {getTagged} from '../../deps/bp_logger.js';
2 | import {MSE} from '../presentation/mse.js';
3 | import {BaseRemuxer} from './base.js';
4 |
5 | const Log = getTagged("remuxer:aac");
6 | // TODO: asm.js
7 | export class AACRemuxer extends BaseRemuxer {
8 |
9 | constructor(timescale, scaleFactor = 1, params={}) {
10 | super(timescale, scaleFactor);
11 |
12 | this.codecstring=MSE.CODEC_AAC;
13 | this.units = [];
14 | this.initDTS = undefined;
15 | this.nextAacPts = undefined;
16 | this.lastPts = 0;
17 | this.firstDTS = 0;
18 | this.firstPTS = 0;
19 | this.duration = params.duration || 1;
20 | this.initialized = false;
21 |
22 | this.mp4track={
23 | id:BaseRemuxer.getTrackID(),
24 | type: 'audio',
25 | fragmented:true,
26 | channelCount:0,
27 | audiosamplerate: this.timescale,
28 | duration: 0,
29 | timescale: this.timescale,
30 | volume: 1,
31 | samples: [],
32 | config: '',
33 | len: 0
34 | };
35 | if (params.config) {
36 | this.setConfig(params.config);
37 | }
38 | }
39 |
40 | setConfig(config) {
41 | this.mp4track.channelCount = config.channels;
42 | this.mp4track.audiosamplerate = config.samplerate;
43 | if (!this.mp4track.duration) {
44 | this.mp4track.duration = (this.duration?this.duration:1)*config.samplerate;
45 | }
46 | this.mp4track.timescale = config.samplerate;
47 | this.mp4track.config = config.config;
48 | this.mp4track.codec = config.codec;
49 | this.timescale = config.samplerate;
50 | this.scaleFactor = BaseRemuxer.MP4_TIMESCALE / config.samplerate;
51 | this.expectedSampleDuration = 1024 * this.scaleFactor;
52 | this.readyToDecode = true;
53 | }
54 |
55 | remux(aac) {
56 | if (super.remux.call(this, aac)) {
57 | this.mp4track.len += aac.getSize();
58 | }
59 | }
60 |
61 | getPayload() {
62 | if (!this.readyToDecode || !this.samples.length) return null;
63 | this.samples.sort(function(a, b) {
64 | return (a.dts-b.dts);
65 | });
66 |
67 | let payload = new Uint8Array(this.mp4track.len);
68 | let offset = 0;
69 | let samples=this.mp4track.samples;
70 | let mp4Sample, lastDTS, pts, dts;
71 |
72 | while (this.samples.length) {
73 | let sample = this.samples.shift();
74 | if (sample === null) {
75 | // discontinuity
76 | this.nextDts = undefined;
77 | break;
78 | }
79 | let unit = sample.unit;
80 | pts = sample.pts - this.initDTS;
81 | dts = sample.dts - this.initDTS;
82 |
83 | if (lastDTS === undefined) {
84 | if (this.nextDts) {
85 | let delta = Math.round(this.scaled(pts - this.nextAacPts));
86 | // if fragment are contiguous, or delta less than 600ms, ensure there is no overlap/hole between fragments
87 | if (/*contiguous || */Math.abs(delta) < 600) {
88 | // log delta
89 | if (delta) {
90 | if (delta > 0) {
91 | Log.log(`${delta} ms hole between AAC samples detected,filling it`);
92 | // if we have frame overlap, overlapping for more than half a frame duraion
93 | } else if (delta < -12) {
94 | // drop overlapping audio frames... browser will deal with it
95 | Log.log(`${(-delta)} ms overlapping between AAC samples detected, drop frame`);
96 | this.mp4track.len -= unit.getSize();
97 | continue;
98 | }
99 | // set DTS to next DTS
100 | pts = dts = this.nextAacPts;
101 | }
102 | }
103 | }
104 | // remember first PTS of our aacSamples, ensure value is positive
105 | this.firstDTS = Math.max(0, dts);
106 | }
107 |
108 | mp4Sample = {
109 | size: unit.getSize(),
110 | cts: 0,
111 | duration:1024,
112 | flags: {
113 | isLeading: 0,
114 | isDependedOn: 0,
115 | hasRedundancy: 0,
116 | degradPrio: 0,
117 | dependsOn: 1
118 | }
119 | };
120 |
121 | payload.set(unit.getData(), offset);
122 | offset += unit.getSize();
123 | samples.push(mp4Sample);
124 | lastDTS = dts;
125 | }
126 | if (!samples.length) return null;
127 | this.nextDts =pts+this.expectedSampleDuration;
128 | return new Uint8Array(payload.buffer, 0, this.mp4track.len);
129 | }
130 | }
131 | //test.bundle.js:42 [remuxer:h264] skip frame from the past at DTS=18397972271140676 with expected DTS=18397998040950484
--------------------------------------------------------------------------------
/frameworks/react/public/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Streamedian RTSP player example
14 | Streamedian RTSP Player Example using the React framework
19 |
20 |
21 | View HTML5 RTSP video player log
22 |
23 | clear
24 | scroll up
25 | scroll down
26 | Scroll off
27 | How to use the player in the global network
30 |
31 | With an empty license file, you can only watch the stream on your computer locally (intranet).
36 |
37 | Windows: C:\Program Files\Streamedian\WS RTSP Proxy Server\activation_appMac OS: /Library/Application Support/Streamedian/WS RTSP Proxy Server/activation_appLinux (Ubunty, Debian, Centos, Fedora ): /usr/bin/wsp/activation_app
41 | For more information go to documentation
42 |
134 |
135 |
136 |
--------------------------------------------------------------------------------
/frameworks/react/src/serviceWorker.js:
--------------------------------------------------------------------------------
1 | // This optional code is used to register a service worker.
2 | // register() is not called by default.
3 |
4 | // This lets the app load faster on subsequent visits in production, and gives
5 | // it offline capabilities. However, it also means that developers (and users)
6 | // will only see deployed updates on subsequent visits to a page, after all the
7 | // existing tabs open on the page have been closed, since previously cached
8 | // resources are updated in the background.
9 |
10 | // To learn more about the benefits of this model and instructions on how to
11 | // opt-in, read http://bit.ly/CRA-PWA
12 |
13 | const isLocalhost = Boolean(
14 | window.location.hostname === 'localhost' ||
15 | // [::1] is the IPv6 localhost address.
16 | window.location.hostname === '[::1]' ||
17 | // 127.0.0.1/8 is considered localhost for IPv4.
18 | window.location.hostname.match(
19 | /^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/
20 | )
21 | );
22 |
23 | export function register(config) {
24 | if (process.env.NODE_ENV === 'production' && 'serviceWorker' in navigator) {
25 | // The URL constructor is available in all browsers that support SW.
26 | const publicUrl = new URL(process.env.PUBLIC_URL, window.location.href);
27 | if (publicUrl.origin !== window.location.origin) {
28 | // Our service worker won't work if PUBLIC_URL is on a different origin
29 | // from what our page is served on. This might happen if a CDN is used to
30 | // serve assets; see https://github.com/facebook/create-react-app/issues/2374
31 | return;
32 | }
33 |
34 | window.addEventListener('load', () => {
35 | const swUrl = `${process.env.PUBLIC_URL}/service-worker.js`;
36 |
37 | if (isLocalhost) {
38 | // This is running on localhost. Let's check if a service worker still exists or not.
39 | checkValidServiceWorker(swUrl, config);
40 |
41 | // Add some additional logging to localhost, pointing developers to the
42 | // service worker/PWA documentation.
43 | navigator.serviceWorker.ready.then(() => {
44 | console.log(
45 | 'This web app is being served cache-first by a service ' +
46 | 'worker. To learn more, visit http://bit.ly/CRA-PWA'
47 | );
48 | });
49 | } else {
50 | // Is not localhost. Just register service worker
51 | registerValidSW(swUrl, config);
52 | }
53 | });
54 | }
55 | }
56 |
57 | function registerValidSW(swUrl, config) {
58 | navigator.serviceWorker
59 | .register(swUrl)
60 | .then(registration => {
61 | registration.onupdatefound = () => {
62 | const installingWorker = registration.installing;
63 | if (installingWorker == null) {
64 | return;
65 | }
66 | installingWorker.onstatechange = () => {
67 | if (installingWorker.state === 'installed') {
68 | if (navigator.serviceWorker.controller) {
69 | // At this point, the updated precached content has been fetched,
70 | // but the previous service worker will still serve the older
71 | // content until all client tabs are closed.
72 | console.log(
73 | 'New content is available and will be used when all ' +
74 | 'tabs for this page are closed. See http://bit.ly/CRA-PWA.'
75 | );
76 |
77 | // Execute callback
78 | if (config && config.onUpdate) {
79 | config.onUpdate(registration);
80 | }
81 | } else {
82 | // At this point, everything has been precached.
83 | // It's the perfect time to display a
84 | // "Content is cached for offline use." message.
85 | console.log('Content is cached for offline use.');
86 |
87 | // Execute callback
88 | if (config && config.onSuccess) {
89 | config.onSuccess(registration);
90 | }
91 | }
92 | }
93 | };
94 | };
95 | })
96 | .catch(error => {
97 | console.error('Error during service worker registration:', error);
98 | });
99 | }
100 |
101 | function checkValidServiceWorker(swUrl, config) {
102 | // Check if the service worker can be found. If it can't reload the page.
103 | fetch(swUrl)
104 | .then(response => {
105 | // Ensure service worker exists, and that we really are getting a JS file.
106 | const contentType = response.headers.get('content-type');
107 | if (
108 | response.status === 404 ||
109 | (contentType != null && contentType.indexOf('javascript') === -1)
110 | ) {
111 | // No service worker found. Probably a different app. Reload the page.
112 | navigator.serviceWorker.ready.then(registration => {
113 | registration.unregister().then(() => {
114 | window.location.reload();
115 | });
116 | });
117 | } else {
118 | // Service worker found. Proceed as normal.
119 | registerValidSW(swUrl, config);
120 | }
121 | })
122 | .catch(() => {
123 | console.log(
124 | 'No internet connection found. App is running in offline mode.'
125 | );
126 | });
127 | }
128 |
129 | export function unregister() {
130 | if ('serviceWorker' in navigator) {
131 | navigator.serviceWorker.ready.then(registration => {
132 | registration.unregister();
133 | });
134 | }
135 | }
136 |
--------------------------------------------------------------------------------
/src/core/parsers/pes.js:
--------------------------------------------------------------------------------
1 | import {appendByteArray} from '../util/binary.js';
2 |
3 | export class PESAsm {
4 |
5 | constructor() {
6 | this.fragments = [];
7 | this.pesLength=0;
8 | this.pesPkt = null;
9 | }
10 |
11 | parse(frag) {
12 |
13 | if (this.extPresent) {
14 | let ext = this.parseExtension(frag);
15 | ext.data = frag.subarray(ext.offset);
16 | } else {
17 | return null;
18 | }
19 | }
20 |
21 | parseHeader() {
22 | let hdr = this.fragments[0];
23 | let pesPrefix = (hdr[0] << 16) + (hdr[1] << 8) + hdr[2];
24 | this.extPresent = ![0xbe, 0xbf].includes(hdr[3]);
25 | if (pesPrefix === 1) {
26 | let pesLength = (hdr[4] << 8) + hdr[5];
27 | if (pesLength) {
28 | this.pesLength = pesLength;
29 | this.hasLength = true;
30 | } else {
31 | this.hasLength = false;
32 | this.pesPkt = null;
33 | }
34 | return true;
35 | }
36 | return false;
37 | }
38 |
39 | static PTSNormalize(value, reference) {
40 |
41 | let offset;
42 | if (reference === undefined) {
43 | return value;
44 | }
45 | if (reference < value) {
46 | // - 2^33
47 | offset = -8589934592;
48 | } else {
49 | // + 2^33
50 | offset = 8589934592;
51 | }
52 | /* PTS is 33bit (from 0 to 2^33 -1)
53 | if diff between value and reference is bigger than half of the amplitude (2^32) then it means that
54 | PTS looping occured. fill the gap */
55 | while (Math.abs(value - reference) > 4294967296) {
56 | value += offset;
57 | }
58 | return value;
59 | }
60 |
61 | parseExtension(frag) {
62 | let pesFlags, pesPrefix, pesLen, pesHdrLen, pesPts, pesDts, payloadStartOffset;
63 | pesFlags = frag[1];
64 | if (pesFlags & 0xC0) {
65 | /* PES header described here : http://dvd.sourceforge.net/dvdinfo/pes-hdr.html
66 | as PTS / DTS is 33 bit we cannot use bitwise operator in JS,
67 | as Bitwise operators treat their operands as a sequence of 32 bits */
68 | pesPts = (frag[3] & 0x0E) * 536870912 +// 1 << 29
69 | (frag[4] & 0xFF) * 4194304 +// 1 << 22
70 | (frag[5] & 0xFE) * 16384 +// 1 << 14
71 | (frag[6] & 0xFF) * 128 +// 1 << 7
72 | (frag[7] & 0xFE) / 2;
73 | // check if greater than 2^32 -1
74 | if (pesPts > 4294967295) {
75 | // decrement 2^33
76 | pesPts -= 8589934592;
77 | }
78 | if (pesFlags & 0x40) {
79 | pesDts = (frag[8] & 0x0E ) * 536870912 +// 1 << 29
80 | (frag[9] & 0xFF ) * 4194304 +// 1 << 22
81 | (frag[10] & 0xFE ) * 16384 +// 1 << 14
82 | (frag[11] & 0xFF ) * 128 +// 1 << 7
83 | (frag[12] & 0xFE ) / 2;
84 | // check if greater than 2^32 -1
85 | if (pesDts > 4294967295) {
86 | // decrement 2^33
87 | pesDts -= 8589934592;
88 | }
89 | } else {
90 | pesDts = pesPts;
91 | }
92 |
93 | pesHdrLen = frag[2];
94 | payloadStartOffset = pesHdrLen + 9;
95 |
96 | // TODO: normalize pts/dts
97 | return {offset: payloadStartOffset, pts: pesPts, dts: pesDts};
98 | } else {
99 | return null;
100 | }
101 | }
102 |
103 | feed(frag, shouldParse) {
104 |
105 | let res = null;
106 | if (shouldParse && this.fragments.length) {
107 | if (!this.parseHeader()) {
108 | throw new Error("Invalid PES packet");
109 | }
110 |
111 | let offset = 6;
112 | let parsed = {};
113 | if (this.extPresent) {
114 | // TODO: make sure fragment have necessary length
115 | parsed = this.parseExtension(this.fragments[0].subarray(6));
116 | offset = parsed.offset;
117 | }
118 | if (!this.pesPkt) {
119 | this.pesPkt = new Uint8Array(this.pesLength);
120 | }
121 |
122 | let poffset = 0;
123 | while (this.pesLength && this.fragments.length) {
124 | let data = this.fragments.shift();
125 | if (offset) {
126 | if (data.byteLength < offset) {
127 | offset -= data.byteLength;
128 | continue;
129 | } else {
130 | data = data.subarray(offset);
131 | this.pesLength -= offset - (this.hasLength?6:0);
132 | offset = 0;
133 | }
134 | }
135 | this.pesPkt.set(data, poffset);
136 | poffset += data.byteLength;
137 | this.pesLength -= data.byteLength;
138 | }
139 | res = {data:this.pesPkt, pts: parsed.pts, dts: parsed.dts};
140 | } else {
141 | this.pesPkt = null;
142 | }
143 | this.pesLength += frag.byteLength;
144 |
145 | if (this.fragments.length && this.fragments[this.fragments.length-1].byteLength < 6) {
146 | this.fragments[this.fragments.length-1] = appendByteArray(this.fragments[0], frag);
147 | } else {
148 | this.fragments.push(frag);
149 | }
150 |
151 | return res;
152 | }
153 | }
--------------------------------------------------------------------------------
/Server(NodeJS):
--------------------------------------------------------------------------------
1 | /**
2 | * Created by wendy on 2017/4/13.
3 | * 4/14 可以正常播放，但是花屏。。。效果不好啊
4 | */
5 | var wsserver = new (require('ws').Server)({port:1104});
6 | var net = require('net');
7 | var channelIndex = 1;
8 | wsserver.on("close", function () {
9 | console.log("close",conn);
10 | });
11 | var channelsocket = {};
12 | wsserver.on('connection',function(conn) {
13 | console.log("protocol",conn.protocol);
14 | var protocol = conn.protocol;
15 | if(protocol == "control") {
16 | conn.onmessage = function (msg) {
17 | console.log(msg.data);
18 | var res = wspParse(msg.data);
19 | if(res.msg == "INIT"){
20 | var ipIndex = _ip2int(res.data.host);
21 |
22 | var channel = channelIndex++;
23 | conn.channel = channel;
24 | InitChannel(channel,ipIndex,res.data.host,res.data.port,function(){
25 | var msg = wspMsg("200","INIT OK",res.data.seq,{"channel":channel});
26 | conn.send(msg);
27 | },function(msgFail){
28 | var msg = wspMsg("501",msgFail,res.data.seq);
29 | conn.send(msg);
30 | });
31 |
32 |
33 | }
34 | else if(res.msg == "WRAP"){
35 | //console.log(res.payload);
36 | if(channelsocket[conn.channel])
37 | {
38 | channelsocket[conn.channel].outControlData = true;
39 | channelsocket[conn.channel].once('data',function(data){
40 | console.log(data.toString('utf8'));
41 | var msg = wspMsg("200","WRAP OK",res.data.seq,{"channel":conn.channel},data);
42 | conn.send(msg);
43 | });
44 | channelsocket[conn.channel].write(res.payload);
45 | }
46 | }
47 |
48 | }
49 | }
50 | else if(protocol == "data"){
51 | //建立pipe
52 | conn.onmessage = function (msg) {
53 | console.log(msg.data);
54 | var res = wspParse(msg.data);
55 | if(res.msg == "JOIN") {
56 | channelsocket[res.data.channel].on('rtpData', function (data) {
57 | console.log(data);
58 | conn.send(data);
59 | });
60 |
61 | var msg = wspMsg("200", "JOIN OK", res.data.seq);
62 | conn.send(msg);
63 |
64 |
65 | }
66 | }
67 | }
68 | });
69 | function _ip2int(ip)
70 | {
71 | var num = 0;
72 | ip = ip.split(".");
73 | num = Number(ip[0]) * 256 * 256 * 256 + Number(ip[1]) * 256 * 256 + Number(ip[2]) * 256 + Number(ip[3]);
74 | num = num >>> 0;
75 | return num;
76 | }
77 | function InitChannel(channel,ipIndex,ip,prt,okFunc,failFunc){
78 |
79 | var sock = net.connect({host:ip,port:prt},function(){
80 | channelsocket[channel] = sock;
81 | okFunc();
82 | sock.connectInfo = true;
83 |
84 | sock.rtpBuffer = new Buffer(2048);
85 | sock.on('data',function(data){
86 | if(sock.outControlData)
87 | {
88 | sock.outControlData = false;
89 | return;
90 | }
91 |
92 | var flag = 0;
93 | if(sock.SubBuffer && sock.SubBufferLen>0){
94 | flag = sock.SubBuffer.length - sock.SubBufferLen;
95 | data.copy(sock.SubBuffer,sock.SubBufferLen, 0, flag - 1);
96 | sock.emit("rtpData",sock.SubBuffer);
97 |
98 | sock.SubBufferLen = 0;
99 | }
100 |
101 | while(flag < data.length) {
102 | var len = data.readUIntBE(flag + 2, 2);
103 | sock.SubBuffer = new Buffer(4 + len);
104 |
105 | if ((flag+4+len) <= data.length)
106 | {
107 | data.copy(sock.SubBuffer, 0, flag, flag + len - 1);
108 | sock.emit("rtpData",sock.SubBuffer);
109 | sock.SubBufferLen = 0;
110 | }
111 | else {
112 | data.copy(sock.SubBuffer, 0, flag,data.length - 1);
113 | sock.SubBufferLen = data.length - flag;
114 | }
115 | flag += 4;
116 | flag += len;
117 | }
118 | });
119 |
120 | }).on('error',function(e){
121 | //clean all client;
122 | console.log(e);
123 | });
124 | sock.setTimeout(1000 * 3,function() {
125 | if(!sock.connectInfo) {
126 | console.log("time out");
127 | failFunc("relink host[" + ip + "] time out");
128 | sock.destroy();
129 | }
130 | });
131 |
132 | sock.on('close',function(code){
133 | //关闭所有子项目
134 |
135 | });
136 | }
137 |
138 |
139 | function wspParse(data){
140 | var payIdx = data.indexOf('\r\n\r\n');
141 | var lines = data.substr(0, payIdx).split('\r\n');
142 | var hdr = lines.shift().match(new RegExp('WSP/1.1\\s+(.+)'));
143 | if (hdr) {
144 | var res = {
145 | msg: hdr[1],
146 | data: {},
147 | payload: ''
148 | };
149 | while (lines.length) {
150 | var line = lines.shift();
151 | if (line) {
152 | var subD = line.split(':');
153 | res.data[subD[0]] = subD[1].trim();
154 | } else {
155 | break;
156 | }
157 | }
158 | res.payload = data.substr(payIdx+4);
159 | return res;
160 | }
161 | return null;
162 | }
163 | function wspMsg(code,msg,seq,data,play){
164 |
165 | var msg = "WSP/1.1 " + code + " " + msg + "\r\n";
166 | msg += "seq:" + seq ;
167 | if(data) {
168 | for (var i in data) {
169 | msg += "\r\n";
170 | msg += i.toString() + ":" + data[i].toString();
171 | }
172 | }
173 | msg += "\r\n\r\n";
174 | if(play)
175 | msg += play;
176 |
177 | return msg;
178 | }
179 |
--------------------------------------------------------------------------------
/src/client/rtsp/stream.js:
--------------------------------------------------------------------------------
1 | import {getTagged} from '../../deps/bp_logger.js';
2 |
3 | import {RTSPClientSM as RTSPClient} from './client.js';
4 | import {Url} from '../../core/util/url.js';
5 | import {RTSPError} from "./client";
6 |
7 | const LOG_TAG = "rtsp:stream";
8 | const Log = getTagged(LOG_TAG);
9 |
10 | export class RTSPStream {
11 |
12 | constructor(client, track) {
13 | this.state = null;
14 | this.client = client;
15 | this.track = track;
16 | this.rtpChannel = 1;
17 |
18 | this.stopKeepAlive();
19 | this.keepaliveInterval = null;
20 | this.keepaliveTime = 30000;
21 | }
22 |
23 | reset() {
24 | this.stopKeepAlive();
25 | this.client.forgetRTPChannel(this.rtpChannel);
26 | this.client = null;
27 | this.track = null;
28 | }
29 |
30 | start(lastSetupPromise = null) {
31 | if (lastSetupPromise != null) {
32 | // if a setup was already made, use the same session
33 | return lastSetupPromise.then((obj) => this.sendSetup(obj.session))
34 | } else {
35 | return this.sendSetup();
36 | }
37 | }
38 |
39 | stop() {
40 | return this.sendTeardown();
41 | }
42 |
43 | getSetupURL(track) {
44 | let sessionBlock = this.client.sdp.getSessionBlock();
45 | if (Url.isAbsolute(track.control)) {
46 | return track.control;
47 | } else if (Url.isAbsolute(`${sessionBlock.control}${track.control}`)) {
48 | return `${sessionBlock.control}${track.control}`;
49 | } else if (Url.isAbsolute(`${this.client.contentBase}${track.control}`)) {
50 | /* Check the end of the address for a separator */
51 | if (this.client.contentBase[this.client.contentBase.length - 1] !== '/') {
52 | return `${this.client.contentBase}/${track.control}`;
53 | }
54 |
55 | /* Should probably check session level control before this */
56 | return `${this.client.contentBase}${track.control}`;
57 | }
58 | else {//need return default
59 | return track.control;
60 | }
61 | Log.error('Can\'t determine track URL from ' +
62 | 'block.control:' + track.control + ', ' +
63 | 'session.control:' + sessionBlock.control + ', and ' +
64 | 'content-base:' + this.client.contentBase);
65 | }
66 |
67 | getControlURL() {
68 | let ctrl = this.client.sdp.getSessionBlock().control;
69 | if (Url.isAbsolute(ctrl)) {
70 | return ctrl;
71 | } else if (!ctrl || '*' === ctrl) {
72 | return this.client.contentBase;
73 | } else {
74 | return `${this.client.contentBase}${ctrl}`;
75 | }
76 | }
77 |
78 | sendKeepalive() {
79 | if (this.client.methods.includes('GET_PARAMETER')) {
80 | return this.client.sendRequest('GET_PARAMETER', this.getSetupURL(this.track), {
81 | 'Session': this.session
82 | });
83 | } else {
84 | return this.client.sendRequest('OPTIONS', '*');
85 | }
86 | }
87 |
88 | stopKeepAlive() {
89 | clearInterval(this.keepaliveInterval);
90 | }
91 |
92 | startKeepAlive() {
93 | this.keepaliveInterval = setInterval(() => {
94 | this.sendKeepalive().catch((e) => {
95 | Log.error(e);
96 | if (e instanceof RTSPError) {
97 | if (Number(e.data.parsed.code) == 501) {
98 | return;
99 | }
100 | }
101 | this.client.reconnect();
102 | });
103 | }, this.keepaliveTime);
104 | }
105 |
106 | sendRequest(_cmd, _params = {}) {
107 | let params = {};
108 | if (this.session) {
109 | params['Session'] = this.session;
110 | }
111 | Object.assign(params, _params);
112 | return this.client.sendRequest(_cmd, this.getControlURL(), params);
113 | }
114 |
115 | sendSetup(session = null) {
116 | this.state = RTSPClient.STATE_SETUP;
117 | this.rtpChannel = this.client.interleaveChannelIndex;
118 | let interleavedChannels = this.client.interleaveChannelIndex++ + "-" + this.client.interleaveChannelIndex++;
119 | let params = {
120 | 'Transport': `RTP/AVP/TCP;unicast;interleaved=${interleavedChannels}`,
121 | 'Date': new Date().toUTCString()
122 | };
123 | if(session){
124 | params.Session = session;
125 | }
126 | return this.client.sendRequest('SETUP', this.getSetupURL(this.track), params).then((_data) => {
127 | this.session = _data.headers['session'].split(';');
128 | let transport = _data.headers['transport'];
129 | if (transport) {
130 | let interleaved = transport.match(/interleaved=([0-9]+)-([0-9]+)/)[1];
131 | if (interleaved) {
132 | this.rtpChannel = Number(interleaved);
133 | }
134 | }
135 |
136 | let sessionParamsChunks = this.session.slice(1);
137 | let sessionParams = {};
138 | for (let chunk of sessionParamsChunks) {
139 | let kv = chunk.split('=');
140 | sessionParams[kv[0]] = kv[1];
141 | }
142 | if (sessionParams['timeout']) {
143 | this.keepaliveInterval = Number(sessionParams['timeout']) * 500; // * 1000 / 2
144 | }
145 | /*if (!/RTP\/AVP\/TCP;unicast;interleaved=/.test(_data.headers["transport"])) {
146 | // TODO: disconnect stream and notify client
147 | throw new Error("Connection broken");
148 | }*/
149 | this.client.useRTPChannel(this.rtpChannel);
150 | this.startKeepAlive();
151 | return {track: this.track, data: _data, session: this.session[0]};
152 | });
153 | }
154 | }
155 |
--------------------------------------------------------------------------------
/plugins/videojs/example/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Streamedian RTSP player example
6 |
19 | URL
20 | Set
22 |
23 |
24 | Buffer
25 | 120sec.
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 | View HTML5 RTSP video player log
35 |
36 | clear
37 | scroll up
38 | scroll down
39 | Scroll off
40 |
41 |
42 |
136 |
137 |
177 |
178 |
179 |
--------------------------------------------------------------------------------
/plugins/flowplayer/example/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Streamedian RTSP player example
6 |
15 | URL
16 | Set
18 |
19 |
20 | Buffer
21 | 120sec.
23 |
24 |
25 |
26 |
27 |
28 | View HTML5 RTSP video player log
29 |
30 | clear
31 | scroll up
32 | scroll down
33 | Scroll off
34 |
35 |
36 |
130 |
131 |
187 |
188 |
--------------------------------------------------------------------------------
/plugins/clappr/example/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Streamedian RTSP player example
6 |
11 | URL
12 | Set
14 |
15 |
16 | Buffer
17 | 10sec
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 | View HTML5 RTSP video player log
28 |
29 | clear
30 | scroll up
31 | scroll down
32 | Scroll off
33 |
34 |
35 |
36 |
37 |
38 |
132 |
133 |
185 |