//#define H264_PARSE_SLICE_HDR
//#ifdef H264_PARSE_SLICE_HDR

#include "h264.h"
#include "h264parse.h"
#include <vbp_trace.h>

extern int32_t viddec_pm_get_au_pos(void *parent, uint32_t *bit, uint32_t *byte, unsigned char *is_emul);


/*-----------------------------------------------------------------------------------------*/
// Slice header 1----
// 1) first_mb_in_slice, slice_type, pic_parameter_id
/*-----------------------------------------------------------------------------------------*/
h264_Status h264_Parse_Slice_Header_1(void *parent,h264_Info* pInfo, h264_Slice_Header_t *SliceHeader)
{
    h264_Status ret = H264_STATUS_ERROR;

    //h264_Slice_Header_t* SliceHeader = &pInfo->SliceHeader;
    int32_t slice_type =0;
    uint32_t data =0;

    do {
        ///// first_mb_in_slice
        SliceHeader->first_mb_in_slice = h264_GetVLCElement(parent, pInfo, false);

        ///// slice_type
        slice_type = h264_GetVLCElement(parent, pInfo, false);

        SliceHeader->slice_type = (slice_type % 5);

        if (SliceHeader->slice_type > h264_PtypeI)
        {
            WTRACE("Slice type (%d) is not supported", SliceHeader->slice_type);
            ret = H264_STATUS_NOTSUPPORT;
            break;
        }

        ////// pic_parameter_id
        data = h264_GetVLCElement(parent, pInfo, false);
        if (data > MAX_PIC_PARAMS)
        {
            WTRACE("pic_parameter_id is invalid", data);
            ret = H264_PPS_INVALID_PIC_ID;
            break;
        }
        SliceHeader->pic_parameter_id  = (uint8_t)data;
        ret = H264_STATUS_OK;
    } while (0);

    return ret;
}

/*-----------------------------------------------------------------------------------------*/
// slice header 2
// 	frame_num
// 	field_pic_flag, structure
// 	idr_pic_id
// 	pic_order_cnt_lsb, delta_pic_order_cnt_bottom
/*-----------------------------------------------------------------------------------------*/

h264_Status h264_Parse_Slice_Header_2(void *parent, h264_Info* pInfo, h264_Slice_Header_t *SliceHeader)
{
    h264_Status ret = H264_SliceHeader_ERROR;

    //h264_Slice_Header_t* SliceHeader = &pInfo->SliceHeader;
    uint32_t code;
    int32_t max_mb_num=0;

    do {
        //////////////////////////////////// Slice header part 2//////////////////

        /// Frame_num
        viddec_pm_get_bits(parent, &code, pInfo->active_SPS.log2_max_frame_num_minus4 + 4);
        SliceHeader->frame_num = (int32_t)code;

        /// Picture structure
        SliceHeader->structure = FRAME;
        SliceHeader->field_pic_flag = 0;
        SliceHeader->bottom_field_flag = 0;

        if (!(pInfo->active_SPS.sps_disp.frame_mbs_only_flag))
        {
            /// field_pic_flag
            viddec_pm_get_bits(parent, &code, 1);
            SliceHeader->field_pic_flag = (uint8_t)code;

            if (SliceHeader->field_pic_flag)
            {
                viddec_pm_get_bits(parent, &code, 1);
                SliceHeader->bottom_field_flag = (uint8_t)code;

                SliceHeader->structure = SliceHeader->bottom_field_flag ? BOTTOM_FIELD: TOP_FIELD;
            }
        }

        ////// Check valid or not of first_mb_in_slice
        if (SliceHeader->structure == FRAME)
        {
            max_mb_num = pInfo->img.FrameHeightInMbs * pInfo->img.PicWidthInMbs;
        }
        else
        {
            max_mb_num = pInfo->img.FrameHeightInMbs * pInfo->img.PicWidthInMbs / 2;
        }

        ///if(pInfo->img.MbaffFrameFlag)
        if (pInfo->active_SPS.sps_disp.mb_adaptive_frame_field_flag & (!(pInfo->SliceHeader.field_pic_flag)))
        {
            SliceHeader->first_mb_in_slice <<= 1;
        }

        if (SliceHeader->first_mb_in_slice >= max_mb_num)
            break;

        if (pInfo->nal_unit_type == h264_NAL_UNIT_TYPE_IDR)
        {
            SliceHeader->idr_pic_id = h264_GetVLCElement(parent, pInfo, false);
        }

        if (pInfo->active_SPS.pic_order_cnt_type == 0)
        {
            viddec_pm_get_bits(parent, &code , pInfo->active_SPS.log2_max_pic_order_cnt_lsb_minus4 + 4);
            SliceHeader->pic_order_cnt_lsb = (uint32_t)code;

            if ((pInfo->active_PPS.pic_order_present_flag) && !(SliceHeader->field_pic_flag))
            {
                SliceHeader->delta_pic_order_cnt_bottom = h264_GetVLCElement(parent, pInfo, true);
            }
            else
            {
                SliceHeader->delta_pic_order_cnt_bottom = 0;
            }
        }

        if ((pInfo->active_SPS.pic_order_cnt_type == 1) && !(pInfo->active_SPS.delta_pic_order_always_zero_flag))
        {
            SliceHeader->delta_pic_order_cnt[0] = h264_GetVLCElement(parent, pInfo, true);
            if ((pInfo->active_PPS.pic_order_present_flag) && !(SliceHeader->field_pic_flag))
            {
                SliceHeader->delta_pic_order_cnt[1] = h264_GetVLCElement(parent, pInfo, true);
            }
        }

        if (pInfo->active_PPS.redundant_pic_cnt_present_flag)
        {
            SliceHeader->redundant_pic_cnt = h264_GetVLCElement(parent, pInfo, false);
            if (SliceHeader->redundant_pic_cnt > 127)
                break;
        }
        else
        {
            SliceHeader->redundant_pic_cnt = 0;
        }

        ret = H264_STATUS_OK;
    } while (0);

    //////////// FMO is not supported curently, so comment out the following code
    //if((pInfo->active_PPS.num_slice_groups_minus1 > 0) && (pInfo->active_PPS.slice_group_map_type >= 3) && (pInfo->active_PPS.slice_group_map_type <= 5) )
    //{
    //	SliceHeader->slice_group_change_cycle = 0;				//one of the variables is not known in the high profile
    //}

    return ret;
}

