mb_access.cpp | searchcode

/Avc/mb_access.cpp

http://github.com/mbebenita/Broadway
C++ | 471 lines | 379 code | 54 blank | 38 comment | 99 complexity | d9b7dcf8927defa147d8dcd8ca4821bb MD5 | raw file
Possible License(s): BSD-3-Clause

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

#include "avclib_common.h"

OSCL_EXPORT_REF void InitNeighborAvailability(AVCCommonObj *video, int mbNum)
{
    int PicWidthInMbs = video->PicWidthInMbs;

    // do frame-only and postpone intraAvail calculattion
    video->mbAddrA = mbNum - 1;
    video->mbAddrB = mbNum - PicWidthInMbs;
    video->mbAddrC = mbNum - PicWidthInMbs + 1;
    video->mbAddrD = mbNum - PicWidthInMbs - 1;

    video->mbAvailA = video->mbAvailB = video->mbAvailC = video->mbAvailD = 0;
    if (video->mb_x)
    {
        video->mbAvailA = (video->mblock[video->mbAddrA].slice_id == video->currMB->slice_id);
        if (video->mb_y)
        {
            video->mbAvailD = (video->mblock[video->mbAddrD].slice_id == video->currMB->slice_id);
        }
    }

    if (video->mb_y)
    {
        video->mbAvailB = (video->mblock[video->mbAddrB].slice_id == video->currMB->slice_id);
        if (video->mb_x < (PicWidthInMbs - 1))
        {
            video->mbAvailC = (video->mblock[video->mbAddrC].slice_id == video->currMB->slice_id);
        }
    }
    return ;
}

bool mb_is_available(AVCMacroblock *mblock, uint PicSizeInMbs, int mbAddr, int currMbAddr)
{
    if (mbAddr < 0 || mbAddr >= (int)PicSizeInMbs)
    {
        return FALSE;
    }

    if (mblock[mbAddr].slice_id != mblock[currMbAddr].slice_id)
    {
        return FALSE;
    }

    return TRUE;
}

OSCL_EXPORT_REF int predict_nnz(AVCCommonObj *video, int i, int j)
{
    int pred_nnz = 0;
    int cnt      = 1;
    AVCMacroblock *tempMB;

    /* left block */
    /*getLuma4x4Neighbour(video, mb_nr, i, j, -1, 0, &pix);
    leftMB = video->mblock + pix.mb_addr; */
    /* replace the above with below (won't work for field decoding),  1/19/04 */

    if (i)
    {
        pred_nnz = video->currMB->nz_coeff[(j<<2)+i-1];
    }
    else
    {
        if (video->mbAvailA)
        {
            tempMB = video->mblock + video->mbAddrA;
            pred_nnz = tempMB->nz_coeff[(j<<2)+3];
        }
        else
        {
            cnt = 0;
        }
    }


    /* top block */
    /*getLuma4x4Neighbour(video, mb_nr, i, j, 0, -1, &pix);
    topMB = video->mblock + pix.mb_addr;*/
    /* replace the above with below (won't work for field decoding),  1/19/04 */

    if (j)
    {
        pred_nnz += video->currMB->nz_coeff[((j-1)<<2)+i];
        cnt++;
    }
    else
    {
        if (video->mbAvailB)
        {
            tempMB = video->mblock + video->mbAddrB;
            pred_nnz += tempMB->nz_coeff[12+i];
            cnt++;
        }
    }


    if (cnt == 2)
    {
        pred_nnz = (pred_nnz + 1) >> 1;
    }

    return pred_nnz;

}


