xref: /frameworks/av/media/libstagefright/codecs/m4v_h263/dec/src/dcac_prediction.cpp

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

/*----------------------------------------------------------------------------
; INCLUDES
----------------------------------------------------------------------------*/
#include "mp4dec_lib.h"
#include "vlc_decode.h"
#include "bitstream.h"
#include "zigzag.h"
#include "scaling.h"

void    doDCACPrediction(
    VideoDecData *video,
    int comp,
    int16 *q_block,
    int *direction
)
{
    /*----------------------------------------------------------------------------
    ; Define all local variables
    ----------------------------------------------------------------------------*/
    int i;
    int mbnum = video->mbnum;
    int nMBPerRow = video->nMBPerRow;
    int x_pos = video->mbnum_col;
    int y_pos = video->mbnum_row;
    int16 *AC_tmp;
    int QP_tmp;
    int16 *QP_store = video->QPMB + mbnum;
    int QP = video->QPMB[mbnum];
    int QP_half = QP >> 1;
    int32 val;
    int flag_0 = FALSE, flag_1 = FALSE;
    uint8 *slice_nb = video->sliceNo;
    typeDCStore *DC_store = video->predDC + mbnum;
    typeDCACStore *DCAC_row = video->predDCAC_row + x_pos;
    typeDCACStore *DCAC_col = video->predDCAC_col;

    uint ACpred_flag = (uint) video->acPredFlag[mbnum];

    int left_bnd, up_bnd;

    static const int Xpos[6] = { -1, 0, -1, 0, -1, -1};
    static const int Ypos[6] = { -1, -1, 0, 0, -1, -1};

    static const int Xtab[6] = {1, 0, 3, 2, 4, 5};
    static const int Ytab[6] = {2, 3, 0, 1, 4, 5};
    static const int Ztab[6] = {3, 2, 1, 0, 4, 5};

    /* I added these to speed up comparisons */
    static const int Pos0[6] = { 1, 1, 0, 0, 1, 1};
    static const int Pos1[6] = { 1, 0, 1, 0, 1, 1};

    static const int B_Xtab[6] = {0, 1, 0, 1, 2, 3};
    static const int B_Ytab[6] = {0, 0, 1, 1, 2, 3};

//  int *direction;     /* 0: HORIZONTAL, 1: VERTICAL */
    int block_A, block_B, block_C;
    int DC_pred;
    int y_offset, x_offset, x_tab, y_tab, z_tab;    /* speedup coefficients */
    int b_xtab, b_ytab;

    if (!comp && x_pos && !(video->headerInfo.Mode[mbnum-1]&INTRA_MASK)) /* not intra */
    {
        oscl_memset(DCAC_col, 0, sizeof(typeDCACStore));
    }
    if (!comp && y_pos && !(video->headerInfo.Mode[mbnum-nMBPerRow]&INTRA_MASK)) /* not intra */
    {
        oscl_memset(DCAC_row, 0, sizeof(typeDCACStore));
    }

    y_offset = Ypos[comp] * nMBPerRow;
    x_offset = Xpos[comp];
    x_tab = Xtab[comp];
    y_tab = Ytab[comp];
    z_tab = Ztab[comp];

    b_xtab = B_Xtab[comp];
    b_ytab = B_Ytab[comp];

    /*----------------------------------------------------------------------------
    ; Function body here
    ----------------------------------------------------------------------------*/
    /* Find the direction of prediction and the DC prediction */

    if (x_pos == 0 && y_pos == 0)
    {   /* top left corner */
        block_A = (comp == 1 || comp == 3) ? flag_0 = TRUE, DC_store[0][x_tab] : mid_gray;
        block_B = (comp == 3) ? DC_store[x_offset][z_tab] : mid_gray;
        block_C = (comp == 2 || comp == 3) ? flag_1 = TRUE, DC_store[0][y_tab] : mid_gray;
    }
    else if (x_pos == 0)
    {   /* left edge */
        up_bnd   = Pos0[comp] && slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow];

        block_A = (comp == 1 || comp == 3) ? flag_0 = TRUE, DC_store[0][x_tab] : mid_gray;
        block_B = ((comp == 1 && up_bnd) || comp == 3) ?  DC_store[y_offset+x_offset][z_tab] : mid_gray;
        block_C = (comp == 2 || comp == 3 || up_bnd) ? flag_1 = TRUE, DC_store[y_offset][y_tab] : mid_gray;
    }
    else if (y_pos == 0)
    { /* top row */
        left_bnd = Pos1[comp] && slice_nb[mbnum] == slice_nb[mbnum-1];

        block_A = (comp == 1 || comp == 3 || left_bnd) ? flag_0 = TRUE, DC_store[x_offset][x_tab] : mid_gray;
        block_B = ((comp == 2 && left_bnd) || comp == 3) ? DC_store[y_offset + x_offset][z_tab] : mid_gray;
        block_C = (comp == 2 || comp == 3) ? flag_1 = TRUE, DC_store[y_offset][y_tab] : mid_gray;
    }
    else
    {
        up_bnd   = Pos0[comp] && slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow];
        left_bnd = Pos1[comp] && slice_nb[mbnum] == slice_nb[mbnum-1];

        block_A = (comp == 1 || comp == 3 || left_bnd) ? flag_0 = TRUE, DC_store[x_offset][x_tab] : mid_gray;
        block_B = (((comp == 0 || comp == 4 || comp == 5) && slice_nb[mbnum] == slice_nb[mbnum-1-nMBPerRow]) ||
                   (comp == 1 && up_bnd) || (comp == 2 && left_bnd) || (comp == 3)) ? DC_store[y_offset+x_offset][z_tab] : mid_gray;
        block_C = (comp == 2 || comp == 3 || up_bnd) ? flag_1 = TRUE, DC_store[y_offset][y_tab] : mid_gray;
    }


    if ((PV_ABS((block_A - block_B))) < (PV_ABS((block_B - block_C))))
    {
        DC_pred = block_C;
        *direction = 1;
        if (ACpred_flag == 1)
        {
            if (flag_1)
            {
                AC_tmp = DCAC_row[0][b_xtab];
                QP_tmp = QP_store[y_offset];
                if (QP_tmp == QP)
                {
                    for (i = 1; i < 8; i++)
                    {
                        q_block[i] = *AC_tmp++;
                    }
                }
                else
                {
                    for (i = 1; i < 8; i++)
                    {
                        val = (int32)(*AC_tmp++) * QP_tmp;
                        q_block[i] = (val < 0) ? (int16)((val - QP_half) / QP) : (int16)((val + QP_half) / QP);
                        /* Vertical, top ROW of block C */
                    }
                }
            }
        }
    }
    else
    {
        DC_pred = block_A;
        *direction = 0;
        if (ACpred_flag == 1)
        {
            if (flag_0)
            {
                AC_tmp = DCAC_col[0][b_ytab];
                QP_tmp = QP_store[x_offset];
                if (QP_tmp == QP)
                {
                    for (i = 1; i < 8; i++)
                    {
                        q_block[i<<3] = *AC_tmp++;
                    }
                }
                else
                {
                    for (i = 1; i < 8; i++)
                    {
                        val = (int32)(*AC_tmp++) * QP_tmp;
                        q_block[i<<3] = (val < 0) ? (int16)((val - QP_half) / QP) : (int16)((val + QP_half) / QP);
                        /* Vertical, top ROW of block C */
                    }
                }
            }
        }
    }

    /* Now predict the DC coefficient */
    QP_tmp = (comp < 4) ? video->mblock->DCScalarLum : video->mblock->DCScalarChr;
    q_block[0] += (int16)((DC_pred + (QP_tmp >> 1)) * scale[QP_tmp] >> 18);