/*-----------------------------------------------------------------------------------------*/
// slice header 3
// (direct_spatial_mv_pred_flag, num_ref_idx, pic_list_reorder, PWT,  ref_pic_remark, alpha, beta, etc)
/*-----------------------------------------------------------------------------------------*/

h264_Status h264_Parse_Slice_Header_3(void *parent, h264_Info* pInfo, h264_Slice_Header_t *SliceHeader)
{
    h264_Status ret = H264_SliceHeader_ERROR;

    //h264_Slice_Header_t* SliceHeader = &pInfo->SliceHeader;
    int32_t  slice_alpha_c0_offset, slice_beta_offset;
    uint32_t code;
    uint32_t bits_offset =0, byte_offset =0;
    uint8_t  is_emul =0;

    do {
        /// direct_spatial_mv_pred_flag
        if (SliceHeader->slice_type == h264_PtypeB)
        {
            viddec_pm_get_bits(parent, &code , 1);
            SliceHeader->direct_spatial_mv_pred_flag = (uint8_t)code;
        }
        else
        {
            SliceHeader->direct_spatial_mv_pred_flag = 0;
        }

        //
        // Reset ref_idx and Overide it if exist
        //
        SliceHeader->num_ref_idx_l0_active = pInfo->active_PPS.num_ref_idx_l0_active;
        SliceHeader->num_ref_idx_l1_active = pInfo->active_PPS.num_ref_idx_l1_active;

        if ((SliceHeader->slice_type == h264_PtypeP) || (SliceHeader->slice_type == h264_PtypeSP) || (SliceHeader->slice_type == h264_PtypeB))
        {
            viddec_pm_get_bits(parent, &code, 1);
            SliceHeader->num_ref_idx_active_override_flag  = (uint8_t)code;

            if (SliceHeader->num_ref_idx_active_override_flag)
            {
                SliceHeader->num_ref_idx_l0_active = h264_GetVLCElement(parent, pInfo, false) + 1;
                if (SliceHeader->slice_type == h264_PtypeB)
                {
                    SliceHeader->num_ref_idx_l1_active = h264_GetVLCElement(parent, pInfo, false) + 1;
                }
            }
        }

        if (SliceHeader->slice_type != h264_PtypeB)
        {
            SliceHeader->num_ref_idx_l1_active = 0;
        }

        if ((SliceHeader->num_ref_idx_l0_active > MAX_NUM_REF_FRAMES) || (SliceHeader->num_ref_idx_l1_active > MAX_NUM_REF_FRAMES))
        {
            WTRACE("ref index greater than expected during slice header parsing.");
            break;
        }

#ifdef USE_AVC_SHORT_FORMAT
        bool keepParsing = false;
        keepParsing = h264_is_new_picture_start(pInfo, *SliceHeader, pInfo->SliceHeader) && (SliceHeader->nal_ref_idc != 0);
        if (!keepParsing)
        {
            ITRACE("short format parsing: no need to go on!");
            ret = H264_STATUS_OK;
            break;
        }
#endif
        if (h264_Parse_Ref_Pic_List_Reordering(parent, pInfo, SliceHeader) != H264_STATUS_OK)
        {
            WTRACE("ref list reordering failed during slice header parsing.");
            break;
        }


        ////
        //// Parse Pred_weight_table but not store it becasue it will be reparsed in HW
        ////
        if (((pInfo->active_PPS.weighted_pred_flag) && ((SliceHeader->slice_type == h264_PtypeP) || (SliceHeader->slice_type == h264_PtypeSP))) || ((pInfo->active_PPS.weighted_bipred_idc == 1) && (SliceHeader->slice_type == h264_PtypeB)))
        {

            viddec_pm_get_au_pos(parent, &bits_offset, &byte_offset, &is_emul);

            pInfo->h264_pwt_enabled = 1;
            pInfo->h264_pwt_start_byte_offset = byte_offset;
            pInfo->h264_pwt_start_bit_offset  = bits_offset;

            if (h264_Parse_Pred_Weight_Table(parent, pInfo, SliceHeader) != H264_STATUS_OK)
            {
                break;
            }

            viddec_pm_get_au_pos(parent, &bits_offset, &byte_offset, &is_emul);

            if (0 == bits_offset)
            {
                pInfo->h264_pwt_end_byte_offset = byte_offset-1;
                pInfo->h264_pwt_end_bit_offset  = 8;
            }
            else
            {
                pInfo->h264_pwt_end_byte_offset = byte_offset;
                pInfo->h264_pwt_end_bit_offset  = bits_offset;
            }

        }


        ////
        //// Parse Ref_pic marking if there
        ////
        if (SliceHeader->nal_ref_idc != 0)
        {
            if (h264_Parse_Dec_Ref_Pic_Marking(parent, pInfo, SliceHeader) != H264_STATUS_OK)
            {
                WTRACE("ref pic marking failed during slice header parsing.");
                break;
            }
        }

        if ((pInfo->active_PPS.entropy_coding_mode_flag) && (SliceHeader->slice_type != h264_PtypeI) && (SliceHeader->slice_type != h264_PtypeSI))
        {
            SliceHeader->cabac_init_idc = h264_GetVLCElement(parent, pInfo, false);
        }
        else
        {
            SliceHeader->cabac_init_idc = 0;
        }

        if (SliceHeader->cabac_init_idc > 2)
        {
            break;
        }

        SliceHeader->slice_qp_delta = h264_GetVLCElement(parent, pInfo, true);
        if ((SliceHeader->slice_qp_delta > (25 - pInfo->active_PPS.pic_init_qp_minus26)) || (SliceHeader->slice_qp_delta < -(26 + pInfo->active_PPS.pic_init_qp_minus26)))
        {
            WTRACE("slice_qp_delta value is invalid.");
            break;
        }

        if ((SliceHeader->slice_type == h264_PtypeSP) || (SliceHeader->slice_type == h264_PtypeSI))
        {
            if (SliceHeader->slice_type == h264_PtypeSP)
            {
                viddec_pm_get_bits(parent, &code, 1);
                SliceHeader->sp_for_switch_flag  = (uint8_t)code;

            }
            SliceHeader->slice_qs_delta = h264_GetVLCElement(parent, pInfo, true);

            if ((SliceHeader->slice_qs_delta > (25 - pInfo->active_PPS.pic_init_qs_minus26)) || (SliceHeader->slice_qs_delta < -(26+pInfo->active_PPS.pic_init_qs_minus26)) )
            {
                WTRACE("slice_qp_delta value is invalid.");
                break;
            }
        }
        if (pInfo->active_PPS.deblocking_filter_control_present_flag)
        {
            SliceHeader->disable_deblocking_filter_idc = h264_GetVLCElement(parent, pInfo, false);
            if (SliceHeader->disable_deblocking_filter_idc != 1)
            {
                SliceHeader->slice_alpha_c0_offset_div2 = h264_GetVLCElement(parent, pInfo, true);
                slice_alpha_c0_offset = SliceHeader->slice_alpha_c0_offset_div2 << 1;
                if (slice_alpha_c0_offset < -12 || slice_alpha_c0_offset > 12)
                {
                    break;
                }

                SliceHeader->slice_beta_offset_div2 = h264_GetVLCElement(parent, pInfo, true);
                slice_beta_offset = SliceHeader->slice_beta_offset_div2 << 1;
                if (slice_beta_offset < -12 || slice_beta_offset > 12)
                {
                    break;
                }
            }
            else
            {
                SliceHeader->slice_alpha_c0_offset_div2 = 0;
                SliceHeader->slice_beta_offset_div2 = 0;
            }
        }

        ret = H264_STATUS_OK;
    } while (0);

    //////////// FMO is not supported curently, so comment out the following code
    //if((pInfo->active_PPS.num_slice_groups_minus1 > 0) && (pInfo->active_PPS.slice_group_map_type >= 3) && (pInfo->active_PPS.slice_group_map_type <= 5) )
    //{
    //	SliceHeader->slice_group_change_cycle = 0;				//one of the variables is not known in the high profile
    //}

    return ret;
}


