1/****************************************************************************** 2* 3* Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore 4* 5* Licensed under the Apache License, Version 2.0 (the "License"); 6* you may not use this file except in compliance with the License. 7* You may obtain a copy of the License at: 8* 9* http://www.apache.org/licenses/LICENSE-2.0 10* 11* Unless required by applicable law or agreed to in writing, software 12* distributed under the License is distributed on an "AS IS" BASIS, 13* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14* See the License for the specific language governing permissions and 15* limitations under the License. 16* 17******************************************************************************/ 18/** 19******************************************************************************* 20* @file 21* ihevcd_api.c 22* 23* @brief 24* Contains functions definitions for reference list generation 25* 26* @author 27* Srinivas T 28* 29* @par List of Functions:\ 30* - ihevcd_ref_pic 31* 32* @remarks 33* None 34* 35******************************************************************************* 36*/ 37 38/*****************************************************************************/ 39/* File Includes */ 40/*****************************************************************************/ 41#include <stdio.h> 42#include <stddef.h> 43#include <stdlib.h> 44#include <string.h> 45#include <assert.h> 46 47#include "ihevc_typedefs.h" 48#include "iv.h" 49#include "ivd.h" 50#include "ihevcd_cxa.h" 51 52#include "ihevc_defs.h" 53#include "ihevc_debug.h" 54#include "ihevc_defs.h" 55#include "ihevc_macros.h" 56#include "ihevc_platform_macros.h" 57#include "ihevc_structs.h" 58#include "ihevc_buf_mgr.h" 59#include "ihevc_dpb_mgr.h" 60 61#include "ihevcd_trace.h" 62#include "ihevcd_defs.h" 63#include "ihevc_cabac_tables.h" 64#include "ihevcd_function_selector.h" 65#include "ihevcd_structs.h" 66#include "ihevcd_error.h" 67#include "ihevcd_nal.h" 68#include "ihevcd_bitstream.h" 69#include "ihevcd_debug.h" 70#include "ihevcd_error.h" 71 72 73mv_buf_t* ihevcd_mv_mgr_get_poc(buf_mgr_t *ps_mv_buf_mgr, UWORD32 abs_poc) 74{ 75 UWORD32 i; 76 mv_buf_t *ps_mv_buf = NULL; 77 78 79 80 for(i = 0; i < ps_mv_buf_mgr->u4_max_buf_cnt; i++) 81 { 82 ps_mv_buf = (mv_buf_t *)ps_mv_buf_mgr->apv_ptr[i]; 83 if(ps_mv_buf && (ps_mv_buf->i4_abs_poc == (WORD32)abs_poc)) 84 { 85 break; 86 } 87 } 88 89 return ps_mv_buf; 90} 91 92 93WORD32 ihevcd_ref_list(codec_t *ps_codec, pps_t *ps_pps, sps_t *ps_sps, slice_header_t *ps_slice_hdr) 94{ 95 WORD32 i; 96 WORD32 st_rps_idx; 97 WORD32 num_neg_pics, num_pos_pics; 98 WORD8 *pi1_used; 99 WORD16 *pi2_delta_poc; 100 UWORD32 u4_max_poc_lsb; 101 pic_buf_t *ps_pic_buf; 102 mv_buf_t *ps_mv_buf; 103 UWORD32 r_idx; 104 105 dpb_mgr_t *ps_dpb_mgr = (dpb_mgr_t *)ps_codec->pv_dpb_mgr; 106 buf_mgr_t *ps_mv_buf_mgr = (buf_mgr_t *)ps_codec->pv_mv_buf_mgr; 107 108 WORD32 ai4_poc_st_curr_before[MAX_DPB_SIZE], ai4_poc_st_foll[MAX_DPB_SIZE], ai4_poc_st_curr_after[MAX_DPB_SIZE]; 109 WORD32 ai4_poc_lt_curr[MAX_DPB_SIZE], ai4_poc_lt_foll[MAX_DPB_SIZE]; 110 UWORD32 u4_num_st_curr_before, u4_num_st_foll, u4_num_st_curr_after, u4_num_lt_curr, u4_num_lt_foll; 111 UWORD32 u4_num_total_curr; 112 113 WORD8 ai1_curr_delta_poc_msb_present_flag[MAX_DPB_SIZE], ai1_foll_delta_poc_msb_present_flag[MAX_DPB_SIZE]; 114 115 pic_buf_t *as_ref_pic_lt_curr[MAX_DPB_SIZE]; 116 pic_buf_t *as_ref_pic_lt_foll[MAX_DPB_SIZE]; 117 pic_buf_t *as_ref_pic_st_curr_after[MAX_DPB_SIZE]; 118 pic_buf_t *as_ref_pic_st_curr_before[MAX_DPB_SIZE]; 119 pic_buf_t *as_ref_pic_st_foll[MAX_DPB_SIZE]; 120 121 pic_buf_t *as_ref_pic_list_temp0[MAX_DPB_SIZE], *as_ref_pic_list_temp1[MAX_DPB_SIZE]; 122 123 UWORD32 u4_num_rps_curr_temp_list0, u4_num_rps_curr_temp_list1; 124 125 WORD32 i4_pic_order_cnt_val; 126 WORD32 i4_poc_lt; 127 UNUSED(as_ref_pic_lt_foll); 128 UNUSED(as_ref_pic_st_foll); 129 UNUSED(ps_pps); 130 131 RETURN_IF_NAL_INFO; 132 133 u4_max_poc_lsb = (1 << ps_sps->i1_log2_max_pic_order_cnt_lsb); 134 135 i4_pic_order_cnt_val = ps_slice_hdr->i4_abs_pic_order_cnt; 136 137 if(1 == ps_slice_hdr->i1_short_term_ref_pic_set_sps_flag) 138 { 139 st_rps_idx = ps_slice_hdr->i1_short_term_ref_pic_set_idx; 140 num_neg_pics = ps_sps->as_stref_picset[st_rps_idx].i1_num_neg_pics; 141 num_pos_pics = ps_sps->as_stref_picset[st_rps_idx].i1_num_pos_pics; 142 pi1_used = ps_sps->as_stref_picset[st_rps_idx].ai1_used; 143 pi2_delta_poc = ps_sps->as_stref_picset[st_rps_idx].ai2_delta_poc; 144 } 145 else 146 { 147 st_rps_idx = ps_sps->i1_num_short_term_ref_pic_sets; 148 num_neg_pics = ps_slice_hdr->s_stref_picset.i1_num_neg_pics; 149 num_pos_pics = ps_slice_hdr->s_stref_picset.i1_num_pos_pics; 150 pi1_used = ps_slice_hdr->s_stref_picset.ai1_used; 151 pi2_delta_poc = ps_slice_hdr->s_stref_picset.ai2_delta_poc; 152 } 153 154 u4_num_st_curr_before = 0; 155 u4_num_st_foll = 0; 156 for(i = 0; i < num_neg_pics; i++) 157 { 158 if(pi1_used[i]) 159 { 160 ai4_poc_st_curr_before[u4_num_st_curr_before] = i4_pic_order_cnt_val + pi2_delta_poc[i]; 161 u4_num_st_curr_before++; 162 } 163 else 164 { 165 ai4_poc_st_foll[u4_num_st_foll] = i4_pic_order_cnt_val + pi2_delta_poc[i]; 166 u4_num_st_foll++; 167 } 168 } 169 u4_num_st_curr_after = 0; 170 for(i = num_neg_pics; i < num_neg_pics + num_pos_pics; i++) 171 { 172 if(pi1_used[i]) 173 { 174 ai4_poc_st_curr_after[u4_num_st_curr_after] = i4_pic_order_cnt_val + pi2_delta_poc[i]; 175 u4_num_st_curr_after++; 176 } 177 else 178 { 179 ai4_poc_st_foll[u4_num_st_foll] = i4_pic_order_cnt_val + pi2_delta_poc[i]; 180 u4_num_st_foll++; 181 } 182 } 183 184 u4_num_lt_curr = 0; 185 u4_num_lt_foll = 0; 186 for(i = 0; i < ps_slice_hdr->i1_num_long_term_sps + ps_slice_hdr->i1_num_long_term_pics; i++) 187 { 188 i4_poc_lt = ps_slice_hdr->ai4_poc_lsb_lt[i]; 189 if(ps_slice_hdr->ai1_delta_poc_msb_present_flag[i]) 190 { 191 i4_poc_lt += i4_pic_order_cnt_val - ps_slice_hdr->ai1_delta_poc_msb_cycle_lt[i] * u4_max_poc_lsb - ps_slice_hdr->i4_pic_order_cnt_lsb; 192 } 193 194 if(ps_slice_hdr->ai1_used_by_curr_pic_lt_flag[i]) 195 { 196 ai4_poc_lt_curr[u4_num_lt_curr] = i4_poc_lt; 197 ai1_curr_delta_poc_msb_present_flag[u4_num_lt_curr] = ps_slice_hdr->ai1_delta_poc_msb_present_flag[i]; 198 u4_num_lt_curr++; 199 } 200 else 201 { 202 ai4_poc_lt_foll[u4_num_lt_foll] = i4_poc_lt; 203 ai1_foll_delta_poc_msb_present_flag[u4_num_lt_foll] = ps_slice_hdr->ai1_delta_poc_msb_present_flag[i]; 204 u4_num_lt_foll++; 205 } 206 } 207 208 u4_num_total_curr = u4_num_lt_curr + u4_num_st_curr_after + u4_num_st_curr_before; 209 210 /* Bit stream conformance tests */ 211/* 212 for(i = 0; i < u4_num_lt_curr; i++) 213 { 214 int j; 215 if(ai1_curr_delta_poc_msb_present_flag[i]) 216 { 217 for(j = 0; j < u4_num_st_curr_before; j++) 218 { 219 ASSERT(ai4_poc_st_curr_before[j] != ai4_poc_lt_curr[i]); 220 } 221 for(j = 0; j < u4_num_st_curr_after; j++) 222 { 223 ASSERT(ai4_poc_st_curr_after[j] != ai4_poc_lt_curr[i]); 224 } 225 for(j = 0; j < u4_num_st_foll; j++) 226 { 227 ASSERT(ai4_poc_st_foll[j] != ai4_poc_lt_curr[i]); 228 } 229 for(j = 0; j < u4_num_lt_curr; j++) 230 { 231 ASSERT((ai4_poc_lt_curr[j] != ai4_poc_lt_curr[i]) || (j == i)); 232 } 233 } 234 else 235 { 236 for(j = 0; j < u4_num_st_curr_before; j++) 237 { 238 ASSERT((ai4_poc_st_curr_before[j] & (u4_max_poc_lsb - 1)) != ai4_poc_lt_curr[i]); 239 } 240 for(j = 0; j < u4_num_st_curr_after; j++) 241 { 242 ASSERT((ai4_poc_st_curr_after[j] & (u4_max_poc_lsb - 1)) != ai4_poc_lt_curr[i]); 243 } 244 for(j = 0; j < u4_num_st_foll; j++) 245 { 246 ASSERT((ai4_poc_st_foll[j] & (u4_max_poc_lsb - 1)) != ai4_poc_lt_curr[i]); 247 } 248 for(j = 0; j < u4_num_lt_curr; j++) 249 { 250 ASSERT(((ai4_poc_lt_curr[j] & (u4_max_poc_lsb - 1)) != ai4_poc_lt_curr[i]) || (j == i)); 251 } 252 } 253 } 254 255 for(i = 0; i < u4_num_lt_foll; i++) 256 { 257 int j; 258 if(ai1_foll_delta_poc_msb_present_flag[i]) 259 { 260 for(j = 0; j < u4_num_st_curr_before; j++) 261 { 262 ASSERT(ai4_poc_st_curr_before[j] != ai4_poc_lt_foll[i]); 263 } 264 for(j = 0; j < u4_num_st_curr_after; j++) 265 { 266 ASSERT(ai4_poc_st_curr_after[j] != ai4_poc_lt_foll[i]); 267 } 268 for(j = 0; j < u4_num_st_foll; j++) 269 { 270 ASSERT(ai4_poc_st_foll[j] != ai4_poc_lt_foll[i]); 271 } 272 for(j = 0; j < u4_num_lt_curr; j++) 273 { 274 ASSERT(ai4_poc_lt_curr[j] != ai4_poc_lt_foll[i]); 275 } 276 for(j = 0; j < u4_num_lt_foll; j++) 277 { 278 ASSERT((ai4_poc_lt_foll[j] != ai4_poc_lt_foll[i]) || (j == i)); 279 } 280 } 281 else 282 { 283 for(j = 0; j < u4_num_st_curr_before; j++) 284 { 285 ASSERT((ai4_poc_st_curr_before[j] & (u4_max_poc_lsb - 1)) != ai4_poc_lt_foll[i]); 286 } 287 for(j = 0; j < u4_num_st_curr_after; j++) 288 { 289 ASSERT((ai4_poc_st_curr_after[j] & (u4_max_poc_lsb - 1)) != ai4_poc_lt_foll[i]); 290 } 291 for(j = 0; j < u4_num_st_foll; j++) 292 { 293 ASSERT((ai4_poc_st_foll[j] & (u4_max_poc_lsb - 1)) != ai4_poc_lt_foll[i]); 294 } 295 for(j = 0; j < u4_num_lt_curr; j++) 296 { 297 ASSERT((ai4_poc_lt_curr[j] & (u4_max_poc_lsb - 1)) != ai4_poc_lt_foll[i]); 298 } 299 for(j = 0; j < u4_num_lt_foll; j++) 300 { 301 ASSERT(((ai4_poc_lt_foll[j] & (u4_max_poc_lsb - 1)) != ai4_poc_lt_foll[i]) || (j == i)); 302 } 303 } 304 } 305*/ 306 307 308 /* Reference Pic sets creation */ 309 310 /* Set all the DPB buffers to UNUSED_FOR_REF */ 311 if(0 == ps_codec->i4_pic_present) 312 { 313 for(i = 0; i < MAX_DPB_BUFS; i++) 314 { 315 if(ps_dpb_mgr->as_dpb_info[i].ps_pic_buf) 316 ps_dpb_mgr->as_dpb_info[i].ps_pic_buf->u1_used_as_ref = UNUSED_FOR_REF; 317 } 318 } 319 320 for(i = 0; i < (WORD32)u4_num_lt_curr; i++) 321 { 322 if(0 == ai1_curr_delta_poc_msb_present_flag[i]) 323 { 324 ps_pic_buf = ihevc_dpb_mgr_get_ref_by_poc_lsb(ps_dpb_mgr, ai4_poc_lt_curr[i]); 325 if(NULL != ps_pic_buf) 326 ps_pic_buf->u1_used_as_ref = LONG_TERM_REF; 327 328 as_ref_pic_lt_curr[i] = ps_pic_buf; 329 } 330 else 331 { 332 ps_pic_buf = ihevc_dpb_mgr_get_ref_by_poc(ps_dpb_mgr, ai4_poc_lt_curr[i]); 333 if(NULL != ps_pic_buf) 334 ps_pic_buf->u1_used_as_ref = LONG_TERM_REF; 335 336 as_ref_pic_lt_curr[i] = ps_pic_buf; 337 } 338 } 339 340 for(i = 0; i < (WORD32)u4_num_lt_foll; i++) 341 { 342 if(0 == ai1_foll_delta_poc_msb_present_flag[i]) 343 { 344 ps_pic_buf = ihevc_dpb_mgr_get_ref_by_poc_lsb(ps_dpb_mgr, ai4_poc_lt_foll[i]); 345 if(NULL != ps_pic_buf) 346 ps_pic_buf->u1_used_as_ref = LONG_TERM_REF; 347 348 as_ref_pic_lt_foll[i] = ps_pic_buf; 349 } 350 else 351 { 352 ps_pic_buf = ihevc_dpb_mgr_get_ref_by_poc(ps_dpb_mgr, ai4_poc_lt_foll[i]); 353 if(NULL != ps_pic_buf) 354 ps_pic_buf->u1_used_as_ref = LONG_TERM_REF; 355 356 as_ref_pic_lt_foll[i] = ps_pic_buf; 357 } 358 } 359 360 361 for(i = 0; i < (WORD32)u4_num_st_curr_before; i++) 362 { 363 364 ps_pic_buf = ihevc_dpb_mgr_get_ref_by_poc(ps_dpb_mgr, ai4_poc_st_curr_before[i]); 365 if(NULL != ps_pic_buf) 366 ps_pic_buf->u1_used_as_ref = SHORT_TERM_REF; 367 368 as_ref_pic_st_curr_before[i] = ps_pic_buf; 369 } 370 371 for(i = 0; i < (WORD32)u4_num_st_curr_after; i++) 372 { 373 ps_pic_buf = ihevc_dpb_mgr_get_ref_by_poc(ps_dpb_mgr, ai4_poc_st_curr_after[i]); 374 if(NULL != ps_pic_buf) 375 ps_pic_buf->u1_used_as_ref = SHORT_TERM_REF; 376 377 as_ref_pic_st_curr_after[i] = ps_pic_buf; 378 } 379 380 for(i = 0; i < (WORD32)u4_num_st_foll; i++) 381 { 382 ps_pic_buf = ihevc_dpb_mgr_get_ref_by_poc(ps_dpb_mgr, ai4_poc_st_foll[i]); 383 if(NULL != ps_pic_buf) 384 ps_pic_buf->u1_used_as_ref = SHORT_TERM_REF; 385 386 as_ref_pic_st_foll[i] = ps_pic_buf; 387 } 388 389 //TODO: Bit stream conformance tests to be included 390 391 u4_num_rps_curr_temp_list0 = (WORD32)u4_num_total_curr > ps_slice_hdr->i1_num_ref_idx_l0_active ? (WORD32)u4_num_total_curr : ps_slice_hdr->i1_num_ref_idx_l0_active; 392 393 r_idx = 0; 394 if((PSLICE == ps_slice_hdr->i1_slice_type) || 395 (BSLICE == ps_slice_hdr->i1_slice_type)) 396 { 397 while(r_idx < u4_num_rps_curr_temp_list0) 398 { 399 for(i = 0; (i < (WORD32)u4_num_st_curr_before) && (r_idx < u4_num_rps_curr_temp_list0); r_idx++, i++) 400 { 401 if(NULL == as_ref_pic_st_curr_before[i]) 402 { 403 as_ref_pic_st_curr_before[i] = ihevc_dpb_mgr_get_ref_by_nearest_poc(ps_dpb_mgr, ai4_poc_st_curr_before[i]); 404 } 405 as_ref_pic_list_temp0[r_idx] = as_ref_pic_st_curr_before[i]; 406 } 407 408 for(i = 0; (i < (WORD32)u4_num_st_curr_after) && (r_idx < u4_num_rps_curr_temp_list0); r_idx++, i++) 409 { 410 if(NULL == as_ref_pic_st_curr_after[i]) 411 { 412 as_ref_pic_st_curr_after[i] = ihevc_dpb_mgr_get_ref_by_nearest_poc(ps_dpb_mgr, ai4_poc_st_curr_after[i]); 413 } 414 as_ref_pic_list_temp0[r_idx] = as_ref_pic_st_curr_after[i]; 415 } 416 417 for(i = 0; (i < (WORD32)u4_num_lt_curr) && (r_idx < u4_num_rps_curr_temp_list0); r_idx++, i++) 418 { 419 if(NULL == as_ref_pic_lt_curr[i]) 420 { 421 as_ref_pic_lt_curr[i] = ihevc_dpb_mgr_get_ref_by_nearest_poc(ps_dpb_mgr, ai4_poc_lt_curr[i]); 422 } 423 as_ref_pic_list_temp0[r_idx] = as_ref_pic_lt_curr[i]; 424 } 425 } 426 427 for(r_idx = 0; (WORD32)r_idx < ps_slice_hdr->i1_num_ref_idx_l0_active; r_idx++) 428 { 429 pic_buf_t *ps_pic_buf; 430 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_pic_buf = ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l0 ? (void *)as_ref_pic_list_temp0[ps_slice_hdr->s_rplm.i1_list_entry_l0[r_idx]] : (void *)as_ref_pic_list_temp0[r_idx]; 431 ps_pic_buf = (pic_buf_t *)ps_slice_hdr->as_ref_pic_list0[r_idx].pv_pic_buf; 432 433 if(ps_pic_buf == NULL) 434 return IHEVCD_REF_PIC_NOT_FOUND; 435 436 ps_mv_buf = ihevcd_mv_mgr_get_poc(ps_mv_buf_mgr, ps_pic_buf->i4_abs_poc); 437 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_mv_buf = ps_mv_buf; 438 } 439 440 441 if(ps_slice_hdr->i1_slice_type == BSLICE) 442 { 443 u4_num_rps_curr_temp_list1 = (WORD32)u4_num_total_curr > ps_slice_hdr->i1_num_ref_idx_l1_active ? (WORD32)u4_num_total_curr : ps_slice_hdr->i1_num_ref_idx_l1_active; 444 445 r_idx = 0; 446 while(r_idx < u4_num_rps_curr_temp_list1) 447 { 448 for(i = 0; (i < (WORD32)u4_num_st_curr_after) && (r_idx < u4_num_rps_curr_temp_list1); r_idx++, i++) 449 { 450 if(NULL == as_ref_pic_st_curr_after[i]) 451 { 452 as_ref_pic_st_curr_after[i] = ihevc_dpb_mgr_get_ref_by_nearest_poc(ps_dpb_mgr, ai4_poc_st_curr_after[i]); 453 } 454 as_ref_pic_list_temp1[r_idx] = as_ref_pic_st_curr_after[i]; 455 } 456 457 for(i = 0; (i < (WORD32)u4_num_st_curr_before) && (r_idx < u4_num_rps_curr_temp_list1); r_idx++, i++) 458 { 459 if(NULL == as_ref_pic_st_curr_before[i]) 460 { 461 as_ref_pic_st_curr_before[i] = ihevc_dpb_mgr_get_ref_by_nearest_poc(ps_dpb_mgr, ai4_poc_st_curr_before[i]); 462 } 463 as_ref_pic_list_temp1[r_idx] = as_ref_pic_st_curr_before[i]; 464 } 465 466 for(i = 0; (i < (WORD32)u4_num_lt_curr) && (r_idx < u4_num_rps_curr_temp_list1); r_idx++, i++) 467 { 468 if(NULL == as_ref_pic_lt_curr[i]) 469 { 470 as_ref_pic_lt_curr[i] = ihevc_dpb_mgr_get_ref_by_nearest_poc(ps_dpb_mgr, ai4_poc_lt_curr[i]); 471 } 472 as_ref_pic_list_temp1[r_idx] = as_ref_pic_lt_curr[i]; 473 } 474 } 475 476 for(r_idx = 0; (WORD32)r_idx < ps_slice_hdr->i1_num_ref_idx_l1_active; r_idx++) 477 { 478 pic_buf_t *ps_pic_buf; 479 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_pic_buf = ps_slice_hdr->s_rplm.i1_ref_pic_list_modification_flag_l1 ? (void *)as_ref_pic_list_temp1[ps_slice_hdr->s_rplm.i1_list_entry_l1[r_idx]] : (void *)as_ref_pic_list_temp1[r_idx]; 480 ps_pic_buf = (pic_buf_t *)ps_slice_hdr->as_ref_pic_list1[r_idx].pv_pic_buf; 481 482 if(ps_pic_buf == NULL) 483 return IHEVCD_REF_PIC_NOT_FOUND; 484 485 ps_mv_buf = ihevcd_mv_mgr_get_poc(ps_mv_buf_mgr, ps_pic_buf->i4_abs_poc); 486 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_mv_buf = ps_mv_buf; 487 } 488 } 489 } 490 491 DEBUG_PRINT_REF_LIST_POCS(i4_pic_order_cnt_val, ps_slice_hdr, ps_dpb_mgr, u4_num_st_curr_before, u4_num_st_curr_after, u4_num_st_foll, u4_num_lt_curr, u4_num_lt_foll, ai4_poc_st_curr_before, ai4_poc_st_curr_after, ai4_poc_st_foll, ai4_poc_lt_curr, ai4_poc_lt_foll); 492 /* Buffers that are still marked as UNUSED_FOR_REF are released from dpb (internally dpb calls release from pic buf manager)*/ 493 for(i = 0; i < MAX_DPB_BUFS; i++) 494 { 495 if((ps_dpb_mgr->as_dpb_info[i].ps_pic_buf) && (UNUSED_FOR_REF == ps_dpb_mgr->as_dpb_info[i].ps_pic_buf->u1_used_as_ref)) 496 { 497 pic_buf_t *ps_pic_buf = ps_dpb_mgr->as_dpb_info[i].ps_pic_buf; 498 mv_buf_t *ps_mv_buf; 499 500 /* Long term index is set to MAX_DPB_BUFS to ensure it is not added as LT */ 501 ihevc_dpb_mgr_del_ref(ps_dpb_mgr, (buf_mgr_t *)ps_codec->pv_pic_buf_mgr, ps_pic_buf->i4_abs_poc); 502 503 504 /* Find buffer id of the MV bank corresponding to the buffer being freed (Buffer with POC of u4_abs_poc) */ 505 ps_mv_buf = (mv_buf_t *)ps_codec->ps_mv_buf; 506 for(i = 0; i < BUF_MGR_MAX_CNT; i++) 507 { 508 if(ps_mv_buf->i4_abs_poc == ps_pic_buf->i4_abs_poc) 509 { 510 ihevc_buf_mgr_release((buf_mgr_t *)ps_codec->pv_mv_buf_mgr, i, BUF_MGR_REF); 511 break; 512 } 513 ps_mv_buf++; 514 } 515 } 516 517 } 518 519 return IHEVCD_SUCCESS; 520} 521