/*
 * Copyright 2015 Rockchip Electronics Co. LTD
 *
 * 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.
 */

#define MODULE_TAG "h265e_slice"

#include <string.h>

#include "mpp_debug.h"
#include "h265e_codec.h"
#include "h265e_slice.h"

H265eDpbFrm* get_ref_pic(H265eDpbFrm *frame_list, RK_S32 poc)
{
    RK_S32 index = 0;
    H265eDpbFrm *frame = NULL;

    h265e_dbg_func("enter\n");
    for (index = 0; index < MAX_REFS; index++) {
        frame = &frame_list[index];
        if (frame->inited && frame->poc == poc) {
            break;
        }
    }
    h265e_dbg_func("leave\n");
    return frame;
}

H265eDpbFrm* get_lt_ref_pic(H265eDpbFrm *frame_list, H265eSlice *slice, RK_S32 poc, RK_U32 pocHasMsb)
{
    RK_S32 index = 0;
    H265eDpbFrm *frame = NULL;
    H265eDpbFrm* stPic = &frame_list[MAX_REFS - 1];
    RK_S32 pocCycle = 1 << slice->m_sps->m_bitsForPOC;

    h265e_dbg_func("enter\n");
    if (!pocHasMsb) {
        poc = poc % pocCycle;
    }

    for (index = MAX_REFS - 1 ; index >= 0; index--) {
        frame = &frame_list[index];
        if (frame->on_used && frame->poc != slice->poc && frame->slice->is_referenced) {
            RK_S32 picPoc = frame->poc;
            if (!pocHasMsb) {
                picPoc = picPoc % pocCycle;
            }

            if (poc == picPoc) {
                if (frame->is_long_term) {
                    return frame;
                } else {
                    stPic = frame;
                }
            }
        }

    }
    h265e_dbg_func("leave\n");
    return stPic;
}