/*--------------------------------------------------------------------------------------------------*/
//
// The syntax elements reordering_of_pic_nums_idc, abs_diff_pic_num_minus1, and long_term_pic_num
// specify the change from the initial reference picture lists to the reference picture lists to be used
// for decoding the slice

// reordering_of_pic_nums_idc:
//		0:	abs_diff_pic_num_minus1 is present and corresponds to a difference to subtract from a picture number prediction value
//		1:	abs_diff_pic_num_minus1 is present and corresponds to a difference to add to a picture number prediction value
//		2:	long_term_pic_num is present and specifies the long-term picture number for a reference picture
//		3:	End loop for reordering of the initial reference picture list
//
/*--------------------------------------------------------------------------------------------------*/

h264_Status h264_Parse_Ref_Pic_List_Reordering(void *parent, h264_Info* pInfo,h264_Slice_Header_t *SliceHeader)
{
    //h264_Slice_Header_t* SliceHeader = &pInfo->SliceHeader;
    int32_t reorder= -1;
    uint32_t code;

    if ((SliceHeader->slice_type != h264_PtypeI) && (SliceHeader->slice_type != h264_PtypeSI))
    {
        viddec_pm_get_bits(parent, &code, 1);
        SliceHeader->sh_refpic_l0.ref_pic_list_reordering_flag = (uint8_t)code;

        if (SliceHeader->sh_refpic_l0.ref_pic_list_reordering_flag)
        {
            reorder = -1;
            do
            {
                reorder++;

                if (reorder > MAX_NUM_REF_FRAMES)
                {
                    return H264_SliceHeader_ERROR;
                }

                SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] = h264_GetVLCElement(parent, pInfo, false);
                if ((SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] == 0) || (SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] == 1))
                {
                    SliceHeader->sh_refpic_l0.list_reordering_num[reorder].abs_diff_pic_num_minus1 = h264_GetVLCElement(parent, pInfo, false);
                }
                else if (SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] == 2)
                {
                    SliceHeader->sh_refpic_l0.list_reordering_num[reorder].long_term_pic_num = h264_GetVLCElement(parent, pInfo, false);
                }

            } while (SliceHeader->sh_refpic_l0.reordering_of_pic_nums_idc[reorder] != 3);
        }
    }

    if (SliceHeader->slice_type == h264_PtypeB)
    {
        viddec_pm_get_bits(parent, &code, 1);
        SliceHeader->sh_refpic_l1.ref_pic_list_reordering_flag = (uint8_t)code;

        if (SliceHeader->sh_refpic_l1.ref_pic_list_reordering_flag)
        {
            reorder = -1;
            do
            {
                reorder++;
                if (reorder > MAX_NUM_REF_FRAMES)
                {
                    return H264_SliceHeader_ERROR;
                }
                SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] = h264_GetVLCElement(parent, pInfo, false);
                if ((SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] == 0) || (SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] == 1))
                {
                    SliceHeader->sh_refpic_l1.list_reordering_num[reorder].abs_diff_pic_num_minus1 = h264_GetVLCElement(parent, pInfo, false);
                }
                else if (SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] == 2)
                {
                    SliceHeader->sh_refpic_l1.list_reordering_num[reorder].long_term_pic_num = h264_GetVLCElement(parent, pInfo, false);
                }
            } while (SliceHeader->sh_refpic_l1.reordering_of_pic_nums_idc[reorder] != 3);
        }
    }

    //currently just two reference frames but in case mroe than two, then should use an array for the above structures that is why reorder
    return H264_STATUS_OK;

}

