m3u8stream
Version:
Reads segments from a m3u8 or dash playlist into a consumable stream.
126 lines • 4.77 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const crypto_1 = __importDefault(require("crypto"));
const miniget_1 = __importDefault(require("miniget"));
const getKeyExpiration = (headers) => {
const cc = headers['cache-control'];
if (cc) {
if (/no-cache|no-store/.test(cc)) {
return 0;
}
const match = cc.match(/max-age=(\d+)/);
if (match) {
const maxAge = parseInt(match[1], 10);
return maxAge > 0 ? Date.now() + maxAge * 1000 : 0;
}
}
if (headers.expires) {
const expiresTime = Date.parse(headers.expires);
if (!isNaN(expiresTime) && expiresTime > Date.now()) {
return expiresTime;
}
}
return 0;
};
const createSegmentDecipher = (keyBuffer, ivHex, seq) => {
let iv;
if (ivHex) {
iv = Buffer.from(ivHex.slice(2).padStart(32, '0'), 'hex');
}
else {
iv = Buffer.alloc(16);
iv.writeBigUInt64BE(BigInt(seq), 8);
}
return crypto_1.default.createDecipheriv('aes-128-cbc', keyBuffer, iv);
};
class KeyManager {
constructor(requestOptions, forwardEvents) {
this._keyCache = new Map();
this._inflightKeys = new Map();
this._requests = new Map();
this._requestOptions = requestOptions;
this._forwardEvents = forwardEvents;
}
getKey(keyUrl) {
const cached = this._keyCache.get(keyUrl);
if (cached) {
if (Date.now() < cached.expiresAt) {
return Promise.resolve(cached.buffer);
}
this._keyCache.delete(keyUrl);
}
const inflight = this._inflightKeys.get(keyUrl);
if (inflight) {
return inflight;
}
let keyReq;
const promise = new Promise((resolve, reject) => {
keyReq = (0, miniget_1.default)(keyUrl, this._requestOptions);
this._requests.set(keyReq, reject);
if (this._forwardEvents) {
this._forwardEvents(keyReq);
}
let expiresAt = 0;
keyReq.on('response', (res) => {
expiresAt = getKeyExpiration(res.headers);
});
let chunks = [];
keyReq.on('data', (chunk) => chunks.push(chunk));
keyReq.on('end', () => {
const keyBuffer = Buffer.concat(chunks);
if (keyBuffer.length !== 16) {
reject(new Error(`Invalid key length: expected 16 octets, got ${keyBuffer.length}`));
return;
}
if (expiresAt > Date.now()) {
this._keyCache.set(keyUrl, { buffer: keyBuffer, expiresAt });
}
resolve(keyBuffer);
});
keyReq.on('error', reject);
}).finally(() => {
this._inflightKeys.delete(keyUrl);
if (keyReq) {
this._requests.delete(keyReq);
}
});
this._inflightKeys.set(keyUrl, promise);
return promise;
}
getDecipher(key, playlistURL, seq) {
return __awaiter(this, void 0, void 0, function* () {
if (!key) {
return null;
}
if (key.method === 'SAMPLE-AES') {
throw Error('`SAMPLE-AES` encryption is not supported');
}
const keyUrl = new URL(key.uri, playlistURL).toString();
const keyBuffer = yield this.getKey(keyUrl);
return createSegmentDecipher(keyBuffer, key.iv, seq);
});
}
clear() {
for (const [request, reject] of this._requests) {
request.destroy();
reject(new Error('Key request cancelled'));
}
this._requests.clear();
this._keyCache.clear();
this._inflightKeys.clear();
}
}
exports.default = KeyManager;
//# sourceMappingURL=key-manager.js.map