OSCL_EXPORT_REF int predict_nnz_chroma(AVCCommonObj *video, int i, int j)
{
    int pred_nnz = 0;
    int cnt      = 1;
    AVCMacroblock *tempMB;

    /* left block */
    /*getChroma4x4Neighbour(video, mb_nr, i%2, j-4, -1, 0, &pix);
    leftMB = video->mblock + pix.mb_addr;*/
    /* replace the above with below (won't work for field decoding),  1/19/04 */
    if (i&1)
    {
        pred_nnz = video->currMB->nz_coeff[(j<<2)+i-1];

    }
    else
    {
        if (video->mbAvailA)
        {
            tempMB = video->mblock + video->mbAddrA;
            pred_nnz = tempMB->nz_coeff[(j<<2)+i+1];
        }
        else
        {
            cnt = 0;
        }
    }


    /* top block */
    /*getChroma4x4Neighbour(video, mb_nr, i%2, j-4, 0, -1, &pix);
    topMB = video->mblock + pix.mb_addr;*/
    /* replace the above with below (won't work for field decoding),  1/19/04 */

    if (j&1)
    {
        pred_nnz += video->currMB->nz_coeff[((j-1)<<2)+i];
        cnt++;
    }
    else
    {
        if (video->mbAvailB)
        {
            tempMB = video->mblock + video->mbAddrB;
            pred_nnz += tempMB->nz_coeff[20+i];
            cnt++;
        }

    }

    if (cnt == 2)
    {
        pred_nnz = (pred_nnz + 1) >> 1;
    }

    return pred_nnz;
}

