/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
#include "avcenc_lib.h"
#include "avcenc_api.h"

/** see subclause 7.4.2.1 */
/* no need for checking the valid range , already done in SetEncodeParam(),
if we have to send another SPS, the ranges should be verified first before
users call PVAVCEncodeSPS() */
AVCEnc_Status EncodeSPS(AVCEncObject *encvid, AVCEncBitstream *stream)
{
    AVCCommonObj *video = encvid->common;
    AVCSeqParamSet *seqParam = video->currSeqParams;
    AVCVUIParams *vui = &(seqParam->vui_parameters);
    int i;
    AVCEnc_Status status = AVCENC_SUCCESS;

    //DEBUG_LOG(userData,AVC_LOGTYPE_INFO,"EncodeSPS",-1,-1);

    status = BitstreamWriteBits(stream, 8, seqParam->profile_idc);
    status = BitstreamWrite1Bit(stream, seqParam->constrained_set0_flag);
    status = BitstreamWrite1Bit(stream, seqParam->constrained_set1_flag);
    status = BitstreamWrite1Bit(stream, seqParam->constrained_set2_flag);
    status = BitstreamWrite1Bit(stream, seqParam->constrained_set3_flag);
    status = BitstreamWriteBits(stream, 4, 0);  /* forbidden zero bits */
    if (status != AVCENC_SUCCESS)  /* we can check after each write also */
    {
        return status;
    }

    status = BitstreamWriteBits(stream, 8, seqParam->level_idc);
    status = ue_v(stream, seqParam->seq_parameter_set_id);
    status = ue_v(stream, seqParam->log2_max_frame_num_minus4);
    status = ue_v(stream, seqParam->pic_order_cnt_type);
    if (status != AVCENC_SUCCESS)
    {
        return status;
    }

    if (seqParam->pic_order_cnt_type == 0)
    {
        status = ue_v(stream, seqParam->log2_max_pic_order_cnt_lsb_minus4);
    }
    else if (seqParam->pic_order_cnt_type == 1)
    {
        status = BitstreamWrite1Bit(stream, seqParam->delta_pic_order_always_zero_flag);
        status = se_v(stream, seqParam->offset_for_non_ref_pic); /* upto 32 bits */
        status = se_v(stream, seqParam->offset_for_top_to_bottom_field); /* upto 32 bits */
        status = ue_v(stream, seqParam->num_ref_frames_in_pic_order_cnt_cycle);

        for (i = 0; i < (int)(seqParam->num_ref_frames_in_pic_order_cnt_cycle); i++)
        {
            status = se_v(stream, seqParam->offset_for_ref_frame[i]); /* upto 32 bits */
        }
    }
    if (status != AVCENC_SUCCESS)
    {
        return status;
    }

    status = ue_v(stream, seqParam->num_ref_frames);
    status = BitstreamWrite1Bit(stream, seqParam->gaps_in_frame_num_value_allowed_flag);
    status = ue_v(stream, seqParam->pic_width_in_mbs_minus1);
    status = ue_v(stream, seqParam->pic_height_in_map_units_minus1);
    status = BitstreamWrite1Bit(stream, seqParam->frame_mbs_only_flag);
    if (status != AVCENC_SUCCESS)
    {
        return status;
    }
    /* if frame_mbs_only_flag is 0, then write, mb_adaptive_frame_field_frame here */

    status = BitstreamWrite1Bit(stream, seqParam->direct_8x8_inference_flag);
    status = BitstreamWrite1Bit(stream, seqParam->frame_cropping_flag);
    if (seqParam->frame_cropping_flag)
    {
        status = ue_v(stream, seqParam->frame_crop_left_offset);
        status = ue_v(stream, seqParam->frame_crop_right_offset);
        status = ue_v(stream, seqParam->frame_crop_top_offset);
        status = ue_v(stream, seqParam->frame_crop_bottom_offset);
    }
    if (status != AVCENC_SUCCESS)
    {
        return status;
    }

    status = BitstreamWrite1Bit(stream, seqParam->vui_parameters_present_flag);
    if (seqParam->vui_parameters_present_flag)
    {
        /* not supported */
        //return AVCENC_SPS_FAIL;
        EncodeVUI(stream, vui);
    }

    return status;
}


