/******************************************************************************

 *

 * Copyright (C) 2018 The Android Open Source Project

 *

 * 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.

 *

 *****************************************************************************

 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore

*/

/**

******************************************************************************

* @file ihevce_had_satd.c

*

* @brief

*    This file contains functions of Hadamard SAD and SATD

*

* @author

*    Ittiam

*

* List of Functions

*   <TODO: TO BE ADDED>

*

******************************************************************************

*/

/*****************************************************************************/

/* File Includes                                                             */

/*****************************************************************************/

/* System include files */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <assert.h>

#include <stdarg.h>

#include <math.h>

/* User include files */

#include "ihevc_typedefs.h"

#include "itt_video_api.h"

#include "ihevce_api.h"

#include "rc_cntrl_param.h"

#include "rc_frame_info_collector.h"

#include "rc_look_ahead_params.h"

#include "ihevc_defs.h"

#include "ihevc_structs.h"

#include "ihevc_platform_macros.h"

#include "ihevc_deblk.h"

#include "ihevc_itrans_recon.h"

#include "ihevc_chroma_itrans_recon.h"

#include "ihevc_chroma_intra_pred.h"

#include "ihevc_intra_pred.h"

#include "ihevc_inter_pred.h"

#include "ihevc_mem_fns.h"

#include "ihevc_padding.h"

#include "ihevc_weighted_pred.h"

#include "ihevc_sao.h"

#include "ihevc_resi_trans.h"

#include "ihevc_quant_iquant_ssd.h"

#include "ihevc_cabac_tables.h"

#include "ihevce_defs.h"

#include "ihevce_lap_enc_structs.h"

#include "ihevce_multi_thrd_structs.h"

#include "ihevce_multi_thrd_funcs.h"

#include "ihevce_me_common_defs.h"

#include "ihevce_had_satd.h"

#include "ihevce_error_codes.h"

#include "ihevce_bitstream.h"

#include "ihevce_cabac.h"

#include "ihevce_rdoq_macros.h"

#include "ihevce_function_selector.h"

#include "ihevce_enc_structs.h"

#include "ihevce_cmn_utils_instr_set_router.h"

#include "hme_datatype.h"

#include "hme_interface.h"

#include "hme_common_defs.h"

#include "hme_defs.h"

/*****************************************************************************/

/* Function Definitions                                                      */

/*****************************************************************************/

static void ihevce_hadamard_4x4_8bit(

    UWORD8 *pu1_src,

    WORD32 src_strd,

    UWORD8 *pu1_pred,

    WORD32 pred_strd,

    WORD16 *pi2_dst,

    WORD32 dst_strd)

{

    WORD32 k;

    WORD16 m[16];

    /*===== hadamard horz transform =====*/

    for(k = 0; k < 4; k++)

    {

        WORD32 r0, r1, r2, r3;

        WORD32 h0, h1, h2, h3;

        /* Compute the residue block */

        r0 = pu1_src[0] - pu1_pred[0];

        r1 = pu1_src[1] - pu1_pred[1];

        r2 = pu1_src[2] - pu1_pred[2];

        r3 = pu1_src[3] - pu1_pred[3];

        h0 = r0 + r1;

        h1 = r0 - r1;

        h2 = r2 + r3;

        h3 = r2 - r3;

        m[k * 4 + 0] = h0 + h2;

        m[k * 4 + 1] = h1 + h3;

        m[k * 4 + 2] = h0 - h2;

        m[k * 4 + 3] = h1 - h3;

        pu1_pred += pred_strd;

        pu1_src += src_strd;

    }

    /*===== hadamard vert transform =====*/

    for(k = 0; k < 4; k++)

    {

        WORD32 v0, v1, v2, v3;

        v0 = m[0 + k] + m[4 + k];

        v1 = m[0 + k] - m[4 + k];

        v2 = m[8 + k] + m[12 + k];

        v3 = m[8 + k] - m[12 + k];

        pi2_dst[0 * dst_strd + k] = v0 + v2;

        pi2_dst[1 * dst_strd + k] = v1 + v3;

        pi2_dst[2 * dst_strd + k] = v0 - v2;

        pi2_dst[3 * dst_strd + k] = v1 - v3;

    }

}

static void ihevce_hadamard_8x8_8bit(

    UWORD8 *pu1_src,

    WORD32 src_strd,

    UWORD8 *pu1_pred,

    WORD32 pred_strd,

    WORD16 *pi2_dst,

    WORD32 dst_strd)

