1 use nihav_core::codecs::DecoderResult;
2 //use nihav_core::frame::{FrameType, NAVideoBufferRef, NATimeInfo};
3 use super::sets::SeqParameterSet;
6 use libva::VASurfaceID;
8 pub const MISSING_POC: u16 = 0xFFFF;
11 pub struct PictureInfo {
16 // pub pic_type: FrameType,
19 pub long_term: Option<usize>,
20 pub surface_id: VASurfaceID,
24 pub struct SliceRefs {
25 pub ref_list0: Vec<Option<PictureInfo>>,
26 pub ref_list1: Vec<Option<PictureInfo>>,
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)
42 pub struct FrameRefs {
43 pub ref_pics: Vec<PictureInfo>,
44 pub cur_refs: SliceRefs,
45 pub long_term: Vec<Option<PictureInfo>>,
49 prev_ref_poc_lsb: u16,
51 frame_num_offset: u32,
55 #[allow(clippy::new_without_default)]
57 pub fn new() -> Self {
59 ref_pics: Vec::with_capacity(16),
61 ref_list0: Vec::with_capacity(3),
62 ref_list1: Vec::with_capacity(3),
65 long_term: Vec::new(),
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);
81 for pic in self.long_term.iter().flatten() {
82 if !dst.contains(&pic.full_id) {
83 dst.push(pic.full_id);
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 {
92 self.prev_poc_msb = 0;
93 self.prev_poc_lsb = 0;
95 self.prev_poc_lsb = self.prev_ref_poc_lsb;
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)
107 let poc = poc_msb + u32::from(cur_lsb);
109 self.prev_ref_poc_lsb = slice_hdr.pic_order_cnt_lsb;
110 self.prev_poc_msb = poc_msb;
115 let off = if self.prev_frame_num > slice_hdr.frame_num {
116 self.frame_num_offset + (1 << sps.log2_max_frame_num)
118 self.frame_num_offset
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)
125 if ref_id == 0 && anum > 0 {
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)
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;
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() {
148 expected_poc += sps.offset_for_non_ref_pic;
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];
154 } else if !slice_hdr.bottom_field {
155 (expected_poc + slice_hdr.delta_pic_order_cnt[0], 0)
157 (0, sps.offset_for_top_to_bottom_field + slice_hdr.delta_pic_order_cnt[1])
159 self.prev_frame_num = slice_hdr.frame_num;
160 self.frame_num_offset = off;
161 (top_id as u32, bot_id as u32)
164 if slice_hdr.frame_num < self.prev_frame_num {
165 self.frame_num_offset += 1 << sps.log2_max_frame_num;
167 self.prev_frame_num = slice_hdr.frame_num;
168 let poc = self.frame_num_offset + u32::from(slice_hdr.frame_num);
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();
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) {
179 let src_id = cur_id.wrapping_sub(arg1) & (max_id - 1);
180 let mut found = false;
182 for (i, pic) in self.ref_pics.iter().enumerate() {
183 if pic.id == src_id {
190 self.ref_pics.remove(idx);
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;
200 let src_id = cur_id.wrapping_sub(arg1) & (max_id - 1);
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());
213 self.long_term.resize(arg1 as usize, None);
216 self.ref_pics.clear();
217 self.long_term.clear();
220 // assign an long term index to current pic - done elsewhere
227 pub fn clear_refs(&mut self) {
228 self.ref_pics.clear();
229 self.long_term.clear();
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 {
239 (1 << sps.log2_max_frame_num) - 1
242 if !slice_hdr.slice_type.is_intra() {
243 let has_reordering = slice_hdr.ref_pic_list_reordering_l0;
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()));
254 for (i, pic) in self.ref_pics.iter().enumerate() {
256 if pic.full_id > cur_id {
260 for pic in self.ref_pics[..pivot].iter().rev() {
261 if self.cur_refs.ref_list0.len() >= num_ref {
264 self.cur_refs.ref_list0.push(Some(pic.clone()));
266 for pic in self.ref_pics.iter().skip(pivot) {
267 if self.cur_refs.ref_list0.len() >= num_ref {
270 self.cur_refs.ref_list0.push(Some(pic.clone()));
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());
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);
285 if slice_hdr.slice_type.is_b() {
286 let has_reordering = slice_hdr.ref_pic_list_reordering_l1;
288 let num_ref = slice_hdr.num_ref_idx_l1_active;
290 for (i, pic) in self.ref_pics.iter().enumerate() {
292 if pic.full_id > cur_id {
296 for pic in self.ref_pics.iter().skip(pivot) {
297 if self.cur_refs.ref_list1.len() >= num_ref {
300 self.cur_refs.ref_list1.push(Some(pic.clone()));
302 for pic in self.ref_pics[..pivot].iter().rev() {
303 if self.cur_refs.ref_list1.len() >= num_ref {
306 self.cur_refs.ref_list1.push(Some(pic.clone()));
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());
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()) {
318 (Some(p1), Some(p2)) => {
319 if p1.full_id != p2.full_id {
332 self.cur_refs.ref_list1.swap(0, 1);
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);
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;
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;
359 self.ref_pics.remove(min_idx);
361 if self.ref_pics.is_empty() || self.ref_pics.last().unwrap().full_id < cpic.full_id {
362 self.ref_pics.push(cpic);
365 for (i, pic) in self.ref_pics.iter().enumerate() {
366 if pic.full_id < cpic.full_id {
372 self.ref_pics.insert(idx + 1, cpic);
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);
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) {
387 ref_pic_id = ref_pic_id.wrapping_sub(num) & pic_num_mask;
389 ref_pic_id = ref_pic_id.wrapping_add(num) & pic_num_mask;
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()));
403 let idx = num as usize;
404 if idx < long_term.len() {
405 ref_list.push(long_term[idx].clone());