psarc2 0.1.1

PlayStation archive reader
Documentation 
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! Compression logic.

#[cfg(feature = "zlib")]
mod zlib;

use std::{
    fmt::Display,
    io::{Read, Seek, SeekFrom, Write},
};

use crate::{
    error::{Error, Result},
    file::BasicFileEntry,
    read::BlockSize,
};

/// How the archive is compressed.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum CompressionType {
    /// No compression is applied.
    None,
    /// Zlib compression, requires the `zlib` feature flag to parse.
    Zlib,
    /// LZMA compression, requires the `lzma` feature flag to parse.
    Lzma,
}

impl CompressionType {
    /// Decompress a byte buffer based on the implementation.
    pub(crate) fn decompress<R, W, F>(
        self,
        reader: &mut R,
        writer: &mut W,
        entry: &F,
        block_size: BlockSize,
        block_sizes: &[u32],
    ) -> Result<()>
    where
        R: Read + Seek,
        W: Write,
        F: BasicFileEntry,
    {
        // Find the bytes
        reader.seek(SeekFrom::Start(
            u64::try_from(entry.offset()).map_err(|_| Error::AddressTooSmall)?,
        ))?;

        // Extract them, based on the compression
        match self {
            Self::None => {
                // Read exact amount of bytes
                let mut bytes = reader
                    .take(u64::try_from(entry.output_size()).map_err(|_| Error::AddressTooSmall)?);

                // Write to writer
                std::io::copy(&mut bytes, writer)?;

                Ok(())
            }
            // Only parse the compression if we support it directly
            #[cfg(feature = "zlib")]
            Self::Zlib => zlib::decompress(reader, writer, entry, block_size, block_sizes),
            // Only parse the compression if we support it directly
            #[cfg(feature = "lzma")]
            Self::Lzma => todo!(),
            #[cfg(not(all(feature = "lzma", feature = "zlib")))]
            unsupported => Err(Error::UnsupportedCompression(unsupported.to_string())),
        }
    }
}

impl Display for CompressionType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            Self::None => "none",
            Self::Zlib => "zlib",
            Self::Lzma => "lzma",
        })
    }
}

impl TryFrom<u32> for CompressionType {
    type Error = Error;

    fn try_from(value: u32) -> Result<Self> {
        match &value.to_be_bytes() {
            [0, 0, 0, 0] => Ok(Self::None),
            b"zlib" => Ok(Self::Zlib),
            b"lzma" => Ok(Self::Lzma),
            unsupported => Err(Error::UnsupportedCompression(
                String::from_utf8_lossy(unsupported).into_owned(),
            )),
        }
    }
}