{

    WORD32 i;

    // y0

    ihevce_hadamard_4x4_8bit(pu1_src, src_strd, pu1_pred, pred_strd, pi2_dst, dst_strd);

    // y1

    ihevce_hadamard_4x4_8bit(pu1_src + 4, src_strd, pu1_pred + 4, pred_strd, pi2_dst + 4, dst_strd);

    // y2

    ihevce_hadamard_4x4_8bit(

        pu1_src + 4 * src_strd,

        src_strd,

        pu1_pred + 4 * pred_strd,

        pred_strd,

        pi2_dst + (4 * dst_strd),

        dst_strd);

    // y3

    ihevce_hadamard_4x4_8bit(

        pu1_src + 4 + 4 * src_strd,

        src_strd,

        pu1_pred + 4 + 4 * pred_strd,

        pred_strd,

        pi2_dst + (4 * dst_strd) + 4,

        dst_strd);

    /*   Child HAD results combined as follows to get Parent result */

    /*  _                                                 _         */

    /* |  (y0 + y1) + (y2 + y3)    (y0 - y1) + (y2 - y3)   |        */

    /* |  (y0 + y1) - (y2 + y3)    (y0 - y1) - (y2 - y3)   |        */

    /* \-                                                 -/        */

    for(i = 0; i < 16; i++)

    {

        WORD32 idx = (i >> 2) * dst_strd + (i % 4);

        WORD16 a0 = pi2_dst[idx];

        WORD16 a1 = pi2_dst[4 + idx];

        WORD16 a2 = pi2_dst[(4 * dst_strd) + idx];

        WORD16 a3 = pi2_dst[(4 * dst_strd) + 4 + idx];

        WORD16 b0 = (a0 + a1);

        WORD16 b1 = (a0 - a1);

        WORD16 b2 = (a2 + a3);

        WORD16 b3 = (a2 - a3);

        pi2_dst[idx] = b0 + b2;

        pi2_dst[4 + idx] = b1 + b3;

        pi2_dst[(4 * dst_strd) + idx] = b0 - b2;

        pi2_dst[(4 * dst_strd) + 4 + idx] = b1 - b3;

    }

}

static void ihevce_hadamard_16x16_8bit(

    UWORD8 *pu1_src,

    WORD32 src_strd,

    UWORD8 *pu1_pred,

    WORD32 pred_strd,

    WORD16 *pi2_dst,

    WORD32 dst_strd)

{

    WORD32 i;

    // y0

    ihevce_hadamard_8x8_8bit(pu1_src, src_strd, pu1_pred, pred_strd, pi2_dst, dst_strd);

    // y1

    ihevce_hadamard_8x8_8bit(pu1_src + 8, src_strd, pu1_pred + 8, pred_strd, pi2_dst + 8, dst_strd);

    // y2

    ihevce_hadamard_8x8_8bit(

        pu1_src + 8 * src_strd,

        src_strd,

        pu1_pred + 8 * pred_strd,

        pred_strd,

        pi2_dst + (8 * dst_strd),

        dst_strd);

    // y3

    ihevce_hadamard_8x8_8bit(

        pu1_src + 8 + 8 * src_strd,

        src_strd,

        pu1_pred + 8 + 8 * pred_strd,

        pred_strd,

        pi2_dst + (8 * dst_strd) + 8,

        dst_strd);

    /*   Child HAD results combined as follows to get Parent result */

    /*  _                                                 _         */

    /* |  (y0 + y1) + (y2 + y3)    (y0 - y1) + (y2 - y3)   |        */

    /* |  (y0 + y1) - (y2 + y3)    (y0 - y1) - (y2 - y3)   |        */

    /* \-                                                 -/        */

    for(i = 0; i < 64; i++)

    {

        WORD32 idx = (i >> 3) * dst_strd + (i % 8);

        WORD16 a0 = pi2_dst[idx];

        WORD16 a1 = pi2_dst[8 + idx];

        WORD16 a2 = pi2_dst[(8 * dst_strd) + idx];

        WORD16 a3 = pi2_dst[(8 * dst_strd) + 8 + idx];

        WORD16 b0 = (a0 + a1) >> 1;

        WORD16 b1 = (a0 - a1) >> 1;

        WORD16 b2 = (a2 + a3) >> 1;

        WORD16 b3 = (a2 - a3) >> 1;

        pi2_dst[idx] = b0 + b2;

        pi2_dst[8 + idx] = b1 + b3;

        pi2_dst[(8 * dst_strd) + idx] = b0 - b2;

        pi2_dst[(8 * dst_strd) + 8 + idx] = b1 - b3;

    }

}

static void ihevce_hadamard_32x32_8bit(

    UWORD8 *pu1_src,

    WORD32 src_strd,

    UWORD8 *pu1_pred,

    WORD32 pred_strd,

    WORD16 *pi2_dst,

    WORD32 dst_strd)

