You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
383 lines
11 KiB
383 lines
11 KiB
/*
|
|
* 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);
|
|
|
|
}
|
|
|
|
|