void h265e_slice_set_ref_list(H265eDpbFrm *frame_list, H265eSlice *slice)
{
    H265eReferencePictureSet *rps = slice->m_rps;
    H265eDpbFrm* refPic = NULL;
    H265eDpbFrm* refPicSetStCurr0[MAX_REFS];
    H265eDpbFrm* refPicSetStCurr1[MAX_REFS];
    H265eDpbFrm* refPicSetLtCurr[MAX_REFS];
    RK_S32 numPocStCurr0 = 0;
    RK_S32 numPocStCurr1 = 0;
    RK_S32 numPocLtCurr = 0;
    RK_S32 i, cIdx = 0, rIdx = 0;

    h265e_dbg_func("enter\n");
    if (slice->m_sliceType == I_SLICE) {
        memset(slice->m_refPicList, 0, sizeof(slice->m_refPicList));
        memset(slice->m_numRefIdx,  0, sizeof(slice->m_numRefIdx));
        return;
    }
    for (i = 0; i < rps->num_negative_pic; i++) {
        if (rps->m_used[i]) {
            refPic = get_ref_pic(frame_list, slice->poc + rps->delta_poc[i]);
            refPic->is_long_term = 0;
            refPicSetStCurr0[numPocStCurr0] = refPic;
            numPocStCurr0++;
            refPic->check_lt_msb = 0;
        }
    }

    for (; i < rps->num_negative_pic + rps->num_positive_pic; i++) {
        if (rps->m_used[i]) {
            refPic = get_ref_pic(frame_list,  slice->poc + rps->delta_poc[i]);
            refPic->is_long_term = 0;
            refPicSetStCurr1[numPocStCurr1] = refPic;
            numPocStCurr1++;
            refPic->check_lt_msb = 0;
        }
    }

    for (i = rps->num_negative_pic + rps->num_positive_pic + rps->num_long_term_pic - 1;
         i > rps->num_negative_pic + rps->num_positive_pic - 1; i--) {
        if (rps->m_used[i]) {
            refPic = get_lt_ref_pic(frame_list, slice, rps->m_RealPoc[i], rps->check_lt_msb[i]);
            refPic->is_long_term = 1;
            /*due to only one ref if num_negative_pic > 0 set lt not used*/
            /* if (rps->num_negative_pic > 0) {
                 rps->m_used[i] = 0;
             }*/
            refPicSetLtCurr[numPocLtCurr] = refPic;
            numPocLtCurr++;
        }
        if (refPic == NULL) {
            refPic = get_lt_ref_pic(frame_list, slice, rps->m_RealPoc[i], rps->check_lt_msb[i]);
        }
        refPic->check_lt_msb = rps->check_lt_msb[i];
    }

    // ref_pic_list_init
    H265eDpbFrm* rpsCurrList0[MAX_REFS + 1];
    H265eDpbFrm* rpsCurrList1[MAX_REFS + 1];
    RK_S32 numPocTotalCurr = numPocStCurr0 + numPocStCurr1 + numPocLtCurr;

    for (i = 0; i < numPocStCurr0; i++, cIdx++) {
        rpsCurrList0[cIdx] = refPicSetStCurr0[i];
    }

    for (i = 0; i < numPocStCurr1; i++, cIdx++) {
        rpsCurrList0[cIdx] = refPicSetStCurr1[i];
    }

    for (i = 0; i < numPocLtCurr; i++, cIdx++) {
        rpsCurrList0[cIdx] = refPicSetLtCurr[i];
    }

    mpp_assert(cIdx == numPocTotalCurr);

    if (slice->m_sliceType == B_SLICE) {
        cIdx = 0;
        for (i = 0; i < numPocStCurr1; i++, cIdx++) {
            rpsCurrList1[cIdx] = refPicSetStCurr1[i];
        }

        for (i = 0; i < numPocStCurr0; i++, cIdx++) {
            rpsCurrList1[cIdx] = refPicSetStCurr0[i];
        }

        for (i = 0; i < numPocLtCurr; i++, cIdx++) {
            rpsCurrList1[cIdx] = refPicSetLtCurr[i];
        }

        mpp_assert(cIdx == numPocTotalCurr);
    }

    memset(slice->m_bIsUsedAsLongTerm, 0, sizeof(slice->m_bIsUsedAsLongTerm));

    for ( rIdx = 0; rIdx < slice->m_numRefIdx[0]; rIdx++) {
        cIdx = slice->m_RefPicListModification.m_refPicListModificationFlagL0 ? slice->m_RefPicListModification.m_RefPicSetIdxL0[rIdx] : (RK_U32)rIdx % numPocTotalCurr;
        mpp_assert(cIdx >= 0 && cIdx < numPocTotalCurr);
        slice->m_refPicList[0][rIdx] = rpsCurrList0[cIdx];
        slice->m_bIsUsedAsLongTerm[0][rIdx] = (cIdx >= numPocStCurr0 + numPocStCurr1);
    }

    if (slice->m_sliceType != B_SLICE) {
        slice->m_numRefIdx[1] = 0;
        memset(slice->m_refPicList[1], 0, sizeof(slice->m_refPicList[1]));
    } else {
        for (rIdx = 0; rIdx < slice->m_numRefIdx[1]; rIdx++) {
            cIdx = slice->m_RefPicListModification.m_refPicListModificationFlagL1 ? slice->m_RefPicListModification.m_RefPicSetIdxL1[rIdx] : (RK_U32)rIdx % numPocTotalCurr;
            mpp_assert(cIdx >= 0 && cIdx < numPocTotalCurr);
            slice->m_refPicList[1][rIdx] = rpsCurrList1[cIdx];
            slice->m_bIsUsedAsLongTerm[1][rIdx] = (cIdx >= numPocStCurr0 + numPocStCurr1);
        }
    }

    h265e_dbg_func("leave\n");
}

void h265e_slice_set_ref_poc_list(H265eSlice *slice)
{
    RK_S32 dir, numRefIdx;

    h265e_dbg_func("enter\n");

    for (dir = 0; dir < 2; dir++) {
        for (numRefIdx = 0; numRefIdx < slice->m_numRefIdx[dir]; numRefIdx++) {
            slice->m_refPOCList[dir][numRefIdx] = slice->m_refPicList[dir][numRefIdx]->poc;
        }
    }

    h265e_dbg_func("leave\n");
}