void EncodeVUI(AVCEncBitstream* stream, AVCVUIParams* vui)
{
    int temp;

    temp = vui->aspect_ratio_info_present_flag;
    BitstreamWrite1Bit(stream, temp);
    if (temp)
    {
        BitstreamWriteBits(stream, 8, vui->aspect_ratio_idc);
        if (vui->aspect_ratio_idc == 255)
        {
            BitstreamWriteBits(stream, 16, vui->sar_width);
            BitstreamWriteBits(stream, 16, vui->sar_height);
        }
    }
    temp = vui->overscan_info_present_flag;
    BitstreamWrite1Bit(stream, temp);
    if (temp)
    {
        BitstreamWrite1Bit(stream, vui->overscan_appropriate_flag);
    }
    temp = vui->video_signal_type_present_flag;
    BitstreamWrite1Bit(stream, temp);
    if (temp)
    {
        BitstreamWriteBits(stream, 3, vui->video_format);
        BitstreamWrite1Bit(stream, vui->video_full_range_flag);
        temp = vui->colour_description_present_flag;
        BitstreamWrite1Bit(stream, temp);
        if (temp)
        {
            BitstreamWriteBits(stream, 8, vui->colour_primaries);
            BitstreamWriteBits(stream, 8, vui->transfer_characteristics);
            BitstreamWriteBits(stream, 8, vui->matrix_coefficients);
        }
    }
    temp = vui->chroma_location_info_present_flag;
    BitstreamWrite1Bit(stream, temp);
    if (temp)
    {
        ue_v(stream, vui->chroma_sample_loc_type_top_field);
        ue_v(stream, vui->chroma_sample_loc_type_bottom_field);
    }

    temp = vui->timing_info_present_flag;
    BitstreamWrite1Bit(stream, temp);
    if (temp)
    {
        BitstreamWriteBits(stream, 32, vui->num_units_in_tick);
        BitstreamWriteBits(stream, 32, vui->time_scale);
        BitstreamWrite1Bit(stream, vui->fixed_frame_rate_flag);
    }

    temp = vui->nal_hrd_parameters_present_flag;
    BitstreamWrite1Bit(stream, temp);
    if (temp)
    {
        EncodeHRD(stream, &(vui->nal_hrd_parameters));
    }
    temp = vui->vcl_hrd_parameters_present_flag;
    BitstreamWrite1Bit(stream, temp);
    if (temp)
    {
        EncodeHRD(stream, &(vui->vcl_hrd_parameters));
    }
    if (vui->nal_hrd_parameters_present_flag || vui->vcl_hrd_parameters_present_flag)
    {
        BitstreamWrite1Bit(stream, vui->low_delay_hrd_flag);
    }
    BitstreamWrite1Bit(stream, vui->pic_struct_present_flag);
    temp = vui->bitstream_restriction_flag;
    BitstreamWrite1Bit(stream, temp);
    if (temp)
    {
        BitstreamWrite1Bit(stream, vui->motion_vectors_over_pic_boundaries_flag);
        ue_v(stream, vui->max_bytes_per_pic_denom);
        ue_v(stream, vui->max_bits_per_mb_denom);
        ue_v(stream, vui->log2_max_mv_length_horizontal);
        ue_v(stream, vui->log2_max_mv_length_vertical);
        ue_v(stream, vui->max_dec_frame_reordering);
        ue_v(stream, vui->max_dec_frame_buffering);
    }

    return ;
}


void EncodeHRD(AVCEncBitstream* stream, AVCHRDParams* hrd)
{
    int i;

    ue_v(stream, hrd->cpb_cnt_minus1);
    BitstreamWriteBits(stream, 4, hrd->bit_rate_scale);
    BitstreamWriteBits(stream, 4, hrd->cpb_size_scale);
    for (i = 0; i <= (int)hrd->cpb_cnt_minus1; i++)
    {
        ue_v(stream, hrd->bit_rate_value_minus1[i]);
        ue_v(stream, hrd->cpb_size_value_minus1[i]);
        ue_v(stream, hrd->cbr_flag[i]);
    }
    BitstreamWriteBits(stream, 5, hrd->initial_cpb_removal_delay_length_minus1);
    BitstreamWriteBits(stream, 5, hrd->cpb_removal_delay_length_minus1);
    BitstreamWriteBits(stream, 5, hrd->dpb_output_delay_length_minus1);
    BitstreamWriteBits(stream, 5, hrd->time_offset_length);

    return ;
}


