dvdcss 0.1.2

Safe, Rust bindings to libdvdcss.
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
96
97
98
99
100
101
102
103
104
105
106
107

//! # Dvdcss
//!
//! The `dvdcss` crate contains bindings to the C library `libdvdcss`, providing a simple and
//! easy way to read content from encrypted DVDs.

use std::ffi::CStr;
use std::os::raw::c_void;

mod ffi;

#[repr(i32)]
/// Describes whether to recalculate keys.
pub enum SeekOptions {
    None = 0,
    /// At the discretion of libdvdcss, checks the title key and allows for it to be recalculated.
    Mpeg = 1 << 0,
    /// Checks the title key and allows for it to be recalculated.
    Key = 1 << 1,
}

/// Information may only be loaded out of a DVD in 2048 byte increments.
pub type Block = [u8; 2048];

#[repr(transparent)]
/// An instance of dvdcss. Represents a DVD which has been loaded into a drive.
///
/// Must have its destructor run.
pub struct DVD {
    ptr: ffi::dvdcss_t,
}

impl DVD {
    /// Opens the DVD at the device location specified in the string (eg /dev/sr0).
    ///
    /// Returns `None` if there is no DVD in the drive.
    pub fn new(location: &CStr) -> Option<Self> {
        let ptr = unsafe { ffi::dvdcss_open(location.as_ptr()) };

        match !ptr.is_null() {
            true => Some(Self { ptr }),
            false => None,
        }
    }

    /// Sets the absolute position of the needle of the DVD.
    ///
    /// The value `blocks` determines in intervals of 2048 (the size of a block) the absolute
    /// location to which the needle should be moved.
    ///
    /// The `flags` behavior is documented in `SeekOptions`.
    ///
    /// Returns `Ok` and the new position in blocks if the operation succeeded, and
    /// `Err` if it did not.
    pub fn seek(&self, blocks: u32, flags: SeekOptions) -> Result<u32, ()> {
        let val = unsafe { ffi::dvdcss_seek(self.ptr, blocks as i32, flags as i32) };
        match val >= 0 {
            true => Ok(val as u32),
            false => Err(()),
        }
    }

    /// Fills each `Block` of `buffer` with the raw contents of the DVD from the current
    /// position of the needle, which is modifiable with the `seek` function.
    ///
    /// The `decrypt` boolean should be enabled when the DVD is encrypted.
    ///
    /// Returns `Ok` and the accompanying number of blocks read if the operation
    /// succeeded, and `Err` if it did not.
    pub fn read(&self, buffer: &mut [Block], decrypt: bool) -> Result<u32, ()> {
        let val = unsafe {
            ffi::dvdcss_read(
                self.ptr,
                buffer.as_mut_ptr() as *mut c_void,
                buffer.len() as i32,
                // if decrypt == 0, uses empty flag 0, else uses set flag 1; this is valid
                decrypt as i32,
            )
        };
        match val >= 0 {
            true => Ok(val as u32),
            false => Err(()),
        }
    }

    /// Returns whether the DVD being read is scrambled.
    pub fn is_scrambled(&self) -> bool {
        match unsafe { ffi::dvdcss_is_scrambled(self.ptr) } {
            0 => false,
            1 => true,
            _ => unreachable!(),
        }
    }

    /// Returns text describing the latest error encountered by dvdcss.
    ///
    /// Output is undefined if no error was encountered, but should not crash to read.
    pub fn latest_error(&self) -> &CStr {
        unsafe { CStr::from_ptr(ffi::dvdcss_error(self.ptr)) }
    }
}

impl Drop for DVD {
    fn drop(&mut self) {
        let val = unsafe { ffi::dvdcss_close(self.ptr) };
        assert_eq!(val, 0);
    }
}