1 /****************************************************************************** 2 * 3 * Copyright (C) 2015 The Android Open Source Project 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 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore 19 */ 20 #include "ih264_typedefs.h" 21 #include "ih264_macros.h" 22 #include "ih264_platform_macros.h" 23 #include "iv.h" 24 #include "ih264d_dpb_manager.h" 25 #include "ih264d_bitstrm.h" 26 #include "ih264d_parse_cavlc.h" 27 #include "ih264d_defs.h" 28 #include "ih264d_structs.h" 29 #include "ih264d_process_bslice.h" 30 #include "ih264d_debug.h" 31 #include "ih264d_tables.h" 32 #include "ih264d_error_handler.h" 33 #include "string.h" 34 #include "ih264d_defs.h" 35 #include "ih264_error.h" 36 #include "ih264_buf_mgr.h" 37 #include "assert.h" 38 39 /*! 40 *************************************************************************** 41 * \file ih264d_dpb_mgr.c 42 * 43 * \brief 44 * Functions for managing the decoded picture buffer 45 * 46 * Detailed_description 47 * 48 * \date 49 * 19-12-2002 50 * 51 * \author Sriram Sethuraman 52 *************************************************************************** 53 */ 54 55 /*! 56 ************************************************************************** 57 * \if Function name : ih264d_init_ref_bufs \endif 58 * 59 * \brief 60 * Called at the start for initialization. 61 * 62 * \return 63 * none 64 ************************************************************************** 65 */ 66 void ih264d_init_ref_bufs(dpb_manager_t *ps_dpb_mgr) 67 { 68 UWORD32 i; 69 struct dpb_info_t *ps_dpb_info = ps_dpb_mgr->as_dpb_info; 70 for(i = 0; i < MAX_REF_BUFS; i++) 71 { 72 ps_dpb_info[i].u1_used_as_ref = UNUSED_FOR_REF; 73 ps_dpb_info[i].u1_lt_idx = MAX_REF_BUFS + 1; 74 ps_dpb_info[i].ps_prev_short = NULL; 75 ps_dpb_info[i].ps_prev_long = NULL; 76 ps_dpb_info[i].ps_pic_buf = NULL; 77 ps_dpb_info[i].s_top_field.u1_reference_info = UNUSED_FOR_REF; 78 ps_dpb_info[i].s_bot_field.u1_reference_info = UNUSED_FOR_REF; 79 ps_dpb_info[i].s_top_field.u1_long_term_frame_idx = MAX_REF_BUFS + 1; 80 ps_dpb_info[i].s_bot_field.u1_long_term_frame_idx = MAX_REF_BUFS + 1; 81 82 } 83 ps_dpb_mgr->u1_num_st_ref_bufs = ps_dpb_mgr->u1_num_lt_ref_bufs = 0; 84 ps_dpb_mgr->ps_dpb_st_head = NULL; 85 ps_dpb_mgr->ps_dpb_ht_head = NULL; 86 ps_dpb_mgr->i1_gaps_deleted = 0; 87 ps_dpb_mgr->i1_poc_buf_id_entries = 0; 88 89 ps_dpb_mgr->u1_num_gaps = 0; 90 for(i = 0; i < MAX_FRAMES; i++) 91 { 92 ps_dpb_mgr->ai4_gaps_start_frm_num[i] = INVALID_FRAME_NUM; 93 ps_dpb_mgr->ai4_gaps_end_frm_num[i] = 0; 94 ps_dpb_mgr->ai1_gaps_per_seq[i] = 0; 95 ps_dpb_mgr->ai4_poc_buf_id_map[i][0] = -1; 96 ps_dpb_mgr->ai4_poc_buf_id_map[i][1] = 0x7fffffff; 97 ps_dpb_mgr->ai4_poc_buf_id_map[i][2] = 0; 98 } 99 100 } 101 102 void ih264d_free_ref_pic_mv_bufs(void* pv_dec, UWORD8 pic_buf_id) 103 { 104 dec_struct_t *ps_dec = (dec_struct_t *)pv_dec; 105 106 if((pic_buf_id == ps_dec->u1_pic_buf_id) && 107 ps_dec->ps_cur_slice->u1_field_pic_flag && 108 (ps_dec->u1_top_bottom_decoded == 0)) 109 { 110 return; 111 } 112 113 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 114 pic_buf_id, 115 BUF_MGR_REF); 116 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr, 117 ps_dec->au1_pic_buf_id_mv_buf_id_map[pic_buf_id], 118 BUF_MGR_REF); 119 } 120 /*! 121 ************************************************************************** 122 * \if Function name : ih264d_delete_lt_node \endif 123 * 124 * \brief 125 * Delete a buffer with a long term index from the LT linked list 126 * 127 * \return 128 * none 129 ************************************************************************** 130 */ 131 WORD32 ih264d_delete_lt_node(dpb_manager_t *ps_dpb_mgr, 132 UWORD32 u4_lt_idx, 133 UWORD8 u1_fld_pic_flag, 134 struct dpb_info_t *ps_lt_node_to_insert, 135 WORD32 *pi4_status) 136 { 137 *pi4_status = 0; 138 if(ps_dpb_mgr->u1_num_lt_ref_bufs > 0) 139 { 140 WORD32 i; 141 struct dpb_info_t *ps_next_dpb; 142 /* ps_unmark_node points to the node to be removed */ 143 /* from long term list. */ 144 struct dpb_info_t *ps_unmark_node; 145 //Find the node with matching LTIndex 146 ps_next_dpb = ps_dpb_mgr->ps_dpb_ht_head; 147 if(ps_next_dpb->u1_lt_idx == u4_lt_idx) 148 { 149 ps_unmark_node = ps_next_dpb; 150 } 151 else 152 { 153 for(i = 1; i < ps_dpb_mgr->u1_num_lt_ref_bufs; i++) 154 { 155 if(ps_next_dpb->ps_prev_long->u1_lt_idx == u4_lt_idx) 156 break; 157 ps_next_dpb = ps_next_dpb->ps_prev_long; 158 } 159 if(i == ps_dpb_mgr->u1_num_lt_ref_bufs) 160 *pi4_status = 1; 161 else 162 ps_unmark_node = ps_next_dpb->ps_prev_long; 163 } 164 165 if(*pi4_status == 0) 166 { 167 if(u1_fld_pic_flag) 168 { 169 if(ps_lt_node_to_insert != ps_unmark_node) 170 { 171 UWORD8 u1_deleted = 0; 172 /* for the ps_unmark_node mark the corresponding field */ 173 /* field as unused for reference */ 174 175 if(ps_unmark_node->s_top_field.u1_long_term_frame_idx 176 == u4_lt_idx) 177 { 178 ps_unmark_node->s_top_field.u1_reference_info = 179 UNUSED_FOR_REF; 180 ps_unmark_node->s_top_field.u1_long_term_frame_idx = 181 MAX_REF_BUFS + 1; 182 u1_deleted = 1; 183 } 184 if(ps_unmark_node->s_bot_field.u1_long_term_frame_idx 185 == u4_lt_idx) 186 { 187 ps_unmark_node->s_bot_field.u1_reference_info = 188 UNUSED_FOR_REF; 189 ps_unmark_node->s_bot_field.u1_long_term_frame_idx = 190 MAX_REF_BUFS + 1; 191 u1_deleted = 1; 192 } 193 194 if(!u1_deleted) 195 { 196 197 UWORD32 i4_error_code; 198 i4_error_code = ERROR_DBP_MANAGER_T; 199 200 return i4_error_code; 201 } 202 } 203 204 ps_unmark_node->u1_used_as_ref = 205 ps_unmark_node->s_top_field.u1_reference_info 206 | ps_unmark_node->s_bot_field.u1_reference_info; 207 } 208 else 209 ps_unmark_node->u1_used_as_ref = UNUSED_FOR_REF; 210 211 if(UNUSED_FOR_REF == ps_unmark_node->u1_used_as_ref) 212 { 213 if(ps_unmark_node == ps_dpb_mgr->ps_dpb_ht_head) 214 ps_dpb_mgr->ps_dpb_ht_head = ps_next_dpb->ps_prev_long; 215 216 ps_unmark_node->u1_lt_idx = MAX_REF_BUFS + 1; 217 ps_unmark_node->s_top_field.u1_reference_info = 218 UNUSED_FOR_REF; 219 ps_unmark_node->s_bot_field.u1_reference_info = 220 UNUSED_FOR_REF; 221 // Release the physical buffer 222 ih264d_free_ref_pic_mv_bufs(ps_dpb_mgr->pv_codec_handle, 223 ps_unmark_node->u1_buf_id); 224 ps_next_dpb->ps_prev_long = ps_unmark_node->ps_prev_long; //update link 225 ps_unmark_node->ps_prev_long = NULL; 226 ps_dpb_mgr->u1_num_lt_ref_bufs--; //decrement LT buf count 227 } 228 } 229 } 230 return OK; 231 } 232 233 /*! 234 ************************************************************************** 235 * \if Function name : ih264d_insert_lt_node \endif 236 * 237 * \brief 238 * Insert a buffer into the LT linked list at a given LT index 239 * 240 * \return 241 * none 242 ************************************************************************** 243 */ 244 WORD32 ih264d_insert_lt_node(dpb_manager_t *ps_dpb_mgr, 245 struct dpb_info_t *ps_mov_node, 246 UWORD32 u4_lt_idx, 247 UWORD8 u1_fld_pic_flag) 248 { 249 UWORD8 u1_mark_top_field_long_term = 0; 250 UWORD8 u1_mark_bot_field_long_term = 0; 251 252 { 253 if(u1_fld_pic_flag) 254 { 255 /* Assign corresponding field (top or bottom) long_term_frame_idx */ 256 257 if((ps_mov_node->s_top_field.u1_reference_info == IS_LONG_TERM) 258 && (ps_mov_node->s_bot_field.u1_reference_info 259 == IS_LONG_TERM)) 260 { 261 if(ps_mov_node->u1_lt_idx == u4_lt_idx) 262 u1_mark_bot_field_long_term = 1; 263 else 264 { 265 266 UWORD32 i4_error_code; 267 i4_error_code = ERROR_DBP_MANAGER_T; 268 269 return i4_error_code; 270 271 } 272 } 273 else if(ps_mov_node->s_top_field.u1_reference_info == IS_LONG_TERM) 274 { 275 u1_mark_top_field_long_term = 1; 276 } 277 278 if(!(u1_mark_top_field_long_term || u1_mark_bot_field_long_term)) 279 { 280 UWORD32 i4_error_code; 281 i4_error_code = ERROR_DBP_MANAGER_T; 282 return i4_error_code; 283 } 284 } 285 else 286 { 287 ps_mov_node->s_top_field.u1_reference_info = IS_LONG_TERM; 288 ps_mov_node->s_bot_field.u1_reference_info = IS_LONG_TERM; 289 ps_mov_node->s_top_field.u1_long_term_frame_idx = u4_lt_idx; 290 ps_mov_node->s_bot_field.u1_long_term_frame_idx = u4_lt_idx; 291 } 292 293 ps_mov_node->u1_lt_idx = u4_lt_idx; //Assign the LT index to the node 294 ps_mov_node->ps_pic_buf->u1_long_term_frm_idx = u4_lt_idx; 295 ps_mov_node->u1_used_as_ref = IS_LONG_TERM; 296 297 /* Insert the new long term in the LT list with u4_lt_idx */ 298 /* in ascending order. */ 299 if(ps_dpb_mgr->u1_num_lt_ref_bufs > 0) 300 { 301 struct dpb_info_t *ps_next_dpb = ps_dpb_mgr->ps_dpb_ht_head; 302 if(u4_lt_idx < ps_next_dpb->u1_lt_idx) 303 { 304 //LTIndex to be inserted is the smallest LT index 305 //Update head and point prev to the next higher index 306 ps_mov_node->ps_prev_long = ps_next_dpb; 307 ps_dpb_mgr->ps_dpb_ht_head = ps_mov_node; 308 } 309 else 310 { 311 WORD32 i; 312 struct dpb_info_t *ps_nxtDPB = ps_next_dpb; 313 ps_next_dpb = ps_next_dpb->ps_prev_long; 314 for(i = 1; i < ps_dpb_mgr->u1_num_lt_ref_bufs; i++) 315 { 316 if(ps_next_dpb->u1_lt_idx > u4_lt_idx) 317 break; 318 ps_nxtDPB = ps_next_dpb; 319 ps_next_dpb = ps_next_dpb->ps_prev_long; 320 } 321 322 ps_nxtDPB->ps_prev_long = ps_mov_node; 323 ps_mov_node->ps_prev_long = ps_next_dpb; 324 } 325 } 326 else 327 { 328 ps_dpb_mgr->ps_dpb_ht_head = ps_mov_node; 329 ps_mov_node->ps_prev_long = NULL; 330 } 331 /* Identify the picture buffer as a long term picture buffer */ 332 ps_mov_node->ps_pic_buf->u1_is_short = 0; 333 334 /* Increment LT buf count only if new LT node inserted */ 335 /* If Increment during top_field is done, don't increment */ 336 /* for bottom field, as both them are part of same pic. */ 337 if(!u1_mark_bot_field_long_term) 338 ps_dpb_mgr->u1_num_lt_ref_bufs++; 339 340 } 341 return OK; 342 } 343 344 /*! 345 ************************************************************************** 346 * \if Function name : ih264d_insert_st_node \endif 347 * 348 * \brief 349 * Adds a short term reference picture into the ST linked list 350 * 351 * \return 352 * None 353 * 354 * \note 355 * Called only for a new coded picture with nal_ref_idc!=0 356 ************************************************************************** 357 */ 358 WORD32 ih264d_insert_st_node(dpb_manager_t *ps_dpb_mgr, 359 struct pic_buffer_t *ps_pic_buf, 360 UWORD8 u1_buf_id, 361 UWORD32 u4_cur_pic_num) 362 { 363 WORD32 i; 364 struct dpb_info_t *ps_dpb_info = ps_dpb_mgr->as_dpb_info; 365 UWORD8 u1_picture_type = ps_pic_buf->u1_picturetype; 366 /* Find an unused dpb location */ 367 for(i = 0; i < MAX_REF_BUFS; i++) 368 { 369 if((ps_dpb_info[i].ps_pic_buf == ps_pic_buf) 370 && ps_dpb_info[i].u1_used_as_ref) 371 { 372 /* Can occur only for field bottom pictures */ 373 ps_dpb_info[i].s_bot_field.u1_reference_info = IS_SHORT_TERM; 374 return 0; 375 } 376 377 if((ps_dpb_info[i].u1_used_as_ref == UNUSED_FOR_REF) 378 && (ps_dpb_info[i].s_top_field.u1_reference_info 379 == UNUSED_FOR_REF) 380 && (ps_dpb_info[i].s_bot_field.u1_reference_info 381 == UNUSED_FOR_REF)) 382 break; 383 } 384 if(i == MAX_REF_BUFS) 385 { 386 UWORD32 i4_error_code; 387 i4_error_code = ERROR_DBP_MANAGER_T; 388 return i4_error_code; 389 } 390 391 /* Create dpb info */ 392 ps_dpb_info[i].ps_pic_buf = ps_pic_buf; 393 ps_dpb_info[i].ps_prev_short = ps_dpb_mgr->ps_dpb_st_head; 394 ps_dpb_info[i].u1_buf_id = u1_buf_id; 395 ps_dpb_info[i].u1_used_as_ref = TRUE; 396 ps_dpb_info[i].u1_lt_idx = MAX_REF_BUFS + 1; 397 ps_dpb_info[i].i4_frame_num = u4_cur_pic_num; 398 ps_dpb_info[i].ps_pic_buf->i4_frame_num = u4_cur_pic_num; 399 400 /* update the head node of linked list to point to the cur Pic */ 401 ps_dpb_mgr->ps_dpb_st_head = ps_dpb_info + i; 402 403 // Increment Short term bufCount 404 ps_dpb_mgr->u1_num_st_ref_bufs++; 405 /* Identify the picture as a short term picture buffer */ 406 ps_pic_buf->u1_is_short = IS_SHORT_TERM; 407 408 if((u1_picture_type & 0x03) == FRM_PIC) 409 { 410 ps_dpb_info[i].u1_used_as_ref = IS_SHORT_TERM; 411 ps_dpb_info[i].s_top_field.u1_reference_info = IS_SHORT_TERM; 412 ps_dpb_info[i].s_bot_field.u1_reference_info = IS_SHORT_TERM; 413 } 414 415 if((u1_picture_type & 0x03) == TOP_FLD) 416 ps_dpb_info[i].s_top_field.u1_reference_info = IS_SHORT_TERM; 417 418 if((u1_picture_type & 0x03) == BOT_FLD) 419 ps_dpb_info[i].s_bot_field.u1_reference_info = IS_SHORT_TERM; 420 421 return OK; 422 } 423 424 /*! 425 ************************************************************************** 426 * \if Function name : ih264d_delete_st_node_or_make_lt \endif 427 * 428 * \brief 429 * Delete short term ref with a given picNum from the ST linked list or 430 * make it an LT node 431 * 432 * \return 433 * 0 - if successful; -1 - otherwise 434 * 435 * \note 436 * Common parts to MMCO==1 and MMCO==3 have been combined here 437 ************************************************************************** 438 */ 439 WORD32 ih264d_delete_st_node_or_make_lt(dpb_manager_t *ps_dpb_mgr, 440 WORD32 i4_pic_num, 441 UWORD32 u4_lt_idx, 442 UWORD8 u1_fld_pic_flag) 443 { 444 WORD32 i; 445 struct dpb_info_t *ps_next_dpb; 446 WORD32 i4_frame_num = i4_pic_num; 447 struct dpb_info_t *ps_unmark_node = NULL; 448 UWORD8 u1_del_node = 0, u1_del_st = 0; 449 UWORD8 u1_reference_type = UNUSED_FOR_REF; 450 WORD32 ret; 451 452 if(u1_fld_pic_flag) 453 { 454 i4_frame_num = i4_frame_num >> 1; 455 456 if(u4_lt_idx == (MAX_REF_BUFS + 1)) 457 u1_reference_type = UNUSED_FOR_REF; 458 else 459 u1_reference_type = IS_LONG_TERM; 460 } 461 462 //Find the node with matching picNum 463 ps_next_dpb = ps_dpb_mgr->ps_dpb_st_head; 464 if((WORD32)ps_next_dpb->i4_frame_num == i4_frame_num) 465 { 466 ps_unmark_node = ps_next_dpb; 467 } 468 else 469 { 470 for(i = 1; i < ps_dpb_mgr->u1_num_st_ref_bufs; i++) 471 { 472 if((WORD32)ps_next_dpb->ps_prev_short->i4_frame_num == i4_frame_num) 473 break; 474 ps_next_dpb = ps_next_dpb->ps_prev_short; 475 } 476 477 if(i == ps_dpb_mgr->u1_num_st_ref_bufs) 478 { 479 if(ps_dpb_mgr->u1_num_gaps) 480 { 481 ret = ih264d_delete_gap_frm_mmco(ps_dpb_mgr, i4_frame_num, &u1_del_st); 482 if(ret != OK) 483 return ret; 484 } 485 else 486 { 487 UWORD32 i4_error_code; 488 i4_error_code = ERROR_DBP_MANAGER_T; 489 490 return i4_error_code; 491 } 492 493 if(u1_del_st) 494 { 495 UWORD32 i4_error_code; 496 i4_error_code = ERROR_DBP_MANAGER_T; 497 return i4_error_code; 498 } 499 else 500 { 501 return 0; 502 } 503 } 504 else 505 ps_unmark_node = ps_next_dpb->ps_prev_short; 506 } 507 508 if(u1_fld_pic_flag) 509 { 510 /* Mark the corresponding field ( top or bot) as */ 511 /* UNUSED_FOR_REF or IS_LONG_TERM depending on */ 512 /* u1_reference_type. */ 513 if(ps_unmark_node->s_top_field.i4_pic_num == i4_pic_num) 514 { 515 ps_unmark_node->s_top_field.u1_reference_info = u1_reference_type; 516 ps_unmark_node->s_top_field.u1_long_term_frame_idx = u4_lt_idx; 517 { 518 UWORD8 *pu1_src = ps_unmark_node->ps_pic_buf->pu1_col_zero_flag; 519 WORD32 i4_size = ((ps_dpb_mgr->u2_pic_wd 520 * ps_dpb_mgr->u2_pic_ht) >> 5); 521 /* memset the colocated zero u4_flag buffer */ 522 memset(pu1_src, 0, i4_size); 523 } 524 } 525 526 else if(ps_unmark_node->s_bot_field.i4_pic_num == i4_pic_num) 527 { 528 529 ps_unmark_node->s_bot_field.u1_reference_info = u1_reference_type; 530 ps_unmark_node->s_bot_field.u1_long_term_frame_idx = u4_lt_idx; 531 { 532 UWORD8 *pu1_src = 533 ps_unmark_node->ps_pic_buf->pu1_col_zero_flag 534 + ((ps_dpb_mgr->u2_pic_wd 535 * ps_dpb_mgr->u2_pic_ht) 536 >> 5); 537 WORD32 i4_size = ((ps_dpb_mgr->u2_pic_wd 538 * ps_dpb_mgr->u2_pic_ht) >> 5); 539 /* memset the colocated zero u4_flag buffer */ 540 memset(pu1_src, 0, i4_size); 541 } 542 } 543 ps_unmark_node->u1_used_as_ref = 544 ps_unmark_node->s_top_field.u1_reference_info 545 | ps_unmark_node->s_bot_field.u1_reference_info; 546 } 547 else 548 { 549 ps_unmark_node->u1_used_as_ref = UNUSED_FOR_REF; 550 ps_unmark_node->s_top_field.u1_reference_info = UNUSED_FOR_REF; 551 ps_unmark_node->s_bot_field.u1_reference_info = UNUSED_FOR_REF; 552 553 { 554 UWORD8 *pu1_src = ps_unmark_node->ps_pic_buf->pu1_col_zero_flag; 555 556 WORD32 i4_size = ((ps_dpb_mgr->u2_pic_wd 557 * ps_dpb_mgr->u2_pic_ht) >> 4); 558 /* memset the colocated zero u4_flag buffer */ 559 memset(pu1_src, 0, i4_size); 560 } 561 } 562 563 if(!(ps_unmark_node->u1_used_as_ref & IS_SHORT_TERM)) 564 { 565 if(ps_unmark_node == ps_dpb_mgr->ps_dpb_st_head) 566 ps_dpb_mgr->ps_dpb_st_head = ps_next_dpb->ps_prev_short; 567 else 568 ps_next_dpb->ps_prev_short = ps_unmark_node->ps_prev_short; //update link 569 ps_dpb_mgr->u1_num_st_ref_bufs--; //decrement ST buf count 570 u1_del_node = 1; 571 } 572 573 if(u4_lt_idx == MAX_REF_BUFS + 1) 574 { 575 if(u1_del_node) 576 { 577 // Release the physical buffer 578 ih264d_free_ref_pic_mv_bufs(ps_dpb_mgr->pv_codec_handle, 579 ps_unmark_node->u1_buf_id); 580 ps_unmark_node->ps_prev_short = NULL; 581 } 582 } 583 else 584 { 585 WORD32 i4_status; 586 //If another node has the same LT index, delete that node 587 ret = ih264d_delete_lt_node(ps_dpb_mgr, u4_lt_idx, 588 u1_fld_pic_flag, ps_unmark_node, &i4_status); 589 if(ret != OK) 590 return ret; 591 // Now insert the short term node as a long term node 592 ret = ih264d_insert_lt_node(ps_dpb_mgr, ps_unmark_node, u4_lt_idx, 593 u1_fld_pic_flag); 594 if(ret != OK) 595 return ret; 596 } 597 return OK; 598 } 599 /*! 600 ************************************************************************** 601 * \if Function name : ih264d_reset_ref_bufs \endif 602 * 603 * \brief 604 * Called if MMCO==5/7 or on the first slice of an IDR picture 605 * 606 * \return 607 * none 608 ************************************************************************** 609 */ 610 void ih264d_reset_ref_bufs(dpb_manager_t *ps_dpb_mgr) 611 { 612 WORD32 i; 613 struct dpb_info_t *ps_dpb_info = ps_dpb_mgr->as_dpb_info; 614 615 for(i = 0; i < MAX_REF_BUFS; i++) 616 { 617 if(ps_dpb_info[i].u1_used_as_ref) 618 { 619 ps_dpb_info[i].u1_used_as_ref = UNUSED_FOR_REF; 620 ps_dpb_info[i].u1_lt_idx = MAX_REF_BUFS + 1; 621 ps_dpb_info[i].ps_prev_short = NULL; 622 ps_dpb_info[i].ps_prev_long = NULL; 623 ps_dpb_info[i].ps_pic_buf = NULL; 624 ps_dpb_info[i].s_top_field.u1_reference_info = UNUSED_FOR_REF; 625 ps_dpb_info[i].s_bot_field.u1_reference_info = UNUSED_FOR_REF; 626 ps_dpb_info[i].s_top_field.u1_long_term_frame_idx = MAX_REF_BUFS + 1; 627 ps_dpb_info[i].s_bot_field.u1_long_term_frame_idx = MAX_REF_BUFS + 1; 628 629 //Release physical buffer 630 ih264d_free_ref_pic_mv_bufs(ps_dpb_mgr->pv_codec_handle, 631 ps_dpb_info[i].u1_buf_id); 632 } 633 } 634 ps_dpb_mgr->u1_num_st_ref_bufs = ps_dpb_mgr->u1_num_lt_ref_bufs = 0; 635 ps_dpb_mgr->ps_dpb_st_head = NULL; 636 ps_dpb_mgr->ps_dpb_ht_head = NULL; 637 638 /* release all gaps */ 639 ps_dpb_mgr->u1_num_gaps = 0; 640 for(i = 0; i < MAX_FRAMES; i++) 641 { 642 ps_dpb_mgr->ai4_gaps_start_frm_num[i] = INVALID_FRAME_NUM; 643 ps_dpb_mgr->ai4_gaps_end_frm_num[i] = 0; 644 ps_dpb_mgr->ai1_gaps_per_seq[i] = 0; 645 } 646 } 647 648 /*! 649 ************************************************************************** 650 * \if Function name : Name \endif 651 * 652 * \brief 653 * create the default index list after an MMCO 654 * 655 * \return 656 * 0 - if no_error; -1 - error 657 * 658 ************************************************************************** 659 */ 660 WORD32 ih264d_update_default_index_list(dpb_manager_t *ps_dpb_mgr) 661 { 662 WORD32 i; 663 struct dpb_info_t *ps_next_dpb = ps_dpb_mgr->ps_dpb_st_head; 664 665 for(i = 0; i < ps_dpb_mgr->u1_num_st_ref_bufs; i++) 666 { 667 ps_dpb_mgr->ps_def_dpb[i] = ps_next_dpb->ps_pic_buf; 668 ps_next_dpb = ps_next_dpb->ps_prev_short; 669 } 670 671 ps_next_dpb = ps_dpb_mgr->ps_dpb_ht_head; 672 for(;i< ps_dpb_mgr->u1_num_st_ref_bufs + ps_dpb_mgr->u1_num_lt_ref_bufs; i++) 673 { 674 ps_dpb_mgr->ps_def_dpb[i] = ps_next_dpb->ps_pic_buf; 675 ps_next_dpb = ps_next_dpb->ps_prev_long; 676 } 677 return 0; 678 } 679 680 /*! 681 ************************************************************************** 682 * \if Function name : ref_idx_reordering \endif 683 * 684 * \brief 685 * Parse the bitstream and reorder indices for the current slice 686 * 687 * \return 688 * 0 - if no_error; -1 - error 689 * 690 * \note 691 * Called only if ref_idx_reordering_flag_l0 is decoded as 1 692 * Remove error checking for unmatching picNum or LTIndex later (if not needed) 693 * \para 694 * This section implements 7.3.3.1 and 8.2.6.4 695 * Uses the default index list as the starting point and 696 * remaps the picNums sent to the next higher index in the 697 * modified list. The unmodified ones are copied from the 698 * default to modified list retaining their order in the default list. 699 * 700 ************************************************************************** 701 */ 702 WORD32 ih264d_ref_idx_reordering(dec_struct_t *ps_dec, UWORD8 uc_lx) 703 { 704 dpb_manager_t *ps_dpb_mgr = ps_dec->ps_dpb_mgr; 705 UWORD16 u4_cur_pic_num = ps_dec->ps_cur_slice->u2_frame_num; 706 /*< Maximum Picture Number Minus 1 */ 707 UWORD16 ui_max_frame_num = 708 ps_dec->ps_cur_sps->u2_u4_max_pic_num_minus1 + 1; 709 710 WORD32 i; 711 UWORD32 ui_remapIdc, ui_nextUev; 712 WORD16 u2_pred_frame_num = u4_cur_pic_num; 713 WORD32 i_temp; 714 UWORD16 u2_def_mod_flag = 0; /* Flag to keep track of which indices have been remapped */ 715 UWORD8 modCount = 0; 716 UWORD32 *pu4_bitstrm_buf = ps_dec->ps_bitstrm->pu4_buffer; 717 UWORD32 *pu4_bitstrm_ofst = &ps_dec->ps_bitstrm->u4_ofst; 718 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice; 719 UWORD8 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag; 720 721 if(u1_field_pic_flag) 722 { 723 u4_cur_pic_num = u4_cur_pic_num * 2 + 1; 724 ui_max_frame_num = ui_max_frame_num * 2; 725 } 726 727 u2_pred_frame_num = u4_cur_pic_num; 728 729 ui_remapIdc = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 730 731 while(ui_remapIdc != 3) 732 { 733 ui_nextUev = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 734 if(ui_remapIdc != 2) 735 { 736 ui_nextUev = ui_nextUev + 1; 737 if(ui_remapIdc == 0) 738 { 739 // diffPicNum is -ve 740 i_temp = u2_pred_frame_num - ui_nextUev; 741 if(i_temp < 0) 742 i_temp += ui_max_frame_num; 743 } 744 else 745 { 746 // diffPicNum is +ve 747 i_temp = u2_pred_frame_num + ui_nextUev; 748 if(i_temp >= ui_max_frame_num) 749 i_temp -= ui_max_frame_num; 750 } 751 /* Find the dpb with the matching picNum (picNum==frameNum for framePic) */ 752 753 if(i_temp > u4_cur_pic_num) 754 i_temp = i_temp - ui_max_frame_num; 755 756 for(i = 0; i < (ps_cur_slice->u1_initial_list_size[uc_lx]); i++) 757 { 758 if(ps_dpb_mgr->ps_init_dpb[uc_lx][i]->i4_pic_num == i_temp) 759 break; 760 } 761 if(i == (ps_cur_slice->u1_initial_list_size[uc_lx])) 762 { 763 UWORD32 i4_error_code; 764 i4_error_code = ERROR_DBP_MANAGER_T; 765 return i4_error_code; 766 } 767 768 u2_def_mod_flag |= (1 << i); 769 ps_dpb_mgr->ps_mod_dpb[uc_lx][modCount++] = 770 ps_dpb_mgr->ps_init_dpb[uc_lx][i]; 771 u2_pred_frame_num = i_temp; //update predictor to be the picNum just obtained 772 } 773 else //2 774 { 775 UWORD8 u1_lt_idx = (UWORD8)ui_nextUev; 776 777 for(i = 0; i < (ps_cur_slice->u1_initial_list_size[uc_lx]); i++) 778 { 779 if(!ps_dpb_mgr->ps_init_dpb[uc_lx][i]->u1_is_short) 780 { 781 if(ps_dpb_mgr->ps_init_dpb[uc_lx][i]->u1_long_term_pic_num 782 == u1_lt_idx) 783 break; 784 } 785 } 786 if(i == (ps_cur_slice->u1_initial_list_size[uc_lx])) 787 { 788 UWORD32 i4_error_code; 789 i4_error_code = ERROR_DBP_MANAGER_T; 790 return i4_error_code; 791 } 792 793 u2_def_mod_flag |= (1 << i); 794 ps_dpb_mgr->ps_mod_dpb[uc_lx][modCount++] = 795 ps_dpb_mgr->ps_init_dpb[uc_lx][i]; 796 } 797 798 ui_remapIdc = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 799 /* Get the remapping_idc - 0/1/2/3 */ 800 } 801 802 //Handle the ref indices that were not remapped 803 for(i = 0; i < (ps_cur_slice->u1_num_ref_idx_lx_active[uc_lx]); i++) 804 { 805 if(!(u2_def_mod_flag & (1 << i))) 806 ps_dpb_mgr->ps_mod_dpb[uc_lx][modCount++] = 807 ps_dpb_mgr->ps_init_dpb[uc_lx][i]; 808 } 809 return OK; 810 } 811 /*! 812 ************************************************************************** 813 * \if Function name : ih264d_read_mmco_commands \endif 814 * 815 * \brief 816 * Parses MMCO commands and stores them in a structure for later use. 817 * 818 * \return 819 * 0 - No error; -1 - Error 820 * 821 * \note 822 * This function stores MMCO commands in structure only for the first time. 823 * In case of MMCO commands being issued for same Picture Number, they are 824 * just parsed and not stored them in the structure. 825 * 826 ************************************************************************** 827 */ 828 WORD32 ih264d_read_mmco_commands(struct _DecStruct * ps_dec) 829 { 830 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm; 831 dpb_commands_t *ps_dpb_cmds = ps_dec->ps_dpb_cmds; 832 dec_slice_params_t * ps_slice = ps_dec->ps_cur_slice; 833 WORD32 j; 834 UWORD8 u1_buf_mode; 835 struct MMCParams *ps_mmc_params; 836 UWORD32 *pu4_bitstrm_buf = ps_dec->ps_bitstrm->pu4_buffer; 837 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst; 838 UWORD32 u4_bit_ofst = ps_dec->ps_bitstrm->u4_ofst; 839 840 ps_slice->u1_mmco_equalto5 = 0; 841 { 842 if(ps_dec->u1_nal_unit_type == IDR_SLICE_NAL) 843 { 844 ps_slice->u1_no_output_of_prior_pics_flag = 845 ih264d_get_bit_h264(ps_bitstrm); 846 COPYTHECONTEXT("SH: no_output_of_prior_pics_flag", 847 ps_slice->u1_no_output_of_prior_pics_flag); 848 ps_slice->u1_long_term_reference_flag = ih264d_get_bit_h264( 849 ps_bitstrm); 850 COPYTHECONTEXT("SH: long_term_reference_flag", 851 ps_slice->u1_long_term_reference_flag); 852 ps_dpb_cmds->u1_idr_pic = 1; 853 ps_dpb_cmds->u1_no_output_of_prior_pics_flag = 854 ps_slice->u1_no_output_of_prior_pics_flag; 855 ps_dpb_cmds->u1_long_term_reference_flag = 856 ps_slice->u1_long_term_reference_flag; 857 } 858 else 859 { 860 u1_buf_mode = ih264d_get_bit_h264(ps_bitstrm); //0 - sliding window; 1 - arbitrary 861 COPYTHECONTEXT("SH: adaptive_ref_pic_buffering_flag", u1_buf_mode); 862 ps_dpb_cmds->u1_buf_mode = u1_buf_mode; 863 j = 0; 864 865 if(u1_buf_mode == 1) 866 { 867 UWORD32 u4_mmco; 868 UWORD32 u4_diff_pic_num; 869 UWORD32 u4_lt_idx, u4_max_lt_idx; 870 871 u4_mmco = ih264d_uev(pu4_bitstrm_ofst, 872 pu4_bitstrm_buf); 873 while(u4_mmco != END_OF_MMCO) 874 { 875 ps_mmc_params = &ps_dpb_cmds->as_mmc_params[j]; 876 ps_mmc_params->u4_mmco = u4_mmco; 877 switch(u4_mmco) 878 { 879 case MARK_ST_PICNUM_AS_NONREF: 880 u4_diff_pic_num = ih264d_uev(pu4_bitstrm_ofst, 881 pu4_bitstrm_buf); 882 //Get absDiffPicnumMinus1 883 ps_mmc_params->u4_diff_pic_num = u4_diff_pic_num; 884 break; 885 886 case MARK_LT_INDEX_AS_NONREF: 887 u4_lt_idx = ih264d_uev(pu4_bitstrm_ofst, 888 pu4_bitstrm_buf); 889 ps_mmc_params->u4_lt_idx = u4_lt_idx; 890 break; 891 892 case MARK_ST_PICNUM_AS_LT_INDEX: 893 u4_diff_pic_num = ih264d_uev(pu4_bitstrm_ofst, 894 pu4_bitstrm_buf); 895 ps_mmc_params->u4_diff_pic_num = u4_diff_pic_num; 896 u4_lt_idx = ih264d_uev(pu4_bitstrm_ofst, 897 pu4_bitstrm_buf); 898 ps_mmc_params->u4_lt_idx = u4_lt_idx; 899 break; 900 901 case SET_MAX_LT_INDEX: 902 { 903 u4_max_lt_idx = ih264d_uev(pu4_bitstrm_ofst, 904 pu4_bitstrm_buf); 905 ps_mmc_params->u4_max_lt_idx_plus1 = u4_max_lt_idx; 906 break; 907 } 908 case RESET_REF_PICTURES: 909 { 910 ps_slice->u1_mmco_equalto5 = 1; 911 break; 912 } 913 914 case SET_LT_INDEX: 915 u4_lt_idx = ih264d_uev(pu4_bitstrm_ofst, 916 pu4_bitstrm_buf); 917 ps_mmc_params->u4_lt_idx = u4_lt_idx; 918 break; 919 920 default: 921 break; 922 } 923 u4_mmco = ih264d_uev(pu4_bitstrm_ofst, 924 pu4_bitstrm_buf); 925 926 j++; 927 } 928 ps_dpb_cmds->u1_num_of_commands = j; 929 930 } 931 } 932 ps_dpb_cmds->u1_dpb_commands_read = 1; 933 ps_dpb_cmds->u1_dpb_commands_read_slc = 1; 934 935 } 936 u4_bit_ofst = ps_dec->ps_bitstrm->u4_ofst - u4_bit_ofst; 937 return u4_bit_ofst; 938 } 939 940 /*! 941 ************************************************************************** 942 * \if Function name : ih264d_do_mmco_buffer \endif 943 * 944 * \brief 945 * Perform decoded picture buffer memory management control operations 946 * 947 * \return 948 * 0 - No error; -1 - Error 949 * 950 * \note 951 * Bitstream is also parsed here to get the MMCOs 952 * 953 ************************************************************************** 954 */ 955 WORD32 ih264d_do_mmco_buffer(dpb_commands_t *ps_dpb_cmds, 956 dpb_manager_t *ps_dpb_mgr, 957 UWORD8 u1_numRef_frames_for_seq, /*!< num_ref_frames from active SeqParSet*/ 958 UWORD32 u4_cur_pic_num, 959 UWORD32 u2_u4_max_pic_num_minus1, 960 UWORD8 u1_nal_unit_type, 961 struct pic_buffer_t *ps_pic_buf, 962 UWORD8 u1_buf_id, 963 UWORD8 u1_fld_pic_flag, 964 UWORD8 u1_curr_pic_in_err) 965 { 966 WORD32 i; 967 UWORD8 u1_buf_mode, u1_marked_lt; 968 struct dpb_info_t *ps_next_dpb; 969 UWORD8 u1_num_gaps; 970 UWORD8 u1_del_node = 1; 971 UWORD8 u1_insert_st_pic = 1; 972 WORD32 ret; 973 UNUSED(u1_nal_unit_type); 974 UNUSED(u2_u4_max_pic_num_minus1); 975 u1_buf_mode = ps_dpb_cmds->u1_buf_mode; //0 - sliding window; 1 - Adaptive 976 u1_marked_lt = 0; 977 u1_num_gaps = ps_dpb_mgr->u1_num_gaps; 978 979 if(!u1_buf_mode) 980 { 981 //Sliding window - implements 8.2.5.3 982 if((ps_dpb_mgr->u1_num_st_ref_bufs 983 + ps_dpb_mgr->u1_num_lt_ref_bufs + u1_num_gaps) 984 == u1_numRef_frames_for_seq) 985 { 986 UWORD8 u1_new_node_flag = 1; 987 if((0 == ps_dpb_mgr->u1_num_st_ref_bufs) && (0 == u1_num_gaps)) 988 { 989 UWORD32 i4_error_code; 990 i4_error_code = ERROR_DBP_MANAGER_T; 991 return i4_error_code; 992 } 993 994 // Chase the links to reach the last but one picNum, if available 995 ps_next_dpb = ps_dpb_mgr->ps_dpb_st_head; 996 997 if(ps_dpb_mgr->u1_num_st_ref_bufs > 1) 998 { 999 if(ps_next_dpb->i4_frame_num == (WORD32)u4_cur_pic_num) 1000 { 1001 /* Incase of filed pictures top_field has been allocated */ 1002 /* picture buffer and complementary bottom field pair comes */ 1003 /* then the sliding window mechanism should not allocate a */ 1004 /* new node */ 1005 u1_new_node_flag = 0; 1006 } 1007 1008 for(i = 1; i < (ps_dpb_mgr->u1_num_st_ref_bufs - 1); i++) 1009 { 1010 if(ps_next_dpb == NULL) 1011 { 1012 UWORD32 i4_error_code; 1013 i4_error_code = ERROR_DBP_MANAGER_T; 1014 return i4_error_code; 1015 } 1016 if(ps_next_dpb->i4_frame_num == (WORD32)u4_cur_pic_num) 1017 { 1018 /* Incase of field pictures top_field has been allocated */ 1019 /* picture buffer and complementary bottom field pair comes */ 1020 /* then the sliding window mechanism should not allocate a */ 1021 /* new node */ 1022 u1_new_node_flag = 0; 1023 } 1024 ps_next_dpb = ps_next_dpb->ps_prev_short; 1025 } 1026 1027 if(ps_next_dpb->ps_prev_short->ps_prev_short != NULL) 1028 { 1029 UWORD32 i4_error_code; 1030 i4_error_code = ERROR_DBP_MANAGER_T; 1031 return i4_error_code; 1032 } 1033 1034 if(u1_new_node_flag) 1035 { 1036 if(u1_num_gaps) 1037 { 1038 ret = ih264d_delete_gap_frm_sliding(ps_dpb_mgr, 1039 ps_next_dpb->ps_prev_short->i4_frame_num, 1040 &u1_del_node); 1041 if(ret != OK) 1042 return ret; 1043 } 1044 1045 if(u1_del_node) 1046 { 1047 ps_dpb_mgr->u1_num_st_ref_bufs--; 1048 ps_next_dpb->ps_prev_short->u1_used_as_ref = 1049 UNUSED_FOR_REF; 1050 ps_next_dpb->ps_prev_short->s_top_field.u1_reference_info = 1051 UNUSED_FOR_REF; 1052 ps_next_dpb->ps_prev_short->s_bot_field.u1_reference_info = 1053 UNUSED_FOR_REF; 1054 ih264d_free_ref_pic_mv_bufs(ps_dpb_mgr->pv_codec_handle, 1055 ps_next_dpb->ps_prev_short->u1_buf_id); 1056 ps_next_dpb->ps_prev_short->ps_pic_buf = NULL; 1057 ps_next_dpb->ps_prev_short = NULL; 1058 } 1059 } 1060 } 1061 else 1062 { 1063 if(ps_dpb_mgr->u1_num_st_ref_bufs) 1064 { 1065 ret = ih264d_delete_gap_frm_sliding(ps_dpb_mgr, 1066 ps_next_dpb->i4_frame_num, 1067 &u1_del_node); 1068 if(ret != OK) 1069 return ret; 1070 if((ps_next_dpb->i4_frame_num != (WORD32)u4_cur_pic_num) 1071 && u1_del_node) 1072 { 1073 ps_dpb_mgr->u1_num_st_ref_bufs--; 1074 ps_next_dpb->u1_used_as_ref = FALSE; 1075 ps_next_dpb->s_top_field.u1_reference_info = 1076 UNUSED_FOR_REF; 1077 ps_next_dpb->s_bot_field.u1_reference_info = 1078 UNUSED_FOR_REF; 1079 ih264d_free_ref_pic_mv_bufs(ps_dpb_mgr->pv_codec_handle, 1080 ps_next_dpb->u1_buf_id); 1081 ps_next_dpb->ps_pic_buf = NULL; 1082 ps_next_dpb->ps_prev_short = NULL; 1083 ps_dpb_mgr->ps_dpb_st_head = NULL; 1084 ps_next_dpb = NULL; 1085 } 1086 else if(ps_next_dpb->i4_frame_num == (WORD32)u4_cur_pic_num) 1087 { 1088 if(u1_curr_pic_in_err) 1089 { 1090 u1_insert_st_pic = 0; 1091 } 1092 else if(ps_dpb_mgr->u1_num_st_ref_bufs > 0) 1093 { 1094 ps_dpb_mgr->u1_num_st_ref_bufs--; 1095 ps_next_dpb->u1_used_as_ref = FALSE; 1096 ps_next_dpb->s_top_field.u1_reference_info = 1097 UNUSED_FOR_REF; 1098 ps_next_dpb->s_bot_field.u1_reference_info = 1099 UNUSED_FOR_REF; 1100 ih264d_free_ref_pic_mv_bufs(ps_dpb_mgr->pv_codec_handle, 1101 ps_next_dpb->u1_buf_id); 1102 ps_next_dpb->ps_pic_buf = NULL; 1103 ps_next_dpb = NULL; 1104 } 1105 } 1106 } 1107 else 1108 { 1109 ret = ih264d_delete_gap_frm_sliding(ps_dpb_mgr, 1110 INVALID_FRAME_NUM, 1111 &u1_del_node); 1112 if(ret != OK) 1113 return ret; 1114 if(u1_del_node) 1115 { 1116 UWORD32 i4_error_code; 1117 i4_error_code = ERROR_DBP_MANAGER_T; 1118 return i4_error_code; 1119 } 1120 } 1121 } 1122 } 1123 } 1124 else 1125 { 1126 //Adaptive memory control - implements 8.2.5.4 1127 UWORD32 u4_mmco; 1128 UWORD32 u4_diff_pic_num; 1129 WORD32 i4_pic_num; 1130 UWORD32 u4_lt_idx; 1131 WORD32 j; 1132 struct MMCParams *ps_mmc_params; 1133 1134 for(j = 0; j < ps_dpb_cmds->u1_num_of_commands; j++) 1135 { 1136 ps_mmc_params = &ps_dpb_cmds->as_mmc_params[j]; 1137 u4_mmco = ps_mmc_params->u4_mmco; //Get MMCO 1138 1139 switch(u4_mmco) 1140 { 1141 case MARK_ST_PICNUM_AS_NONREF: 1142 { 1143 1144 { 1145 UWORD32 i4_cur_pic_num = u4_cur_pic_num; 1146 u4_diff_pic_num = ps_mmc_params->u4_diff_pic_num; //Get absDiffPicnumMinus1 1147 if(u1_fld_pic_flag) 1148 i4_cur_pic_num = i4_cur_pic_num * 2 + 1; 1149 i4_pic_num = i4_cur_pic_num - (u4_diff_pic_num + 1); 1150 } 1151 1152 if(ps_dpb_mgr->u1_num_st_ref_bufs > 0) 1153 { 1154 ret = ih264d_delete_st_node_or_make_lt(ps_dpb_mgr, 1155 i4_pic_num, 1156 MAX_REF_BUFS + 1, 1157 u1_fld_pic_flag); 1158 if(ret != OK) 1159 return ret; 1160 } 1161 else 1162 { 1163 UWORD8 u1_dummy; 1164 ret = ih264d_delete_gap_frm_mmco(ps_dpb_mgr, i4_pic_num, &u1_dummy); 1165 if(ret != OK) 1166 return ret; 1167 } 1168 break; 1169 } 1170 case MARK_LT_INDEX_AS_NONREF: 1171 { 1172 WORD32 i4_status; 1173 u4_lt_idx = ps_mmc_params->u4_lt_idx; //Get long term index 1174 ret = ih264d_delete_lt_node(ps_dpb_mgr, 1175 u4_lt_idx, 1176 u1_fld_pic_flag, 1177 0, &i4_status); 1178 if(ret != OK) 1179 return ret; 1180 if(i4_status) 1181 { 1182 UWORD32 i4_error_code; 1183 i4_error_code = ERROR_DBP_MANAGER_T; 1184 return i4_error_code; 1185 } 1186 break; 1187 } 1188 1189 case MARK_ST_PICNUM_AS_LT_INDEX: 1190 { 1191 { 1192 UWORD32 i4_cur_pic_num = u4_cur_pic_num; 1193 u4_diff_pic_num = ps_mmc_params->u4_diff_pic_num; //Get absDiffPicnumMinus1 1194 if(u1_fld_pic_flag) 1195 i4_cur_pic_num = i4_cur_pic_num * 2 + 1; 1196 1197 i4_pic_num = i4_cur_pic_num - (u4_diff_pic_num + 1); 1198 } 1199 1200 u4_lt_idx = ps_mmc_params->u4_lt_idx; //Get long term index 1201 if(ps_dpb_mgr->u1_num_st_ref_bufs > 0) 1202 { 1203 ret = ih264d_delete_st_node_or_make_lt(ps_dpb_mgr, 1204 i4_pic_num, u4_lt_idx, 1205 u1_fld_pic_flag); 1206 if(ret != OK) 1207 return ret; 1208 } 1209 break; 1210 } 1211 case SET_MAX_LT_INDEX: 1212 { 1213 UWORD8 uc_numLT = ps_dpb_mgr->u1_num_lt_ref_bufs; 1214 u4_lt_idx = ps_mmc_params->u4_max_lt_idx_plus1; //Get Max_long_term_index_plus1 1215 if(u4_lt_idx < ps_dpb_mgr->u1_max_lt_pic_idx_plus1 1216 && uc_numLT > 0) 1217 { 1218 struct dpb_info_t *ps_nxtDPB; 1219 //Set all LT buffers with index >= u4_lt_idx to nonreference 1220 ps_nxtDPB = ps_dpb_mgr->ps_dpb_ht_head; 1221 ps_next_dpb = ps_nxtDPB->ps_prev_long; 1222 if(ps_nxtDPB->u1_lt_idx >= u4_lt_idx) 1223 { 1224 i = 0; 1225 ps_dpb_mgr->ps_dpb_ht_head = NULL; 1226 } 1227 else 1228 { 1229 for(i = 1; i < uc_numLT; i++) 1230 { 1231 if(ps_next_dpb->u1_lt_idx >= u4_lt_idx) 1232 break; 1233 ps_nxtDPB = ps_next_dpb; 1234 ps_next_dpb = ps_next_dpb->ps_prev_long; 1235 } 1236 ps_nxtDPB->ps_prev_long = NULL; //Terminate the link of the closest LTIndex that is <=Max 1237 } 1238 ps_dpb_mgr->u1_num_lt_ref_bufs = i; 1239 if(i == 0) 1240 ps_next_dpb = ps_nxtDPB; 1241 1242 for(; i < uc_numLT; i++) 1243 { 1244 ps_nxtDPB = ps_next_dpb; 1245 ps_nxtDPB->u1_lt_idx = MAX_REF_BUFS + 1; 1246 ps_nxtDPB->u1_used_as_ref = UNUSED_FOR_REF; 1247 ps_nxtDPB->s_top_field.u1_reference_info = 1248 UNUSED_FOR_REF; 1249 ps_nxtDPB->s_bot_field.u1_reference_info = 1250 UNUSED_FOR_REF; 1251 1252 ps_nxtDPB->ps_pic_buf = NULL; 1253 //Release buffer 1254 ih264d_free_ref_pic_mv_bufs(ps_dpb_mgr->pv_codec_handle, 1255 ps_nxtDPB->u1_buf_id); 1256 ps_next_dpb = ps_nxtDPB->ps_prev_long; 1257 ps_nxtDPB->ps_prev_long = NULL; 1258 } 1259 } 1260 ps_dpb_mgr->u1_max_lt_pic_idx_plus1 = u4_lt_idx; 1261 1262 break; 1263 } 1264 case SET_LT_INDEX: 1265 { 1266 u4_lt_idx = ps_mmc_params->u4_lt_idx; //Get long term index 1267 ret = ih264d_insert_st_node(ps_dpb_mgr, ps_pic_buf, u1_buf_id, 1268 u4_cur_pic_num); 1269 if(ret != OK) 1270 return ret; 1271 ret = ih264d_delete_st_node_or_make_lt(ps_dpb_mgr, 1272 u4_cur_pic_num, u4_lt_idx, 1273 u1_fld_pic_flag); 1274 if(ret != OK) 1275 return ret; 1276 u1_marked_lt = 1; 1277 break; 1278 } 1279 1280 default: 1281 break; 1282 } 1283 if(u4_mmco == RESET_REF_PICTURES || u4_mmco == RESET_ALL_PICTURES) 1284 { 1285 ih264d_reset_ref_bufs(ps_dpb_mgr); 1286 u4_cur_pic_num = 0; 1287 } 1288 } 1289 } 1290 if(!u1_marked_lt && u1_insert_st_pic) 1291 { 1292 ret = ih264d_insert_st_node(ps_dpb_mgr, ps_pic_buf, u1_buf_id, 1293 u4_cur_pic_num); 1294 if(ret != OK) 1295 return ret; 1296 } 1297 return OK; 1298 } 1299 1300 /*****************************************************************************/ 1301 /* */ 1302 /* Function Name : ih264d_release_pics_in_dpb */ 1303 /* */ 1304 /* Description : This function deletes all pictures from DPB */ 1305 /* */ 1306 /* Inputs : h_pic_buf_api: pointer to picture buffer API */ 1307 /* u1_disp_bufs: number pictures ready for display */ 1308 /* */ 1309 /* Globals : None */ 1310 /* Outputs : None */ 1311 /* Returns : None */ 1312 /* */ 1313 /* Issues : None */ 1314 /* */ 1315 /* Revision History: */ 1316 /* */ 1317 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1318 /* 22 06 2005 NS Draft */ 1319 /* */ 1320 /*****************************************************************************/ 1321 void ih264d_release_pics_in_dpb(void *pv_dec, 1322 UWORD8 u1_disp_bufs) 1323 { 1324 WORD8 i; 1325 dec_struct_t *ps_dec = (dec_struct_t *)pv_dec; 1326 1327 for(i = 0; i < u1_disp_bufs; i++) 1328 { 1329 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 1330 i, 1331 BUF_MGR_REF); 1332 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr, 1333 ps_dec->au1_pic_buf_id_mv_buf_id_map[i], 1334 BUF_MGR_REF); 1335 } 1336 } 1337 1338 /*****************************************************************************/ 1339 /* */ 1340 /* Function Name : ih264d_delete_gap_frm_sliding */ 1341 /* */ 1342 /* Description : This function deletes a picture from the list of gaps, */ 1343 /* if the frame number of gap frame is lesser than the one */ 1344 /* to be deleted by sliding window */ 1345 /* Inputs : ps_dpb_mgr: pointer to dpb manager */ 1346 /* i4_frame_num: frame number of picture that's going to */ 1347 /* be deleted by sliding window */ 1348 /* pu1_del_node: holds 0 if a gap is deleted else 1 */ 1349 /* Globals : None */ 1350 /* Processing : Function searches for frame number lesser than */ 1351 /* i4_frame_num in the gaps list */ 1352 /* Outputs : None */ 1353 /* Returns : None */ 1354 /* */ 1355 /* Issues : None */ 1356 /* */ 1357 /* Revision History: */ 1358 /* */ 1359 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1360 /* 22 06 2005 NS Draft */ 1361 /* */ 1362 /*****************************************************************************/ 1363 WORD32 ih264d_delete_gap_frm_sliding(dpb_manager_t *ps_dpb_mgr, 1364 WORD32 i4_frame_num, 1365 UWORD8 *pu1_del_node) 1366 { 1367 WORD8 i1_gap_idx, i, j, j_min; 1368 WORD32 *pi4_gaps_start_frm_num, *pi4_gaps_end_frm_num, i4_gap_frame_num; 1369 WORD32 i4_start_frm_num, i4_end_frm_num; 1370 WORD32 i4_max_frm_num; 1371 WORD32 i4_frm_num, i4_gap_frm_num_min; 1372 1373 /* find the least frame num from gaps and current DPB node */ 1374 /* Delete the least one */ 1375 *pu1_del_node = 1; 1376 if(0 == ps_dpb_mgr->u1_num_gaps) 1377 return OK; 1378 pi4_gaps_start_frm_num = ps_dpb_mgr->ai4_gaps_start_frm_num; 1379 pi4_gaps_end_frm_num = ps_dpb_mgr->ai4_gaps_end_frm_num; 1380 i4_gap_frame_num = INVALID_FRAME_NUM; 1381 i4_max_frm_num = ps_dpb_mgr->i4_max_frm_num; 1382 1383 i1_gap_idx = -1; 1384 if(INVALID_FRAME_NUM != i4_frame_num) 1385 { 1386 i4_gap_frame_num = i4_frame_num; 1387 for(i = 0; i < MAX_FRAMES; i++) 1388 { 1389 i4_start_frm_num = pi4_gaps_start_frm_num[i]; 1390 if(INVALID_FRAME_NUM != i4_start_frm_num) 1391 { 1392 i4_end_frm_num = pi4_gaps_end_frm_num[i]; 1393 if(i4_end_frm_num < i4_max_frm_num) 1394 { 1395 if(i4_start_frm_num <= i4_gap_frame_num) 1396 { 1397 i4_gap_frame_num = i4_start_frm_num; 1398 i1_gap_idx = i; 1399 } 1400 } 1401 else 1402 { 1403 if(((i4_start_frm_num <= i4_gap_frame_num) 1404 && (i4_gap_frame_num <= i4_max_frm_num)) 1405 || ((i4_start_frm_num >= i4_gap_frame_num) 1406 && ((i4_gap_frame_num 1407 + i4_max_frm_num) 1408 >= i4_end_frm_num))) 1409 { 1410 i4_gap_frame_num = i4_start_frm_num; 1411 i1_gap_idx = i; 1412 } 1413 } 1414 } 1415 } 1416 } 1417 else 1418 { 1419 /* no valid short term buffers, delete one gap from the least start */ 1420 /* of gap sequence */ 1421 i4_gap_frame_num = pi4_gaps_start_frm_num[0]; 1422 i1_gap_idx = 0; 1423 for(i = 1; i < MAX_FRAMES; i++) 1424 { 1425 if(INVALID_FRAME_NUM != pi4_gaps_start_frm_num[i]) 1426 { 1427 if(pi4_gaps_start_frm_num[i] < i4_gap_frame_num) 1428 { 1429 i4_gap_frame_num = pi4_gaps_start_frm_num[i]; 1430 i1_gap_idx = i; 1431 } 1432 } 1433 } 1434 if(INVALID_FRAME_NUM == i4_gap_frame_num) 1435 { 1436 UWORD32 i4_error_code; 1437 i4_error_code = ERROR_DBP_MANAGER_T; 1438 return i4_error_code; 1439 } 1440 } 1441 1442 if(-1 != i1_gap_idx) 1443 { 1444 /* find least frame_num in the poc_map, which is in this range */ 1445 i4_start_frm_num = pi4_gaps_start_frm_num[i1_gap_idx]; 1446 if(i4_start_frm_num < 0) 1447 i4_start_frm_num += i4_max_frm_num; 1448 i4_end_frm_num = pi4_gaps_end_frm_num[i1_gap_idx]; 1449 if(i4_end_frm_num < 0) 1450 i4_end_frm_num += i4_max_frm_num; 1451 1452 i4_gap_frm_num_min = 0xfffffff; 1453 j_min = MAX_FRAMES; 1454 for(j = 0; j < MAX_FRAMES; j++) 1455 { 1456 i4_frm_num = ps_dpb_mgr->ai4_poc_buf_id_map[j][2]; 1457 if((i4_start_frm_num <= i4_frm_num) 1458 && (i4_end_frm_num >= i4_frm_num)) 1459 { 1460 if(i4_frm_num < i4_gap_frm_num_min) 1461 { 1462 j_min = j; 1463 i4_gap_frm_num_min = i4_frm_num; 1464 } 1465 } 1466 } 1467 1468 if(j_min != MAX_FRAMES) 1469 { 1470 1471 ps_dpb_mgr->ai4_poc_buf_id_map[j_min][0] = -1; 1472 ps_dpb_mgr->ai4_poc_buf_id_map[j_min][1] = 0x7fffffff; 1473 ps_dpb_mgr->ai4_poc_buf_id_map[j_min][2] = GAP_FRAME_NUM; 1474 ps_dpb_mgr->i1_gaps_deleted++; 1475 1476 ps_dpb_mgr->ai1_gaps_per_seq[i1_gap_idx]--; 1477 ps_dpb_mgr->u1_num_gaps--; 1478 *pu1_del_node = 0; 1479 if(0 == ps_dpb_mgr->ai1_gaps_per_seq[i1_gap_idx]) 1480 { 1481 ps_dpb_mgr->ai4_gaps_start_frm_num[i1_gap_idx] = 1482 INVALID_FRAME_NUM; 1483 ps_dpb_mgr->ai4_gaps_end_frm_num[i1_gap_idx] = 0; 1484 } 1485 } 1486 } 1487 1488 return OK; 1489 } 1490 1491 /*****************************************************************************/ 1492 /* */ 1493 /* Function Name : ih264d_delete_gap_frm_mmco */ 1494 /* */ 1495 /* Description : This function deletes a picture from the list of gaps, */ 1496 /* if the frame number (specified by mmco commands) to be */ 1497 /* deleted is in the range by gap sequence. */ 1498 /* */ 1499 /* Inputs : ps_dpb_mgr: pointer to dpb manager */ 1500 /* i4_frame_num: frame number of picture that's going to */ 1501 /* be deleted by mmco */ 1502 /* pu1_del_node: holds 0 if a gap is deleted else 1 */ 1503 /* Globals : None */ 1504 /* Processing : Function searches for frame number lesser in the range */ 1505 /* specified by gap sequence */ 1506 /* Outputs : None */ 1507 /* Returns : None */ 1508 /* */ 1509 /* Issues : None */ 1510 /* */ 1511 /* Revision History: */ 1512 /* */ 1513 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1514 /* 22 06 2005 NS Draft */ 1515 /* */ 1516 /*****************************************************************************/ 1517 WORD32 ih264d_delete_gap_frm_mmco(dpb_manager_t *ps_dpb_mgr, 1518 WORD32 i4_frame_num, 1519 UWORD8 *pu1_del_node) 1520 { 1521 WORD8 i, j; 1522 WORD32 *pi4_start, *pi4_end; 1523 WORD32 i4_start_frm_num, i4_end_frm_num, i4_max_frm_num; 1524 1525 /* find the least frame num from gaps and current DPB node */ 1526 /* Delete the gaps */ 1527 *pu1_del_node = 1; 1528 pi4_start = ps_dpb_mgr->ai4_gaps_start_frm_num; 1529 pi4_end = ps_dpb_mgr->ai4_gaps_end_frm_num; 1530 i4_max_frm_num = ps_dpb_mgr->i4_max_frm_num; 1531 1532 if(0 == ps_dpb_mgr->u1_num_gaps) 1533 return OK; 1534 1535 if(i4_frame_num < 0) 1536 i4_frame_num += i4_max_frm_num; 1537 for(i = 0; i < MAX_FRAMES; i++) 1538 { 1539 i4_start_frm_num = pi4_start[i]; 1540 if(i4_start_frm_num < 0) 1541 i4_start_frm_num += i4_max_frm_num; 1542 if(INVALID_FRAME_NUM != i4_start_frm_num) 1543 { 1544 i4_end_frm_num = pi4_end[i]; 1545 if(i4_end_frm_num < 0) 1546 i4_end_frm_num += i4_max_frm_num; 1547 1548 if((i4_frame_num >= i4_start_frm_num) 1549 && (i4_frame_num <= i4_end_frm_num)) 1550 { 1551 break; 1552 } 1553 else 1554 { 1555 if(((i4_frame_num + i4_max_frm_num) >= i4_start_frm_num) 1556 && ((i4_frame_num + i4_max_frm_num) 1557 <= i4_end_frm_num)) 1558 { 1559 UWORD32 i4_error_code; 1560 i4_error_code = ERROR_DBP_MANAGER_T; 1561 return i4_error_code; 1562 } 1563 } 1564 } 1565 } 1566 1567 /* find frame_num index, in the poc_map which needs to be deleted */ 1568 for(j = 0; j < MAX_FRAMES; j++) 1569 { 1570 if(i4_frame_num == ps_dpb_mgr->ai4_poc_buf_id_map[j][2]) 1571 break; 1572 } 1573 1574 if(MAX_FRAMES != i) 1575 { 1576 if(j == MAX_FRAMES) 1577 { 1578 UWORD32 i4_error_code; 1579 i4_error_code = ERROR_DBP_MANAGER_T; 1580 return i4_error_code; 1581 } 1582 1583 ps_dpb_mgr->ai4_poc_buf_id_map[j][0] = -1; 1584 ps_dpb_mgr->ai4_poc_buf_id_map[j][1] = 0x7fffffff; 1585 ps_dpb_mgr->ai4_poc_buf_id_map[j][2] = GAP_FRAME_NUM; 1586 ps_dpb_mgr->i1_gaps_deleted++; 1587 1588 ps_dpb_mgr->ai1_gaps_per_seq[i]--; 1589 ps_dpb_mgr->u1_num_gaps--; 1590 *pu1_del_node = 0; 1591 if(0 == ps_dpb_mgr->ai1_gaps_per_seq[i]) 1592 { 1593 ps_dpb_mgr->ai4_gaps_start_frm_num[i] = INVALID_FRAME_NUM; 1594 ps_dpb_mgr->ai4_gaps_end_frm_num[i] = 0; 1595 } 1596 } 1597 else 1598 { 1599 UWORD32 i4_error_code; 1600 i4_error_code = ERROR_DBP_MANAGER_T; 1601 return i4_error_code; 1602 } 1603 1604 return OK; 1605 } 1606 1607 /*! 1608 ************************************************************************** 1609 * \if Function name : ih264d_do_mmco_for_gaps \endif 1610 * 1611 * \brief 1612 * Perform decoded picture buffer memory management control operations 1613 * 1614 * \return 1615 * 0 - No error; -1 - Error 1616 * 1617 * \note 1618 * Bitstream is also parsed here to get the MMCOs 1619 * 1620 ************************************************************************** 1621 */ 1622 WORD32 ih264d_do_mmco_for_gaps(dpb_manager_t *ps_dpb_mgr, 1623 UWORD8 u1_num_ref_frames /*!< num_ref_frames from active SeqParSet*/ 1624 ) 1625 { 1626 struct dpb_info_t *ps_next_dpb; 1627 UWORD8 u1_num_gaps; 1628 UWORD8 u1_st_ref_bufs, u1_lt_ref_bufs, u1_del_node; 1629 WORD8 i; 1630 WORD32 i4_frame_gaps = 1; 1631 WORD32 ret; 1632 1633 //Sliding window - implements 8.2.5.3, flush out buffers 1634 u1_st_ref_bufs = ps_dpb_mgr->u1_num_st_ref_bufs; 1635 u1_lt_ref_bufs = ps_dpb_mgr->u1_num_lt_ref_bufs; 1636 1637 while(1) 1638 { 1639 u1_num_gaps = ps_dpb_mgr->u1_num_gaps; 1640 if((u1_st_ref_bufs + u1_lt_ref_bufs + u1_num_gaps + i4_frame_gaps) 1641 > u1_num_ref_frames) 1642 { 1643 if(0 == (u1_st_ref_bufs + u1_num_gaps)) 1644 { 1645 i4_frame_gaps = 0; 1646 ps_dpb_mgr->u1_num_gaps = (u1_num_ref_frames 1647 - u1_lt_ref_bufs); 1648 } 1649 else 1650 { 1651 u1_del_node = 1; 1652 ps_next_dpb = ps_dpb_mgr->ps_dpb_st_head; 1653 1654 if(u1_st_ref_bufs > 1) 1655 { 1656 for(i = 1; i < (u1_st_ref_bufs - 1); i++) 1657 { 1658 if(ps_next_dpb == NULL) 1659 { 1660 UWORD32 i4_error_code; 1661 i4_error_code = ERROR_DBP_MANAGER_T; 1662 return i4_error_code; 1663 } 1664 ps_next_dpb = ps_next_dpb->ps_prev_short; 1665 } 1666 1667 if(ps_next_dpb->ps_prev_short->ps_prev_short != NULL) 1668 { 1669 return ERROR_DBP_MANAGER_T; 1670 } 1671 1672 if(u1_num_gaps) 1673 { 1674 ret = ih264d_delete_gap_frm_sliding(ps_dpb_mgr, 1675 ps_next_dpb->ps_prev_short->i4_frame_num, 1676 &u1_del_node); 1677 if(ret != OK) 1678 return ret; 1679 } 1680 1681 if(u1_del_node) 1682 { 1683 u1_st_ref_bufs--; 1684 ps_next_dpb->ps_prev_short->u1_used_as_ref = 1685 UNUSED_FOR_REF; 1686 ps_next_dpb->ps_prev_short->s_top_field.u1_reference_info = 1687 UNUSED_FOR_REF; 1688 ps_next_dpb->ps_prev_short->s_bot_field.u1_reference_info = 1689 UNUSED_FOR_REF; 1690 ih264d_free_ref_pic_mv_bufs(ps_dpb_mgr->pv_codec_handle, 1691 ps_next_dpb->ps_prev_short->u1_buf_id); 1692 ps_next_dpb->ps_prev_short->ps_pic_buf = NULL; 1693 ps_next_dpb->ps_prev_short = NULL; 1694 } 1695 } 1696 else 1697 { 1698 if(u1_st_ref_bufs) 1699 { 1700 if(u1_num_gaps) 1701 { 1702 ret = ih264d_delete_gap_frm_sliding(ps_dpb_mgr, 1703 ps_next_dpb->i4_frame_num, 1704 &u1_del_node); 1705 if(ret != OK) 1706 return ret; 1707 } 1708 1709 if(u1_del_node) 1710 { 1711 u1_st_ref_bufs--; 1712 ps_next_dpb->u1_used_as_ref = FALSE; 1713 ps_next_dpb->s_top_field.u1_reference_info = 1714 UNUSED_FOR_REF; 1715 ps_next_dpb->s_bot_field.u1_reference_info = 1716 UNUSED_FOR_REF; 1717 ih264d_free_ref_pic_mv_bufs(ps_dpb_mgr->pv_codec_handle, 1718 ps_next_dpb->u1_buf_id); 1719 ps_next_dpb->ps_pic_buf = NULL; 1720 ps_next_dpb = NULL; 1721 ps_dpb_mgr->ps_dpb_st_head = NULL; 1722 ps_dpb_mgr->u1_num_st_ref_bufs = u1_st_ref_bufs; 1723 } 1724 } 1725 else 1726 { 1727 ret = ih264d_delete_gap_frm_sliding(ps_dpb_mgr, 1728 INVALID_FRAME_NUM, 1729 &u1_del_node); 1730 if(ret != OK) 1731 return ret; 1732 if(u1_del_node) 1733 { 1734 return ERROR_DBP_MANAGER_T; 1735 } 1736 } 1737 } 1738 } 1739 } 1740 else 1741 { 1742 ps_dpb_mgr->u1_num_gaps += i4_frame_gaps; 1743 break; 1744 } 1745 } 1746 1747 ps_dpb_mgr->u1_num_st_ref_bufs = u1_st_ref_bufs; 1748 1749 return OK; 1750 } 1751 /****************************************************************************/ 1752 /* */ 1753 /* Function Name : ih264d_free_node_from_dpb */ 1754 /* */ 1755 /* Description : */ 1756 /* */ 1757 /* Inputs : */ 1758 /* */ 1759 /* Globals : */ 1760 /* */ 1761 /* Processing : */ 1762 /* */ 1763 /* Outputs : */ 1764 /* */ 1765 /* Returns : */ 1766 /* */ 1767 /* Known Issues : */ 1768 /* */ 1769 /* Revision History */ 1770 /* */ 1771 /* DD MM YY Author Changes */ 1772 /* Sarat */ 1773 /****************************************************************************/ 1774 /**** Function Added for Error Resilience *****/ 1775 WORD32 ih264d_free_node_from_dpb(dpb_manager_t *ps_dpb_mgr, 1776 UWORD32 u4_cur_pic_num, 1777 UWORD8 u1_numRef_frames_for_seq) 1778 { 1779 WORD32 i; 1780 UWORD8 u1_num_gaps = ps_dpb_mgr->u1_num_gaps; 1781 struct dpb_info_t *ps_next_dpb; 1782 UWORD8 u1_del_node = 1; 1783 WORD32 ret; 1784 1785 //Sliding window - implements 8.2.5.3 1786 if((ps_dpb_mgr->u1_num_st_ref_bufs + ps_dpb_mgr->u1_num_lt_ref_bufs 1787 + u1_num_gaps) == u1_numRef_frames_for_seq) 1788 { 1789 UWORD8 u1_new_node_flag = 1; 1790 if((0 == ps_dpb_mgr->u1_num_st_ref_bufs) && (0 == u1_num_gaps)) 1791 { 1792 return ERROR_DBP_MANAGER_T; 1793 } 1794 1795 // Chase the links to reach the last but one picNum, if available 1796 ps_next_dpb = ps_dpb_mgr->ps_dpb_st_head; 1797 1798 if(ps_dpb_mgr->u1_num_st_ref_bufs > 1) 1799 { 1800 if(ps_next_dpb->i4_frame_num == (WORD32)u4_cur_pic_num) 1801 { 1802 /* Incase of filed pictures top_field has been allocated */ 1803 /* picture buffer and complementary bottom field pair comes */ 1804 /* then the sliding window mechanism should not allocate a */ 1805 /* new node */ 1806 u1_new_node_flag = 0; 1807 } 1808 1809 for(i = 1; i < (ps_dpb_mgr->u1_num_st_ref_bufs - 1); i++) 1810 { 1811 if(ps_next_dpb == NULL) 1812 return ERROR_DBP_MANAGER_T; 1813 1814 if(ps_next_dpb->i4_frame_num == (WORD32)u4_cur_pic_num) 1815 { 1816 /* Incase of field pictures top_field has been allocated */ 1817 /* picture buffer and complementary bottom field pair comes */ 1818 /* then the sliding window mechanism should not allocate a */ 1819 /* new node */ 1820 u1_new_node_flag = 0; 1821 } 1822 ps_next_dpb = ps_next_dpb->ps_prev_short; 1823 } 1824 1825 if(ps_next_dpb->ps_prev_short->ps_prev_short != NULL) 1826 return ERROR_DBP_MANAGER_T; 1827 1828 if(u1_new_node_flag) 1829 { 1830 if(u1_num_gaps) 1831 { 1832 ret = ih264d_delete_gap_frm_sliding(ps_dpb_mgr, 1833 ps_next_dpb->ps_prev_short->i4_frame_num, 1834 &u1_del_node); 1835 if(ret != OK) 1836 return ret; 1837 } 1838 1839 if(u1_del_node) 1840 { 1841 ps_dpb_mgr->u1_num_st_ref_bufs--; 1842 ps_next_dpb->ps_prev_short->u1_used_as_ref = UNUSED_FOR_REF; 1843 ps_next_dpb->ps_prev_short->s_top_field.u1_reference_info = 1844 UNUSED_FOR_REF; 1845 ps_next_dpb->ps_prev_short->s_bot_field.u1_reference_info = 1846 UNUSED_FOR_REF; 1847 ih264d_free_ref_pic_mv_bufs(ps_dpb_mgr->pv_codec_handle, 1848 ps_next_dpb->ps_prev_short->u1_buf_id); 1849 ps_next_dpb->ps_prev_short->ps_pic_buf = NULL; 1850 ps_next_dpb->ps_prev_short = NULL; 1851 } 1852 } 1853 } 1854 else 1855 { 1856 if(ps_dpb_mgr->u1_num_st_ref_bufs) 1857 { 1858 ret = ih264d_delete_gap_frm_sliding(ps_dpb_mgr, 1859 ps_next_dpb->i4_frame_num, 1860 &u1_del_node); 1861 if(ret != OK) 1862 return ret; 1863 if((ps_next_dpb->i4_frame_num != (WORD32)u4_cur_pic_num) 1864 && u1_del_node) 1865 { 1866 ps_dpb_mgr->u1_num_st_ref_bufs--; 1867 ps_next_dpb->u1_used_as_ref = FALSE; 1868 ps_next_dpb->s_top_field.u1_reference_info = UNUSED_FOR_REF; 1869 ps_next_dpb->s_bot_field.u1_reference_info = UNUSED_FOR_REF; 1870 ih264d_free_ref_pic_mv_bufs(ps_dpb_mgr->pv_codec_handle, 1871 ps_next_dpb->u1_buf_id); 1872 ps_next_dpb->ps_pic_buf = NULL; 1873 ps_next_dpb = NULL; 1874 } 1875 } 1876 else 1877 { 1878 ret = ih264d_delete_gap_frm_sliding(ps_dpb_mgr, INVALID_FRAME_NUM, &u1_del_node); 1879 if(ret != OK) 1880 return ret; 1881 if(u1_del_node) 1882 return ERROR_DBP_MANAGER_T; 1883 } 1884 } 1885 } 1886 return OK; 1887 } 1888 /*****************************************************************************/ 1889 /* */ 1890 /* Function Name : ih264d_delete_nonref_nondisplay_pics */ 1891 /* */ 1892 /* Description : */ 1893 /* */ 1894 /* */ 1895 /* Inputs : */ 1896 /* Globals : */ 1897 /* Processing : */ 1898 /* */ 1899 /* Outputs : */ 1900 /* Returns : */ 1901 /* */ 1902 /* Issues : */ 1903 /* */ 1904 /* Revision History: */ 1905 /* */ 1906 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1907 /* 05 06 2007 Varun Draft */ 1908 /* */ 1909 /*****************************************************************************/ 1910 1911 void ih264d_delete_nonref_nondisplay_pics(dpb_manager_t *ps_dpb_mgr) 1912 { 1913 WORD8 i; 1914 WORD32 (*i4_poc_buf_id_map)[3] = ps_dpb_mgr->ai4_poc_buf_id_map; 1915 1916 /* remove all gaps marked as unused for ref */ 1917 for(i = 0; (i < MAX_FRAMES) && ps_dpb_mgr->i1_gaps_deleted; i++) 1918 { 1919 if(GAP_FRAME_NUM == i4_poc_buf_id_map[i][2]) 1920 { 1921 ps_dpb_mgr->i1_gaps_deleted--; 1922 ps_dpb_mgr->i1_poc_buf_id_entries--; 1923 i4_poc_buf_id_map[i][0] = -1; 1924 i4_poc_buf_id_map[i][1] = 0x7fffffff; 1925 i4_poc_buf_id_map[i][2] = 0; 1926 } 1927 } 1928 } 1929 /*****************************************************************************/ 1930 /* */ 1931 /* Function Name : ih264d_insert_pic_in_display_list */ 1932 /* */ 1933 /* Description : */ 1934 /* */ 1935 /* */ 1936 /* Inputs : */ 1937 /* Globals : */ 1938 /* Processing : */ 1939 /* */ 1940 /* Outputs : */ 1941 /* Returns : */ 1942 /* */ 1943 /* Issues : */ 1944 /* */ 1945 /* Revision History: */ 1946 /* */ 1947 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1948 /* 05 06 2007 Varun Draft */ 1949 /* */ 1950 /*****************************************************************************/ 1951 1952 WORD32 ih264d_insert_pic_in_display_list(dpb_manager_t *ps_dpb_mgr, 1953 UWORD8 u1_buf_id, 1954 WORD32 i4_display_poc, 1955 UWORD32 u4_frame_num) 1956 { 1957 WORD8 i; 1958 WORD32 (*i4_poc_buf_id_map)[3] = ps_dpb_mgr->ai4_poc_buf_id_map; 1959 1960 for(i = 0; i < MAX_FRAMES; i++) 1961 { 1962 /* Find an empty slot */ 1963 if(i4_poc_buf_id_map[i][0] == -1) 1964 { 1965 if(GAP_FRAME_NUM == i4_poc_buf_id_map[i][2]) 1966 ps_dpb_mgr->i1_gaps_deleted--; 1967 else 1968 ps_dpb_mgr->i1_poc_buf_id_entries++; 1969 1970 i4_poc_buf_id_map[i][0] = u1_buf_id; 1971 i4_poc_buf_id_map[i][1] = i4_display_poc; 1972 i4_poc_buf_id_map[i][2] = u4_frame_num; 1973 1974 break; 1975 } 1976 } 1977 1978 if(MAX_FRAMES == i) 1979 { 1980 1981 UWORD32 i4_error_code; 1982 i4_error_code = ERROR_GAPS_IN_FRM_NUM; 1983 return i4_error_code; 1984 } 1985 return OK; 1986 } 1987 1988