/** see subclause 7.4.2.2 */
/* no need for checking the valid range , already done in SetEncodeParam().
If we have to send another SPS, the ranges should be verified first before
users call PVAVCEncodeSPS()*/
AVCEnc_Status EncodePPS(AVCEncObject *encvid, AVCEncBitstream *stream)
{
    AVCCommonObj *video = encvid->common;
    AVCEnc_Status status = AVCENC_SUCCESS;
    AVCPicParamSet *picParam = video->currPicParams;
    int i, iGroup, numBits;
    uint temp;

    status = ue_v(stream, picParam->pic_parameter_set_id);
    status = ue_v(stream, picParam->seq_parameter_set_id);
    status = BitstreamWrite1Bit(stream, picParam->entropy_coding_mode_flag);
    status = BitstreamWrite1Bit(stream, picParam->pic_order_present_flag);
    if (status != AVCENC_SUCCESS)
    {
        return status;
    }

    status = ue_v(stream, picParam->num_slice_groups_minus1);
    if (picParam->num_slice_groups_minus1 > 0)
    {
        status = ue_v(stream, picParam->slice_group_map_type);
        if (picParam->slice_group_map_type == 0)
        {
            for (iGroup = 0; iGroup <= (int)picParam->num_slice_groups_minus1; iGroup++)
            {
                status = ue_v(stream, picParam->run_length_minus1[iGroup]);
            }
        }
        else if (picParam->slice_group_map_type == 2)
        {
            for (iGroup = 0; iGroup < (int)picParam->num_slice_groups_minus1; iGroup++)
            {
                status = ue_v(stream, picParam->top_left[iGroup]);
                status = ue_v(stream, picParam->bottom_right[iGroup]);
            }
        }
        else if (picParam->slice_group_map_type == 3 ||
                 picParam->slice_group_map_type == 4 ||
                 picParam->slice_group_map_type == 5)
        {
            status = BitstreamWrite1Bit(stream, picParam->slice_group_change_direction_flag);
            status = ue_v(stream, picParam->slice_group_change_rate_minus1);
        }
        else /*if(picParam->slice_group_map_type == 6)*/
        {
            status = ue_v(stream, picParam->pic_size_in_map_units_minus1);

            numBits = 0;/* ceil(log2(num_slice_groups_minus1+1)) bits */
            i = picParam->num_slice_groups_minus1;
            while (i > 0)
            {
                numBits++;
                i >>= 1;
            }

            for (i = 0; i <= (int)picParam->pic_size_in_map_units_minus1; i++)
            {
                status = BitstreamWriteBits(stream, numBits, picParam->slice_group_id[i]);
            }
        }
    }
    if (status != AVCENC_SUCCESS)
    {
        return status;
    }

    status = ue_v(stream, picParam->num_ref_idx_l0_active_minus1);
    status = ue_v(stream, picParam->num_ref_idx_l1_active_minus1);
    status = BitstreamWrite1Bit(stream, picParam->weighted_pred_flag);
    status = BitstreamWriteBits(stream, 2, picParam->weighted_bipred_idc);
    if (status != AVCENC_SUCCESS)
    {
        return status;
    }

    status = se_v(stream, picParam->pic_init_qp_minus26);
    status = se_v(stream, picParam->pic_init_qs_minus26);
    status = se_v(stream, picParam->chroma_qp_index_offset);

    temp = picParam->deblocking_filter_control_present_flag << 2;
    temp |= (picParam->constrained_intra_pred_flag << 1);
    temp |= picParam->redundant_pic_cnt_present_flag;

    status = BitstreamWriteBits(stream, 3, temp);

    return status;
}

