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