1use crate::bitreader::BitReader;
2use crate::eg::{read_se, read_ue};
3use crate::{Error, Result};
4
5#[derive(Debug, Clone)]
6pub struct Sps {
7 pub profile_idc: u8,
8 pub constraint_set0_flag: bool,
9 pub constraint_set1_flag: bool,
10 pub constraint_set2_flag: bool,
11 pub constraint_set3_flag: bool,
12 pub constraint_set4_flag: bool,
13 pub constraint_set5_flag: bool,
14 pub level_idc: u8,
15 pub seq_parameter_set_id: u8,
16
17 pub chroma_format_idc: u8,
18 pub separate_colour_plane_flag: bool,
19 pub bit_depth_luma_minus8: u8,
20 pub bit_depth_chroma_minus8: u8,
21 pub qpprime_y_zero_transform_bypass_flag: bool,
22 pub seq_scaling_matrix_present_flag: bool,
23
24 pub log2_max_frame_num_minus4: u8,
25 pub pic_order_cnt_type: u8,
26 pub log2_max_pic_order_cnt_lsb_minus4: u8,
27 pub delta_pic_order_always_zero_flag: bool,
28 pub offset_for_non_ref_pic: i32,
29 pub offset_for_top_to_bottom_field: i32,
30 pub num_ref_frames_in_pic_order_cnt_cycle: u8,
31
32 pub max_num_ref_frames: u32,
33 pub gaps_in_frame_num_value_allowed_flag: bool,
34 pub pic_width_in_mbs_minus1: u32,
35 pub pic_height_in_map_units_minus1: u32,
36 pub frame_mbs_only_flag: bool,
37 pub mb_adaptive_frame_field_flag: bool,
38 pub direct_8x8_inference_flag: bool,
39
40 pub frame_cropping_flag: bool,
41 pub frame_crop_left_offset: u32,
42 pub frame_crop_right_offset: u32,
43 pub frame_crop_top_offset: u32,
44 pub frame_crop_bottom_offset: u32,
45
46 pub vui_parameters_present_flag: bool,
47
48 pub width: u32,
49 pub height: u32,
50}
51
52impl Sps {
53 pub fn parse(rbsp: &[u8]) -> Result<Self> {
54 let mut reader = BitReader::new(rbsp);
55
56 let profile_idc = reader.read_u8()?;
57 let constraint_set0_flag = reader.read_flag()?;
58 let constraint_set1_flag = reader.read_flag()?;
59 let constraint_set2_flag = reader.read_flag()?;
60 let constraint_set3_flag = reader.read_flag()?;
61 let constraint_set4_flag = reader.read_flag()?;
62 let constraint_set5_flag = reader.read_flag()?;
63 let _reserved_zero_2bits = reader.read_bits(2)?;
64 let level_idc = reader.read_u8()?;
65
66 let seq_parameter_set_id = read_ue(&mut reader)?;
67 if seq_parameter_set_id > 31 {
68 return Err(Error::MalformedSps("Invalid SPS ID".into()));
69 }
70
71 let mut chroma_format_idc = 1;
72 let mut separate_colour_plane_flag = false;
73 let mut bit_depth_luma_minus8 = 0;
74 let mut bit_depth_chroma_minus8 = 0;
75 let mut qpprime_y_zero_transform_bypass_flag = false;
76 let mut seq_scaling_matrix_present_flag = false;
77
78 if profile_idc == 100 || profile_idc == 110 || profile_idc == 122 ||
79 profile_idc == 244 || profile_idc == 44 || profile_idc == 83 ||
80 profile_idc == 86 || profile_idc == 118 || profile_idc == 128 ||
81 profile_idc == 138 || profile_idc == 139 || profile_idc == 134 ||
82 profile_idc == 135 {
83 chroma_format_idc = read_ue(&mut reader)? as u8;
84 if chroma_format_idc > 3 {
85 return Err(Error::MalformedSps("Invalid chroma format".into()));
86 }
87
88 if chroma_format_idc == 3 {
89 separate_colour_plane_flag = reader.read_flag()?;
90 }
91
92 bit_depth_luma_minus8 = read_ue(&mut reader)? as u8;
93 bit_depth_chroma_minus8 = read_ue(&mut reader)? as u8;
94 qpprime_y_zero_transform_bypass_flag = reader.read_flag()?;
95 seq_scaling_matrix_present_flag = reader.read_flag()?;
96
97 if seq_scaling_matrix_present_flag {
98 let num_lists = if chroma_format_idc != 3 { 8 } else { 12 };
99 for _ in 0..num_lists {
100 let seq_scaling_list_present_flag = reader.read_flag()?;
101 if seq_scaling_list_present_flag {
102 skip_scaling_list(&mut reader)?;
103 }
104 }
105 }
106 }
107
108 let log2_max_frame_num_minus4 = read_ue(&mut reader)? as u8;
109 if log2_max_frame_num_minus4 > 12 {
110 return Err(Error::MalformedSps("Invalid log2_max_frame_num".into()));
111 }
112
113 let pic_order_cnt_type = read_ue(&mut reader)? as u8;
114
115 let mut log2_max_pic_order_cnt_lsb_minus4 = 0;
116 let mut delta_pic_order_always_zero_flag = false;
117 let mut offset_for_non_ref_pic = 0;
118 let mut offset_for_top_to_bottom_field = 0;
119 let mut num_ref_frames_in_pic_order_cnt_cycle = 0;
120
121 match pic_order_cnt_type {
122 0 => {
123 log2_max_pic_order_cnt_lsb_minus4 = read_ue(&mut reader)? as u8;
124 if log2_max_pic_order_cnt_lsb_minus4 > 12 {
125 return Err(Error::MalformedSps("Invalid log2_max_pic_order_cnt_lsb".into()));
126 }
127 }
128 1 => {
129 delta_pic_order_always_zero_flag = reader.read_flag()?;
130 offset_for_non_ref_pic = read_se(&mut reader)?;
131 offset_for_top_to_bottom_field = read_se(&mut reader)?;
132 num_ref_frames_in_pic_order_cnt_cycle = read_ue(&mut reader)? as u8;
133
134 for _ in 0..num_ref_frames_in_pic_order_cnt_cycle {
135 let _offset_for_ref_frame = read_se(&mut reader)?;
136 }
137 }
138 2 => {}
139 _ => return Err(Error::MalformedSps("Invalid pic_order_cnt_type".into())),
140 }
141
142 let max_num_ref_frames = read_ue(&mut reader)?;
143 let gaps_in_frame_num_value_allowed_flag = reader.read_flag()?;
144
145 let pic_width_in_mbs_minus1 = read_ue(&mut reader)?;
146 let pic_height_in_map_units_minus1 = read_ue(&mut reader)?;
147
148 let frame_mbs_only_flag = reader.read_flag()?;
149 let mut mb_adaptive_frame_field_flag = false;
150 if !frame_mbs_only_flag {
151 mb_adaptive_frame_field_flag = reader.read_flag()?;
152 }
153
154 let direct_8x8_inference_flag = reader.read_flag()?;
155
156 let frame_cropping_flag = reader.read_flag()?;
157 let mut frame_crop_left_offset = 0;
158 let mut frame_crop_right_offset = 0;
159 let mut frame_crop_top_offset = 0;
160 let mut frame_crop_bottom_offset = 0;
161
162 if frame_cropping_flag {
163 frame_crop_left_offset = read_ue(&mut reader)?;
164 frame_crop_right_offset = read_ue(&mut reader)?;
165 frame_crop_top_offset = read_ue(&mut reader)?;
166 frame_crop_bottom_offset = read_ue(&mut reader)?;
167 }
168
169 let vui_parameters_present_flag = reader.read_flag()?;
170
171 let width = (pic_width_in_mbs_minus1 + 1) * 16;
172 let height = (pic_height_in_map_units_minus1 + 1) * 16 * if frame_mbs_only_flag { 1 } else { 2 };
173
174 let (sub_width_c, sub_height_c) = match chroma_format_idc {
175 0 => (0, 0),
176 1 => (2, 2),
177 2 => (2, 1),
178 3 => (1, 1),
179 _ => (0, 0),
180 };
181
182 let width = if frame_cropping_flag && sub_width_c > 0 {
183 width - sub_width_c * (frame_crop_left_offset + frame_crop_right_offset)
184 } else {
185 width
186 };
187
188 let height = if frame_cropping_flag && sub_height_c > 0 {
189 let mult = if frame_mbs_only_flag { 1 } else { 2 };
190 height - sub_height_c * mult * (frame_crop_top_offset + frame_crop_bottom_offset)
191 } else {
192 height
193 };
194
195 Ok(Sps {
196 profile_idc,
197 constraint_set0_flag,
198 constraint_set1_flag,
199 constraint_set2_flag,
200 constraint_set3_flag,
201 constraint_set4_flag,
202 constraint_set5_flag,
203 level_idc,
204 seq_parameter_set_id: seq_parameter_set_id as u8,
205 chroma_format_idc,
206 separate_colour_plane_flag,
207 bit_depth_luma_minus8,
208 bit_depth_chroma_minus8,
209 qpprime_y_zero_transform_bypass_flag,
210 seq_scaling_matrix_present_flag,
211 log2_max_frame_num_minus4,
212 pic_order_cnt_type,
213 log2_max_pic_order_cnt_lsb_minus4,
214 delta_pic_order_always_zero_flag,
215 offset_for_non_ref_pic,
216 offset_for_top_to_bottom_field,
217 num_ref_frames_in_pic_order_cnt_cycle,
218 max_num_ref_frames,
219 gaps_in_frame_num_value_allowed_flag,
220 pic_width_in_mbs_minus1,
221 pic_height_in_map_units_minus1,
222 frame_mbs_only_flag,
223 mb_adaptive_frame_field_flag,
224 direct_8x8_inference_flag,
225 frame_cropping_flag,
226 frame_crop_left_offset,
227 frame_crop_right_offset,
228 frame_crop_top_offset,
229 frame_crop_bottom_offset,
230 vui_parameters_present_flag,
231 width,
232 height,
233 })
234 }
235}
236
237fn skip_scaling_list(reader: &mut BitReader) -> Result<()> {
238 let mut last_scale = 8;
239 let mut next_scale = 8;
240
241 for _ in 0..16 {
242 if next_scale != 0 {
243 let delta_scale = read_se(reader)?;
244 next_scale = (last_scale + delta_scale + 256) % 256;
245 }
246 last_scale = if next_scale == 0 { last_scale } else { next_scale };
247 }
248
249 Ok(())
250}
251
252#[cfg(test)]
253mod tests {
254 use super::*;
255 use crate::nal::ebsp_to_rbsp;
256
257 #[test]
258 fn test_basic_sps_parse() {
259 let ebsp = vec![
260 0x42, 0x00, 0x1f, 0xac, 0x34, 0xc8, 0x14, 0x00,
261 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00,
262 0xf0, 0x3c, 0x60, 0xc6, 0x58
263 ];
264
265 let rbsp = ebsp_to_rbsp(&ebsp);
266 let sps = Sps::parse(&rbsp).unwrap();
267
268 assert_eq!(sps.profile_idc, 66);
269 assert_eq!(sps.level_idc, 31);
270 assert!(sps.width > 0);
271 assert!(sps.height > 0);
272 }
273}