diff options
Diffstat (limited to 'media/libstagefright/codecs/on2/h264dec/source/h264bsd_neighbour.c')
-rwxr-xr-x | media/libstagefright/codecs/on2/h264dec/source/h264bsd_neighbour.c | 382 |
1 files changed, 382 insertions, 0 deletions
diff --git a/media/libstagefright/codecs/on2/h264dec/source/h264bsd_neighbour.c b/media/libstagefright/codecs/on2/h264dec/source/h264bsd_neighbour.c new file mode 100755 index 0000000..ce5eeff --- /dev/null +++ b/media/libstagefright/codecs/on2/h264dec/source/h264bsd_neighbour.c @@ -0,0 +1,382 @@ +/* + * Copyright (C) 2009 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. + */ + +/*------------------------------------------------------------------------------ + + 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); + +} + |