scuffle_h265/sps/
sps_scc_extension.rs

1use std::io;
2
3use scuffle_bytes_util::{BitReader, range_check};
4use scuffle_expgolomb::BitReaderExpGolombExt;
5
6/// Sequence parameter set screen content coding extension.
7///
8/// `sps_scc_extension()`
9///
10/// - ISO/IEC 23008-2 - 7.3.2.2.3
11/// - ISO/IEC 23008-2 - 7.4.3.2.3
12#[derive(Debug, Clone, PartialEq)]
13pub struct SpsSccExtension {
14    /// Equal to `true` specifies that a picture in the CVS may be included in a
15    /// reference picture list of a slice of the picture itself.
16    ///
17    /// Equal to `false` specifies that a picture in the CVS is never included in a
18    /// reference picture list of a slice of the picture itself.
19    pub sps_curr_pic_ref_enabled_flag: bool,
20    /// Palette mode information, if `palette_mode_enabled_flag` is `true`.
21    pub palette_mode: Option<SpsSccExtensionPaletteMode>,
22    /// Controls the presence and inference of the `use_integer_mv_flag`
23    /// that specifies the resolution of motion vectors for inter prediction.
24    ///
25    /// The value is in range \[0, 2\].
26    pub motion_vector_resolution_control_idc: u8,
27    /// Equal to `true` specifies that the intra boundary filtering process is
28    /// unconditionally disabled for intra prediction.
29    ///
30    /// Equal to `false` specifies that the intra boundary filtering process may be used.
31    pub intra_boundary_filtering_disabled_flag: bool,
32}
33
34impl SpsSccExtension {
35    pub(crate) fn parse<R: io::Read>(
36        bit_reader: &mut BitReader<R>,
37        chroma_format_idc: u8,
38        bit_depth_y: u8,
39        bit_depth_c: u8,
40    ) -> io::Result<Self> {
41        let sps_curr_pic_ref_enabled_flag = bit_reader.read_bit()?;
42
43        let mut palette_mode = None;
44        let palette_mode_enabled_flag = bit_reader.read_bit()?;
45        if palette_mode_enabled_flag {
46            let palette_max_size = bit_reader.read_exp_golomb()?;
47            let delta_palette_max_predictor_size = bit_reader.read_exp_golomb()?;
48
49            if palette_max_size == 0 && delta_palette_max_predictor_size != 0 {
50                return Err(io::Error::new(
51                    io::ErrorKind::InvalidData,
52                    "delta_palette_max_predictor_size must be 0 when palette_max_size is 0",
53                ));
54            }
55
56            let sps_palette_predictor_initializers_present_flag = bit_reader.read_bit()?;
57            if palette_max_size == 0 && !sps_palette_predictor_initializers_present_flag {
58                return Err(io::Error::new(
59                    io::ErrorKind::InvalidData,
60                    "sps_palette_predictor_initializers_present_flag must be 0 when palette_max_size is 0",
61                ));
62            }
63
64            let mut sps_palette_predictor_initializers = None;
65            if sps_palette_predictor_initializers_present_flag {
66                let sps_num_palette_predictor_initializers_minus1 = bit_reader.read_exp_golomb()?;
67
68                if sps_num_palette_predictor_initializers_minus1 >= palette_max_size {
69                    return Err(io::Error::new(
70                        io::ErrorKind::InvalidData,
71                        "sps_num_palette_predictor_initializers_minus1 + 1 must be less than or equal to palette_max_size",
72                    ));
73                }
74
75                let num_comps = if chroma_format_idc == 0 { 1 } else { 3 };
76
77                let mut initializers = vec![vec![0; sps_num_palette_predictor_initializers_minus1 as usize + 1]; num_comps];
78                for (comp, initializer) in initializers.iter_mut().enumerate().take(num_comps) {
79                    for sps_palette_predictor_initializer in initializer.iter_mut() {
80                        let bit_depth = if comp == 0 { bit_depth_y } else { bit_depth_c };
81                        *sps_palette_predictor_initializer = bit_reader.read_bits(bit_depth)?;
82                    }
83                }
84
85                sps_palette_predictor_initializers = Some(initializers);
86            }
87
88            palette_mode = Some(SpsSccExtensionPaletteMode {
89                palette_max_size,
90                delta_palette_max_predictor_size,
91                sps_palette_predictor_initializers,
92            });
93        }
94
95        let motion_vector_resolution_control_idc = bit_reader.read_bits(2)? as u8;
96        range_check!(motion_vector_resolution_control_idc, 0, 2)?; // 3 is reserved
97
98        let intra_boundary_filtering_disabled_flag = bit_reader.read_bit()?;
99
100        Ok(Self {
101            sps_curr_pic_ref_enabled_flag,
102            palette_mode,
103            motion_vector_resolution_control_idc,
104            intra_boundary_filtering_disabled_flag,
105        })
106    }
107}
108
109/// Directly part of [`SpsSccExtension`].
110#[derive(Debug, Clone, PartialEq)]
111pub struct SpsSccExtensionPaletteMode {
112    /// Specifies the maximum allowed palette size.
113    pub palette_max_size: u64,
114    /// Specifies the difference between the maximum allowed palette predictor size and the maximum allowed palette size.
115    ///
116    /// Defines [`PaletteMaxPredictorSize`](SpsSccExtensionPaletteMode::palette_max_predictor_size).
117    pub delta_palette_max_predictor_size: u64,
118    /// `sps_palette_predictor_initializer[comp][i]`, if `sps_palette_predictor_initializers_present_flag` is `true`.
119    ///
120    /// Specifies the value of the `comp`-th component of the `i`-th
121    /// palette entry in the SPS that is used to initialize the array PredictorPaletteEntries.
122    ///
123    /// The value of `sps_palette_predictor_initializer[0][i]` is in range \[0, `(1 << BitDepthY) − 1`\].
124    /// See [`BitDepthY`](crate::SpsRbsp::bit_depth_y).
125    ///
126    /// The values of `sps_palette_predictor_initializer[1][i]` and `sps_palette_predictor_initializer[2][i]`
127    /// is in range \[0, `(1 << BitDepthC) − 1`\].
128    /// See [`BitDepthC`](crate::SpsRbsp::bit_depth_c).
129    pub sps_palette_predictor_initializers: Option<Vec<Vec<u64>>>,
130}
131
132impl SpsSccExtensionPaletteMode {
133    /// `PaletteMaxPredictorSize = palette_max_size + delta_palette_max_predictor_size` (7-35)
134    ///
135    /// ISO/IEC 23008-2 - 7.4.3.2.3
136    pub fn palette_max_predictor_size(&self) -> u64 {
137        self.palette_max_size + self.delta_palette_max_predictor_size
138    }
139}
140
141#[cfg(test)]
142#[cfg_attr(all(test, coverage_nightly), coverage(off))]
143mod tests {
144    use byteorder::WriteBytesExt;
145    use scuffle_bytes_util::BitWriter;
146    use scuffle_expgolomb::BitWriterExpGolombExt;
147
148    #[test]
149    fn test_parse() {
150        let mut data = Vec::new();
151        let mut bit_writer = BitWriter::new(&mut data);
152
153        bit_writer.write_bit(true).unwrap(); // sps_curr_pic_ref_enabled_flag
154        bit_writer.write_bit(true).unwrap(); // palette_mode_enabled_flag
155
156        bit_writer.write_exp_golomb(5).unwrap(); // palette_max_size
157        bit_writer.write_exp_golomb(2).unwrap(); // delta_palette_max_predictor_size
158        bit_writer.write_bit(true).unwrap(); // sps_palette_predictor_initializers_present_flag
159
160        bit_writer.write_exp_golomb(1).unwrap(); // sps_num_palette_predictor_initializers_minus1
161
162        bit_writer.write_u8(1).unwrap(); // sps_palette_predictor_initializer[0][0]
163        bit_writer.write_u8(2).unwrap(); // sps_palette_predictor_initializer[0][1]
164        bit_writer.write_u8(3).unwrap(); // sps_palette_predictor_initializer[1][0]
165        bit_writer.write_u8(4).unwrap(); // sps_palette_predictor_initializer[1][1]
166        bit_writer.write_u8(5).unwrap(); // sps_palette_predictor_initializer[2][0]
167        bit_writer.write_u8(6).unwrap(); // sps_palette_predictor_initializer[2][1]
168
169        bit_writer.write_bits(0, 2).unwrap(); // motion_vector_resolution_control_idc
170        bit_writer.write_bit(false).unwrap(); // intra_boundary_filtering_disabled_flag
171
172        bit_writer.write_bits(0, 8).unwrap(); // fill the last byte
173
174        let scc_extension = super::SpsSccExtension::parse(
175            &mut scuffle_bytes_util::BitReader::new(&data[..]),
176            1, // chroma_format_idc
177            8, // bit_depth_y
178            8, // bit_depth_c
179        )
180        .unwrap();
181
182        assert!(scc_extension.sps_curr_pic_ref_enabled_flag);
183
184        assert!(scc_extension.palette_mode.is_some());
185        let palette_mode = scc_extension.palette_mode.unwrap();
186        assert_eq!(palette_mode.palette_max_size, 5);
187        assert_eq!(palette_mode.delta_palette_max_predictor_size, 2);
188        assert_eq!(palette_mode.palette_max_predictor_size(), 7);
189
190        assert!(palette_mode.sps_palette_predictor_initializers.is_some());
191        let initializers = palette_mode.sps_palette_predictor_initializers.unwrap();
192        assert_eq!(initializers.len(), 3);
193        assert_eq!(initializers[0].len(), 2);
194        assert_eq!(initializers[0][0], 1);
195        assert_eq!(initializers[0][1], 2);
196        assert_eq!(initializers[1].len(), 2);
197        assert_eq!(initializers[1][0], 3);
198        assert_eq!(initializers[1][1], 4);
199        assert_eq!(initializers[2].len(), 2);
200        assert_eq!(initializers[2][0], 5);
201        assert_eq!(initializers[2][1], 6);
202
203        assert_eq!(scc_extension.motion_vector_resolution_control_idc, 0);
204        assert!(!scc_extension.intra_boundary_filtering_disabled_flag);
205    }
206}
scuffle_h265/sps/sps_scc_extension.rs

scuffle_h265/sps/
sps_scc_extension.rs