{

    WORD32 i;

    // y0

    ihevce_hadamard_16x16_8bit(pu1_src, src_strd, pu1_pred, pred_strd, pi2_dst, dst_strd);

    // y1

    ihevce_hadamard_16x16_8bit(

        pu1_src + 16, src_strd, pu1_pred + 16, pred_strd, pi2_dst + 16, dst_strd);

    // y2

    ihevce_hadamard_16x16_8bit(

        pu1_src + 16 * src_strd,

        src_strd,

        pu1_pred + 16 * pred_strd,

        pred_strd,

        pi2_dst + (16 * dst_strd),

        dst_strd);

    // y3

    ihevce_hadamard_16x16_8bit(

        pu1_src + 16 + 16 * src_strd,

        src_strd,

        pu1_pred + 16 + 16 * pred_strd,

        pred_strd,

        pi2_dst + (16 * dst_strd) + 16,

        dst_strd);

    /*   Child HAD results combined as follows to get Parent result */

    /*  _                                                 _         */

    /* |  (y0 + y1) + (y2 + y3)    (y0 - y1) + (y2 - y3)   |        */

    /* |  (y0 + y1) - (y2 + y3)    (y0 - y1) - (y2 - y3)   |        */

    /* \-                                                 -/        */

    for(i = 0; i < 256; i++)

    {

        WORD32 idx = (i >> 4) * dst_strd + (i % 16);

        WORD16 a0 = pi2_dst[idx] >> 2;

        WORD16 a1 = pi2_dst[16 + idx] >> 2;

        WORD16 a2 = pi2_dst[(16 * dst_strd) + idx] >> 2;

        WORD16 a3 = pi2_dst[(16 * dst_strd) + 16 + idx] >> 2;

        WORD16 b0 = (a0 + a1);

        WORD16 b1 = (a0 - a1);

        WORD16 b2 = (a2 + a3);

        WORD16 b3 = (a2 - a3);

        pi2_dst[idx] = b0 + b2;

        pi2_dst[16 + idx] = b1 + b3;

        pi2_dst[(16 * dst_strd) + idx] = b0 - b2;

        pi2_dst[(16 * dst_strd) + 16 + idx] = b1 - b3;

    }

}

/**

*******************************************************************************

*

* @brief

*  Compute Hadamard sad for 4x4 block with 8-bit input

*

* @par Description:

*

* @param[in] pu1_origin

*  UWORD8 pointer to the current block

*

* @param[in] src_strd

*  WORD32 Source stride

*

* @param[in] pu1_pred_buf

*  UWORD8 pointer to the prediction block

*

* @param[in] pred_strd

*  WORD32 Pred stride

*

* @param[in] pi2_dst

*  WORD16 pointer to the transform block

*

* @param[in] dst_strd

*  WORD32 Destination stride

*

* @param[in] size

*  WORD32 transform Block size

*

* @returns hadamard SAD

*

* @remarks

*  Not updating the transform destination now. Only returning the SATD

*

*******************************************************************************

*/

UWORD32 ihevce_HAD_4x4_8bit(

    UWORD8 *pu1_origin,

    WORD32 src_strd,

    UWORD8 *pu1_pred_buf,

    WORD32 pred_strd,

    WORD16 *pi2_dst,

    WORD32 dst_strd)

{

    WORD32 k;

    WORD16 v[16];

    UWORD32 u4_sad = 0;

    (void)pi2_dst;

    (void)dst_strd;

    ihevce_hadamard_4x4_8bit(pu1_origin, src_strd, pu1_pred_buf, pred_strd, v, 4);

    for(k = 0; k < 16; ++k)

        u4_sad += abs(v[k]);

    u4_sad = ((u4_sad + 2) >> 2);

    return u4_sad;

}

/**

*******************************************************************************

*

* @brief

*  Computes Hadamard Sad for 8x8 block with 8-bit input

*

* @par Description:

*

* @param[in] pu1_origin

*  UWORD8 pointer to the current block

*

* @param[in] src_strd

*  WORD32 Source stride

*

* @param[in] pu1_pred_buf

*  UWORD8 pointer to the prediction block

*

* @param[in] pred_strd

*  WORD32 Pred stride

*

* @param[in] pi2_dst

*  WORD16 pointer to the transform block

*

* @param[in] dst_strd

*  WORD32 Destination stride

*

* @param[in] size

*  WORD32 transform Block size

*

* @returns Hadamard SAD

*

* @remarks

*  Not updating the transform destination now. Only returning the SATD

*

*******************************************************************************

*/