/** see subclause 7.4.3 */
AVCEnc_Status EncodeSliceHeader(AVCEncObject *encvid, AVCEncBitstream *stream)
{
    AVCCommonObj *video = encvid->common;
    AVCSliceHeader *sliceHdr = video->sliceHdr;
    AVCPicParamSet *currPPS = video->currPicParams;
    AVCSeqParamSet *currSPS = video->currSeqParams;
    AVCEnc_Status status = AVCENC_SUCCESS;
    int slice_type, temp, i;
    int num_bits;

    num_bits = (stream->write_pos << 3) - stream->bit_left;

    status = ue_v(stream, sliceHdr->first_mb_in_slice);

    slice_type = video->slice_type;

    if (video->mbNum == 0) /* first mb in frame */
    {
        status = ue_v(stream, sliceHdr->slice_type);
    }
    else
    {
        status = ue_v(stream, slice_type);
    }

    status = ue_v(stream, sliceHdr->pic_parameter_set_id);

    status = BitstreamWriteBits(stream, currSPS->log2_max_frame_num_minus4 + 4, sliceHdr->frame_num);

    if (status != AVCENC_SUCCESS)
    {
        return status;
    }
    /* if frame_mbs_only_flag is 0, encode field_pic_flag, bottom_field_flag here */

    if (video->nal_unit_type == AVC_NALTYPE_IDR)
    {
        status = ue_v(stream, sliceHdr->idr_pic_id);
    }

    if (currSPS->pic_order_cnt_type == 0)
    {
        status = BitstreamWriteBits(stream, currSPS->log2_max_pic_order_cnt_lsb_minus4 + 4,
                                    sliceHdr->pic_order_cnt_lsb);

        if (currPPS->pic_order_present_flag && !sliceHdr->field_pic_flag)
        {
            status = se_v(stream, sliceHdr->delta_pic_order_cnt_bottom); /* 32 bits */
        }
    }
    if (currSPS->pic_order_cnt_type == 1 && !currSPS->delta_pic_order_always_zero_flag)
    {
        status = se_v(stream, sliceHdr->delta_pic_order_cnt[0]);    /* 32 bits */
        if (currPPS->pic_order_present_flag && !sliceHdr->field_pic_flag)
        {
            status = se_v(stream, sliceHdr->delta_pic_order_cnt[1]); /* 32 bits */
        }
    }

    if (currPPS->redundant_pic_cnt_present_flag)
    {
        status = ue_v(stream, sliceHdr->redundant_pic_cnt);
    }

    if (slice_type == AVC_B_SLICE)
    {
        status = BitstreamWrite1Bit(stream, sliceHdr->direct_spatial_mv_pred_flag);
    }

    if (status != AVCENC_SUCCESS)
    {
        return status;
    }

    if (slice_type == AVC_P_SLICE || slice_type == AVC_SP_SLICE || slice_type == AVC_B_SLICE)
    {
        status = BitstreamWrite1Bit(stream, sliceHdr->num_ref_idx_active_override_flag);
        if (sliceHdr->num_ref_idx_active_override_flag)
        {
            /* we shouldn't enter this part at all */
            status = ue_v(stream, sliceHdr->num_ref_idx_l0_active_minus1);
            if (slice_type == AVC_B_SLICE)
            {
                status = ue_v(stream, sliceHdr->num_ref_idx_l1_active_minus1);
            }
        }
    }
    if (status != AVCENC_SUCCESS)
    {
        return status;
    }

    /* ref_pic_list_reordering() */
    status = ref_pic_list_reordering(video, stream, sliceHdr, slice_type);
    if (status != AVCENC_SUCCESS)
    {
        return status;
    }

    if ((currPPS->weighted_pred_flag && (slice_type == AVC_P_SLICE || slice_type == AVC_SP_SLICE)) ||
            (currPPS->weighted_bipred_idc == 1 && slice_type == AVC_B_SLICE))
    {
        //      pred_weight_table(); // not supported !!
        return AVCENC_PRED_WEIGHT_TAB_FAIL;
    }

    if (video->nal_ref_idc != 0)
    {
        status = dec_ref_pic_marking(video, stream, sliceHdr);
        if (status != AVCENC_SUCCESS)
        {
            return status;
        }
    }

    if (currPPS->entropy_coding_mode_flag && slice_type != AVC_I_SLICE && slice_type != AVC_SI_SLICE)
    {
        return AVCENC_CABAC_FAIL;
        /*      ue_v(stream,&(sliceHdr->cabac_init_idc));
                if(sliceHdr->cabac_init_idc > 2){
                    // not supported !!!!
                }*/
    }

    status = se_v(stream, sliceHdr->slice_qp_delta);
    if (status != AVCENC_SUCCESS)
    {
        return status;
    }

    if (slice_type == AVC_SP_SLICE || slice_type == AVC_SI_SLICE)
    {
        if (slice_type == AVC_SP_SLICE)
        {
            status = BitstreamWrite1Bit(stream, sliceHdr->sp_for_switch_flag);
            /* if sp_for_switch_flag is 0, P macroblocks in SP slice is decoded using
            SP decoding process for non-switching pictures in 8.6.1 */
            /* else, P macroblocks in SP slice is decoded using SP and SI decoding
            process for switching picture in 8.6.2 */
        }
        status = se_v(stream, sliceHdr->slice_qs_delta);
        if (status != AVCENC_SUCCESS)
        {
            return status;
        }
    }

    if (currPPS->deblocking_filter_control_present_flag)
    {

        status = ue_v(stream, sliceHdr->disable_deblocking_filter_idc);

        if (sliceHdr->disable_deblocking_filter_idc != 1)
        {
            status = se_v(stream, sliceHdr->slice_alpha_c0_offset_div2);

            status = se_v(stream, sliceHdr->slice_beta_offset_div_2);
        }
        if (status != AVCENC_SUCCESS)
        {
            return status;
        }
    }

    if (currPPS->num_slice_groups_minus1 > 0 && currPPS->slice_group_map_type >= 3
            && currPPS->slice_group_map_type <= 5)
    {
        /* Ceil(Log2(PicSizeInMapUnits/(float)SliceGroupChangeRate + 1)) */
        temp = video->PicSizeInMapUnits / video->SliceGroupChangeRate;
        if (video->PicSizeInMapUnits % video->SliceGroupChangeRate)
        {
            temp++;
        }
        i = 0;
        while (temp > 1)
        {
            temp >>= 1;
            i++;
        }

        BitstreamWriteBits(stream, i, sliceHdr->slice_group_change_cycle);
    }


    encvid->rateCtrl->NumberofHeaderBits += (stream->write_pos << 3) - stream->bit_left - num_bits;

    return AVCENC_SUCCESS;
}