OSCL_EXPORT_REF void GetMotionVectorPredictor(AVCCommonObj *video, int encFlag)
{
    AVCMacroblock *currMB = video->currMB;
    AVCMacroblock *MB_A, *MB_B, *MB_C, *MB_D;
    int block_x, block_y, block_x_1, block_y_1, new_block_x;
    int mbPartIdx, subMbPartIdx, offset_indx;
    int16 *mv, pmv_x, pmv_y;
    int nmSubMbHeight, nmSubMbWidth, mbPartIdx_X, mbPartIdx_Y;
    int avail_a, avail_b, avail_c;
    const static uint32 C = 0x5750;
    int i, j, offset_MbPart_indx, refIdxLXA, refIdxLXB, refIdxLXC = 0, curr_ref_idx;
    int pmv_A_x, pmv_B_x, pmv_C_x = 0, pmv_A_y, pmv_B_y, pmv_C_y = 0;

    /* we have to take care of Intra/skip blocks somewhere, i.e. set MV to  0 and set ref to -1! */
    /* we have to populate refIdx as well */


    MB_A = &video->mblock[video->mbAddrA];
    MB_B = &video->mblock[video->mbAddrB];


    if (currMB->mbMode == AVC_SKIP /* && !encFlag */) /* only for decoder */
    {
        currMB->ref_idx_L0[0] = currMB->ref_idx_L0[1] = currMB->ref_idx_L0[2] = currMB->ref_idx_L0[3] = 0;
        if (video->mbAvailA && video->mbAvailB)
        {
            if ((MB_A->ref_idx_L0[1] == 0 && MB_A->mvL0[3] == 0) ||
                    (MB_B->ref_idx_L0[2] == 0 && MB_B->mvL0[12] == 0))
            {
                memset(currMB->mvL0, 0, sizeof(int32)*16);
                return;
            }
        }
        else
        {
            memset(currMB->mvL0, 0, sizeof(int32)*16);
            return;
        }
        video->mvd_l0[0][0][0] = 0;
        video->mvd_l0[0][0][1] = 0;
    }

    MB_C = &video->mblock[video->mbAddrC];
    MB_D = &video->mblock[video->mbAddrD];

    offset_MbPart_indx = 0;
    for (mbPartIdx = 0; mbPartIdx < currMB->NumMbPart; mbPartIdx++)
    {
        offset_indx = 0;
        nmSubMbHeight = currMB->SubMbPartHeight[mbPartIdx] >> 2;
        nmSubMbWidth = currMB->SubMbPartWidth[mbPartIdx] >> 2;
        mbPartIdx_X = ((mbPartIdx + offset_MbPart_indx) & 1) << 1;
        mbPartIdx_Y = (mbPartIdx + offset_MbPart_indx) & 2;

        for (subMbPartIdx = 0; subMbPartIdx < currMB->NumSubMbPart[mbPartIdx]; subMbPartIdx++)
        {
            block_x = mbPartIdx_X + ((subMbPartIdx + offset_indx) & 1);
            block_y = mbPartIdx_Y + (((subMbPartIdx + offset_indx) >> 1) & 1);

            block_x_1 = block_x - 1;
            block_y_1 = block_y - 1;
            refIdxLXA = refIdxLXB = refIdxLXC = -1;
            pmv_A_x = pmv_A_y = pmv_B_x = pmv_B_y = pmv_C_x = pmv_C_y = 0;

            if (block_x)
            {
                avail_a = 1;
                refIdxLXA = currMB->ref_idx_L0[(block_y & 2) + (block_x_1 >> 1)];
                mv = (int16*)(currMB->mvL0 + (block_y << 2) + block_x_1);
                pmv_A_x = *mv++;
                pmv_A_y = *mv;
            }
            else
            {
                avail_a = video->mbAvailA;
                if (avail_a)
                {
                    refIdxLXA = MB_A->ref_idx_L0[(block_y & 2) + 1];
                    mv = (int16*)(MB_A->mvL0 + (block_y << 2) + 3);
                    pmv_A_x = *mv++;
                    pmv_A_y = *mv;
                }
            }

            if (block_y)
            {
                avail_b = 1;
                refIdxLXB = currMB->ref_idx_L0[(block_y_1 & 2) + (block_x >> 1)];
                mv = (int16*)(currMB->mvL0 + (block_y_1 << 2) + block_x);
                pmv_B_x = *mv++;
                pmv_B_y = *mv;
            }

            else
            {
                avail_b = video->mbAvailB;
                if (avail_b)
                {
                    refIdxLXB = MB_B->ref_idx_L0[2 + (block_x >> 1)];
                    mv = (int16*)(MB_B->mvL0 + 12 + block_x);
                    pmv_B_x = *mv++;
                    pmv_B_y = *mv;
                }
            }

            new_block_x = block_x + (currMB->SubMbPartWidth[mbPartIdx] >> 2) - 1;
            avail_c = (C >> ((block_y << 2) + new_block_x)) & 0x1;

            if (avail_c)
            {
                /* it guaranteed that block_y > 0 && new_block_x<3 ) */
                refIdxLXC = currMB->ref_idx_L0[(block_y_1 & 2) + ((new_block_x+1) >> 1)];
                mv = (int16*)(currMB->mvL0 + (block_y_1 << 2) + (new_block_x + 1));
                pmv_C_x = *mv++;
                pmv_C_y = *mv;
            }
            else
            {
                if (block_y == 0 && new_block_x < 3)
                {
                    avail_c = video->mbAvailB;
                    if (avail_c)
                    {
                        refIdxLXC = MB_B->ref_idx_L0[2 + ((new_block_x+1)>>1)];
                        mv = (int16*)(MB_B->mvL0 + 12 + (new_block_x + 1));
                        pmv_C_x = *mv++;
                        pmv_C_y = *mv;
                    }
                }
                else if (block_y == 0 && new_block_x == 3)
                {
                    avail_c = video->mbAvailC;
                    if (avail_c)
                    {
                        refIdxLXC = MB_C->ref_idx_L0[2];
                        mv = (int16*)(MB_C->mvL0 + 12);
                        pmv_C_x = *mv++;
                        pmv_C_y = *mv;
                    }
                }

                if (avail_c == 0)
                {   /* check D */
                    if (block_x && block_y)
                    {
                        avail_c = 1;
                        refIdxLXC =  currMB->ref_idx_L0[(block_y_1 & 2) + (block_x_1 >> 1)];
                        mv = (int16*)(currMB->mvL0 + (block_y_1 << 2) + block_x_1);
                        pmv_C_x = *mv++;
                        pmv_C_y = *mv;
                    }
                    else if (block_y)
                    {
                        avail_c = video->mbAvailA;
                        if (avail_c)
                        {
                            refIdxLXC =  MB_A->ref_idx_L0[(block_y_1 & 2) + 1];
                            mv = (int16*)(MB_A->mvL0 + (block_y_1 << 2) + 3);
                            pmv_C_x = *mv++;
                            pmv_C_y = *mv;
                        }
                    }
                    else if (block_x)
                    {
                        avail_c = video->mbAvailB;
                        if (avail_c)
                        {
                            refIdxLXC = MB_B->ref_idx_L0[2 + (block_x_1 >> 1)];
                            mv = (int16*)(MB_B->mvL0 + 12 + block_x_1);
                            pmv_C_x = *mv++;
                            pmv_C_y = *mv;
                        }
                    }
                    else
                    {
                        avail_c = video->mbAvailD;
                        if (avail_c)
                        {
                            refIdxLXC = MB_D->ref_idx_L0[3];
                            mv = (int16*)(MB_D->mvL0 + 15);
                            pmv_C_x = *mv++;
                            pmv_C_y = *mv;
                        }
                    }
                }
            }

            offset_indx = currMB->SubMbPartWidth[mbPartIdx] >> 3;

            curr_ref_idx = currMB->ref_idx_L0[(block_y & 2) + (block_x >> 1)];

            if (avail_a && !(avail_b || avail_c))
            {
                pmv_x = pmv_A_x;
                pmv_y = pmv_A_y;
            }
            else if (((curr_ref_idx == refIdxLXA) + (curr_ref_idx == refIdxLXB) + (curr_ref_idx == refIdxLXC)) == 1)
            {
                if (curr_ref_idx == refIdxLXA)
                {
                    pmv_x = pmv_A_x;
                    pmv_y = pmv_A_y;
                }
                else if (curr_ref_idx == refIdxLXB)
                {
                    pmv_x = pmv_B_x;
                    pmv_y = pmv_B_y;
                }
                else
                {
                    pmv_x = pmv_C_x;
                    pmv_y = pmv_C_y;
                }
            }
            else
            {
                pmv_x = AVC_MEDIAN(pmv_A_x, pmv_B_x, pmv_C_x);
                pmv_y = AVC_MEDIAN(pmv_A_y, pmv_B_y, pmv_C_y);
            }

            /* overwrite if special case */
            if (currMB->NumMbPart == 2)
            {
                if (currMB->MbPartWidth == 16)
                {
                    if (mbPartIdx == 0)
                    {
                        if (refIdxLXB == curr_ref_idx)
                        {
                            pmv_x = pmv_B_x;
                            pmv_y = pmv_B_y;
                        }
                    }
                    else if (refIdxLXA == curr_ref_idx)
                    {
                        pmv_x = pmv_A_x;
                        pmv_y = pmv_A_y;
                    }
                }
                else
                {
                    if (mbPartIdx == 0)
                    {
                        if (refIdxLXA == curr_ref_idx)
                        {
                            pmv_x = pmv_A_x;
                            pmv_y = pmv_A_y;
                        }
                    }
                    else if (refIdxLXC == curr_ref_idx)
                    {
                        pmv_x = pmv_C_x;
                        pmv_y = pmv_C_y;
                    }
                }
            }

            mv = (int16*)(currMB->mvL0 + block_x + (block_y << 2));

            if (encFlag) /* calculate residual MV video->mvd_l0 */
            {
                video->mvd_l0[mbPartIdx][subMbPartIdx][0] = *mv++ - pmv_x;
                video->mvd_l0[mbPartIdx][subMbPartIdx][1] = *mv++ - pmv_y;
            }
            else    /* calculate original MV currMB->mvL0 */
            {
                pmv_x += video->mvd_l0[mbPartIdx][subMbPartIdx][0];
                pmv_y += video->mvd_l0[mbPartIdx][subMbPartIdx][1];

                for (i = 0; i < nmSubMbHeight; i++)
                {
                    for (j = 0; j < nmSubMbWidth; j++)
                    {
                        *mv++ = pmv_x;
                        *mv++ = pmv_y;
                    }
                    mv += (8 - (j << 1));
                }
            }
        }
        offset_MbPart_indx = currMB->MbPartWidth >> 4;

    }
}