h264_Status h264_Parse_Pred_Weight_Table(void *parent, h264_Info* pInfo,h264_Slice_Header_t *SliceHeader)
{
    uint32_t i = 0, j = 0;
    uint32_t flag;

    SliceHeader->sh_predwttbl.luma_log2_weight_denom = h264_GetVLCElement(parent, pInfo, false);

    if (pInfo->active_SPS.sps_disp.chroma_format_idc != 0)
    {
        SliceHeader->sh_predwttbl.chroma_log2_weight_denom = h264_GetVLCElement(parent,pInfo, false);
    }

    for (i = 0; i < SliceHeader->num_ref_idx_l0_active; i++)
    {
        viddec_pm_get_bits(parent, (uint32_t *)&flag, 1);
        SliceHeader->sh_predwttbl.luma_weight_l0_flag = flag;

        if (SliceHeader->sh_predwttbl.luma_weight_l0_flag)
        {
            SliceHeader->sh_predwttbl.luma_weight_l0[i] = h264_GetVLCElement(parent, pInfo, true);
            SliceHeader->sh_predwttbl.luma_offset_l0[i] = h264_GetVLCElement(parent, pInfo, true);
        }
        else
        {
            SliceHeader->sh_predwttbl.luma_weight_l0[i] = (1 << SliceHeader->sh_predwttbl.luma_log2_weight_denom);
            SliceHeader->sh_predwttbl.luma_offset_l0[i] = 0;
        }

        if (pInfo->active_SPS.sps_disp.chroma_format_idc != 0)
        {
            viddec_pm_get_bits(parent, (uint32_t *)&flag, 1);
            SliceHeader->sh_predwttbl.chroma_weight_l0_flag = flag;

            if (SliceHeader->sh_predwttbl.chroma_weight_l0_flag)
            {
                for (j = 0; j < 2; j++)
                {
                    SliceHeader->sh_predwttbl.chroma_weight_l0[i][j] = h264_GetVLCElement(parent, pInfo, true);
                    SliceHeader->sh_predwttbl.chroma_offset_l0[i][j] = h264_GetVLCElement(parent, pInfo, true);
                }
            }
            else
            {
                for (j = 0; j < 2; j++)
                {
                    SliceHeader->sh_predwttbl.chroma_weight_l0[i][j] = (1 << SliceHeader->sh_predwttbl.chroma_log2_weight_denom);
                    SliceHeader->sh_predwttbl.chroma_offset_l0[i][j] = 0;
                }
            }
        }

    }

    if (SliceHeader->slice_type == h264_PtypeB)
    {
        for (i = 0; i < SliceHeader->num_ref_idx_l1_active; i++)
        {
            viddec_pm_get_bits(parent, (uint32_t *)&flag, 1);
            SliceHeader->sh_predwttbl.luma_weight_l1_flag = flag;

            if (SliceHeader->sh_predwttbl.luma_weight_l1_flag)
            {
                SliceHeader->sh_predwttbl.luma_weight_l1[i] = h264_GetVLCElement(parent, pInfo, true);
                SliceHeader->sh_predwttbl.luma_offset_l1[i] = h264_GetVLCElement(parent, pInfo, true);
            }
            else
            {
                SliceHeader->sh_predwttbl.luma_weight_l1[i] = (1 << SliceHeader->sh_predwttbl.luma_log2_weight_denom);
                SliceHeader->sh_predwttbl.luma_offset_l1[i] = 0;
            }

            if (pInfo->active_SPS.sps_disp.chroma_format_idc != 0)
            {
                viddec_pm_get_bits(parent, (uint32_t *)&flag, 1);
                SliceHeader->sh_predwttbl.chroma_weight_l1_flag = flag;

                if (SliceHeader->sh_predwttbl.chroma_weight_l1_flag)
                {
                    for (j = 0; j < 2; j++)
                    {
                        SliceHeader->sh_predwttbl.chroma_weight_l1[i][j] = h264_GetVLCElement(parent, pInfo, true);
                        SliceHeader->sh_predwttbl.chroma_offset_l1[i][j] = h264_GetVLCElement(parent, pInfo, true);
                    }
                }
                else
                {
                    for (j = 0; j < 2; j++)
                    {
                        SliceHeader->sh_predwttbl.chroma_weight_l1[i][j] = (1 << SliceHeader->sh_predwttbl.chroma_log2_weight_denom);
                        SliceHeader->sh_predwttbl.chroma_offset_l1[i][j] = 0;
                    }
                }
            }

        }
    }

    return H264_STATUS_OK;
} ///// End of h264_Parse_Pred_Weight_Table