/** see subclause 7.4.3.1 */
AVCEnc_Status ref_pic_list_reordering(AVCCommonObj *video, AVCEncBitstream *stream, AVCSliceHeader *sliceHdr, int slice_type)
{
    (void)(video);
    int i;
    AVCEnc_Status status = AVCENC_SUCCESS;

    if (slice_type != AVC_I_SLICE && slice_type != AVC_SI_SLICE)
    {
        status = BitstreamWrite1Bit(stream, sliceHdr->ref_pic_list_reordering_flag_l0);
        if (sliceHdr->ref_pic_list_reordering_flag_l0)
        {
            i = 0;
            do
            {
                status = ue_v(stream, sliceHdr->reordering_of_pic_nums_idc_l0[i]);
                if (sliceHdr->reordering_of_pic_nums_idc_l0[i] == 0 ||
                        sliceHdr->reordering_of_pic_nums_idc_l0[i] == 1)
                {
                    status = ue_v(stream, sliceHdr->abs_diff_pic_num_minus1_l0[i]);
                    /* this check should be in InitSlice(), if we ever use it */
                    /*if(sliceHdr->reordering_of_pic_nums_idc_l0[i] == 0 &&
                        sliceHdr->abs_diff_pic_num_minus1_l0[i] > video->MaxPicNum/2 -1)
                    {
                        return AVCENC_REF_PIC_REORDER_FAIL; // out of range
                    }
                    if(sliceHdr->reordering_of_pic_nums_idc_l0[i] == 1 &&
                        sliceHdr->abs_diff_pic_num_minus1_l0[i] > video->MaxPicNum/2 -2)
                    {
                        return AVCENC_REF_PIC_REORDER_FAIL; // out of range
                    }*/
                }
                else if (sliceHdr->reordering_of_pic_nums_idc_l0[i] == 2)
                {
                    status = ue_v(stream, sliceHdr->long_term_pic_num_l0[i]);
                }
                i++;
            }
            while (sliceHdr->reordering_of_pic_nums_idc_l0[i] != 3
                    && i <= (int)sliceHdr->num_ref_idx_l0_active_minus1 + 1) ;
        }
    }
    if (slice_type == AVC_B_SLICE)
    {
        status = BitstreamWrite1Bit(stream, sliceHdr->ref_pic_list_reordering_flag_l1);
        if (sliceHdr->ref_pic_list_reordering_flag_l1)
        {
            i = 0;
            do
            {
                status = ue_v(stream, sliceHdr->reordering_of_pic_nums_idc_l1[i]);
                if (sliceHdr->reordering_of_pic_nums_idc_l1[i] == 0 ||
                        sliceHdr->reordering_of_pic_nums_idc_l1[i] == 1)
                {
                    status = ue_v(stream, sliceHdr->abs_diff_pic_num_minus1_l1[i]);
                    /* This check should be in InitSlice() if we ever use it
                    if(sliceHdr->reordering_of_pic_nums_idc_l1[i] == 0 &&
                        sliceHdr->abs_diff_pic_num_minus1_l1[i] > video->MaxPicNum/2 -1)
                    {
                        return AVCENC_REF_PIC_REORDER_FAIL; // out of range
                    }
                    if(sliceHdr->reordering_of_pic_nums_idc_l1[i] == 1 &&
                        sliceHdr->abs_diff_pic_num_minus1_l1[i] > video->MaxPicNum/2 -2)
                    {
                        return AVCENC_REF_PIC_REORDER_FAIL; // out of range
                    }*/
                }
                else if (sliceHdr->reordering_of_pic_nums_idc_l1[i] == 2)
                {
                    status = ue_v(stream, sliceHdr->long_term_pic_num_l1[i]);
                }
                i++;
            }
            while (sliceHdr->reordering_of_pic_nums_idc_l1[i] != 3
                    && i <= (int)sliceHdr->num_ref_idx_l1_active_minus1 + 1) ;
        }
    }

    return status;
}