UWORD32 ihevce_HAD_8x8_8bit(

    UWORD8 *pu1_origin,

    WORD32 src_strd,

    UWORD8 *pu1_pred_buf,

    WORD32 pred_strd,

    WORD16 *pi2_dst,

    WORD32 dst_strd)

{

    WORD32 k;

    UWORD32 u4_sad = 0;

    WORD16 v[64];

    (void)pi2_dst;

    (void)dst_strd;

    ihevce_hadamard_8x8_8bit(pu1_origin, src_strd, pu1_pred_buf, pred_strd, v, 8);

    for(k = 0; k < 64; ++k)

        u4_sad += abs(v[k]);

    u4_sad = ((u4_sad + 4) >> 3);

    return u4_sad;

}

/**

*******************************************************************************

*

* @brief

*  Compute dc suppressed hadamard sad for 8x8 block with 8-bit input

*

* @par Description:

*

* @param[in] pu1_origin

*  UWORD8 pointer to the current block

*

* @param[in] src_strd

*  WORD32 Source stride

*

* @param[in] pu1_pred_buf

*  UWORD8 pointer to the prediction block

*

* @param[in] pred_strd

*  WORD32 Pred stride

*

* @param[in] pi2_dst

*  WORD16 pointer to the transform block

*

* @param[in] dst_strd

*  WORD32 Destination stride

*

* @param[in] size

*  WORD32 transform Block size

*

* @returns Hadamard SAD with DC Suppressed

*

* @remarks

*  Not updating the transform destination now. Only returning the SATD

*

*******************************************************************************

*/

UWORD32 ihevce_compute_ac_had_8x8_8bit(

    UWORD8 *pu1_origin,

    WORD32 src_strd,

    UWORD8 *pu1_pred_buf,

    WORD32 pred_strd,

    WORD16 *pi2_dst,

    WORD32 dst_strd)

{

    WORD32 k;

    UWORD32 u4_sad = 0;

    WORD16 v[64];

    (void)pi2_dst;

    (void)dst_strd;

    ihevce_hadamard_8x8_8bit(pu1_origin, src_strd, pu1_pred_buf, pred_strd, v, 8);

    v[0] = 0;

    for(k = 0; k < 64; ++k)

        u4_sad += abs(v[k]);

    u4_sad = ((u4_sad + 4) >> 3);

    return u4_sad;

}

/**

*******************************************************************************

*

* @brief

*  Computes Hadamard Sad for 16x16 block with 8-bit input

*

* @par Description:

*

* @param[in] pu1_origin

*  UWORD8 pointer to the current block

*

* @param[in] src_strd

*  WORD32 Source stride

*

* @param[in] pu1_pred_buf

*  UWORD8 pointer to the prediction block

*

* @param[in] pred_strd

*  WORD32 Pred stride

*

* @param[in] pi2_dst

*  WORD16 pointer to the transform block

*

* @param[in] dst_strd

*  WORD32 Destination stride

*

* @param[in] size

*  WORD32 transform Block size

*

* @returns Hadamard SAD

*

* @remarks

*  Not updating the transform destination now. Only returning the SATD

*

*******************************************************************************

*/

UWORD32 ihevce_HAD_16x16_8bit(

    UWORD8 *pu1_origin,

    WORD32 src_strd,

    UWORD8 *pu1_pred_buf,

    WORD32 pred_strd,

    WORD16 *pi2_dst,

    WORD32 dst_strd)

{

    WORD32 k;

    UWORD32 u4_sad = 0;

    WORD16 v[256];

    (void)pi2_dst;

    (void)dst_strd;

    ihevce_hadamard_16x16_8bit(pu1_origin, src_strd, pu1_pred_buf, pred_strd, v, 16);

    for(k = 0; k < 256; ++k)

        u4_sad += abs(v[k]);

    u4_sad = ((u4_sad + 4) >> 3);

    return u4_sad;

}

/**

*******************************************************************************

*

* @brief

*  Computes Hadamard Sad for 32x32 block with 8-bit input

*

* @par Description:

*

* @param[in] pu1_origin

*  UWORD8 pointer to the current block

*

* @param[in] src_strd

*  WORD32 Source stride

*

* @param[in] pu1_pred_buf

*  UWORD8 pointer to the prediction block

*

* @param[in] pred_strd

*  WORD32 Pred stride

*

* @param[in] pi2_dst

*  WORD16 pointer to the transform block

*

* @param[in] dst_strd

*  WORD32 Destination stride

*

* @param[in] size

*  WORD32 transform Block size

*

* @returns Hadamard SAD

*

* @remarks

*  Not updating the transform destination now. Only returning the SATD

*

*******************************************************************************

*/