void h265e_slice_init(void *ctx, EncFrmStatus curr)
{
    H265eCtx *p = (H265eCtx *)ctx;
    H265eVps *vps = &p->vps;
    H265eSps *sps = &p->sps;
    H265ePps *pps = &p->pps;
    MppEncCfgSet *cfg = p->cfg;
    MppEncH265Cfg *codec = &cfg->codec.h265;
    H265eSlice *slice = p->dpb->curr->slice;
    p->slice = p->dpb->curr->slice;
    h265e_dbg_func("enter\n");
    memset(slice, 0, sizeof(H265eSlice));
    slice->m_sps = sps;
    slice->m_vps = vps;
    slice->m_pps = pps;
    slice->m_numRefIdx[0] = 0;
    slice->m_numRefIdx[1] = 0;
    slice->m_colFromL0Flag = 1;
    slice->m_colRefIdx = 0;
    slice->m_bCheckLDC = 0;
    slice->m_sliceQpDeltaCb = 0;
    slice->m_sliceQpDeltaCr = 0;
    slice->m_maxNumMergeCand = 5;
    slice->m_bFinalized = 0;

    slice->m_cabacInitFlag = 0;
    slice->m_numEntryPointOffsets = 0;
    slice->m_enableTMVPFlag = sps->m_TMVPFlagsPresent;
    slice->m_picOutputFlag = 1;
    p->dpb->curr->is_key_frame = 0;
    if (curr.is_idr) {
        slice->m_sliceType = I_SLICE;
        p->dpb->curr->is_key_frame = 1;
        p->dpb->curr->status.is_intra = 1;
        p->dpb->gop_idx = 0;
    } else {
        slice->m_sliceType = P_SLICE;
        p->dpb->curr->status.is_intra = 0;
    }

    p->dpb->curr->status.val = curr.val;

    if (slice->m_sliceType  != B_SLICE && !curr.non_recn)
        slice->is_referenced = 1;

    if (slice->m_pps->m_deblockingFilterOverrideEnabledFlag) {
        h265e_dbg_slice("to do in this case");
    } else {
        slice->m_deblockingFilterDisable = pps->m_picDisableDeblockingFilterFlag;
        slice->m_deblockingFilterBetaOffsetDiv2 = pps->m_deblockingFilterBetaOffsetDiv2;
        slice->m_deblockingFilterTcOffsetDiv2 = pps->m_deblockingFilterTcOffsetDiv2;
    }
    slice->m_saoEnabledFlag = !codec->sao_cfg.slice_sao_luma_disable;
    slice->m_saoEnabledFlagChroma = !codec->sao_cfg.slice_sao_chroma_disable;
    slice->m_maxNumMergeCand = codec->merge_cfg.max_mrg_cnd;
    slice->m_cabacInitFlag = codec->entropy_cfg.cabac_init_flag;
    slice->m_picOutputFlag = 1;
    slice->m_ppsId = pps->m_PPSId;
    if (slice->m_pps->m_bSliceChromaQpFlag) {
        slice->m_sliceQpDeltaCb = codec->trans_cfg.cb_qp_offset;
        slice->m_sliceQpDeltaCr = codec->trans_cfg.cr_qp_offset;
    }

    slice->poc = p->dpb->curr->seq_idx;
    slice->gop_idx = p->dpb->gop_idx;
    p->dpb->curr->gop_idx =  p->dpb->gop_idx++;
    p->dpb->curr->poc = slice->poc;
    if (curr.is_lt_ref)
        p->dpb->curr->is_long_term = 1;

    h265e_dbg_slice("slice->m_sliceType = %d slice->is_referenced = %d \n",
                    slice->m_sliceType, slice->is_referenced);
    h265e_dbg_func("leave\n");
}

void code_st_refpic_set(MppWriteCtx *bitIf, H265eReferencePictureSet* rps, RK_S32 idx)
{
    if (idx > 0) {
        mpp_writer_put_bits(bitIf, rps->m_interRPSPrediction, 1); // inter_RPS_prediction_flag
    }
    if (rps->m_interRPSPrediction) {
        RK_S32 deltaRPS = rps->m_deltaRPS;
        RK_S32 j;

        mpp_writer_put_ue(bitIf, rps->m_deltaRIdxMinus1); // delta index of the Reference Picture Set used for prediction minus 1

        mpp_writer_put_bits(bitIf, (deltaRPS >= 0 ? 0 : 1), 1); //delta_rps_sign
        mpp_writer_put_ue(bitIf, abs(deltaRPS) - 1); // absolute delta RPS minus 1

        for (j = 0; j < rps->m_numRefIdc; j++) {
            RK_S32 refIdc = rps->m_refIdc[j];
            mpp_writer_put_bits(bitIf, (refIdc == 1 ? 1 : 0), 1); //first bit is "1" if Idc is 1
            if (refIdc != 1) {
                mpp_writer_put_bits(bitIf, refIdc >> 1, 1); //second bit is "1" if Idc is 2, "0" otherwise.
            }
        }
    } else {
        mpp_writer_put_ue(bitIf, rps->num_negative_pic);
        mpp_writer_put_ue(bitIf, rps->num_positive_pic);
        RK_S32 prev = 0;
        RK_S32 j;

        for (j = 0; j < rps->num_negative_pic; j++) {
            mpp_writer_put_ue(bitIf, prev - rps->delta_poc[j] - 1);
            prev = rps->delta_poc[j];
            mpp_writer_put_bits(bitIf, rps->m_used[j], 1);
        }

        prev = 0;
        for (j = rps->num_negative_pic; j < rps->num_negative_pic + rps->num_positive_pic; j++) {
            mpp_writer_put_ue(bitIf, rps->delta_poc[j] - prev - 1);
            prev = rps->delta_poc[j];
            mpp_writer_put_bits(bitIf, rps->m_used[j], 1);
        }
    }
}

