teamtalk 6.0.0

TeamTalk SDK for Rust
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! Media file playback and streaming APIs.
use super::Client;
use crate::types::{UserId, VideoCodec};
use crate::utils::ToTT;
use teamtalk_sys as ffi;

/// Controls media file playback behavior.
#[derive(Debug, Clone, Default)]
pub struct MediaFilePlayback {
    pub offset_ms: u32,
    pub paused: bool,
}

impl MediaFilePlayback {
    pub fn to_ffi(&self) -> ffi::MediaFilePlayback {
        ffi::MediaFilePlayback {
            uOffsetMSec: self.offset_ms,
            bPaused: self.paused as i32,
            ..Default::default()
        }
    }
}

impl Client {
    /// Queries media-file metadata before playback or streaming.
    pub fn get_media_file_info(&self, file_path: &str) -> Option<crate::types::MediaFileInfo> {
        let mut info = ffi::MediaFileInfo::default();
        let path = file_path.tt();
        unsafe {
            (ffi::api().TT_GetMediaFileInfo(path.as_ptr(), &mut info) == 1)
                .then(|| crate::types::MediaFileInfo::from(info))
        }
    }

    /// Returns a palette entry for 8-bit desktop bitmaps.
    pub fn get_palette_color(
        &self,
        bitmap_format: ffi::BitmapFormat,
        index: i32,
    ) -> Option<[u8; 3]> {
        let ptr = unsafe { ffi::api().TT_Palette_GetColorTable(bitmap_format, index) };
        if ptr.is_null() {
            return None;
        }
        let bytes = unsafe { std::slice::from_raw_parts(ptr, 3) };
        Some([bytes[0], bytes[1], bytes[2]])
    }

    /// Starts streaming a media file to the channel.
    pub fn start_streaming_media_file_to_channel(
        &self,
        file_path: &str,
        codec: Option<&VideoCodec>,
    ) -> bool {
        let codec_ptr = codec.map_or(std::ptr::null(), |c| &c.to_ffi());
        unsafe {
            ffi::api().TT_StartStreamingMediaFileToChannel(
                self.ptr.0,
                file_path.tt().as_ptr(),
                codec_ptr,
            ) == 1
        }
    }

    /// Starts streaming a media file with advanced playback options.
    pub fn start_streaming_media_file_to_channel_ex(
        &self,
        file_path: &str,
        playback: &MediaFilePlayback,
        codec: Option<&VideoCodec>,
    ) -> bool {
        let codec_ptr = codec.map_or(std::ptr::null(), |c| &c.to_ffi());
        unsafe {
            ffi::api().TT_StartStreamingMediaFileToChannelEx(
                self.ptr.0,
                file_path.tt().as_ptr(),
                &playback.to_ffi(),
                codec_ptr,
            ) == 1
        }
    }

    /// Updates the currently streaming media file info.
    pub fn update_streaming_media_file_to_channel(
        &self,
        playback: &MediaFilePlayback,
        codec: Option<&VideoCodec>,
    ) -> bool {
        let codec_ptr = codec.map_or(std::ptr::null(), |c| &c.to_ffi());
        unsafe {
            ffi::api().TT_UpdateStreamingMediaFileToChannel(
                self.ptr.0,
                &playback.to_ffi(),
                codec_ptr,
            ) == 1
        }
    }

    /// Stops media file streaming.
    pub fn stop_streaming_media_file_to_channel(&self) -> bool {
        unsafe { ffi::api().TT_StopStreamingMediaFileToChannel(self.ptr.0) == 1 }
    }

    /// Initializes local media playback.
    pub fn init_local_playback(&self, file_path: &str, playback: &MediaFilePlayback) -> i32 {
        unsafe {
            ffi::api().TT_InitLocalPlayback(self.ptr.0, file_path.tt().as_ptr(), &playback.to_ffi())
        }
    }

    /// Updates local playback info.
    pub fn update_local_playback(&self, session_id: i32, playback: &MediaFilePlayback) -> bool {
        unsafe {
            ffi::api().TT_UpdateLocalPlayback(self.ptr.0, session_id, &playback.to_ffi()) == 1
        }
    }

    /// Stops local playback.
    pub fn stop_local_playback(&self, session_id: i32) -> bool {
        unsafe { ffi::api().TT_StopLocalPlayback(self.ptr.0, session_id) == 1 }
    }

    /// Acquires a media video frame for a user.
    pub fn acquire_user_media_video_frame(&self, user_id: UserId) -> Option<*mut ffi::VideoFrame> {
        unsafe {
            let ptr = ffi::api().TT_AcquireUserMediaVideoFrame(self.ptr.0, user_id.0);
            if ptr.is_null() { None } else { Some(ptr) }
        }
    }

    /// Releases a previously acquired media video frame.
    ///
    /// # Safety
    /// - `frame` must be a pointer returned by `acquire_user_media_video_frame`.
    /// - The frame must not be released more than once.
    /// - The pointer must not be used after release.
    pub unsafe fn release_user_media_video_frame(&self, frame: *mut ffi::VideoFrame) -> bool {
        if frame.is_null() {
            return false;
        }
        unsafe { ffi::api().TT_ReleaseUserMediaVideoFrame(self.ptr.0, frame) == 1 }
    }
}