//      q_block[0] += (DC_pred+(QP_tmp>>1))/QP_tmp;

    /*----------------------------------------------------------------------------
    ; Return nothing or data or data pointer
    ----------------------------------------------------------------------------*/
    return;
}
#ifdef PV_ANNEX_IJKT_SUPPORT
void    doDCACPrediction_I(
    VideoDecData *video,
    int comp,
    int16 *q_block
)
{
    /*----------------------------------------------------------------------------
    ; Define all local variables
    ----------------------------------------------------------------------------*/
    int mbnum = video->mbnum;
    int nMBPerRow = video->nMBPerRow;
    int x_pos = video->mbnum_col;
    int y_pos = video->mbnum_row;
    int16 *AC_tmp;
    int flag_0 = FALSE, flag_1 = FALSE;
    uint8 *slice_nb = video->sliceNo;
    typeDCStore *DC_store = video->predDC + mbnum;
    typeDCACStore *DCAC_row = video->predDCAC_row + x_pos;
    typeDCACStore *DCAC_col = video->predDCAC_col;
    int left_bnd, up_bnd;
    uint8 *mode = video->headerInfo.Mode;
    uint ACpred_flag = (uint) video->acPredFlag[mbnum];



    static const int Xpos[6] = { -1, 0, -1, 0, -1, -1};
    static const int Ypos[6] = { -1, -1, 0, 0, -1, -1};

    static const int Xtab[6] = {1, 0, 3, 2, 4, 5};
    static const int Ytab[6] = {2, 3, 0, 1, 4, 5};

    /* I added these to speed up comparisons */
    static const int Pos0[6] = { 1, 1, 0, 0, 1, 1};
    static const int Pos1[6] = { 1, 0, 1, 0, 1, 1};

    static const int B_Xtab[6] = {0, 1, 0, 1, 2, 3};
    static const int B_Ytab[6] = {0, 0, 1, 1, 2, 3};

//  int *direction;     /* 0: HORIZONTAL, 1: VERTICAL */
    int block_A, block_C;
    int y_offset, x_offset, x_tab, y_tab;   /* speedup coefficients */
    int b_xtab, b_ytab;
    y_offset = Ypos[comp] * nMBPerRow;
    x_offset = Xpos[comp];
    x_tab = Xtab[comp];
    y_tab = Ytab[comp];

    b_xtab = B_Xtab[comp];
    b_ytab = B_Ytab[comp];

    /*----------------------------------------------------------------------------
    ; Function body here
    ----------------------------------------------------------------------------*/
    /* Find the direction of prediction and the DC prediction */

    if (x_pos == 0 && y_pos == 0)
    {   /* top left corner */
        block_A = (comp == 1 || comp == 3) ? flag_0 = TRUE, DC_store[0][x_tab] : mid_gray;
        block_C = (comp == 2 || comp == 3) ? flag_1 = TRUE, DC_store[0][y_tab] : mid_gray;
    }
    else if (x_pos == 0)
    {   /* left edge */
        up_bnd   = (Pos0[comp] && slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow])
                   && (mode[mbnum-nMBPerRow] == MODE_INTRA || mode[mbnum-nMBPerRow] == MODE_INTRA_Q);;

        block_A = (comp == 1 || comp == 3) ? flag_0 = TRUE, DC_store[0][x_tab] : mid_gray;
        block_C = (comp == 2 || comp == 3 || up_bnd) ? flag_1 = TRUE, DC_store[y_offset][y_tab] : mid_gray;
    }
    else if (y_pos == 0)
    { /* top row */
        left_bnd = (Pos1[comp] && slice_nb[mbnum] == slice_nb[mbnum-1])
                   && (mode[mbnum-1] == MODE_INTRA || mode[mbnum-1] == MODE_INTRA_Q);

        block_A = (comp == 1 || comp == 3 || left_bnd) ? flag_0 = TRUE, DC_store[x_offset][x_tab] : mid_gray;
        block_C = (comp == 2 || comp == 3) ? flag_1 = TRUE, DC_store[y_offset][y_tab] : mid_gray;
    }
    else
    {
        up_bnd   = (Pos0[comp] && slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow])
                   && (mode[mbnum-nMBPerRow] == MODE_INTRA || mode[mbnum-nMBPerRow] == MODE_INTRA_Q);
        left_bnd = (Pos1[comp] && slice_nb[mbnum] == slice_nb[mbnum-1])
                   && (mode[mbnum-1] == MODE_INTRA || mode[mbnum-1] == MODE_INTRA_Q);

        block_A = (comp == 1 || comp == 3 || left_bnd) ? flag_0 = TRUE, DC_store[x_offset][x_tab] : mid_gray;
        block_C = (comp == 2 || comp == 3 || up_bnd) ? flag_1 = TRUE, DC_store[y_offset][y_tab] : mid_gray;
    }

    if (ACpred_flag == 0)
    {
        if (flag_0 == TRUE)
        {
            if (flag_1 == TRUE)
            {
                q_block[0] = (int16)((block_A + block_C) >> 1);
            }
            else
            {
                q_block[0] = (int16)block_A;
            }
        }
        else
        {
            if (flag_1 == TRUE)
            {
                q_block[0] = (int16)block_C;
            }
            else
            {
                q_block[0] = mid_gray;
            }
        }

    }
    else
    {
        if (video->mblock->direction == 1)
        {
            if (flag_1 == TRUE)
            {
                q_block[0] = (int16)block_C;

                AC_tmp = DCAC_row[0][b_xtab];
                q_block[1] = AC_tmp[0];
                q_block[2] = AC_tmp[1];
                q_block[3] = AC_tmp[2];
                q_block[4] = AC_tmp[3];
                q_block[5] = AC_tmp[4];
                q_block[6] = AC_tmp[5];
                q_block[7] = AC_tmp[6];
            }
            else
            {
                q_block[0] = mid_gray;
            }
        }
        else
        {
            if (flag_0 == TRUE)
            {
                q_block[0] = (int16)block_A;

                AC_tmp = DCAC_col[0][b_ytab];
                q_block[8] = AC_tmp[0];
                q_block[16] = AC_tmp[1];
                q_block[24] = AC_tmp[2];
                q_block[32] = AC_tmp[3];
                q_block[40] = AC_tmp[4];
                q_block[48] = AC_tmp[5];
                q_block[56] = AC_tmp[6];
            }
            else
            {
                q_block[0] = mid_gray;
            }
        }
    }
    /*----------------------------------------------------------------------------
    ; Return nothing or data or data pointer
    ----------------------------------------------------------------------------*/
    return;
}
#endif