RK_U8 find_matching_ltrp(H265eSlice* slice, RK_U32 *ltrpsIndex, RK_S32 ltrpPOC, RK_U32 usedFlag)
{
    RK_U32 lsb = ltrpPOC % (1 << slice->m_sps->m_bitsForPOC);
    RK_U32 k;
    for (k = 0; k < slice->m_sps->m_numLongTermRefPicSPS; k++) {
        if ((lsb == slice->m_sps->m_ltRefPicPocLsbSps[k]) && (usedFlag == slice->m_sps->m_usedByCurrPicLtSPSFlag[k])) {
            *ltrpsIndex = k;
            return 1;
        }
    }

    return 0;
}

RK_S32 get_num_rps_cur_templist(H265eReferencePictureSet* rps)
{
    RK_S32 numRpsCurrTempList = 0;
    RK_S32 i;
    for ( i = 0; i < rps->num_negative_pic + rps->num_positive_pic + rps->num_long_term_pic; i++) {
        if (rps->m_used[i]) {
            numRpsCurrTempList++;
        }
    }

    return numRpsCurrTempList;
}


void h265e_code_slice_header(H265eSlice *slice, MppWriteCtx *bitIf)
{
    RK_U32 i = 0;
    mpp_writer_put_bits(bitIf, 1, 1); //first_slice_segment_in_pic_flag
    mpp_writer_put_ue(bitIf, slice->m_ppsId);
    H265eReferencePictureSet* rps = slice->m_rps;
    slice->m_enableTMVPFlag = 0;
    if (!slice->m_dependentSliceSegmentFlag) {
        for (i = 0; i < (RK_U32)slice->m_pps->m_numExtraSliceHeaderBits; i++) {
            mpp_writer_put_bits(bitIf, (slice->slice_reserved_flag >> i) & 0x1, 1);
        }

        mpp_writer_put_ue(bitIf, slice->m_sliceType);

        if (slice->m_pps->m_outputFlagPresentFlag) {
            mpp_writer_put_bits(bitIf, slice->m_picOutputFlag ? 1 : 0, 1);
        }

        if (slice->m_sliceType != I_SLICE) { // skip frame can't iDR
            RK_S32 picOrderCntLSB = (slice->poc - slice->last_idr + (1 << slice->m_sps->m_bitsForPOC)) % (1 << slice->m_sps->m_bitsForPOC);
            mpp_writer_put_bits(bitIf, picOrderCntLSB, slice->m_sps->m_bitsForPOC);
            if (slice->m_bdIdx < 0) {
                mpp_writer_put_bits(bitIf, 0, 1);
                code_st_refpic_set(bitIf, rps, slice->m_sps->m_RPSList.m_numberOfReferencePictureSets);
            } else {
                mpp_writer_put_bits(bitIf, 1, 1);
                RK_S32 numBits = 0;
                while ((1 << numBits) < slice->m_sps->m_RPSList.m_numberOfReferencePictureSets) {
                    numBits++;
                }

                if (numBits > 0) {
                    mpp_writer_put_bits(bitIf, slice->m_bdIdx, numBits);
                }
            }
            if (slice->m_sps->m_bLongTermRefsPresent) {

                RK_S32 numLtrpInSH = rps->m_numberOfPictures;
                RK_S32 ltrpInSPS[MAX_REFS];
                RK_S32 numLtrpInSPS = 0;
                RK_U32 ltrpIndex;
                RK_S32 counter = 0;
                RK_S32 k;
                for (k = rps->m_numberOfPictures - 1; k > rps->m_numberOfPictures - rps->num_long_term_pic - 1; k--) {
                    if (find_matching_ltrp(slice, &ltrpIndex, rps->poc[k], rps->m_used[k])) {
                        ltrpInSPS[numLtrpInSPS] = ltrpIndex;
                        numLtrpInSPS++;
                    } else {
                        counter++;
                    }
                }

                numLtrpInSH -= numLtrpInSPS;

                RK_S32 bitsForLtrpInSPS = 0;
                while (slice->m_sps->m_numLongTermRefPicSPS > (RK_U32)(1 << bitsForLtrpInSPS)) {
                    bitsForLtrpInSPS++;
                }

                if (slice->m_sps->m_numLongTermRefPicSPS > 0) {
                    mpp_writer_put_ue(bitIf, numLtrpInSPS);
                }
                mpp_writer_put_ue(bitIf, numLtrpInSH);
                // Note that the LSBs of the LT ref. pic. POCs must be sorted before.
                // Not sorted here because LT ref indices will be used in setRefPicList()
                RK_S32 prevDeltaMSB = 0;
                RK_S32 offset = rps->num_negative_pic + rps->num_positive_pic;
                for ( k = rps->m_numberOfPictures - 1; k > offset - 1; k--) {
                    if (counter < numLtrpInSPS) {
                        if (bitsForLtrpInSPS > 0) {
                            mpp_writer_put_bits(bitIf, ltrpInSPS[counter], bitsForLtrpInSPS);
                        }
                    } else {
                        mpp_writer_put_bits(bitIf, rps->m_pocLSBLT[k], slice->m_sps->m_bitsForPOC);
                        mpp_writer_put_bits(bitIf, rps->m_used[k], 1);
                    }
                    mpp_writer_put_bits(bitIf, rps->m_deltaPocMSBPresentFlag[k], 1);

                    if (rps->m_deltaPocMSBPresentFlag[k]) {
                        RK_U32 deltaFlag = 0;
                        if ((k == rps->m_numberOfPictures - 1) || (k == rps->m_numberOfPictures - 1 - numLtrpInSPS)) {
                            deltaFlag = 1;
                        }
                        if (deltaFlag) {
                            mpp_writer_put_ue(bitIf, rps->m_deltaPOCMSBCycleLT[k]);
                        } else {
                            RK_S32 differenceInDeltaMSB = rps->m_deltaPOCMSBCycleLT[k] - prevDeltaMSB;
                            mpp_writer_put_ue(bitIf, differenceInDeltaMSB);
                        }
                        prevDeltaMSB = rps->m_deltaPOCMSBCycleLT[k];
                    }
                }
            }
            if (slice->m_sps->m_TMVPFlagsPresent) {
                mpp_writer_put_bits(bitIf, slice->m_enableTMVPFlag ? 1 : 0, 1);
            }
        }

        if (slice->m_sps->m_bUseSAO) { //skip frame close sao
            mpp_writer_put_bits(bitIf, 0, 1);
            mpp_writer_put_bits(bitIf, 0, 1);

        }
        //check if numrefidxes match the defaults. If not, override

        if (slice->m_sliceType != I_SLICE) {
            RK_U32 overrideFlag = (slice->m_numRefIdx[0] != (RK_S32)slice->m_pps->m_numRefIdxL0DefaultActive);
            mpp_writer_put_bits(bitIf, overrideFlag ? 1 : 0, 1);
            if (overrideFlag) {
                mpp_writer_put_ue(bitIf, slice->m_numRefIdx[0] - 1);
                slice->m_numRefIdx[1] = 0;
            }
        }

        if (slice->m_pps->m_listsModificationPresentFlag && get_num_rps_cur_templist(rps) > 1) {
            H265eRefPicListModification* refPicListModification = &slice->m_RefPicListModification;
            mpp_writer_put_bits(bitIf, refPicListModification->m_refPicListModificationFlagL0 ? 1 : 0, 1);
            if (refPicListModification->m_refPicListModificationFlagL0) {
                RK_S32 numRpsCurrTempList0 = get_num_rps_cur_templist(rps);
                if (numRpsCurrTempList0 > 1) {
                    RK_S32 length = 1;
                    numRpsCurrTempList0--;
                    while (numRpsCurrTempList0 >>= 1) {
                        length++;
                    }
                    for (i = 0; i < (RK_U32)slice->m_numRefIdx[0]; i++) {
                        mpp_writer_put_bits(bitIf, refPicListModification->m_RefPicSetIdxL0[i], length);
                    }
                }
            }
        }

        if (slice->m_pps->m_cabacInitPresentFlag) {
            mpp_writer_put_bits(bitIf, slice->m_cabacInitFlag, 1);
        }

        if (slice->m_enableTMVPFlag) {

            if (slice->m_sliceType != I_SLICE &&
                ((slice->m_colFromL0Flag == 1 && slice->m_numRefIdx[0] > 1) ||
                 (slice->m_colFromL0Flag == 0 && slice->m_numRefIdx[1] > 1))) {
                mpp_writer_put_ue(bitIf, slice->m_colRefIdx);
            }
        }

        if (slice->m_sliceType != I_SLICE) {
            RK_S32 flag = MRG_MAX_NUM_CANDS - slice->m_maxNumMergeCand;
            flag = flag == 5 ? 4 : flag;
            mpp_writer_put_ue(bitIf, flag);
        }
        RK_S32 code = slice->m_sliceQp - (slice->m_pps->m_picInitQPMinus26 + 26);
        mpp_writer_put_se(bitIf, code);
        if (slice->m_pps->m_bSliceChromaQpFlag) {
            code = slice->m_sliceQpDeltaCb;
            mpp_writer_put_se(bitIf, code);
            code = slice->m_sliceQpDeltaCr;
            mpp_writer_put_se(bitIf, code);
        }
        if (slice->m_pps->m_deblockingFilterControlPresentFlag) {
            if (slice->m_pps->m_deblockingFilterOverrideEnabledFlag) {
                mpp_writer_put_bits(bitIf, slice->m_deblockingFilterOverrideFlag, 1);
            }
            if (slice->m_deblockingFilterOverrideFlag) {
                mpp_writer_put_bits(bitIf, slice->m_deblockingFilterDisable, 1);
                if (!slice->m_deblockingFilterDisable) {
                    mpp_writer_put_se(bitIf, slice->m_deblockingFilterBetaOffsetDiv2);
                    mpp_writer_put_se(bitIf, slice->m_deblockingFilterTcOffsetDiv2);
                }
            }
        }
    }
    if (slice->m_pps->m_sliceHeaderExtensionPresentFlag) {
        mpp_writer_put_ue(bitIf, slice->slice_header_extension_length);
        for (i = 0; i < slice->slice_header_extension_length; i++) {
            mpp_writer_put_bits(bitIf, 0, 8);
        }
    }
    h265e_dbg_func("leave\n");
}