/** see subclause 7.4.3.3 */
AVCEnc_Status dec_ref_pic_marking(AVCCommonObj *video, AVCEncBitstream *stream, AVCSliceHeader *sliceHdr)
{
    int i;
    AVCEnc_Status status = AVCENC_SUCCESS;

    if (video->nal_unit_type == AVC_NALTYPE_IDR)
    {
        status = BitstreamWrite1Bit(stream, sliceHdr->no_output_of_prior_pics_flag);
        status = BitstreamWrite1Bit(stream, sliceHdr->long_term_reference_flag);
        if (sliceHdr->long_term_reference_flag == 0) /* used for short-term */
        {
            video->MaxLongTermFrameIdx = -1; /* no long-term frame indx */
        }
        else /* used for long-term */
        {
            video->MaxLongTermFrameIdx = 0;
            video->LongTermFrameIdx = 0;
        }
    }
    else
    {
        status = BitstreamWrite1Bit(stream, sliceHdr->adaptive_ref_pic_marking_mode_flag); /* default to zero */
        if (sliceHdr->adaptive_ref_pic_marking_mode_flag)
        {
            i = 0;
            do
            {
                status = ue_v(stream, sliceHdr->memory_management_control_operation[i]);
                if (sliceHdr->memory_management_control_operation[i] == 1 ||
                        sliceHdr->memory_management_control_operation[i] == 3)
                {
                    status = ue_v(stream, sliceHdr->difference_of_pic_nums_minus1[i]);
                }
                if (sliceHdr->memory_management_control_operation[i] == 2)
                {
                    status = ue_v(stream, sliceHdr->long_term_pic_num[i]);
                }
                if (sliceHdr->memory_management_control_operation[i] == 3 ||
                        sliceHdr->memory_management_control_operation[i] == 6)
                {
                    status = ue_v(stream, sliceHdr->long_term_frame_idx[i]);
                }
                if (sliceHdr->memory_management_control_operation[i] == 4)
                {
                    status = ue_v(stream, sliceHdr->max_long_term_frame_idx_plus1[i]);
                }
                i++;
            }
            while (sliceHdr->memory_management_control_operation[i] != 0 && i < MAX_DEC_REF_PIC_MARKING);
            if (i >= MAX_DEC_REF_PIC_MARKING && sliceHdr->memory_management_control_operation[i] != 0)
            {
                return AVCENC_DEC_REF_PIC_MARK_FAIL; /* we're screwed!!, not enough memory */
            }
        }
    }

    return status;
}