/*--------------------------------------------------------------------------------------------------*/
// The syntax elements specify marking of the reference pictures.
//			1)IDR:		no_output_of_prior_pics_flag,
//						long_term_reference_flag,
//			2)NonIDR:	adaptive_ref_pic_marking_mode_flag,
//						memory_management_control_operation,
//						difference_of_pic_nums_minus1,
//						long_term_frame_idx,
//						long_term_pic_num, and
//						max_long_term_frame_idx_plus1
//
//The marking of a reference picture can be "unused for reference", "used for short-term reference", or "used for longterm
// reference", but only one among these three.
/*--------------------------------------------------------------------------------------------------*/


h264_Status h264_Parse_Dec_Ref_Pic_Marking(void *parent, h264_Info* pInfo,h264_Slice_Header_t *SliceHeader)
{
    //h264_Slice_Header_t* SliceHeader = &pInfo->SliceHeader;
    uint8_t i = 0;
    uint32_t code = 0;

    if (pInfo->nal_unit_type == h264_NAL_UNIT_TYPE_IDR)
    {
        viddec_pm_get_bits(parent, &code, 1);
        SliceHeader->sh_dec_refpic.no_output_of_prior_pics_flag = (uint8_t)code;

        viddec_pm_get_bits(parent, &code, 1);
        SliceHeader->sh_dec_refpic.long_term_reference_flag = (uint8_t)code;
        pInfo->img.long_term_reference_flag = (uint8_t)code;
    }
    else
    {
        viddec_pm_get_bits(parent, &code, 1);
        SliceHeader->sh_dec_refpic.adaptive_ref_pic_marking_mode_flag = (uint8_t)code;

        ///////////////////////////////////////////////////////////////////////////////////////
        //adaptive_ref_pic_marking_mode_flag 			Reference picture marking mode specified
        //	0 						Sliding window reference picture marking mode: A marking mode
        //							providing a first-in first-out mechanism for short-term reference pictures.
        //  	1 						Adaptive reference picture marking mode: A reference picture
        //							marking mode providing syntax elements to specify marking of
        //							reference pictures as �unused for reference?and to assign long-term
        //							frame indices.
        ///////////////////////////////////////////////////////////////////////////////////////

        if (SliceHeader->sh_dec_refpic.adaptive_ref_pic_marking_mode_flag)
        {
            do
            {
                if (i < NUM_MMCO_OPERATIONS)
                {
                    SliceHeader->sh_dec_refpic.memory_management_control_operation[i] = h264_GetVLCElement(parent, pInfo, false);
                    if ((SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 1) || (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 3))
                    {
                        SliceHeader->sh_dec_refpic.difference_of_pic_num_minus1[i] = h264_GetVLCElement(parent, pInfo, false);
                    }

                    if (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 2)
                    {
                        SliceHeader->sh_dec_refpic.long_term_pic_num[i] = h264_GetVLCElement(parent, pInfo, false);
                    }

                    if ((SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 3) || (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 6))
                    {
                        SliceHeader->sh_dec_refpic.long_term_frame_idx[i] = h264_GetVLCElement(parent, pInfo, false);
                    }

                    if (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 4)
                    {
                        SliceHeader->sh_dec_refpic.max_long_term_frame_idx_plus1[i] = h264_GetVLCElement(parent, pInfo, false);
                    }

                    if (SliceHeader->sh_dec_refpic.memory_management_control_operation[i] == 5)
                    {
                        pInfo->img.curr_has_mmco_5 = 1;
                    }
                }

                if (i >= NUM_MMCO_OPERATIONS) {
                    return H264_STATUS_ERROR;
                }

            } while (SliceHeader->sh_dec_refpic.memory_management_control_operation[i++] != 0);
        }
    }

    SliceHeader->sh_dec_refpic.dec_ref_pic_marking_count = i;

    return H264_STATUS_OK;
}

//#endif