void code_skip_flag(H265eSlice *slice, RK_U32 abs_part_idx, DataCu *cu)
{
    // get context function is here
    H265eCabacCtx *cabac_ctx = &slice->m_cabac;
    H265eSps *sps = slice->m_sps;
    RK_U32  ctxSkip;
    RK_U32 tpelx = cu->pixelX + sps->raster2pelx[sps->zscan2raster[abs_part_idx]];
    RK_U32 tpely = cu->pixelY + sps->raster2pely[sps->zscan2raster[abs_part_idx]];
    //RK_U32 ctxSkip = cu->getCtxSkipFlag(abs_part_idx);

    h265e_dbg_skip("tpelx = %d", tpelx);
    if (cu->cur_addr == 0 ) {
        ctxSkip = 0;
    } else if ((tpely == 0) || (tpelx == 0)) {
        ctxSkip = 1;
    } else {
        ctxSkip = 2;
    }
    h265e_dbg_skip("ctxSkip = %d", ctxSkip);
    h265e_cabac_encodeBin(cabac_ctx, &slice->m_contextModels[OFF_SKIP_FLAG_CTX + ctxSkip], 1);
}

static void code_merge_index(H265eSlice *slice)
{
    H265eCabacCtx *cabac_ctx = &slice->m_cabac;

    h265e_cabac_encodeBin(cabac_ctx, &slice->m_contextModels[OFF_MERGE_IDX_EXT_CTX], 0);
}

