ass-renderer 0.1.2

High-performance ASS subtitle renderer with modular backends
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
144
145
146
147
148
149
150
151
152
153
154
155

//! Rendering context with fonts, resolution, and backend configuration

use fontdb::Database as FontDatabase;

#[cfg(feature = "nostd")]
use alloc::sync::Arc;
#[cfg(not(feature = "nostd"))]
use std::sync::Arc;

/// Rendering context containing fonts, resolution, and configuration
#[derive(Clone)]
pub struct RenderContext {
    width: u32,
    height: u32,
    font_database: Arc<FontDatabase>,
    playback_res_x: u32,
    playback_res_y: u32,
    storage_res_x: u32,
    storage_res_y: u32,
    frame_rate: f32,
    par: f32,
}

impl RenderContext {
    /// Create a new render context with the given dimensions
    pub fn new(width: u32, height: u32) -> Self {
        let mut font_database = FontDatabase::new();
        font_database.load_system_fonts();

        Self {
            width,
            height,
            font_database: Arc::new(font_database),
            playback_res_x: width,
            playback_res_y: height,
            storage_res_x: width,
            storage_res_y: height,
            frame_rate: 24.0,
            par: 1.0,
        }
    }

    /// Create context with custom font database
    pub fn with_font_database(width: u32, height: u32, font_database: FontDatabase) -> Self {
        Self {
            width,
            height,
            font_database: Arc::new(font_database),
            playback_res_x: width,
            playback_res_y: height,
            storage_res_x: width,
            storage_res_y: height,
            frame_rate: 24.0,
            par: 1.0,
        }
    }

    /// Set playback resolution (from script info)
    pub fn set_playback_resolution(&mut self, x: u32, y: u32) {
        self.playback_res_x = x;
        self.playback_res_y = y;
    }

    /// Set storage resolution (original script resolution)
    pub fn set_storage_resolution(&mut self, x: u32, y: u32) {
        self.storage_res_x = x;
        self.storage_res_y = y;
    }

    /// Set frame rate
    pub fn set_frame_rate(&mut self, fps: f32) {
        self.frame_rate = fps;
    }

    /// Set pixel aspect ratio
    pub fn set_pixel_aspect_ratio(&mut self, par: f32) {
        self.par = par;
    }

    /// Get render width
    pub fn width(&self) -> u32 {
        self.width
    }

    /// Get render height
    pub fn height(&self) -> u32 {
        self.height
    }

    /// Get font database
    pub fn font_database(&self) -> &FontDatabase {
        &self.font_database
    }

    /// Get mutable font database
    pub fn font_database_mut(&mut self) -> &mut FontDatabase {
        Arc::get_mut(&mut self.font_database).expect("Font database has multiple references")
    }

    /// Get playback resolution X
    pub fn playback_res_x(&self) -> u32 {
        self.playback_res_x
    }

    /// Get playback resolution Y
    pub fn playback_res_y(&self) -> u32 {
        self.playback_res_y
    }

    /// Get storage resolution X
    pub fn storage_res_x(&self) -> u32 {
        self.storage_res_x
    }

    /// Get storage resolution Y
    pub fn storage_res_y(&self) -> u32 {
        self.storage_res_y
    }

    /// Get frame rate
    pub fn frame_rate(&self) -> f32 {
        self.frame_rate
    }

    /// Get pixel aspect ratio
    pub fn pixel_aspect_ratio(&self) -> f32 {
        self.par
    }

    /// Calculate X scale factor from storage to playback resolution
    pub fn scale_x(&self) -> f32 {
        self.playback_res_x as f32 / self.storage_res_x.max(1) as f32
    }

    /// Calculate Y scale factor from storage to playback resolution
    pub fn scale_y(&self) -> f32 {
        self.playback_res_y as f32 / self.storage_res_y.max(1) as f32
    }

    /// Calculate X scale factor from playback to render resolution
    pub fn render_scale_x(&self) -> f32 {
        self.width as f32 / self.playback_res_x.max(1) as f32
    }

    /// Calculate Y scale factor from playback to render resolution
    pub fn render_scale_y(&self) -> f32 {
        self.height as f32 / self.playback_res_y.max(1) as f32
    }
}

impl Default for RenderContext {
    fn default() -> Self {
        Self::new(1920, 1080)
    }
}