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