playready/
pssh.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
//! PSSH module.

use crate::binary_format::pssh::{PSSHBox, PlayreadyHeader};
use base64::prelude::*;
use binrw::BinRead;
use std::io::Cursor;

#[derive(Debug, Clone)]
/// Wrm header which is extracted from PSSH box.
pub struct WrmHeader(String);

impl From<String> for WrmHeader {
    fn from(value: String) -> Self {
        WrmHeader(value)
    }
}

impl From<WrmHeader> for String {
    fn from(value: WrmHeader) -> Self {
        value.0
    }
}

/// Wrapper for `PlayreadyObject` binary format.
#[derive(Debug, Clone)]
pub struct Pssh {
    parsed: PlayreadyHeader,
}

impl Pssh {
    /// Creates [`Pssh`] from bytes.
    pub fn from_bytes(b: &[u8]) -> Result<Self, binrw::Error> {
        let pssh_box = PSSHBox::read(&mut Cursor::new(b));

        match pssh_box {
            Ok(pssh_box) => Ok(Self {
                parsed: pssh_box.data,
            }),
            Err(_) => Ok(Self {
                parsed: PlayreadyHeader::read(&mut Cursor::new(b))?,
            }),
        }
    }

    /// Creates [`Pssh`] from Base64 encoded bytes.
    pub fn from_b64(b64: &[u8]) -> Result<Self, crate::Error> {
        let bytes = BASE64_STANDARD.decode(b64)?;
        Self::from_bytes(&bytes).map_err(|e| e.into())
    }

    /// Returns WRM headers parsed from `PSSHBox` or `PlayreadyObject` format.
    pub fn wrm_headers(&self) -> Vec<WrmHeader> {
        self.parsed
            .records
            .iter()
            .filter(|o| o.type_ == 1)
            .filter_map(|o| {
                String::from_utf16(&o.data)
                    .inspect_err(|e| {
                        log::error!("Failed create uf16 string from wrm header: {e:?}")
                    })
                    .map(WrmHeader)
                    .ok()
            })
            .collect()
    }
}

impl TryFrom<&[u8]> for Pssh {
    type Error = binrw::Error;

    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
        Self::from_bytes(value)
    }
}