UWORD32 ihevce_HAD_32x32_8bit(

    UWORD8 *pu1_origin,

    WORD32 src_strd,

    UWORD8 *pu1_pred_buf,

    WORD32 pred_strd,

    WORD16 *pi2_dst,

    WORD32 dst_strd)

{

    WORD32 k;

    UWORD32 u4_sad = 0;

    WORD16 v[32 * 32];

    (void)pi2_dst;

    (void)dst_strd;

    ihevce_hadamard_32x32_8bit(pu1_origin, src_strd, pu1_pred_buf, pred_strd, v, 32);

    for(k = 0; k < 32 * 32; ++k)

        u4_sad += abs(v[k]);

    u4_sad = ((u4_sad + 2) >> 2);

    return u4_sad;

}

//#if COMPUTE_16x16_R == C

/**

*******************************************************************************

*

* @brief

*   Computes 8x8 transform using children 4x4 hadamard results

*

* @par Description:

*

* @param[in] pi2_4x4_had

*  WORD16 pointer to 4x4 hadamard buffer(y0, y1, y2, y3 hadmard in Zscan order)

*

* @param[in] had4_strd

*  stride of 4x4 hadmard buffer pi2_y0, pi2_y1, pi2_y2, pi2_y3

*

* @param[out] pi2_dst

*  destination buffer where 8x8 hadamard result is stored

*

* @param[in] dst_stride

*  stride of destination block

*

* @param[in] i4_frm_qstep

*  frm_qstep value based on the which the threshold value is calculated

*

* @returns

*  8x8 Hadamard SATD

* @remarks

*

*******************************************************************************

*/

static UWORD32 ihevce_compute_8x8HAD_using_4x4(

    WORD16 *pi2_4x4_had,

    WORD32 had4_strd,

    WORD16 *pi2_dst,

    WORD32 dst_strd,

    WORD32 i4_frm_qstep,

    WORD32 *pi4_cbf)

{

    /* Qstep value is right shifted by 8 */

    WORD32 threshold = (i4_frm_qstep >> 8);

    /* Initialize pointers to 4 subblocks of 4x4 HAD buffer */

    WORD16 *pi2_y0 = pi2_4x4_had;

    WORD16 *pi2_y1 = pi2_4x4_had + 4;

    WORD16 *pi2_y2 = pi2_4x4_had + had4_strd * 4;

    WORD16 *pi2_y3 = pi2_4x4_had + had4_strd * 4 + 4;

    /* Initialize pointers to store 8x8 HAD output */

    WORD16 *pi2_dst0 = pi2_dst;

    WORD16 *pi2_dst1 = pi2_dst + 4;

    WORD16 *pi2_dst2 = pi2_dst + dst_strd * 4;

    WORD16 *pi2_dst3 = pi2_dst + dst_strd * 4 + 4;

    UWORD32 u4_satd = 0;

    WORD32 i;

    /*   Child HAD results combined as follows to get Parent result */

    /*  _                                                 _         */

    /* |  (y0 + y1) + (y2 + y3)    (y0 - y1) + (y2 - y3)   |        */

    /* |  (y0 + y1) - (y2 + y3)    (y0 - y1) - (y2 - y3)   |        */

    /* \-                                                 -/        */

    for(i = 0; i < 16; i++)

    {

        WORD32 src_idx = (i >> 2) * had4_strd + (i % 4);

        WORD32 dst_idx = (i >> 2) * dst_strd + (i % 4);

        WORD16 a0 = pi2_y0[src_idx];

        WORD16 a1 = pi2_y1[src_idx];

        WORD16 a2 = pi2_y2[src_idx];

        WORD16 a3 = pi2_y3[src_idx];

        WORD16 b0 = (a0 + a1);

        WORD16 b1 = (a0 - a1);

        WORD16 b2 = (a2 + a3);

        WORD16 b3 = (a2 - a3);

        pi2_dst0[dst_idx] = b0 + b2;

        pi2_dst1[dst_idx] = b1 + b3;

        pi2_dst2[dst_idx] = b0 - b2;

        pi2_dst3[dst_idx] = b1 - b3;

        if(ABS(pi2_dst0[dst_idx]) > threshold)

            *pi4_cbf = 1;

        if(ABS(pi2_dst1[dst_idx]) > threshold)

            *pi4_cbf = 1;

        if(ABS(pi2_dst2[dst_idx]) > threshold)

            *pi4_cbf = 1;

        if(ABS(pi2_dst3[dst_idx]) > threshold)

            *pi4_cbf = 1;

        u4_satd += ABS(pi2_dst0[dst_idx]);

        u4_satd += ABS(pi2_dst1[dst_idx]);

        u4_satd += ABS(pi2_dst2[dst_idx]);

        u4_satd += ABS(pi2_dst3[dst_idx]);

    }

    /* return the 8x8 satd */

    return (u4_satd);

}

