| /* |
| * 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); |
| |
| } |
| |