static void code_split_flag(H265eSlice *slice, RK_U32 abs_part_idx, RK_U32 depth, DataCu *cu)
{
    H265eSps *sps = slice->m_sps;

    if (depth == slice->m_sps->m_maxCUDepth - slice->m_sps->m_addCUDepth)
        return;

    h265e_dbg_skip("depth %d cu->m_cuDepth %d", depth, cu->m_cuDepth[sps->zscan2raster[abs_part_idx]]);

    H265eCabacCtx *cabac_ctx = &slice->m_cabac;
    RK_U32 currSplitFlag = (cu->m_cuDepth[sps->zscan2raster[abs_part_idx]] > depth) ? 1 : 0;

    h265e_cabac_encodeBin(cabac_ctx, &slice->m_contextModels[OFF_SPLIT_FLAG_CTX], currSplitFlag);
}

static void encode_cu(H265eSlice *slice, RK_U32 abs_part_idx, RK_U32 depth, DataCu *cu)
{
    H265eSps *sps = slice->m_sps;
    RK_U32 bBoundary = 0;
    RK_U32 lpelx = cu->pixelX + sps->raster2pelx[sps->zscan2raster[abs_part_idx]];
    RK_U32 rpelx = lpelx + (sps->m_maxCUSize >> depth) - 1;
    RK_U32 tpely = cu->pixelY + sps->raster2pely[sps->zscan2raster[abs_part_idx]];
    RK_U32 bpely = tpely + (sps->m_maxCUSize >> depth) - 1;

    h265e_dbg_skip("EncodeCU depth %d, abs_part_idx %d", depth, abs_part_idx);

    if ((rpelx < sps->m_picWidthInLumaSamples) && (bpely < sps->m_picHeightInLumaSamples)) {

        h265e_dbg_skip("code_split_flag in depth %d", depth);
        code_split_flag(slice, abs_part_idx, depth, cu);
    } else {
        h265e_dbg_skip("boundary flag found");
        bBoundary = 1;
    }

    h265e_dbg_skip("m_cuDepth[%d] = %d maxCUDepth %d, m_addCUDepth %d", abs_part_idx, cu->m_cuDepth[sps->zscan2raster[abs_part_idx]], sps->m_maxCUDepth, sps->m_addCUDepth);

    if ((depth < cu->m_cuDepth[sps->zscan2raster[abs_part_idx]] && (depth < (sps->m_maxCUDepth - sps->m_addCUDepth))) || bBoundary) {
        RK_U32 qNumParts = (256 >> (depth << 1)) >> 2;
        RK_U32 partUnitIdx = 0;

        for (partUnitIdx = 0; partUnitIdx < 4; partUnitIdx++, abs_part_idx += qNumParts) {
            h265e_dbg_skip("depth %d partUnitIdx = %d, qNumParts %d, abs_part_idx %d", depth, partUnitIdx, qNumParts, abs_part_idx);
            lpelx = cu->pixelX + sps->raster2pelx[sps->zscan2raster[abs_part_idx]];
            tpely = cu->pixelY + sps->raster2pely[sps->zscan2raster[abs_part_idx]];
            if ((lpelx < sps->m_picWidthInLumaSamples) && (tpely < sps->m_picHeightInLumaSamples)) {
                encode_cu(slice, abs_part_idx, depth + 1, cu);
            }
        }
        return;
    }

    h265e_dbg_skip("code_skip_flag in depth %d", depth);
    code_skip_flag(slice, abs_part_idx, cu);
    h265e_dbg_skip("code_merge_index in depth %d", depth);
    code_merge_index(slice);
    return;
}