/**

*******************************************************************************

*

* @brief

*    Computes Residue and Hadamard Transform for four 4x4 blocks (Z scan) of

*    a 8x8 block (Residue is computed for 8-bit src and prediction buffers)

*    Modified to incorporate the dead-zone implementation - Lokesh

*

* @par Description:

*

* @param[in] pu1_origin

*  UWORD8 pointer to the current block

*

* @param[in] src_strd

*  WORD32 Source stride

*

* @param[in] pu1_pred

*  UWORD8 pointer to the prediction block

*

* @param[in] pred_strd

*  WORD32 Pred stride

*

* @param[out] pi2_dst

*  WORD16 pointer to the transform block

*

* @param[in] dst_strd

*  WORD32 Destination stride

*

* @param[out] pi4_hsad

*  array for storing hadmard sad of each 4x4 block

*

* @param[in] hsad_stride

*  stride of hadmard sad destination buffer (for Zscan order of storing sads)

*

* @param[in] i4_frm_qstep

*  frm_qstep value based on the which the threshold value is calculated

*

* @returns

*

* @remarks

*

*******************************************************************************

*/

static WORD32 ihevce_had4_4x4(

    UWORD8 *pu1_src,

    WORD32 src_strd,

    UWORD8 *pu1_pred,

    WORD32 pred_strd,

    WORD16 *pi2_dst4x4,

    WORD32 dst_strd,

    WORD32 *pi4_hsad,

    WORD32 hsad_stride,

    WORD32 i4_frm_qstep)

{

    WORD32 i, k;

    WORD32 i4_child_total_sad = 0;

    (void)i4_frm_qstep;

    /* -------- Compute four 4x4 HAD Transforms ---------*/

    for(i = 0; i < 4; i++)

    {

        UWORD8 *pu1_pi0, *pu1_pi1;

        WORD16 *pi2_dst;

        WORD32 blkx, blky;

        UWORD32 u4_hsad = 0;

        // TODO: choose deadzone as f(qstep)

        WORD32 threshold = 0;

        /*****************************************************/

        /*    Assuming the looping structure of the four     */

        /*    blocks is in Z scan order of 4x4s in a 8x8     */

        /*    block instead of raster scan                   */

        /*****************************************************/

        blkx = (i & 0x1);

        blky = (i >> 1);

        pu1_pi0 = pu1_src + (blkx * 4) + (blky * 4 * src_strd);

        pu1_pi1 = pu1_pred + (blkx * 4) + (blky * 4 * pred_strd);

        pi2_dst = pi2_dst4x4 + (blkx * 4) + (blky * 4 * dst_strd);

        ihevce_hadamard_4x4_8bit(pu1_pi0, src_strd, pu1_pi1, pred_strd, pi2_dst, dst_strd);

        for(k = 0; k < 4; k++)

        {

            if(ABS(pi2_dst[0 * dst_strd + k]) < threshold)

                pi2_dst[0 * dst_strd + k] = 0;

            if(ABS(pi2_dst[1 * dst_strd + k]) < threshold)

                pi2_dst[1 * dst_strd + k] = 0;

            if(ABS(pi2_dst[2 * dst_strd + k]) < threshold)

                pi2_dst[2 * dst_strd + k] = 0;

            if(ABS(pi2_dst[3 * dst_strd + k]) < threshold)

                pi2_dst[3 * dst_strd + k] = 0;

            /* Accumulate the SATD */

            u4_hsad += ABS(pi2_dst[0 * dst_strd + k]);

            u4_hsad += ABS(pi2_dst[1 * dst_strd + k]);

            u4_hsad += ABS(pi2_dst[2 * dst_strd + k]);

            u4_hsad += ABS(pi2_dst[3 * dst_strd + k]);

        }

        /*===== Normalize the HSAD =====*/

        pi4_hsad[blkx + (blky * hsad_stride)] = ((u4_hsad + 2) >> 2);

        i4_child_total_sad += ((u4_hsad + 2) >> 2);

    }

    return i4_child_total_sad;

}

/**

*******************************************************************************

*

* @brief

*    HSAD is returned for the 4, 4x4 in 8x8

*

* @par Description:

*

* @param[in] pu1_origin

*  UWORD8 pointer to the current block

*

* @param[in] src_strd

*  WORD32 Source stride

*

* @param[in] pu1_pred

*  UWORD8 pointer to the prediction block

*

* @param[in] pred_strd

*  WORD32 Pred stride

*

* @param[out] pi2_dst

*  WORD16 pointer to the transform output block

*

* @param[out] dst_strd

*  WORD32 Destination stride

*

* @param[out] ppi4_hsad

*   pointer to base pointers for storing hadmard sads of various

*   block sizes (4x4 to 32x32)

*

* @param[in] pos_x_y_4x4

*   Denotes packed x,y postion of current 4x4 block w.r.t to start of ctb/CU/MB

*   Lower 16bits denote xpos and upper 16ypos of the 4x4block

*

* @param[in] num_4x4_in_row

*   Denotes the number of current 4x4 blocks in a ctb/CU/MB

*

* @returns

*

* @remarks

*

*******************************************************************************

*/

