([#18](https://github.com/videojs/mpd-parser/issues/18)) ([71b8976](https://github.com/videojs/mpd-parser/commit/71b8976))
79 | * Support for inheriting BaseURL and alternate BaseURLs ([#17](https://github.com/videojs/mpd-parser/issues/17)) ([7dad5d5](https://github.com/videojs/mpd-parser/commit/7dad5d5))
80 | * add support for SegmentTemplate padding format string and SegmentTimeline ([#16](https://github.com/videojs/mpd-parser/issues/16)) ([87933f6](https://github.com/videojs/mpd-parser/commit/87933f6))
81 |
82 |
83 | ## [0.2.1](https://github.com/videojs/mpd-parser/compare/v0.2.0...v0.2.1) (2017-12-15)
84 |
85 | ### Bug Fixes
86 |
87 | * access HTMLCollections with IE11 compatibility ([#15](https://github.com/videojs/mpd-parser/issues/15)) ([5612984](https://github.com/videojs/mpd-parser/commit/5612984))
88 |
89 |
90 | # [0.2.0](https://github.com/videojs/mpd-parser/compare/v0.1.1...v0.2.0) (2017-12-12)
91 |
92 | ### Features
93 |
94 | * Support for vtt ([#13](https://github.com/videojs/mpd-parser/issues/13)) ([96fc406](https://github.com/videojs/mpd-parser/commit/96fc406))
95 |
96 | ### Tests
97 |
98 | * add more tests for vtt ([#14](https://github.com/videojs/mpd-parser/issues/14)) ([4068790](https://github.com/videojs/mpd-parser/commit/4068790))
99 |
100 |
101 | ## [0.1.1](https://github.com/videojs/mpd-parser/compare/v0.1.0...v0.1.1) (2017-12-07)
102 |
103 | ### Bug Fixes
104 |
105 | * avoid using Array.prototype.fill for IE support ([#11](https://github.com/videojs/mpd-parser/issues/11)) ([5c444de](https://github.com/videojs/mpd-parser/commit/5c444de))
106 |
107 |
108 | # 0.1.0 (2017-11-29)
109 |
110 | ### Bug Fixes
111 |
112 | * switch off in-manifest caption support ([#8](https://github.com/videojs/mpd-parser/issues/8)) ([15712c6](https://github.com/videojs/mpd-parser/commit/15712c6))
113 |
114 | CHANGELOG
115 | =========
116 |
117 | ## HEAD (Unreleased)
118 | _(none)_
119 |
120 | --------------------
121 |
122 |
--------------------------------------------------------------------------------
/mpd-parser/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | # CONTRIBUTING
2 |
3 | We welcome contributions from everyone!
4 |
5 | ## Getting Started
6 |
7 | Make sure you have NodeJS 4.0 or higher and npm installed.
8 |
9 | 1. Fork this repository and clone your fork
10 | 1. Install dependencies: `npm install`
11 | 1. Run a development server: `npm start`
12 |
13 | ### Making Changes
14 |
15 | Refer to the [video.js plugin conventions][conventions] for more detail on best practices and tooling for video.js plugin authorship.
16 |
17 | When you've made your changes, push your commit(s) to your fork and issue a pull request against the original repository.
18 |
19 | ### Running Tests
20 |
21 | Testing is a crucial part of any software project. For all but the most trivial changes (typos, etc) test cases are expected. Tests are run in actual browsers using [Karma][karma].
22 |
23 | - In all available and supported browsers: `npm test`
24 | - In a specific browser: `npm run test:chrome`, `npm run test:firefox`, etc.
25 | - While development server is running (`npm start`), navigate to [`http://localhost:9999/test/`][local]
26 |
27 |
28 | [karma]: http://karma-runner.github.io/
29 | [local]: http://localhost:9999/test/
30 | [conventions]: https://github.com/videojs/generator-videojs-plugin/blob/master/docs/conventions.md
31 |
--------------------------------------------------------------------------------
/mpd-parser/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright Brightcove, Inc
2 |
3 | Licensed under the Apache License, Version 2.0 (the "License");
4 | you may not use this file except in compliance with the License.
5 | You may obtain a copy of the License at
6 |
7 | http://www.apache.org/licenses/LICENSE-2.0
8 |
9 | Unless required by applicable law or agreed to in writing, software
10 | distributed under the License is distributed on an "AS IS" BASIS,
11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | See the License for the specific language governing permissions and
13 | limitations under the License.
14 |
--------------------------------------------------------------------------------
/mpd-parser/README.md:
--------------------------------------------------------------------------------
1 | # mpd-parser
2 |
3 | [](https://travis-ci.org/videojs/mpd-parser)
4 | [](https://greenkeeper.io/)
5 | [](http://slack.videojs.com)
6 |
7 | [](https://nodei.co/npm/mpd-parser/)
8 |
9 | mpd parser
10 |
11 | ## Table of Contents
12 |
13 |
14 |
15 |
16 |
17 | - [Installation](#installation)
18 | - [Usage](#usage)
19 | - [Parsed Output](#parsed-output)
20 | - [Including the Parser](#including-the-parser)
21 | - [`
129 |
133 | ```
134 |
135 | ### Browserify
136 |
137 | When using with Browserify, install mpd-parser via npm and `require` the parser as you would any other module.
138 |
139 | ```js
140 | var mpdParser = require('mpd-parser');
141 |
142 | var parsedManifest = mpdParser.parse(manifest, manifestUrl);
143 | ```
144 |
145 | With ES6:
146 | ```js
147 | import { parse } from 'mpd-parser';
148 |
149 | const parsedManifest = parse(manifest, manifestUrl);
150 | ```
151 |
152 | ### RequireJS/AMD
153 |
154 | When using with RequireJS (or another AMD library), get the script in whatever way you prefer and `require` the parser as you normally would:
155 |
156 | ```js
157 | require(['mpd-parser'], function(mpdParser) {
158 | var parsedManifest = mpdParser.parse(manifest, manifestUrl);
159 | });
160 | ```
161 |
162 | ## License
163 |
164 | Apache-2.0. Copyright (c) Brightcove, Inc
165 |
--------------------------------------------------------------------------------
/mpd-parser/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | mpd-parser Demo
6 |
7 |
8 | Open dev tools to try it out
9 |
13 |
14 |
21 |
22 |
23 |
47 |
48 |
49 |
--------------------------------------------------------------------------------
/mpd-parser/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "_from": "mpd-parser",
3 | "_id": "mpd-parser@0.8.1",
4 | "_inBundle": false,
5 | "_integrity": "sha512-WBTJ1bKk8OLUIxBh6s1ju1e2yz/5CzhPbgi6P3F3kJHKhGy1Z+ElvEnuzEbtC/dnbRcJtMXazE3f93N5LLdp9Q==",
6 | "_location": "/mpd-parser",
7 | "_phantomChildren": {},
8 | "_requested": {
9 | "type": "tag",
10 | "registry": true,
11 | "raw": "mpd-parser",
12 | "name": "mpd-parser",
13 | "escapedName": "mpd-parser",
14 | "rawSpec": "",
15 | "saveSpec": null,
16 | "fetchSpec": "latest"
17 | },
18 | "_requiredBy": [
19 | "#USER",
20 | "/"
21 | ],
22 | "_resolved": "https://registry.npmjs.org/mpd-parser/-/mpd-parser-0.8.1.tgz",
23 | "_shasum": "db299dbec337999fbbbace989d227c7b03dc8ea7",
24 | "_spec": "mpd-parser",
25 | "_where": "/Users/tealbookcsr/Downloads/mpdparse",
26 | "author": {
27 | "name": "Brightcove, Inc"
28 | },
29 | "browserslist": [
30 | "defaults",
31 | "ie 11"
32 | ],
33 | "bugs": {
34 | "url": "https://github.com/videojs/mpd-parser/issues"
35 | },
36 | "bundleDependencies": false,
37 | "dependencies": {
38 | "global": "^4.3.2",
39 | "url-toolkit": "^2.1.1",
40 | "xmldom": "^0.1.27"
41 | },
42 | "deprecated": false,
43 | "description": "mpd parser",
44 | "devDependencies": {
45 | "conventional-changelog-cli": "^2.0.1",
46 | "conventional-changelog-videojs": "^3.0.0",
47 | "doctoc": "^1.3.1",
48 | "husky": "^1.0.0-rc.13",
49 | "jsdoc": "git+https://github.com/BrandonOCasey/jsdoc.git#feat/plugin-from-cli",
50 | "karma": "^3.0.0",
51 | "lint-staged": "^7.2.2",
52 | "not-prerelease": "^1.0.1",
53 | "npm-merge-driver-install": "^1.0.0",
54 | "npm-run-all": "^4.1.5",
55 | "pkg-ok": "^2.2.0",
56 | "rollup": "^0.66.0",
57 | "rollup-plugin-string": "^2.0.2",
58 | "shelljs": "~0.8.2",
59 | "shx": "^0.3.2",
60 | "sinon": "^6.1.5",
61 | "videojs-generate-karma-config": "~5.0.1",
62 | "videojs-generate-rollup-config": "~2.3.0",
63 | "videojs-generator-verify": "~1.0.4",
64 | "videojs-standard": "~7.1.0"
65 | },
66 | "files": [
67 | "CONTRIBUTING.md",
68 | "dist/",
69 | "docs/",
70 | "index.html",
71 | "scripts/",
72 | "src/",
73 | "test/"
74 | ],
75 | "generator-videojs-plugin": {
76 | "version": "7.3.2"
77 | },
78 | "homepage": "https://github.com/videojs/mpd-parser#readme",
79 | "husky": {
80 | "hooks": {
81 | "pre-commit": "lint-staged"
82 | }
83 | },
84 | "keywords": [
85 | "videojs",
86 | "videojs-plugin"
87 | ],
88 | "license": "Apache-2.0",
89 | "lint-staged": {
90 | "*.js": [
91 | "vjsstandard --fix",
92 | "git add"
93 | ],
94 | "README.md": [
95 | "npm run docs:toc",
96 | "git add"
97 | ]
98 | },
99 | "main": "dist/mpd-parser.cjs.js",
100 | "module": "dist/mpd-parser.es.js",
101 | "name": "mpd-parser",
102 | "repository": {
103 | "type": "git",
104 | "url": "git+ssh://git@github.com/videojs/mpd-parser.git"
105 | },
106 | "scripts": {
107 | "build": "npm-run-all -p build:*",
108 | "build:js": "rollup -c scripts/rollup.config.js",
109 | "clean": "shx rm -rf ./dist ./test/dist",
110 | "docs": "npm-run-all docs:*",
111 | "docs:api": "jsdoc src -g plugins/markdown -r -d docs/api",
112 | "docs:toc": "doctoc README.md",
113 | "lint": "vjsstandard",
114 | "netlify": "node scripts/netlify.js",
115 | "postclean": "shx mkdir -p ./dist ./test/dist",
116 | "posttest": "shx cat test/dist/coverage/text.txt",
117 | "prebuild": "npm run clean",
118 | "prenetlify": "npm run build",
119 | "prepublishOnly": "npm run build && vjsverify",
120 | "pretest": "npm-run-all lint build",
121 | "preversion": "npm test",
122 | "server": "karma start scripts/karma.conf.js --singleRun=false --auto-watch",
123 | "start": "npm-run-all -p server watch",
124 | "test": "karma start scripts/karma.conf.js",
125 | "update-changelog": "conventional-changelog -p videojs -i CHANGELOG.md -s",
126 | "version": "is-prerelease || npm run update-changelog && git add CHANGELOG.md",
127 | "watch": "npm-run-all -p watch:*",
128 | "watch:js": "npm run build:js -- -w"
129 | },
130 | "version": "0.8.1",
131 | "vjsstandard": {
132 | "ignore": [
133 | "dist",
134 | "docs",
135 | "test/dist"
136 | ]
137 | }
138 | }
139 |
--------------------------------------------------------------------------------
/mpd-parser/scripts/karma.conf.js:
--------------------------------------------------------------------------------
1 | const generate = require('videojs-generate-karma-config');
2 |
3 | module.exports = function(config) {
4 |
5 | // see https://github.com/videojs/videojs-generate-karma-config
6 | // for options
7 | const options = {};
8 |
9 | config = generate(config, options);
10 |
11 | // any other custom stuff not supported by options here!
12 | };
13 |
14 |
--------------------------------------------------------------------------------
/mpd-parser/scripts/netlify.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const sh = require('shelljs');
3 |
4 | const files = ['dist', 'index.html'];
5 | const deployDir = 'deploy';
6 |
7 | // cleanup previous deploy
8 | sh.rm('-rf', deployDir);
9 | // make sure the directory exists
10 | sh.mkdir('-p', deployDir);
11 |
12 | // copy over dist, and html files
13 | files
14 | .forEach((file) => sh.cp('-r', file, path.join(deployDir, file)));
15 |
--------------------------------------------------------------------------------
/mpd-parser/scripts/rollup.config.js:
--------------------------------------------------------------------------------
1 | const generate = require('videojs-generate-rollup-config');
2 | const string = require('rollup-plugin-string');
3 |
4 | // see https://github.com/videojs/videojs-generate-rollup-config
5 | // for options
6 | const options = {
7 | input: 'src/index.js',
8 | plugins(defaults) {
9 | defaults.test.unshift('string');
10 |
11 | return defaults;
12 | },
13 | primedPlugins(defaults) {
14 | defaults.string = string({include: ['test/manifests/*.mpd']});
15 |
16 | return defaults;
17 | }
18 | };
19 | const config = generate(options);
20 |
21 | // Add additonal builds/customization here!
22 |
23 | // export the builds to rollup
24 | export default Object.values(config.builds);
25 |
--------------------------------------------------------------------------------
/mpd-parser/src/errors.js:
--------------------------------------------------------------------------------
1 | export default {
2 | INVALID_NUMBER_OF_PERIOD: 'INVALID_NUMBER_OF_PERIOD',
3 | DASH_EMPTY_MANIFEST: 'DASH_EMPTY_MANIFEST',
4 | DASH_INVALID_XML: 'DASH_INVALID_XML',
5 | NO_BASE_URL: 'NO_BASE_URL',
6 | MISSING_SEGMENT_INFORMATION: 'MISSING_SEGMENT_INFORMATION',
7 | SEGMENT_TIME_UNSPECIFIED: 'SEGMENT_TIME_UNSPECIFIED',
8 | UNSUPPORTED_UTC_TIMING_SCHEME: 'UNSUPPORTED_UTC_TIMING_SCHEME'
9 | };
10 |
--------------------------------------------------------------------------------
/mpd-parser/src/index.js:
--------------------------------------------------------------------------------
1 | import { version } from '../package.json';
2 | import { toM3u8 } from './toM3u8';
3 | import { toPlaylists } from './toPlaylists';
4 | import { inheritAttributes } from './inheritAttributes';
5 | import { stringToMpdXml } from './stringToMpdXml';
6 | import { parseUTCTimingScheme } from './parseUTCTimingScheme';
7 |
8 | export const VERSION = version;
9 |
10 | export const parse = (manifestString, options = {}) =>
11 | toM3u8(toPlaylists(inheritAttributes(stringToMpdXml(manifestString), options)), options.sidxMapping);
12 |
13 | /**
14 | * Parses the manifest for a UTCTiming node, returning the nodes attributes if found
15 | *
16 | * @param {string} manifestString
17 | * XML string of the MPD manifest
18 | * @return {Object|null}
19 | * Attributes of UTCTiming node specified in the manifest. Null if none found
20 | */
21 | export const parseUTCTiming = (manifestString) =>
22 | parseUTCTimingScheme(stringToMpdXml(manifestString));
23 |
--------------------------------------------------------------------------------
/mpd-parser/src/parseAttributes.js:
--------------------------------------------------------------------------------
1 | import { from } from './utils/list';
2 | import { parseDuration, parseDate } from './utils/time';
3 |
4 | // TODO: maybe order these in some way that makes it easy to find specific attributes
5 | export const parsers = {
6 | /**
7 | * Specifies the duration of the entire Media Presentation. Format is a duration string
8 | * as specified in ISO 8601
9 | *
10 | * @param {string} value
11 | * value of attribute as a string
12 | * @return {number}
13 | * The duration in seconds
14 | */
15 | mediaPresentationDuration(value) {
16 | return parseDuration(value);
17 | },
18 |
19 | /**
20 | * Specifies the Segment availability start time for all Segments referred to in this
21 | * MPD. For a dynamic manifest, it specifies the anchor for the earliest availability
22 | * time. Format is a date string as specified in ISO 8601
23 | *
24 | * @param {string} value
25 | * value of attribute as a string
26 | * @return {number}
27 | * The date as seconds from unix epoch
28 | */
29 | availabilityStartTime(value) {
30 | return parseDate(value) / 1000;
31 | },
32 |
33 | /**
34 | * Specifies the smallest period between potential changes to the MPD. Format is a
35 | * duration string as specified in ISO 8601
36 | *
37 | * @param {string} value
38 | * value of attribute as a string
39 | * @return {number}
40 | * The duration in seconds
41 | */
42 | minimumUpdatePeriod(value) {
43 | return parseDuration(value);
44 | },
45 |
46 | /**
47 | * Specifies the duration of the smallest time shifting buffer for any Representation
48 | * in the MPD. Format is a duration string as specified in ISO 8601
49 | *
50 | * @param {string} value
51 | * value of attribute as a string
52 | * @return {number}
53 | * The duration in seconds
54 | */
55 | timeShiftBufferDepth(value) {
56 | return parseDuration(value);
57 | },
58 |
59 | /**
60 | * Specifies the PeriodStart time of the Period relative to the availabilityStarttime.
61 | * Format is a duration string as specified in ISO 8601
62 | *
63 | * @param {string} value
64 | * value of attribute as a string
65 | * @return {number}
66 | * The duration in seconds
67 | */
68 | start(value) {
69 | return parseDuration(value);
70 | },
71 |
72 | /**
73 | * Specifies the width of the visual presentation
74 | *
75 | * @param {string} value
76 | * value of attribute as a string
77 | * @return {number}
78 | * The parsed width
79 | */
80 | width(value) {
81 | return parseInt(value, 10);
82 | },
83 |
84 | /**
85 | * Specifies the height of the visual presentation
86 | *
87 | * @param {string} value
88 | * value of attribute as a string
89 | * @return {number}
90 | * The parsed height
91 | */
92 | height(value) {
93 | return parseInt(value, 10);
94 | },
95 |
96 | /**
97 | * Specifies the bitrate of the representation
98 | *
99 | * @param {string} value
100 | * value of attribute as a string
101 | * @return {number}
102 | * The parsed bandwidth
103 | */
104 | bandwidth(value) {
105 | return parseInt(value, 10);
106 | },
107 |
108 | /**
109 | * Specifies the number of the first Media Segment in this Representation in the Period
110 | *
111 | * @param {string} value
112 | * value of attribute as a string
113 | * @return {number}
114 | * The parsed number
115 | */
116 | startNumber(value) {
117 | return parseInt(value, 10);
118 | },
119 |
120 | /**
121 | * Specifies the timescale in units per seconds
122 | *
123 | * @param {string} value
124 | * value of attribute as a string
125 | * @return {number}
126 | * The aprsed timescale
127 | */
128 | timescale(value) {
129 | return parseInt(value, 10);
130 | },
131 |
132 | /**
133 | * Specifies the constant approximate Segment duration
134 | * NOTE: The element also contains an @duration attribute. This duration
135 | * specifies the duration of the Period. This attribute is currently not
136 | * supported by the rest of the parser, however we still check for it to prevent
137 | * errors.
138 | *
139 | * @param {string} value
140 | * value of attribute as a string
141 | * @return {number}
142 | * The parsed duration
143 | */
144 | duration(value) {
145 | const parsedValue = parseInt(value, 10);
146 |
147 | if (isNaN(parsedValue)) {
148 | return parseDuration(value);
149 | }
150 |
151 | return parsedValue;
152 | },
153 |
154 | /**
155 | * Specifies the Segment duration, in units of the value of the @timescale.
156 | *
157 | * @param {string} value
158 | * value of attribute as a string
159 | * @return {number}
160 | * The parsed duration
161 | */
162 | d(value) {
163 | return parseInt(value, 10);
164 | },
165 |
166 | /**
167 | * Specifies the MPD start time, in @timescale units, the first Segment in the series
168 | * starts relative to the beginning of the Period
169 | *
170 | * @param {string} value
171 | * value of attribute as a string
172 | * @return {number}
173 | * The parsed time
174 | */
175 | t(value) {
176 | return parseInt(value, 10);
177 | },
178 |
179 | /**
180 | * Specifies the repeat count of the number of following contiguous Segments with the
181 | * same duration expressed by the value of @d
182 | *
183 | * @param {string} value
184 | * value of attribute as a string
185 | * @return {number}
186 | * The parsed number
187 | */
188 | r(value) {
189 | return parseInt(value, 10);
190 | },
191 |
192 | /**
193 | * Default parser for all other attributes. Acts as a no-op and just returns the value
194 | * as a string
195 | *
196 | * @param {string} value
197 | * value of attribute as a string
198 | * @return {string}
199 | * Unparsed value
200 | */
201 | DEFAULT(value) {
202 | return value;
203 | }
204 | };
205 |
206 | /**
207 | * Gets all the attributes and values of the provided node, parses attributes with known
208 | * types, and returns an object with attribute names mapped to values.
209 | *
210 | * @param {Node} el
211 | * The node to parse attributes from
212 | * @return {Object}
213 | * Object with all attributes of el parsed
214 | */
215 | export const parseAttributes = (el) => {
216 | if (!(el && el.attributes)) {
217 | return {};
218 | }
219 |
220 | return from(el.attributes)
221 | .reduce((a, e) => {
222 | const parseFn = parsers[e.name] || parsers.DEFAULT;
223 |
224 | a[e.name] = parseFn(e.value);
225 |
226 | return a;
227 | }, {});
228 | };
229 |
--------------------------------------------------------------------------------
/mpd-parser/src/parseUTCTimingScheme.js:
--------------------------------------------------------------------------------
1 | import { findChildren } from './utils/xml';
2 | import { parseAttributes } from './parseAttributes';
3 | import errors from './errors';
4 |
5 | /**
6 | * Parses the manifest for a UTCTiming node, returning the nodes attributes if found
7 | *
8 | * @param {string} mpd
9 | * XML string of the MPD manifest
10 | * @return {Object|null}
11 | * Attributes of UTCTiming node specified in the manifest. Null if none found
12 | */
13 | export const parseUTCTimingScheme = (mpd) => {
14 | const UTCTimingNode = findChildren(mpd, 'UTCTiming')[0];
15 |
16 | if (!UTCTimingNode) {
17 | return null;
18 | }
19 |
20 | const attributes = parseAttributes(UTCTimingNode);
21 |
22 | switch (attributes.schemeIdUri) {
23 | case 'urn:mpeg:dash:utc:http-head:2014':
24 | case 'urn:mpeg:dash:utc:http-head:2012':
25 | attributes.method = 'HEAD';
26 | break;
27 | case 'urn:mpeg:dash:utc:http-xsdate:2014':
28 | case 'urn:mpeg:dash:utc:http-iso:2014':
29 | case 'urn:mpeg:dash:utc:http-xsdate:2012':
30 | case 'urn:mpeg:dash:utc:http-iso:2012':
31 | attributes.method = 'GET';
32 | break;
33 | case 'urn:mpeg:dash:utc:direct:2014':
34 | case 'urn:mpeg:dash:utc:direct:2012':
35 | attributes.method = 'DIRECT';
36 | attributes.value = Date.parse(attributes.value);
37 | break;
38 | case 'urn:mpeg:dash:utc:http-ntp:2014':
39 | case 'urn:mpeg:dash:utc:ntp:2014':
40 | case 'urn:mpeg:dash:utc:sntp:2014':
41 | default:
42 | throw new Error(errors.UNSUPPORTED_UTC_TIMING_SCHEME);
43 | }
44 |
45 | return attributes;
46 | };
47 |
--------------------------------------------------------------------------------
/mpd-parser/src/segment/durationTimeParser.js:
--------------------------------------------------------------------------------
1 | import { range } from '../utils/list';
2 |
3 | /**
4 | * Functions for calculating the range of available segments in static and dynamic
5 | * manifests.
6 | */
7 | export const segmentRange = {
8 | /**
9 | * Returns the entire range of available segments for a static MPD
10 | *
11 | * @param {Object} attributes
12 | * Inheritied MPD attributes
13 | * @return {{ start: number, end: number }}
14 | * The start and end numbers for available segments
15 | */
16 | static(attributes) {
17 | const {
18 | duration,
19 | timescale = 1,
20 | sourceDuration
21 | } = attributes;
22 |
23 | return {
24 | start: 0,
25 | end: Math.ceil(sourceDuration / (duration / timescale))
26 | };
27 | },
28 |
29 | /**
30 | * Returns the current live window range of available segments for a dynamic MPD
31 | *
32 | * @param {Object} attributes
33 | * Inheritied MPD attributes
34 | * @return {{ start: number, end: number }}
35 | * The start and end numbers for available segments
36 | */
37 | dynamic(attributes) {
38 | const {
39 | NOW,
40 | clientOffset,
41 | availabilityStartTime,
42 | timescale = 1,
43 | duration,
44 | start = 0,
45 | minimumUpdatePeriod = 0,
46 | timeShiftBufferDepth = Infinity
47 | } = attributes;
48 | const now = (NOW + clientOffset) / 1000;
49 | const periodStartWC = availabilityStartTime + start;
50 | const periodEndWC = now + minimumUpdatePeriod;
51 | const periodDuration = periodEndWC - periodStartWC;
52 | const segmentCount = Math.ceil(periodDuration * timescale / duration);
53 | const availableStart =
54 | Math.floor((now - periodStartWC - timeShiftBufferDepth) * timescale / duration);
55 | const availableEnd = Math.floor((now - periodStartWC) * timescale / duration);
56 |
57 | return {
58 | start: Math.max(0, availableStart),
59 | end: Math.min(segmentCount, availableEnd)
60 | };
61 | }
62 | };
63 |
64 | /**
65 | * Maps a range of numbers to objects with information needed to build the corresponding
66 | * segment list
67 | *
68 | * @name toSegmentsCallback
69 | * @function
70 | * @param {number} number
71 | * Number of the segment
72 | * @param {number} index
73 | * Index of the number in the range list
74 | * @return {{ number: Number, duration: Number, timeline: Number, time: Number }}
75 | * Object with segment timing and duration info
76 | */
77 |
78 | /**
79 | * Returns a callback for Array.prototype.map for mapping a range of numbers to
80 | * information needed to build the segment list.
81 | *
82 | * @param {Object} attributes
83 | * Inherited MPD attributes
84 | * @return {toSegmentsCallback}
85 | * Callback map function
86 | */
87 | export const toSegments = (attributes) => (number, index) => {
88 | const {
89 | duration,
90 | timescale = 1,
91 | periodIndex,
92 | startNumber = 1
93 | } = attributes;
94 |
95 | return {
96 | number: startNumber + number,
97 | duration: duration / timescale,
98 | timeline: periodIndex,
99 | time: index * duration
100 | };
101 | };
102 |
103 | /**
104 | * Returns a list of objects containing segment timing and duration info used for
105 | * building the list of segments. This uses the @duration attribute specified
106 | * in the MPD manifest to derive the range of segments.
107 | *
108 | * @param {Object} attributes
109 | * Inherited MPD attributes
110 | * @return {{number: number, duration: number, time: number, timeline: number}[]}
111 | * List of Objects with segment timing and duration info
112 | */
113 | export const parseByDuration = (attributes) => {
114 | const {
115 | type = 'static',
116 | duration,
117 | timescale = 1,
118 | sourceDuration
119 | } = attributes;
120 |
121 | const { start, end } = segmentRange[type](attributes);
122 | const segments = range(start, end).map(toSegments(attributes));
123 |
124 | if (type === 'static') {
125 | const index = segments.length - 1;
126 |
127 | // final segment may be less than full segment duration
128 | segments[index].duration = sourceDuration - (duration / timescale * index);
129 | }
130 |
131 | return segments;
132 | };
133 |
--------------------------------------------------------------------------------
/mpd-parser/src/segment/segmentBase.js:
--------------------------------------------------------------------------------
1 | import errors from '../errors';
2 | import urlTypeConverter from './urlType';
3 | import { parseByDuration } from './durationTimeParser';
4 |
5 | /**
6 | * Translates SegmentBase into a set of segments.
7 | * (DASH SPEC Section 5.3.9.3.2) contains a set of nodes. Each
8 | * node should be translated into segment.
9 | *
10 | * @param {Object} attributes
11 | * Object containing all inherited attributes from parent elements with attribute
12 | * names as keys
13 | * @return {Object.} list of segments
14 | */
15 | export const segmentsFromBase = (attributes) => {
16 | const {
17 | baseUrl,
18 | initialization = {},
19 | sourceDuration,
20 | timescale = 1,
21 | indexRange = '',
22 | duration
23 | } = attributes;
24 |
25 | // base url is required for SegmentBase to work, per spec (Section 5.3.9.2.1)
26 | if (!baseUrl) {
27 | throw new Error(errors.NO_BASE_URL);
28 | }
29 |
30 | const initSegment = urlTypeConverter({
31 | baseUrl,
32 | source: initialization.sourceURL,
33 | range: initialization.range
34 | });
35 |
36 | const segment = urlTypeConverter({ baseUrl, source: baseUrl, indexRange });
37 |
38 | segment.map = initSegment;
39 |
40 | // If there is a duration, use it, otherwise use the given duration of the source
41 | // (since SegmentBase is only for one total segment)
42 | if (duration) {
43 | const segmentTimeInfo = parseByDuration(attributes);
44 |
45 | if (segmentTimeInfo.length) {
46 | segment.duration = segmentTimeInfo[0].duration;
47 | segment.timeline = segmentTimeInfo[0].timeline;
48 | }
49 | } else if (sourceDuration) {
50 | segment.duration = (sourceDuration / timescale);
51 | segment.timeline = 0;
52 | }
53 |
54 | // This is used for mediaSequence
55 | segment.number = 0;
56 |
57 | return [segment];
58 | };
59 |
60 | /**
61 | * Given a playlist, a sidx box, and a baseUrl, update the segment list of the playlist
62 | * according to the sidx information given.
63 | *
64 | * playlist.sidx has metadadata about the sidx where-as the sidx param
65 | * is the parsed sidx box itself.
66 | *
67 | * @param {Object} playlist the playlist to update the sidx information for
68 | * @param {Object} sidx the parsed sidx box
69 | * @return {Object} the playlist object with the updated sidx information
70 | */
71 | export const addSegmentsToPlaylist = (playlist, sidx, baseUrl) => {
72 | // Retain init segment information
73 | const initSegment = playlist.sidx.map ? playlist.sidx.map : null;
74 | // Retain source duration from initial master manifest parsing
75 | const sourceDuration = playlist.sidx.duration;
76 | // Retain source timeline
77 | const timeline = playlist.timeline || 0;
78 | const sidxByteRange = playlist.sidx.byterange;
79 | const sidxEnd = sidxByteRange.offset + sidxByteRange.length;
80 | // Retain timescale of the parsed sidx
81 | const timescale = sidx.timescale;
82 | // referenceType 1 refers to other sidx boxes
83 | const mediaReferences = sidx.references.filter(r => r.referenceType !== 1);
84 | const segments = [];
85 |
86 | // firstOffset is the offset from the end of the sidx box
87 | let startIndex = sidxEnd + sidx.firstOffset;
88 |
89 | for (let i = 0; i < mediaReferences.length; i++) {
90 | const reference = sidx.references[i];
91 | // size of the referenced (sub)segment
92 | const size = reference.referencedSize;
93 | // duration of the referenced (sub)segment, in the timescale
94 | // this will be converted to seconds when generating segments
95 | const duration = reference.subsegmentDuration;
96 | // should be an inclusive range
97 | const endIndex = startIndex + size - 1;
98 | const indexRange = `${startIndex}-${endIndex}`;
99 |
100 | const attributes = {
101 | baseUrl,
102 | timescale,
103 | timeline,
104 | // this is used in parseByDuration
105 | periodIndex: timeline,
106 | duration,
107 | sourceDuration,
108 | indexRange
109 | };
110 |
111 | const segment = segmentsFromBase(attributes)[0];
112 |
113 | if (initSegment) {
114 | segment.map = initSegment;
115 | }
116 |
117 | segments.push(segment);
118 | startIndex += size;
119 | }
120 |
121 | playlist.segments = segments;
122 |
123 | return playlist;
124 | };
125 |
--------------------------------------------------------------------------------
/mpd-parser/src/segment/segmentList.js:
--------------------------------------------------------------------------------
1 | import { parseByTimeline } from './timelineTimeParser';
2 | import { parseByDuration } from './durationTimeParser';
3 | import urlTypeConverter from './urlType';
4 | import errors from '../errors';
5 |
6 | /**
7 | * Converts a (of type URLType from the DASH spec 5.3.9.2 Table 14)
8 | * to an object that matches the output of a segment in videojs/mpd-parser
9 | *
10 | * @param {Object} attributes
11 | * Object containing all inherited attributes from parent elements with attribute
12 | * names as keys
13 | * @param {Object} segmentUrl
14 | * node to translate into a segment object
15 | * @return {Object} translated segment object
16 | */
17 | const SegmentURLToSegmentObject = (attributes, segmentUrl) => {
18 | const { baseUrl, initialization = {} } = attributes;
19 |
20 | const initSegment = urlTypeConverter({
21 | baseUrl,
22 | source: initialization.sourceURL,
23 | range: initialization.range
24 | });
25 |
26 | const segment = urlTypeConverter({
27 | baseUrl,
28 | source: segmentUrl.media,
29 | range: segmentUrl.mediaRange
30 | });
31 |
32 | segment.map = initSegment;
33 |
34 | return segment;
35 | };
36 |
37 | /**
38 | * Generates a list of segments using information provided by the SegmentList element
39 | * SegmentList (DASH SPEC Section 5.3.9.3.2) contains a set of nodes. Each
40 | * node should be translated into segment.
41 | *
42 | * @param {Object} attributes
43 | * Object containing all inherited attributes from parent elements with attribute
44 | * names as keys
45 | * @param {Object[]|undefined} segmentTimeline
46 | * List of objects representing the attributes of each S element contained within
47 | * the SegmentTimeline element
48 | * @return {Object.} list of segments
49 | */
50 | export const segmentsFromList = (attributes, segmentTimeline) => {
51 | const {
52 | duration,
53 | segmentUrls = []
54 | } = attributes;
55 |
56 | // Per spec (5.3.9.2.1) no way to determine segment duration OR
57 | // if both SegmentTimeline and @duration are defined, it is outside of spec.
58 | if ((!duration && !segmentTimeline) ||
59 | (duration && segmentTimeline)) {
60 | throw new Error(errors.SEGMENT_TIME_UNSPECIFIED);
61 | }
62 |
63 | const segmentUrlMap = segmentUrls.map(segmentUrlObject =>
64 | SegmentURLToSegmentObject(attributes, segmentUrlObject));
65 | let segmentTimeInfo;
66 |
67 | if (duration) {
68 | segmentTimeInfo = parseByDuration(attributes);
69 | }
70 |
71 | if (segmentTimeline) {
72 | segmentTimeInfo = parseByTimeline(attributes, segmentTimeline);
73 | }
74 |
75 | const segments = segmentTimeInfo.map((segmentTime, index) => {
76 | if (segmentUrlMap[index]) {
77 | const segment = segmentUrlMap[index];
78 |
79 | segment.timeline = segmentTime.timeline;
80 | segment.duration = segmentTime.duration;
81 | segment.number = segmentTime.number;
82 | return segment;
83 | }
84 | // Since we're mapping we should get rid of any blank segments (in case
85 | // the given SegmentTimeline is handling for more elements than we have
86 | // SegmentURLs for).
87 | }).filter(segment => segment);
88 |
89 | return segments;
90 | };
91 |
--------------------------------------------------------------------------------
/mpd-parser/src/segment/segmentTemplate.js:
--------------------------------------------------------------------------------
1 | import resolveUrl from '../utils/resolveUrl';
2 | import urlTypeToSegment from './urlType';
3 | import { parseByTimeline } from './timelineTimeParser';
4 | import { parseByDuration } from './durationTimeParser';
5 |
6 | const identifierPattern = /\$([A-z]*)(?:(%0)([0-9]+)d)?\$/g;
7 |
8 | /**
9 | * Replaces template identifiers with corresponding values. To be used as the callback
10 | * for String.prototype.replace
11 | *
12 | * @name replaceCallback
13 | * @function
14 | * @param {string} match
15 | * Entire match of identifier
16 | * @param {string} identifier
17 | * Name of matched identifier
18 | * @param {string} format
19 | * Format tag string. Its presence indicates that padding is expected
20 | * @param {string} width
21 | * Desired length of the replaced value. Values less than this width shall be left
22 | * zero padded
23 | * @return {string}
24 | * Replacement for the matched identifier
25 | */
26 |
27 | /**
28 | * Returns a function to be used as a callback for String.prototype.replace to replace
29 | * template identifiers
30 | *
31 | * @param {Obect} values
32 | * Object containing values that shall be used to replace known identifiers
33 | * @param {number} values.RepresentationID
34 | * Value of the Representation@id attribute
35 | * @param {number} values.Number
36 | * Number of the corresponding segment
37 | * @param {number} values.Bandwidth
38 | * Value of the Representation@bandwidth attribute.
39 | * @param {number} values.Time
40 | * Timestamp value of the corresponding segment
41 | * @return {replaceCallback}
42 | * Callback to be used with String.prototype.replace to replace identifiers
43 | */
44 | export const identifierReplacement = (values) => (match, identifier, format, width) => {
45 | if (match === '$$') {
46 | // escape sequence
47 | return '$';
48 | }
49 |
50 | if (typeof values[identifier] === 'undefined') {
51 | return match;
52 | }
53 |
54 | const value = '' + values[identifier];
55 |
56 | if (identifier === 'RepresentationID') {
57 | // Format tag shall not be present with RepresentationID
58 | return value;
59 | }
60 |
61 | if (!format) {
62 | width = 1;
63 | } else {
64 | width = parseInt(width, 10);
65 | }
66 |
67 | if (value.length >= width) {
68 | return value;
69 | }
70 |
71 | return `${(new Array(width - value.length + 1)).join('0')}${value}`;
72 | };
73 |
74 | /**
75 | * Constructs a segment url from a template string
76 | *
77 | * @param {string} url
78 | * Template string to construct url from
79 | * @param {Obect} values
80 | * Object containing values that shall be used to replace known identifiers
81 | * @param {number} values.RepresentationID
82 | * Value of the Representation@id attribute
83 | * @param {number} values.Number
84 | * Number of the corresponding segment
85 | * @param {number} values.Bandwidth
86 | * Value of the Representation@bandwidth attribute.
87 | * @param {number} values.Time
88 | * Timestamp value of the corresponding segment
89 | * @return {string}
90 | * Segment url with identifiers replaced
91 | */
92 | export const constructTemplateUrl = (url, values) =>
93 | url.replace(identifierPattern, identifierReplacement(values));
94 |
95 | /**
96 | * Generates a list of objects containing timing and duration information about each
97 | * segment needed to generate segment uris and the complete segment object
98 | *
99 | * @param {Object} attributes
100 | * Object containing all inherited attributes from parent elements with attribute
101 | * names as keys
102 | * @param {Object[]|undefined} segmentTimeline
103 | * List of objects representing the attributes of each S element contained within
104 | * the SegmentTimeline element
105 | * @return {{number: number, duration: number, time: number, timeline: number}[]}
106 | * List of Objects with segment timing and duration info
107 | */
108 | export const parseTemplateInfo = (attributes, segmentTimeline) => {
109 | if (!attributes.duration && !segmentTimeline) {
110 | // if neither @duration or SegmentTimeline are present, then there shall be exactly
111 | // one media segment
112 | return [{
113 | number: attributes.startNumber || 1,
114 | duration: attributes.sourceDuration,
115 | time: 0,
116 | timeline: attributes.periodIndex
117 | }];
118 | }
119 |
120 | if (attributes.duration) {
121 | return parseByDuration(attributes);
122 | }
123 |
124 | return parseByTimeline(attributes, segmentTimeline);
125 | };
126 |
127 | /**
128 | * Generates a list of segments using information provided by the SegmentTemplate element
129 | *
130 | * @param {Object} attributes
131 | * Object containing all inherited attributes from parent elements with attribute
132 | * names as keys
133 | * @param {Object[]|undefined} segmentTimeline
134 | * List of objects representing the attributes of each S element contained within
135 | * the SegmentTimeline element
136 | * @return {Object[]}
137 | * List of segment objects
138 | */
139 | export const segmentsFromTemplate = (attributes, segmentTimeline) => {
140 | const templateValues = {
141 | RepresentationID: attributes.id,
142 | Bandwidth: attributes.bandwidth || 0
143 | };
144 |
145 | const { initialization = { sourceURL: '', range: '' } } = attributes;
146 |
147 | const mapSegment = urlTypeToSegment({
148 | baseUrl: attributes.baseUrl,
149 | source: constructTemplateUrl(initialization.sourceURL, templateValues),
150 | range: initialization.range
151 | });
152 |
153 | const segments = parseTemplateInfo(attributes, segmentTimeline);
154 |
155 | return segments.map(segment => {
156 | templateValues.Number = segment.number;
157 | templateValues.Time = segment.time;
158 |
159 | const uri = constructTemplateUrl(attributes.media || '', templateValues);
160 |
161 | return {
162 | uri,
163 | timeline: segment.timeline,
164 | duration: segment.duration,
165 | resolvedUri: resolveUrl(attributes.baseUrl || '', uri),
166 | map: mapSegment,
167 | number: segment.number
168 | };
169 | });
170 | };
171 |
--------------------------------------------------------------------------------
/mpd-parser/src/segment/timelineTimeParser.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Calculates the R (repetition) value for a live stream (for the final segment
3 | * in a manifest where the r value is negative 1)
4 | *
5 | * @param {Object} attributes
6 | * Object containing all inherited attributes from parent elements with attribute
7 | * names as keys
8 | * @param {number} time
9 | * current time (typically the total time up until the final segment)
10 | * @param {number} duration
11 | * duration property for the given bar
196 | baz
197 | `;
198 |
199 | this.fixture = parser.parseFromString(xmlString, 'text/xml').documentElement;
200 | }
201 | });
202 |
203 | QUnit.test('findChildren', function(assert) {
204 | assert.deepEqual(findChildren(this.fixture, 'test').length, 1, 'single');
205 | assert.deepEqual(findChildren(this.fixture, 'div').length, 2, 'multiple');
206 | assert.deepEqual(findChildren(this.fixture, 'el').length, 0, 'none');
207 | });
208 |
209 | QUnit.test('getContent', function(assert) {
210 | const result = findChildren(this.fixture, 'test')[0];
211 |
212 | assert.deepEqual(getContent(result), 'foo', 'gets text and trims');
213 | });
214 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "Universal-DRM",
3 | "version": "1.0.0",
4 | "description": "",
5 | "main": "src/server.js",
6 | "scripts": {
7 | "test": "echo \"Error: no test specified\" && exit 1",
8 | "start": "node src/server.js"
9 | },
10 | "apps": [
11 | {
12 | "exec_interpreter": "node",
13 | "name": "auth-app",
14 | "script": "src/server.js",
15 | "post_update": [
16 | "echo App has been updated, running yarn install...",
17 | "yarn install",
18 | "echo App is being restarted now"
19 | ]
20 | }
21 | ],
22 | "author": "DRM-Scripts",
23 | "license": "ISC",
24 | "dependencies": {
25 | "akamai-auth-token": "^1.0.7",
26 | "axios": "^0.19.0",
27 | "basic-auth-connect": "^1.0.0",
28 | "bcrypt": "^3.0.0",
29 | "child-process-promise": "^2.2.1",
30 | "concat": "^1.0.3",
31 | "connect-mongo": "^2.0.1",
32 | "crypto-js": "^3.1.9-1",
33 | "debug-http": "^1.1.0",
34 | "dotenv": "^6.1.0",
35 | "download": "^7.1.0",
36 | "download-file": "^0.1.5",
37 | "es6-promise-pool": "^2.5.0",
38 | "express": "^4.16.3",
39 | "express-ipfilter": "^0.3.1",
40 | "express-session": "^1.15.6",
41 | "fast-glob": "^3.0.3",
42 | "filenamify": "^4.1.0",
43 | "fs-extra": "^8.0.1",
44 | "got": "^9.6.0",
45 | "hls-parser": "^0.1.8",
46 | "http-debug": "^0.1.2",
47 | "jsonfile": "^5.0.0",
48 | "jsonwebtoken": "^8.3.0",
49 | "lint": "^1.1.2",
50 | "m3u8-reader": "^1.1.0",
51 | "m3u8-write": "^1.0.0",
52 | "merge": "^1.2.0",
53 | "mkdirp": "^0.5.1",
54 | "mongodb": "^3.1.1",
55 | "mongoose": "^5.2.2",
56 | "morgan": "^1.9.1",
57 | "mp4-box-encoding": "^1.4.1",
58 | "mp4-stream": "^3.1.0",
59 | "mpd-parser": "file:mpd-parser",
60 | "ncp": "^2.0.0",
61 | "node-fetch": "^2.5.0",
62 | "node-fetch-retry": "^1.0.1",
63 | "notp": "^2.0.3",
64 | "otplib": "^10.0.0",
65 | "portscanner": "^2.2.0",
66 | "promise-request-retry": "^1.0.1",
67 | "promise-retry": "^1.1.1",
68 | "redis": "^2.8.0",
69 | "request": "^2.87.0",
70 | "request-promise": "^4.2.2",
71 | "request-promise-retry": "^1.0.0",
72 | "uuid": "^3.3.2",
73 | "xml2js": "^0.4.19",
74 | "xmldom": "^0.1.27"
75 | },
76 | "devDependencies": {
77 | "eslint": "^5.1.0",
78 | "eslint-config-standard": "^11.0.0",
79 | "eslint-plugin-import": "^2.13.0",
80 | "eslint-plugin-node": "^6.0.1",
81 | "eslint-plugin-promise": "^3.8.0",
82 | "eslint-plugin-standard": "^3.1.0",
83 | "jest": "^24.9.0"
84 | }
85 | }
86 |
--------------------------------------------------------------------------------
/panels/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 | Universal-DRM | DRM SCRIPTS
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
107 |
108 |
109 |
110 |
111 |
135 |
136 |
141 |
142 |
143 |
144 |
148 |
149 |
150 |
151 |
152 |
153 |
154 |
155 |
156 |
157 |
158 |
167 |
168 |
169 |
170 |
171 |
172 |
178 |
179 |