/* see subclause 8.2.1 Decoding process for picture order count.
See also PostPOC() for initialization of some variables. */
AVCEnc_Status InitPOC(AVCEncObject *encvid)
{
    AVCCommonObj *video = encvid->common;
    AVCSeqParamSet *currSPS = video->currSeqParams;
    AVCSliceHeader *sliceHdr = video->sliceHdr;
    AVCFrameIO  *currInput = encvid->currInput;
    int i;

    switch (currSPS->pic_order_cnt_type)
    {
        case 0: /* POC MODE 0 , subclause 8.2.1.1 */
            /* encoding part */
            if (video->nal_unit_type == AVC_NALTYPE_IDR)
            {
                encvid->dispOrdPOCRef = currInput->disp_order;
            }
            while (currInput->disp_order < encvid->dispOrdPOCRef)
            {
                encvid->dispOrdPOCRef -= video->MaxPicOrderCntLsb;
            }
            sliceHdr->pic_order_cnt_lsb = currInput->disp_order - encvid->dispOrdPOCRef;
            while (sliceHdr->pic_order_cnt_lsb >= video->MaxPicOrderCntLsb)
            {
                sliceHdr->pic_order_cnt_lsb -= video->MaxPicOrderCntLsb;
            }
            /* decoding part */
            /* Calculate the MSBs of current picture */
            if (video->nal_unit_type == AVC_NALTYPE_IDR)
            {
                video->prevPicOrderCntMsb = 0;
                video->prevPicOrderCntLsb = 0;
            }
            if (sliceHdr->pic_order_cnt_lsb  <  video->prevPicOrderCntLsb  &&
                    (video->prevPicOrderCntLsb - sliceHdr->pic_order_cnt_lsb)  >= (video->MaxPicOrderCntLsb / 2))
                video->PicOrderCntMsb = video->prevPicOrderCntMsb + video->MaxPicOrderCntLsb;
            else if (sliceHdr->pic_order_cnt_lsb  >  video->prevPicOrderCntLsb  &&
                     (sliceHdr->pic_order_cnt_lsb - video->prevPicOrderCntLsb)  > (video->MaxPicOrderCntLsb / 2))
                video->PicOrderCntMsb = video->prevPicOrderCntMsb - video->MaxPicOrderCntLsb;
            else
                video->PicOrderCntMsb = video->prevPicOrderCntMsb;

            /* JVT-I010 page 81 is different from JM7.3 */
            if (!sliceHdr->field_pic_flag || !sliceHdr->bottom_field_flag)
            {
                video->PicOrderCnt = video->TopFieldOrderCnt = video->PicOrderCntMsb + sliceHdr->pic_order_cnt_lsb;
            }

            if (!sliceHdr->field_pic_flag)
            {
                video->BottomFieldOrderCnt = video->TopFieldOrderCnt + sliceHdr->delta_pic_order_cnt_bottom;
            }
            else if (sliceHdr->bottom_field_flag)
            {
                video->PicOrderCnt = video->BottomFieldOrderCnt = video->PicOrderCntMsb + sliceHdr->pic_order_cnt_lsb;
            }

            if (!sliceHdr->field_pic_flag)
            {
                video->PicOrderCnt = AVC_MIN(video->TopFieldOrderCnt, video->BottomFieldOrderCnt);
            }

            if (video->currPicParams->pic_order_present_flag && !sliceHdr->field_pic_flag)
            {
                sliceHdr->delta_pic_order_cnt_bottom = 0; /* defaulted to zero */
            }

            break;
        case 1: /* POC MODE 1, subclause 8.2.1.2 */
            /* calculate FrameNumOffset */
            if (video->nal_unit_type == AVC_NALTYPE_IDR)
            {
                encvid->dispOrdPOCRef = currInput->disp_order;  /* reset the reference point */
                video->prevFrameNumOffset = 0;
                video->FrameNumOffset = 0;
            }
            else if (video->prevFrameNum > sliceHdr->frame_num)
            {
                video->FrameNumOffset = video->prevFrameNumOffset + video->MaxFrameNum;
            }
            else
            {
                video->FrameNumOffset = video->prevFrameNumOffset;
            }
            /* calculate absFrameNum */
            if (currSPS->num_ref_frames_in_pic_order_cnt_cycle)
            {
                video->absFrameNum = video->FrameNumOffset + sliceHdr->frame_num;
            }
            else
            {
                video->absFrameNum = 0;
            }

            if (video->absFrameNum > 0 && video->nal_ref_idc == 0)
            {
                video->absFrameNum--;
            }

            /* derive picOrderCntCycleCnt and frameNumInPicOrderCntCycle */
            if (video->absFrameNum > 0)
            {
                video->picOrderCntCycleCnt = (video->absFrameNum - 1) / currSPS->num_ref_frames_in_pic_order_cnt_cycle;
                video->frameNumInPicOrderCntCycle = (video->absFrameNum - 1) % currSPS->num_ref_frames_in_pic_order_cnt_cycle;
            }
            /* derive expectedDeltaPerPicOrderCntCycle, this value can be computed up front. */
            video->expectedDeltaPerPicOrderCntCycle = 0;
            for (i = 0; i < (int)currSPS->num_ref_frames_in_pic_order_cnt_cycle; i++)
            {
                video->expectedDeltaPerPicOrderCntCycle += currSPS->offset_for_ref_frame[i];
            }
            /* derive expectedPicOrderCnt */
            if (video->absFrameNum)
            {
                video->expectedPicOrderCnt = video->picOrderCntCycleCnt * video->expectedDeltaPerPicOrderCntCycle;
                for (i = 0; i <= video->frameNumInPicOrderCntCycle; i++)
                {
                    video->expectedPicOrderCnt += currSPS->offset_for_ref_frame[i];
                }
            }
            else
            {
                video->expectedPicOrderCnt = 0;
            }

            if (video->nal_ref_idc == 0)
            {
                video->expectedPicOrderCnt += currSPS->offset_for_non_ref_pic;
            }
            /* derive TopFieldOrderCnt and BottomFieldOrderCnt */
            /* encoding part */
            if (!currSPS->delta_pic_order_always_zero_flag)
            {
                sliceHdr->delta_pic_order_cnt[0] = currInput->disp_order - encvid->dispOrdPOCRef - video->expectedPicOrderCnt;

                if (video->currPicParams->pic_order_present_flag && !sliceHdr->field_pic_flag)
                {
                    sliceHdr->delta_pic_order_cnt[1] = sliceHdr->delta_pic_order_cnt[0]; /* should be calculated from currInput->bottom_field->disp_order */
                }
                else
                {
                    sliceHdr->delta_pic_order_cnt[1] = 0;
                }
            }
            else
            {
                sliceHdr->delta_pic_order_cnt[0] = sliceHdr->delta_pic_order_cnt[1] = 0;
            }

            if (sliceHdr->field_pic_flag == 0)
            {
                video->TopFieldOrderCnt = video->expectedPicOrderCnt + sliceHdr->delta_pic_order_cnt[0];
                video->BottomFieldOrderCnt = video->TopFieldOrderCnt + currSPS->offset_for_top_to_bottom_field + sliceHdr->delta_pic_order_cnt[1];

                video->PicOrderCnt = AVC_MIN(video->TopFieldOrderCnt, video->BottomFieldOrderCnt);
            }
            else if (sliceHdr->bottom_field_flag == 0)
            {
                video->TopFieldOrderCnt = video->expectedPicOrderCnt + sliceHdr->delta_pic_order_cnt[0];
                video->PicOrderCnt = video->TopFieldOrderCnt;
            }
            else
            {
                video->BottomFieldOrderCnt = video->expectedPicOrderCnt + currSPS->offset_for_top_to_bottom_field + sliceHdr->delta_pic_order_cnt[0];
                video->PicOrderCnt = video->BottomFieldOrderCnt;
            }
            break;


        case 2: /* POC MODE 2, subclause 8.2.1.3 */
            /* decoding order must be the same as display order */
            /* we don't check for that. The decoder will just output in decoding order. */
            /* Check for 2 consecutive non-reference frame */
            if (video->nal_ref_idc == 0)
            {
                if (encvid->dispOrdPOCRef == 1)
                {
                    return AVCENC_CONSECUTIVE_NONREF;
                }
                encvid->dispOrdPOCRef = 1;  /* act as a flag for non ref */
            }
            else
            {
                encvid->dispOrdPOCRef = 0;
            }


            if (video->nal_unit_type == AVC_NALTYPE_IDR)
            {
                video->FrameNumOffset = 0;
            }
            else if (video->prevFrameNum > sliceHdr->frame_num)
            {
                video->FrameNumOffset = video->prevFrameNumOffset + video->MaxFrameNum;
            }
            else
            {
                video->FrameNumOffset = video->prevFrameNumOffset;
            }
            /* derive tempPicOrderCnt, we just use PicOrderCnt */
            if (video->nal_unit_type == AVC_NALTYPE_IDR)
            {
                video->PicOrderCnt = 0;
            }
            else if (video->nal_ref_idc == 0)
            {
                video->PicOrderCnt = 2 * (video->FrameNumOffset + sliceHdr->frame_num) - 1;
            }
            else
            {
                video->PicOrderCnt = 2 * (video->FrameNumOffset + sliceHdr->frame_num);
            }
            /* derive TopFieldOrderCnt and BottomFieldOrderCnt */
            if (sliceHdr->field_pic_flag == 0)
            {
                video->TopFieldOrderCnt = video->BottomFieldOrderCnt = video->PicOrderCnt;
            }
            else if (sliceHdr->bottom_field_flag)
            {
                video->BottomFieldOrderCnt = video->PicOrderCnt;
            }
            else
            {
                video->TopFieldOrderCnt = video->PicOrderCnt;
            }
            break;
        default:
            return AVCENC_POC_FAIL;
    }

    return AVCENC_SUCCESS;
}

/** see subclause 8.2.1 */
AVCEnc_Status PostPOC(AVCCommonObj *video)
{
    AVCSliceHeader *sliceHdr = video->sliceHdr;
    AVCSeqParamSet *currSPS = video->currSeqParams;

    video->prevFrameNum = sliceHdr->frame_num;

    switch (currSPS->pic_order_cnt_type)
    {
        case 0: /* subclause 8.2.1.1 */
            if (video->mem_mgr_ctrl_eq_5)
            {
                video->prevPicOrderCntMsb = 0;
                video->prevPicOrderCntLsb = video->TopFieldOrderCnt;
            }
            else
            {
                video->prevPicOrderCntMsb = video->PicOrderCntMsb;
                video->prevPicOrderCntLsb = sliceHdr->pic_order_cnt_lsb;
            }
            break;
        case 1:  /* subclause 8.2.1.2 and 8.2.1.3 */
        case 2:
            if (video->mem_mgr_ctrl_eq_5)
            {
                video->prevFrameNumOffset = 0;
            }
            else
            {
                video->prevFrameNumOffset = video->FrameNumOffset;
            }
            break;
    }

    return AVCENC_SUCCESS;
}