ref: bb4b01a1f96ee6576fb0ccc8237cf635e89a01ec
dir: h264bsd/src/h264bsd_neighbour.c
/*
* Copyright (C) 2009 The Android Open Source Project
* Modified for use by h264bsd standalone library
*
* 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.
*/
/*------------------------------------------------------------------------------
Table of contents
1. Include headers
2. External compiler flags
3. Module defines
4. Local function prototypes
5. Functions
h264bsdInitMbNeighbours
h264bsdGetNeighbourMb
h264bsdNeighbour4x4BlockA
h264bsdNeighbour4x4BlockB
h264bsdNeighbour4x4BlockC
h264bsdNeighbour4x4BlockD
------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------
1. Include headers
------------------------------------------------------------------------------*/
#include "h264bsd_neighbour.h"
#include "h264bsd_util.h"
/*------------------------------------------------------------------------------
2. External compiler flags
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
3. Module defines
------------------------------------------------------------------------------*/
/* Following four tables indicate neighbours of each block of a macroblock.
* First 16 values are for luma blocks, next 4 values for Cb and last 4
* values for Cr. Elements of the table indicate to which macroblock the
* neighbour block belongs and the index of the neighbour block in question.
* Indexing of the blocks goes as follows
*
* Y Cb Cr
* 0 1 4 5 16 17 20 21
* 2 3 6 7 18 19 22 23
* 8 9 12 13
* 10 11 14 15
*/
/* left neighbour for each block */
static const neighbour_t N_A_4x4B[24] = {
{MB_A,5}, {MB_CURR,0}, {MB_A,7}, {MB_CURR,2},
{MB_CURR,1}, {MB_CURR,4}, {MB_CURR,3}, {MB_CURR,6},
{MB_A,13}, {MB_CURR,8}, {MB_A,15}, {MB_CURR,10},
{MB_CURR,9}, {MB_CURR,12},{MB_CURR,11},{MB_CURR,14},
{MB_A,17}, {MB_CURR,16},{MB_A,19}, {MB_CURR,18},
{MB_A,21}, {MB_CURR,20},{MB_A,23}, {MB_CURR,22} };
/* above neighbour for each block */
static const neighbour_t N_B_4x4B[24] = {
{MB_B,10}, {MB_B,11}, {MB_CURR,0}, {MB_CURR,1},
{MB_B,14}, {MB_B,15}, {MB_CURR,4}, {MB_CURR,5},
{MB_CURR,2}, {MB_CURR,3}, {MB_CURR,8}, {MB_CURR,9},
{MB_CURR,6}, {MB_CURR,7}, {MB_CURR,12},{MB_CURR,13},
{MB_B,18}, {MB_B,19}, {MB_CURR,16},{MB_CURR,17},
{MB_B,22}, {MB_B,23}, {MB_CURR,20},{MB_CURR,21} };
/* above-right neighbour for each block */
static const neighbour_t N_C_4x4B[24] = {
{MB_B,11}, {MB_B,14}, {MB_CURR,1}, {MB_NA,4},
{MB_B,15}, {MB_C,10}, {MB_CURR,5}, {MB_NA,0},
{MB_CURR,3}, {MB_CURR,6}, {MB_CURR,9}, {MB_NA,12},
{MB_CURR,7}, {MB_NA,2}, {MB_CURR,13},{MB_NA,8},
{MB_B,19}, {MB_C,18}, {MB_CURR,17},{MB_NA,16},
{MB_B,23}, {MB_C,22}, {MB_CURR,21},{MB_NA,20} };
/* above-left neighbour for each block */
static const neighbour_t N_D_4x4B[24] = {
{MB_D,15}, {MB_B,10}, {MB_A,5}, {MB_CURR,0},
{MB_B,11}, {MB_B,14}, {MB_CURR,1}, {MB_CURR,4},
{MB_A,7}, {MB_CURR,2}, {MB_A,13}, {MB_CURR,8},
{MB_CURR,3}, {MB_CURR,6}, {MB_CURR,9}, {MB_CURR,12},
{MB_D,19}, {MB_B,18}, {MB_A,17}, {MB_CURR,16},
{MB_D,23}, {MB_B,22}, {MB_A,21}, {MB_CURR,20} };
/*------------------------------------------------------------------------------
4. Local function prototypes
------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------
Function: h264bsdInitMbNeighbours
Functional description:
Initialize macroblock neighbours. Function sets neighbour
macroblock pointers in macroblock structures to point to
macroblocks on the left, above, above-right and above-left.
Pointers are set NULL if the neighbour does not fit into the
picture.
Inputs:
picWidth width of the picture in macroblocks
picSizeInMbs no need to clarify
Outputs:
pMbStorage neighbour pointers of each mbStorage structure
stored here
Returns:
none
------------------------------------------------------------------------------*/
void h264bsdInitMbNeighbours(mbStorage_t *pMbStorage, u32 picWidth,
u32 picSizeInMbs)
{
/* Variables */
u32 i, row, col;
/* Code */
ASSERT(pMbStorage);
ASSERT(picWidth);
ASSERT(picWidth <= picSizeInMbs);
ASSERT(((picSizeInMbs / picWidth) * picWidth) == picSizeInMbs);
row = col = 0;
for (i = 0; i < picSizeInMbs; i++)
{
if (col)
pMbStorage[i].mbA = pMbStorage + i - 1;
else
pMbStorage[i].mbA = NULL;
if (row)
pMbStorage[i].mbB = pMbStorage + i - picWidth;
else
pMbStorage[i].mbB = NULL;
if (row && (col < picWidth - 1))
pMbStorage[i].mbC = pMbStorage + i - (picWidth - 1);
else
pMbStorage[i].mbC = NULL;
if (row && col)
pMbStorage[i].mbD = pMbStorage + i - (picWidth + 1);
else
pMbStorage[i].mbD = NULL;
col++;
if (col == picWidth)
{
col = 0;
row++;
}
}
}
/*------------------------------------------------------------------------------
Function: h264bsdGetNeighbourMb
Functional description:
Get pointer to neighbour macroblock.
Inputs:
pMb pointer to macroblock structure of the macroblock
whose neighbour is wanted
neighbour indicates which neighbour is wanted
Outputs:
none
Returns:
pointer to neighbour macroblock
NULL if not available
------------------------------------------------------------------------------*/
mbStorage_t* h264bsdGetNeighbourMb(mbStorage_t *pMb, neighbourMb_e neighbour)
{
/* Variables */
/* Code */
ASSERT((neighbour <= MB_CURR) || (neighbour == MB_NA));
if (neighbour == MB_A)
return(pMb->mbA);
else if (neighbour == MB_B)
return(pMb->mbB);
else if (neighbour == MB_C)
return(pMb->mbC);
else if (neighbour == MB_D)
return(pMb->mbD);
else if (neighbour == MB_CURR)
return(pMb);
else
return(NULL);
}
/*------------------------------------------------------------------------------
Function: h264bsdNeighbour4x4BlockA
Functional description:
Get left neighbour of the block. Function returns pointer to
the table defined in the beginning of the file.
Inputs:
blockIndex indicates the block whose neighbours are wanted
Outputs:
Returns:
pointer to neighbour structure
------------------------------------------------------------------------------*/
const neighbour_t* h264bsdNeighbour4x4BlockA(u32 blockIndex)
{
/* Variables */
/* Code */
ASSERT(blockIndex < 24);
return(N_A_4x4B+blockIndex);
}
/*------------------------------------------------------------------------------
Function: h264bsdNeighbour4x4BlockB
Functional description:
Get above neighbour of the block. Function returns pointer to
the table defined in the beginning of the file.
Inputs:
blockIndex indicates the block whose neighbours are wanted
Outputs:
Returns:
pointer to neighbour structure
------------------------------------------------------------------------------*/
const neighbour_t* h264bsdNeighbour4x4BlockB(u32 blockIndex)
{
/* Variables */
/* Code */
ASSERT(blockIndex < 24);
return(N_B_4x4B+blockIndex);
}
/*------------------------------------------------------------------------------
Function: h264bsdNeighbour4x4BlockC
Functional description:
Get above-right neighbour of the block. Function returns pointer
to the table defined in the beginning of the file.
Inputs:
blockIndex indicates the block whose neighbours are wanted
Outputs:
Returns:
pointer to neighbour structure
------------------------------------------------------------------------------*/
const neighbour_t* h264bsdNeighbour4x4BlockC(u32 blockIndex)
{
/* Variables */
/* Code */
ASSERT(blockIndex < 24);
return(N_C_4x4B+blockIndex);
}
/*------------------------------------------------------------------------------
Function: h264bsdNeighbour4x4BlockD
Functional description:
Get above-left neighbour of the block. Function returns pointer to
the table defined in the beginning of the file.
Inputs:
blockIndex indicates the block whose neighbours are wanted
Outputs:
Returns:
pointer to neighbour structure
------------------------------------------------------------------------------*/
const neighbour_t* h264bsdNeighbour4x4BlockD(u32 blockIndex)
{
/* Variables */
/* Code */
ASSERT(blockIndex < 24);
return(N_D_4x4B+blockIndex);
}
/*------------------------------------------------------------------------------
Function: h264bsdIsNeighbourAvailable
Functional description:
Check if neighbour macroblock is available. Neighbour macroblock
is considered available if it is within the picture and belongs
to the same slice as the current macroblock.
Inputs:
pMb pointer to the current macroblock
pNeighbour pointer to the neighbour macroblock
Outputs:
none
Returns:
TRUE neighbour is available
FALSE neighbour is not available
------------------------------------------------------------------------------*/
u32 h264bsdIsNeighbourAvailable(mbStorage_t *pMb, mbStorage_t *pNeighbour)
{
/* Variables */
/* Code */
if ( (pNeighbour == NULL) || (pMb->sliceId != pNeighbour->sliceId) )
return(HANTRO_FALSE);
else
return(HANTRO_TRUE);
}