void ihevce_had_8x8_using_4_4x4(

    UWORD8 *pu1_src,

    WORD32 src_strd,

    UWORD8 *pu1_pred,

    WORD32 pred_strd,

    WORD16 *pi2_dst,

    WORD32 dst_strd,

    WORD32 **ppi4_hsad,

    WORD32 pos_x_y_4x4,

    WORD32 num_4x4_in_row)

{

    WORD16 ai2_4x4_had[64];

    WORD32 pos_x = pos_x_y_4x4 & 0xFFFF;

    WORD32 pos_y = (pos_x_y_4x4 >> 16) & 0xFFFF;

    WORD32 *pi4_4x4_hsad;

    WORD32 *pi4_8x8_hsad;

    (void)pi2_dst;

    (void)dst_strd;

    ASSERT(pos_x >= 0);

    ASSERT(pos_y >= 0);

    /* Initialize pointers to  store 4x4 and 8x8 HAD SATDs */

    pi4_4x4_hsad = ppi4_hsad[HAD_4x4] + pos_x + pos_y * num_4x4_in_row;

    pi4_8x8_hsad = ppi4_hsad[HAD_8x8] + (pos_x >> 1) + (pos_y >> 1) * (num_4x4_in_row >> 1);

    /* -------- Compute four 4x4 HAD Transforms of 8x8 in one call--------- */

    pi4_8x8_hsad[0] = ihevce_had4_4x4(

        pu1_src, src_strd, pu1_pred, pred_strd, ai2_4x4_had, 8, pi4_4x4_hsad, num_4x4_in_row, 0);

}

/**

*******************************************************************************

*

* @brief

*    Reursive Hadamard Transform for 8x8 block. HSAD is returned for the 8x8

*    block and its four subblocks(4x4).

*

* @par Description:

*

* @param[in] pu1_origin

*  UWORD8 pointer to the current block

*

* @param[in] src_strd

*  WORD32 Source stride

*

* @param[in] pu1_pred

*  UWORD8 pointer to the prediction block

*

* @param[in] pred_strd

*  WORD32 Pred stride

*

* @param[out] pi2_dst

*  WORD16 pointer to the transform output block

*

* @param[out] dst_strd

*  WORD32 Destination stride

*

* @param[out] ppi4_hsad

*   pointer to base pointers for storing hadmard sads of various

*   block sizes (4x4 to 32x32)

*

* @param[in] pos_x_y_4x4

*   Denotes packed x,y postion of current 4x4 block w.r.t to start of ctb/CU/MB

*   Lower 16bits denote xpos and upper 16ypos of the 4x4block

*

* @param[in] num_4x4_in_row

*   Denotes the number of current 4x4 blocks in a ctb/CU/MB

*

* @param[in] i4_frm_qstep

*  frm_qstep value based on the which the threshold value is calculated

*

* @returns

*

* @remarks

*

*******************************************************************************

*/

WORD32 ihevce_had_8x8_using_4_4x4_r(

    UWORD8 *pu1_src,

    WORD32 src_strd,

    UWORD8 *pu1_pred,

    WORD32 pred_strd,

    WORD16 *pi2_dst,

    WORD32 dst_strd,

    WORD32 **ppi4_hsad,

    WORD32 **ppi4_tu_split,

    WORD32 **ppi4_tu_early_cbf,

    WORD32 pos_x_y_4x4,

    WORD32 num_4x4_in_row,

    WORD32 lambda,

    WORD32 lambda_q_shift,

    WORD32 i4_frm_qstep,

    WORD32 i4_cur_depth,

    WORD32 i4_max_depth,

    WORD32 i4_max_tr_size,

    WORD32 *pi4_tu_split_cost,

    void *pv_func_sel)

