avplayer 0.2.0

Safe Rust bindings for Apple's AVPlayer + AVAssetReader — playback and frame-by-frame asset reading on macOS
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
108
109
110

#![allow(clippy::missing_errors_doc, clippy::must_use_candidate)]

use core::ffi::{c_char, c_void};
use core::ptr;

use serde::Deserialize;

use crate::error::{from_swift, AVPlayerError};
use crate::ffi;
use crate::player::PlayerItem;
use crate::util::parse_json_and_free;

#[derive(Debug, Clone, PartialEq, Deserialize)]
#[serde(rename_all = "camelCase")]
struct ErrorLogPayload {
    extended_log: Option<String>,
    extended_log_data_string_encoding: usize,
    events: Vec<ErrorLogEventPayload>,
}

#[derive(Debug, Clone, PartialEq, Deserialize)]
#[serde(rename_all = "camelCase")]
struct ErrorLogEventPayload {
    date: Option<String>,
    uri: Option<String>,
    server_address: Option<String>,
    playback_session_id: Option<String>,
    error_status_code: i64,
    error_domain: String,
    error_comment: Option<String>,
    all_http_response_header_fields: Option<std::collections::BTreeMap<String, String>>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PlayerItemErrorLogEvent {
    pub date: Option<String>,
    pub uri: Option<String>,
    pub server_address: Option<String>,
    pub playback_session_id: Option<String>,
    pub error_status_code: i64,
    pub error_domain: String,
    pub error_comment: Option<String>,
    pub all_http_response_header_fields: Option<std::collections::BTreeMap<String, String>>,
}

impl From<ErrorLogEventPayload> for PlayerItemErrorLogEvent {
    fn from(payload: ErrorLogEventPayload) -> Self {
        Self {
            date: payload.date,
            uri: payload.uri,
            server_address: payload.server_address,
            playback_session_id: payload.playback_session_id,
            error_status_code: payload.error_status_code,
            error_domain: payload.error_domain,
            error_comment: payload.error_comment,
            all_http_response_header_fields: payload.all_http_response_header_fields,
        }
    }
}

pub struct PlayerItemErrorLog {
    pub(crate) ptr: *mut c_void,
}

impl Drop for PlayerItemErrorLog {
    fn drop(&mut self) {
        if !self.ptr.is_null() {
            unsafe { ffi::av_player_item_error_log_release(self.ptr) };
            self.ptr = ptr::null_mut();
        }
    }
}

impl PlayerItemErrorLog {
    fn info(&self) -> Result<ErrorLogPayload, AVPlayerError> {
        let mut err: *mut c_char = ptr::null_mut();
        let json_ptr = unsafe { ffi::av_player_item_error_log_info_json(self.ptr, &mut err) };
        if json_ptr.is_null() {
            return Err(unsafe { from_swift(ffi::status::OPERATION_FAILED, err) });
        }
        parse_json_and_free(json_ptr)
    }

    pub fn extended_log(&self) -> Result<Option<String>, AVPlayerError> {
        Ok(self.info()?.extended_log)
    }

    pub fn extended_log_data_string_encoding(&self) -> Result<usize, AVPlayerError> {
        Ok(self.info()?.extended_log_data_string_encoding)
    }

    pub fn events(&self) -> Result<Vec<PlayerItemErrorLogEvent>, AVPlayerError> {
        Ok(self
            .info()?
            .events
            .into_iter()
            .map(PlayerItemErrorLogEvent::from)
            .collect())
    }
}

impl PlayerItem {
    pub fn error_log(&self) -> Result<Option<PlayerItemErrorLog>, AVPlayerError> {
        let ptr = unsafe { ffi::av_player_item_copy_error_log(self.ptr) };
        if ptr.is_null() {
            return Ok(None);
        }
        Ok(Some(PlayerItemErrorLog { ptr }))
    }
}