]>
Commit | Line | Data |
---|---|---|
1 | use nihav_core::codecs::DecoderResult; | |
2 | //use nihav_core::frame::{FrameType, NAVideoBufferRef, NATimeInfo}; | |
3 | use super::sets::SeqParameterSet; | |
4 | use super::slice::*; | |
5 | ||
6 | use libva::VASurfaceID; | |
7 | ||
8 | pub const MISSING_POC: u16 = 0xFFFF; | |
9 | ||
10 | #[derive(Clone)] | |
11 | pub struct PictureInfo { | |
12 | pub id: u16, | |
13 | pub full_id: u32, | |
14 | pub top_id: u32, | |
15 | pub bot_id: u32, | |
16 | // pub pic_type: FrameType, | |
17 | pub is_ref: bool, | |
18 | pub is_idr: bool, | |
19 | pub long_term: Option<usize>, | |
20 | pub surface_id: VASurfaceID, | |
21 | } | |
22 | ||
23 | #[derive(Clone)] | |
24 | pub struct SliceRefs { | |
25 | pub ref_list0: Vec<Option<PictureInfo>>, | |
26 | pub ref_list1: Vec<Option<PictureInfo>>, | |
27 | pub cur_id: u32, | |
28 | } | |
29 | ||
30 | #[allow(dead_code)] | |
31 | impl SliceRefs { | |
32 | pub fn get_ref_id(&self, list_id: u8, ref_id: usize) -> Option<u32> { | |
33 | let ref_list = if list_id == 0 { &self.ref_list0 } else { &self.ref_list1 }; | |
34 | if ref_list.len() > ref_id { | |
35 | ref_list[ref_id].as_ref().map(|pic| pic.full_id) | |
36 | } else { | |
37 | None | |
38 | } | |
39 | } | |
40 | } | |
41 | ||
42 | pub struct FrameRefs { | |
43 | pub ref_pics: Vec<PictureInfo>, | |
44 | pub cur_refs: SliceRefs, | |
45 | pub long_term: Vec<Option<PictureInfo>>, | |
46 | ||
47 | prev_poc_msb: u32, | |
48 | prev_poc_lsb: u16, | |
49 | prev_ref_poc_lsb: u16, | |
50 | prev_frame_num: u16, | |
51 | frame_num_offset: u32, | |
52 | max_frame_num: i32, | |
53 | } | |
54 | ||
55 | #[allow(clippy::new_without_default)] | |
56 | impl FrameRefs { | |
57 | pub fn new() -> Self { | |
58 | Self { | |
59 | ref_pics: Vec::with_capacity(16), | |
60 | cur_refs: SliceRefs { | |
61 | ref_list0: Vec::with_capacity(3), | |
62 | ref_list1: Vec::with_capacity(3), | |
63 | cur_id: 0, | |
64 | }, | |
65 | long_term: Vec::new(), | |
66 | ||
67 | prev_poc_msb: 0, | |
68 | prev_poc_lsb: 0, | |
69 | prev_ref_poc_lsb: 0, | |
70 | prev_frame_num: 0, | |
71 | frame_num_offset: 0, | |
72 | max_frame_num: 0, | |
73 | } | |
74 | } | |
75 | pub fn fill_ref_nums(&self, dst: &mut Vec<u32>) { | |
76 | for pic in self.ref_pics.iter() { | |
77 | if !dst.contains(&pic.full_id) { | |
78 | dst.push(pic.full_id); | |
79 | } | |
80 | } | |
81 | for pic in self.long_term.iter().flatten() { | |
82 | if !dst.contains(&pic.full_id) { | |
83 | dst.push(pic.full_id); | |
84 | } | |
85 | } | |
86 | } | |
87 | pub fn calc_picture_num(&mut self, slice_hdr: &SliceHeader, is_idr: bool, ref_id: u8, sps: &SeqParameterSet) -> (u32, u32) { | |
88 | self.max_frame_num = 1 << sps.log2_max_frame_num; | |
89 | match sps.pic_order_cnt_type { | |
90 | 0 => { | |
91 | if is_idr { | |
92 | self.prev_poc_msb = 0; | |
93 | self.prev_poc_lsb = 0; | |
94 | } else { | |
95 | self.prev_poc_lsb = self.prev_ref_poc_lsb; | |
96 | } | |
97 | let max_poc_lsb = 1 << sps.log2_max_pic_order_cnt_lsb; | |
98 | let half_max_poc_lsb = 1 << (sps.log2_max_pic_order_cnt_lsb - 1); | |
99 | let cur_lsb = slice_hdr.pic_order_cnt_lsb; | |
100 | let poc_msb = if cur_lsb < self.prev_poc_lsb && (self.prev_poc_lsb - cur_lsb >= half_max_poc_lsb) { | |
101 | self.prev_poc_msb + max_poc_lsb | |
102 | } else if cur_lsb > self.prev_poc_lsb && (cur_lsb - self.prev_poc_lsb > half_max_poc_lsb) { | |
103 | self.prev_poc_msb.wrapping_sub(max_poc_lsb) | |
104 | } else { | |
105 | self.prev_poc_msb | |
106 | }; | |
107 | let poc = poc_msb + u32::from(cur_lsb); | |
108 | if ref_id != 0 { | |
109 | self.prev_ref_poc_lsb = slice_hdr.pic_order_cnt_lsb; | |
110 | self.prev_poc_msb = poc_msb; | |
111 | } | |
112 | (poc, poc) | |
113 | }, | |
114 | 1 => { | |
115 | let off = if self.prev_frame_num > slice_hdr.frame_num { | |
116 | self.frame_num_offset + (1 << sps.log2_max_frame_num) | |
117 | } else { | |
118 | self.frame_num_offset | |
119 | }; | |
120 | let mut anum = if sps.num_ref_frames_in_pic_order_cnt_cycle != 0 { | |
121 | (off as i32) + i32::from(slice_hdr.frame_num) | |
122 | } else { | |
123 | 0 | |
124 | }; | |
125 | if ref_id == 0 && anum > 0 { | |
126 | anum -= 1; | |
127 | } | |
128 | let (poc_cycle_cnt, fno_in_poc_cycle) = if anum > 0 { | |
129 | let nrf = sps.num_ref_frames_in_pic_order_cnt_cycle as i32; | |
130 | ((anum - 1) / nrf, (anum - 1) % nrf) | |
131 | } else { | |
132 | (0, 0) | |
133 | }; | |
134 | let mut expected_delta = 0; | |
135 | for &offset in sps.offset_for_ref_frame[..sps.num_ref_frames_in_pic_order_cnt_cycle].iter() { | |
136 | expected_delta += offset; | |
137 | } | |
138 | let mut expected_poc = if anum > 0 { | |
139 | let mut sum = poc_cycle_cnt * expected_delta; | |
140 | for &offset in sps.offset_for_ref_frame[..=fno_in_poc_cycle as usize].iter() { | |
141 | sum += offset; | |
142 | } | |
143 | sum | |
144 | } else { | |
145 | 0 | |
146 | }; | |
147 | if ref_id == 0 { | |
148 | expected_poc += sps.offset_for_non_ref_pic; | |
149 | } | |
150 | let (top_id, bot_id) = if !slice_hdr.field_pic { | |
151 | let top_id = expected_poc + slice_hdr.delta_pic_order_cnt[0]; | |
152 | let bot_id = top_id + sps.offset_for_top_to_bottom_field + slice_hdr.delta_pic_order_cnt[1]; | |
153 | (top_id, bot_id) | |
154 | } else if !slice_hdr.bottom_field { | |
155 | (expected_poc + slice_hdr.delta_pic_order_cnt[0], 0) | |
156 | } else { | |
157 | (0, sps.offset_for_top_to_bottom_field + slice_hdr.delta_pic_order_cnt[1]) | |
158 | }; | |
159 | self.prev_frame_num = slice_hdr.frame_num; | |
160 | self.frame_num_offset = off; | |
161 | (top_id as u32, bot_id as u32) | |
162 | }, | |
163 | _ => { | |
164 | if slice_hdr.frame_num < self.prev_frame_num { | |
165 | self.frame_num_offset += 1 << sps.log2_max_frame_num; | |
166 | } | |
167 | self.prev_frame_num = slice_hdr.frame_num; | |
168 | let poc = self.frame_num_offset + u32::from(slice_hdr.frame_num); | |
169 | (poc, poc) | |
170 | }, | |
171 | } | |
172 | } | |
173 | pub fn apply_adaptive_marking(&mut self, marking: &AdaptiveMarking, cur_id: u16, max_id: u16) -> DecoderResult<()> { | |
174 | let all_ref_pics = self.ref_pics.clone(); | |
175 | ||
176 | for (&op, (&arg1, &arg2)) in marking.memory_management_control_op.iter().zip(marking.operation_arg.iter().zip(marking.operation_arg2.iter())).take(marking.num_ops) { | |
177 | match op { | |
178 | 1 => { | |
179 | let src_id = cur_id.wrapping_sub(arg1) & (max_id - 1); | |
180 | let mut found = false; | |
181 | let mut idx = 0; | |
182 | for (i, pic) in self.ref_pics.iter().enumerate() { | |
183 | if pic.id == src_id { | |
184 | found = true; | |
185 | idx = i; | |
186 | break; | |
187 | } | |
188 | } | |
189 | if found { | |
190 | self.ref_pics.remove(idx); | |
191 | } | |
192 | }, | |
193 | 2 => { // mark long term picture as unused | |
194 | let idx = arg1 as usize; | |
195 | if idx < self.long_term.len() { | |
196 | self.long_term[idx] = None; | |
197 | } | |
198 | }, | |
199 | 3 => { | |
200 | let src_id = cur_id.wrapping_sub(arg1) & (max_id - 1); | |
201 | ||
202 | let didx = arg2 as usize; | |
203 | for pic in all_ref_pics.iter() { | |
204 | if pic.id == src_id { | |
205 | if didx < self.long_term.len() { | |
206 | self.long_term[didx] = Some(pic.clone()); | |
207 | } | |
208 | break; | |
209 | } | |
210 | } | |
211 | }, | |
212 | 4 => { | |
213 | self.long_term.resize(arg1 as usize, None); | |
214 | }, | |
215 | 5 => { | |
216 | self.ref_pics.clear(); | |
217 | self.long_term.clear(); | |
218 | }, | |
219 | 6 => { | |
220 | // assign an long term index to current pic - done elsewhere | |
221 | }, | |
222 | _ => {}, | |
223 | }; | |
224 | } | |
225 | Ok(()) | |
226 | } | |
227 | pub fn clear_refs(&mut self) { | |
228 | self.ref_pics.clear(); | |
229 | self.long_term.clear(); | |
230 | } | |
231 | #[allow(clippy::cognitive_complexity)] | |
232 | pub fn select_refs(&mut self, sps: &SeqParameterSet, slice_hdr: &SliceHeader, cur_id: u32) { | |
233 | self.cur_refs.cur_id = cur_id; | |
234 | self.cur_refs.ref_list0.clear(); | |
235 | self.cur_refs.ref_list1.clear(); | |
236 | let pic_num_mask = if sps.log2_max_frame_num == 16 { | |
237 | 0xFFFF | |
238 | } else { | |
239 | (1 << sps.log2_max_frame_num) - 1 | |
240 | }; | |
241 | ||
242 | if !slice_hdr.slice_type.is_intra() { | |
243 | let has_reordering = slice_hdr.ref_pic_list_reordering_l0; | |
244 | if !has_reordering { | |
245 | let num_ref = slice_hdr.num_ref_idx_l0_active; | |
246 | if slice_hdr.slice_type.is_p() { | |
247 | if !self.ref_pics.is_empty() { | |
248 | for pic in self.ref_pics.iter().rev().take(num_ref) { | |
249 | self.cur_refs.ref_list0.push(Some(pic.clone())); | |
250 | } | |
251 | } | |
252 | } else { | |
253 | let mut pivot = 0; | |
254 | for (i, pic) in self.ref_pics.iter().enumerate() { | |
255 | pivot = i; | |
256 | if pic.full_id > cur_id { | |
257 | break; | |
258 | } | |
259 | } | |
260 | for pic in self.ref_pics[..pivot].iter().rev() { | |
261 | if self.cur_refs.ref_list0.len() >= num_ref { | |
262 | break; | |
263 | } | |
264 | self.cur_refs.ref_list0.push(Some(pic.clone())); | |
265 | } | |
266 | for pic in self.ref_pics.iter().skip(pivot) { | |
267 | if self.cur_refs.ref_list0.len() >= num_ref { | |
268 | break; | |
269 | } | |
270 | self.cur_refs.ref_list0.push(Some(pic.clone())); | |
271 | } | |
272 | } | |
273 | if !self.long_term.is_empty() && self.cur_refs.ref_list0.len() < num_ref { | |
274 | let copy_size = num_ref - self.cur_refs.ref_list0.len(); | |
275 | for ltpic in self.long_term.iter().take(copy_size) { | |
276 | self.cur_refs.ref_list0.push(ltpic.clone()); | |
277 | } | |
278 | } | |
279 | } else { | |
280 | form_ref_list(&mut self.cur_refs.ref_list0, | |
281 | &self.ref_pics, &self.long_term, | |
282 | &slice_hdr.reordering_list_l0, | |
283 | slice_hdr.frame_num, pic_num_mask); | |
284 | } | |
285 | if slice_hdr.slice_type.is_b() { | |
286 | let has_reordering = slice_hdr.ref_pic_list_reordering_l1; | |
287 | if !has_reordering { | |
288 | let num_ref = slice_hdr.num_ref_idx_l1_active; | |
289 | let mut pivot = 0; | |
290 | for (i, pic) in self.ref_pics.iter().enumerate() { | |
291 | pivot = i; | |
292 | if pic.full_id > cur_id { | |
293 | break; | |
294 | } | |
295 | } | |
296 | for pic in self.ref_pics.iter().skip(pivot) { | |
297 | if self.cur_refs.ref_list1.len() >= num_ref { | |
298 | break; | |
299 | } | |
300 | self.cur_refs.ref_list1.push(Some(pic.clone())); | |
301 | } | |
302 | for pic in self.ref_pics[..pivot].iter().rev() { | |
303 | if self.cur_refs.ref_list1.len() >= num_ref { | |
304 | break; | |
305 | } | |
306 | self.cur_refs.ref_list1.push(Some(pic.clone())); | |
307 | } | |
308 | if !self.long_term.is_empty() && self.cur_refs.ref_list1.len() < num_ref { | |
309 | let copy_size = num_ref - self.cur_refs.ref_list1.len(); | |
310 | for ltpic in self.long_term.iter().take(copy_size) { | |
311 | self.cur_refs.ref_list1.push(ltpic.clone()); | |
312 | } | |
313 | } | |
314 | if self.cur_refs.ref_list1.len() > 1 && self.cur_refs.ref_list0.len() == self.cur_refs.ref_list1.len() { | |
315 | let mut equal = true; | |
316 | for (pic1, pic2) in self.cur_refs.ref_list0.iter().zip(self.cur_refs.ref_list1.iter()) { | |
317 | match (pic1, pic2) { | |
318 | (Some(p1), Some(p2)) => { | |
319 | if p1.full_id != p2.full_id { | |
320 | equal = false; | |
321 | break; | |
322 | } | |
323 | }, | |
324 | (None, None) => {}, | |
325 | _ => { | |
326 | equal = false; | |
327 | break; | |
328 | }, | |
329 | }; | |
330 | } | |
331 | if equal { | |
332 | self.cur_refs.ref_list1.swap(0, 1); | |
333 | } | |
334 | } | |
335 | } else { | |
336 | form_ref_list(&mut self.cur_refs.ref_list1, | |
337 | &self.ref_pics, &self.long_term, | |
338 | &slice_hdr.reordering_list_l1, | |
339 | slice_hdr.frame_num, pic_num_mask); | |
340 | } | |
341 | } | |
342 | } | |
343 | } | |
344 | pub fn add_short_term(&mut self, cpic: PictureInfo, num_ref_frames: usize) { | |
345 | if !self.ref_pics.is_empty() && self.ref_pics.len() >= num_ref_frames { | |
346 | let base_id = i32::from(cpic.id); | |
347 | let mut min_id = base_id; | |
348 | let mut min_idx = 0; | |
349 | for (i, pic) in self.ref_pics.iter().enumerate() { | |
350 | let mut pic_id = i32::from(pic.id); | |
351 | if pic_id > base_id { | |
352 | pic_id -= self.max_frame_num; | |
353 | } | |
354 | if pic_id < min_id { | |
355 | min_id = pic_id; | |
356 | min_idx = i; | |
357 | } | |
358 | } | |
359 | self.ref_pics.remove(min_idx); | |
360 | } | |
361 | if self.ref_pics.is_empty() || self.ref_pics.last().unwrap().full_id < cpic.full_id { | |
362 | self.ref_pics.push(cpic); | |
363 | } else { | |
364 | let mut idx = 0; | |
365 | for (i, pic) in self.ref_pics.iter().enumerate() { | |
366 | if pic.full_id < cpic.full_id { | |
367 | idx = i; | |
368 | } else { | |
369 | break; | |
370 | } | |
371 | } | |
372 | self.ref_pics.insert(idx + 1, cpic); | |
373 | } | |
374 | } | |
375 | pub fn add_long_term(&mut self, lt_idx: usize, cpic: PictureInfo) { | |
376 | if lt_idx < self.long_term.len() { | |
377 | self.long_term[lt_idx] = Some(cpic); | |
378 | } | |
379 | } | |
380 | } | |
381 | ||
382 | fn form_ref_list(ref_list: &mut Vec<Option<PictureInfo>>, ref_pics: &[PictureInfo], long_term: &[Option<PictureInfo>], reord_info: &ReorderingInfo, cur_id: u16, pic_num_mask: u16) { | |
383 | let mut ref_pic_id = cur_id; | |
384 | for (&op, &num) in reord_info.reordering_of_pic_nums_idc.iter().zip(reord_info.abs_diff_or_num.iter()).take(reord_info.num_ops) { | |
385 | if op < 2 { | |
386 | if op == 0 { | |
387 | ref_pic_id = ref_pic_id.wrapping_sub(num) & pic_num_mask; | |
388 | } else { | |
389 | ref_pic_id = ref_pic_id.wrapping_add(num) & pic_num_mask; | |
390 | } | |
391 | let mut found = false; | |
392 | for pic in ref_pics.iter() { | |
393 | if pic.id == ref_pic_id { | |
394 | ref_list.push(Some(pic.clone())); | |
395 | found = true; | |
396 | break; | |
397 | } | |
398 | } | |
399 | if !found { | |
400 | ref_list.push(None); | |
401 | } | |
402 | } else { | |
403 | let idx = num as usize; | |
404 | if idx < long_term.len() { | |
405 | ref_list.push(long_term[idx].clone()); | |
406 | } else { | |
407 | ref_list.push(None); | |
408 | } | |
409 | } | |
410 | } | |
411 | } |