{

    WORD16 ai2_4x4_had[64];

    WORD32 pos_x = pos_x_y_4x4 & 0xFFFF;

    WORD32 pos_y = (pos_x_y_4x4 >> 16) & 0xFFFF;

    WORD32 *pi4_4x4_hsad;

    WORD32 *pi4_8x8_hsad;

    WORD32 *pi4_8x8_tu_split;

    WORD32 *pi4_8x8_tu_early_cbf;

    UWORD32 u4_satd;

    WORD32 cost_child = 0, cost_parent = 0;

    WORD32 early_cbf = 0;

    const UWORD8 u1_cur_tr_size = 8;

    /* Stores the best cost for the Current 8x8: Lokesh */

    WORD32 best_cost = 0;

    (void)pv_func_sel;

    ASSERT(pos_x >= 0);

    ASSERT(pos_y >= 0);

    /* Initialize pointers to  store 4x4 and 8x8 HAD SATDs */

    pi4_4x4_hsad = ppi4_hsad[HAD_4x4] + pos_x + pos_y * num_4x4_in_row;

    pi4_8x8_hsad = ppi4_hsad[HAD_8x8] + (pos_x >> 1) + (pos_y >> 1) * (num_4x4_in_row >> 1);

    pi4_8x8_tu_split = ppi4_tu_split[HAD_8x8] + (pos_x >> 1) + (pos_y >> 1) * (num_4x4_in_row >> 1);

    pi4_8x8_tu_early_cbf =

        ppi4_tu_early_cbf[HAD_8x8] + (pos_x >> 1) + (pos_y >> 1) * (num_4x4_in_row >> 1);

    /* -------- Compute four 4x4 HAD Transforms of 8x8 in one call--------- */

    cost_child = ihevce_had4_4x4(

        pu1_src, src_strd, pu1_pred, pred_strd, ai2_4x4_had, 8, pi4_4x4_hsad, num_4x4_in_row, 0);

    /* -------- Compute 8x8 HAD Transform using 4x4 results ------------- */

    u4_satd = ihevce_compute_8x8HAD_using_4x4(

        ai2_4x4_had, 8, pi2_dst, dst_strd, i4_frm_qstep, &early_cbf);

    /* store the normalized 8x8 satd */

    cost_parent = ((u4_satd + 4) >> 3);

    /* 4 CBF Flags, extra 1 becoz of the 0.5 bits per bin is assumed */

    cost_child += ((4) * lambda) >> (lambda_q_shift + 1);

    if(i4_cur_depth < i4_max_depth)

    {

        if((cost_child < cost_parent) || (i4_max_tr_size < u1_cur_tr_size))

        {

            //cost_child -= ((4) * lambda) >> (lambda_q_shift + 1);

            *pi4_tu_split_cost += (4 * lambda) >> (lambda_q_shift + 1);

            best_cost = cost_child;

            best_cost <<= 1;

            best_cost++;

            pi4_8x8_tu_split[0] = 1;

            pi4_8x8_hsad[0] = cost_child;

        }

        else

        {

            //cost_parent -= ((1) * lambda) >>  (lambda_q_shift + 1);

            best_cost = cost_parent;

            best_cost <<= 1;

            pi4_8x8_tu_split[0] = 0;

            pi4_8x8_hsad[0] = cost_parent;

        }

    }

    else

    {

        //cost_parent -= ((1) * lambda) >>  (lambda_q_shift + 1);

        best_cost = cost_parent;

        best_cost <<= 1;

        pi4_8x8_tu_split[0] = 0;

        pi4_8x8_hsad[0] = cost_parent;

    }

    pi4_8x8_tu_early_cbf[0] = early_cbf;

    /* best cost has tu_split_flag at LSB(Least significant bit) */

    return ((best_cost << 1) + early_cbf);

}

/**

*******************************************************************************

*

* @brief

*   Computes 16x16 transform using children 8x8 hadamard results

*    Modified to incorporate the dead-zone implementation - Lokesh

*

* @par Description:

*

* @param[in] pi2_8x8_had

*  WORD16 pointer to 8x8 hadamard buffer(y0, y1, y2, y3 hadmard in Zscan order)

*

* @param[in] had8_strd

*  stride of 8x8 hadmard buffer pi2_y0, pi2_y1, pi2_y2, pi2_y3

*

* @param[out] pi2_dst

*  destination buffer where 8x8 hadamard result is stored

*

* @param[in] dst_stride

*  stride of destination block

*

* @param[in] i4_frm_qstep

*  frm_qstep value based on the which the threshold value is calculated

*

* @returns

*  16x16 Hadamard SATD

* @remarks

*

*******************************************************************************

*/

static UWORD32 ihevce_compute_16x16HAD_using_8x8(

    WORD16 *pi2_8x8_had,

    WORD32 had8_strd,

    WORD16 *pi2_dst,

    WORD32 dst_strd,

    WORD32 i4_frm_qstep,

    WORD32 *pi4_cbf)

{

    /* Qstep value is right shifted by 8 */

    WORD32 threshold = (i4_frm_qstep >> 8);