multi-downloader-nx_mirror/modules/playready/pssh.ts

import { Parser } from 'binary-parser';
import { Buffer } from 'buffer';
import WRMHeader from './wrmheader';

const SYSTEM_ID = Buffer.from('9a04f07998404286ab92e65be0885f95', 'hex');

const PSSHBox = new Parser()
    .uint32('length')
    .string('pssh', { length: 4, assert: 'pssh' })
    .uint32('fullbox')
    .buffer('system_id', { length: 16 })
    .uint32('data_length')
    .buffer('data', {
        length: 'data_length',
    });

const PlayreadyObject = new Parser()
    .useContextVars()
    .uint16('type')
    .uint16('length')
    .choice('data', {
        tag: 'type',
        choices: {
            1: new Parser().string('data', {
                length: function () {
                    return (this as any).$parent.length;
                },
                encoding: 'utf16le',
            }),
        },
        defaultChoice: new Parser().buffer('data', {
            length: function () {
                return (this as any).$parent.length;
            },
        }),
    });

const PlayreadyHeader = new Parser()
    .uint32('length')
    .uint16('record_count')
    .array('records', {
        length: 'record_count',
        type: PlayreadyObject,
    });

function isPlayreadyPsshBox(data: Buffer): boolean {
    if (data.length < 28) return false;
    return data.subarray(12, 28).equals(SYSTEM_ID);
}

function isUtf16(data: Buffer): boolean {
    for (let i = 1; i < data.length; i += 2) {
        if (data[i] !== 0) {
            return false;
        }
    }
    return true;
}

function* getWrmHeaders(wrm_header: any): IterableIterator<string> {
    for (const record of wrm_header.records) {
        if (record.type === 1 && typeof record.data === 'string') {
            yield record.data;
        }
    }
}

export class PSSH {
    public wrm_headers: string[];

    constructor(data: string | Buffer) {
        if (!data) {
            throw new Error('Data must not be empty');
        }

        if (typeof data === 'string') {
            try {
                data = Buffer.from(data, 'base64');
            } catch (e) {
                throw new Error(`Could not decode data as Base64: ${e}`);
            }
        }

        try {
            if (isPlayreadyPsshBox(data)) {
                const pssh_box = PSSHBox.parse(data);
                const psshData = pssh_box.data;

                if (isUtf16(psshData)) {
                    this.wrm_headers = [psshData.toString('utf16le')];
                } else if (isUtf16(psshData.subarray(6))) {
                    this.wrm_headers = [psshData.subarray(6).toString('utf16le')];
                } else if (isUtf16(psshData.subarray(10))) {
                    this.wrm_headers = [psshData.subarray(10).toString('utf16le')];
                } else {
                    const playready_header = PlayreadyHeader.parse(psshData);
                    this.wrm_headers = Array.from(getWrmHeaders(playready_header));
                }
            } else {
                if (isUtf16(data)) {
                    this.wrm_headers = [data.toString('utf16le')];
                } else if (isUtf16(data.subarray(6))) {
                    this.wrm_headers = [data.subarray(6).toString('utf16le')];
                } else if (isUtf16(data.subarray(10))) {
                    this.wrm_headers = [data.subarray(10).toString('utf16le')];
                } else {
                    const playready_header = PlayreadyHeader.parse(data);
                    this.wrm_headers = Array.from(getWrmHeaders(playready_header));
                }
            }
        } catch (e) {
            throw new Error(
                'Could not parse data as a PSSH Box nor a PlayReadyHeader'
            );
        }
    }

    // Header downgrade
    public get_wrm_headers(downgrade_to_v4: boolean = false): string[] {
        return this.wrm_headers.map(
            downgrade_to_v4 ? this.downgradePSSH : (_) => _
        );
    }

    private downgradePSSH(wrm_header: string): string {
        const header = new WRMHeader(wrm_header);
        return header.to_v4_0_0_0();
    }
}