static void proc_cu8(DataCu *cu, RK_U32 pos_x, RK_U32 pos_y)
{
    RK_S32 nSize = 8;
    RK_S32 nSubPart = nSize * nSize / 4 / 4;
    RK_S32 puIdx = pos_x / 8 + pos_y / 8 * 8;

    h265e_dbg_skip("8 ctu puIdx %d no need split", puIdx);

    memset(cu->m_cuDepth + puIdx * nSubPart, 3, nSubPart);
}

static void proc_cu16(H265eSlice *slice, DataCu *cu, RK_U32 pos_x, RK_U32 pos_y)
{
    RK_U32 m;
    H265eSps *sps = slice->m_sps;
    RK_S32 nSize = 16;
    RK_S32 nSubPart = nSize * nSize / 4 / 4;
    RK_S32 puIdx = pos_x / 16 + pos_y / 16 * 4;
    RK_U32 cu_x_1, cu_y_1;

    h265e_dbg_skip("cu 16 pos_x %d pos_y %d", pos_x, pos_y);

    if ((cu->pixelX + pos_x + 15 < sps->m_picWidthInLumaSamples) &&
        (cu->pixelY + pos_y + 15 < sps->m_picHeightInLumaSamples)) {
        h265e_dbg_skip("16 ctu puIdx %d no need split", puIdx);
        memset(cu->m_cuDepth + puIdx * nSubPart, 2, nSubPart);
        return;
    } else if ((cu->pixelX + pos_x >=  sps->m_picWidthInLumaSamples) ||
               (cu->pixelY + pos_y  >= sps->m_picHeightInLumaSamples)) {
        h265e_dbg_skip("16 ctu puIdx %d out of pic", puIdx);
        memset(cu->m_cuDepth + puIdx * nSubPart, 2, nSubPart);
        return;
    }

    for (m = 0; m < 4; m ++) {
        cu_x_1 = pos_x + (m & 1) * (nSize >> 1);
        cu_y_1 = pos_y + (m >> 1) * (nSize >> 1);

        proc_cu8(cu, cu_x_1, cu_y_1);
    }
}


static void proc_cu32(H265eSlice *slice, DataCu *cu, RK_U32 pos_x, RK_U32 pos_y)
{
    RK_U32 m;
    H265eSps *sps = slice->m_sps;
    RK_S32 nSize = 32;
    RK_S32 nSubPart = nSize * nSize / 4 / 4;
    RK_S32 puIdx = pos_x / 32 + pos_y / 32 * 2;
    RK_U32 cu_x_1, cu_y_1;

    h265e_dbg_skip("cu 32 pos_x %d pos_y %d", pos_x, pos_y);

    if ((cu->pixelX + pos_x + 31 < sps->m_picWidthInLumaSamples) &&
        (cu->pixelY + pos_y + 31 < sps->m_picHeightInLumaSamples)) {
        h265e_dbg_skip("32 ctu puIdx %d no need split", puIdx);
        memset(cu->m_cuDepth + puIdx * nSubPart, 1, nSubPart);
        return;
    } else if ((cu->pixelX + pos_x >=  sps->m_picWidthInLumaSamples) ||
               (cu->pixelY + pos_y  >= sps->m_picHeightInLumaSamples)) {
        h265e_dbg_skip("32 ctu puIdx %d out of pic", puIdx);
        memset(cu->m_cuDepth + puIdx * nSubPart, 1, nSubPart);
        return;
    }

    for (m = 0; m < 4; m ++) {
        cu_x_1 = pos_x + (m & 1) * (nSize >> 1);
        cu_y_1 = pos_y + (m >> 1) * (nSize >> 1);

        proc_cu16(slice, cu, cu_x_1, cu_y_1);
    }
}

static void proc_ctu(H265eSlice *slice, DataCu *cu)
{
    H265eSps *sps = slice->m_sps;
    RK_U32 k, m;
    RK_U32 cu_x_1, cu_y_1, m_nCtuSize = 64;
    RK_U32 lpelx = cu->pixelX;
    RK_U32 rpelx = lpelx + 63;
    RK_U32 tpely = cu->pixelY;
    RK_U32 bpely = tpely + 63;

    for (k = 0; k < 256; k++) {
        cu->m_cuDepth[k] = 0;
        cu->m_cuSize[k] = 64;
    }
    if ((rpelx < sps->m_picWidthInLumaSamples) && (bpely < sps->m_picHeightInLumaSamples))
        return;

    for (m = 0; m < 4; m ++) {
        cu_x_1 = (m & 1) * (m_nCtuSize >> 1);
        cu_y_1 = (m >> 1) * (m_nCtuSize >> 1);
        proc_cu32(slice, cu, cu_x_1, cu_y_1);
    }

    for (k = 0; k < 256; k++) {
        switch (cu->m_cuDepth[k]) {
        case 0: cu->m_cuSize[k] = 64; break;
        case 1: cu->m_cuSize[k] = 32; break;
        case 2: cu->m_cuSize[k] = 16; break;
        case 3: cu->m_cuSize[k] = 8;  break;
        }
    }
}

static void h265e_write_nal(MppWriteCtx *bitIf)
{
    h265e_dbg_func("enter\n");

    mpp_writer_put_raw_bits(bitIf, 0x0, 24);
    mpp_writer_put_raw_bits(bitIf, 0x01, 8);
    mpp_writer_put_bits(bitIf, 0, 1);   // forbidden_zero_bit
    mpp_writer_put_bits(bitIf, 1, 6);   // nal_unit_type
    mpp_writer_put_bits(bitIf, 0, 6);   // nuh_reserved_zero_6bits
    mpp_writer_put_bits(bitIf, 1, 3);   // nuh_temporal_id_plus1

    h265e_dbg_func("leave\n");
}

static void h265e_write_algin(MppWriteCtx *bitIf)
{
    h265e_dbg_func("enter\n");
    mpp_writer_put_bits(bitIf, 1, 1);
    mpp_writer_align_zero(bitIf);
    h265e_dbg_func("leave\n");
}


RK_S32 h265e_code_slice_skip_frame(void *ctx, H265eSlice *slice, RK_U8 *buf, RK_S32 len)
{

    MppWriteCtx bitIf;
    H265eCtx *p = (H265eCtx *)ctx;
    H265eSps *sps = &p->sps;
    H265eCabacCtx *cabac_ctx = &slice->m_cabac;
    h265e_dbg_func("enter\n");
    RK_U32 mb_wd = ((sps->m_picWidthInLumaSamples + 63) >> 6);
    RK_U32 mb_h = ((sps->m_picHeightInLumaSamples + 63) >> 6);
    RK_U32 i = 0, j = 0, cu_cnt = 0;
    if (!buf || !len) {
        mpp_err("buf or size no set");
        return MPP_NOK;
    }
    mpp_writer_init(&bitIf, buf, len);
    h265e_write_nal(&bitIf);
    h265e_code_slice_header(slice, &bitIf);
    h265e_write_algin(&bitIf);
    h265e_reset_enctropy((void*)slice);
    h265e_cabac_init(cabac_ctx, &bitIf);
    DataCu cu;
    cu.mb_w = mb_wd;
    cu.mb_h = mb_h;
    slice->is_referenced = 0;
    for (i = 0; i < mb_h; i++) {
        for ( j = 0; j < mb_wd; j++) {
            cu.pixelX = j * 64;
            cu.pixelY = i * 64;
            cu.cur_addr = cu_cnt;
            proc_ctu(slice, &cu);
            encode_cu(slice, 0, 0, &cu);
            h265e_cabac_encodeBinTrm(cabac_ctx, 0);
            cu_cnt++;
        }
    }

    h265e_cabac_finish(cabac_ctx);
    h265e_write_algin(&bitIf);
    h265e_dbg_func("leave\n");
    return mpp_writer_bytes(&bitIf);
}