| /* |
| * 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 |
| h264bsdInterPrediction |
| MvPrediction16x16 |
| MvPrediction16x8 |
| MvPrediction8x16 |
| MvPrediction8x8 |
| MvPrediction |
| MedianFilter |
| GetInterNeighbour |
| GetPredictionMv |
| |
| ------------------------------------------------------------------------------*/ |
| |
| /*------------------------------------------------------------------------------ |
| 1. Include headers |
| ------------------------------------------------------------------------------*/ |
| |
| #include "h264bsd_inter_prediction.h" |
| #include "h264bsd_neighbour.h" |
| #include "h264bsd_util.h" |
| #include "h264bsd_reconstruct.h" |
| #include "h264bsd_dpb.h" |
| |
| /*------------------------------------------------------------------------------ |
| 2. External compiler flags |
| -------------------------------------------------------------------------------- |
| |
| -------------------------------------------------------------------------------- |
| 3. Module defines |
| ------------------------------------------------------------------------------*/ |
| |
| typedef struct |
| { |
| u32 available; |
| u32 refIndex; |
| mv_t mv; |
| } interNeighbour_t; |
| |
| /*------------------------------------------------------------------------------ |
| 4. Local function prototypes |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 MvPrediction16x16(mbStorage_t *pMb, mbPred_t *mbPred, |
| dpbStorage_t *dpb); |
| static u32 MvPrediction16x8(mbStorage_t *pMb, mbPred_t *mbPred, |
| dpbStorage_t *dpb); |
| static u32 MvPrediction8x16(mbStorage_t *pMb, mbPred_t *mbPred, |
| dpbStorage_t *dpb); |
| static u32 MvPrediction8x8(mbStorage_t *pMb, subMbPred_t *subMbPred, |
| dpbStorage_t *dpb); |
| static u32 MvPrediction(mbStorage_t *pMb, subMbPred_t *subMbPred, |
| u32 mbPartIdx, u32 subMbPartIdx); |
| static i32 MedianFilter(i32 a, i32 b, i32 c); |
| |
| static void GetInterNeighbour(u32 sliceId, mbStorage_t *nMb, |
| interNeighbour_t *n, u32 index); |
| static void GetPredictionMv(mv_t *mv, interNeighbour_t *a, u32 refIndex); |
| |
| static const neighbour_t N_A_SUB_PART[4][4][4] = { |
| { { {MB_A,5}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_A,5}, {MB_A,7}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_A,5}, {MB_CURR,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_A,5}, {MB_CURR,0}, {MB_A,7}, {MB_CURR,2} } }, |
| |
| { { {MB_CURR,1}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,1}, {MB_CURR,3}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,1}, {MB_CURR,4}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,1}, {MB_CURR,4}, {MB_CURR,3}, {MB_CURR,6} } }, |
| |
| { { {MB_A,13}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_A,13}, {MB_A,15}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_A,13}, {MB_CURR,8}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_A,13}, {MB_CURR,8}, {MB_A,15}, {MB_CURR,10} } }, |
| |
| { { {MB_CURR,9}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,9}, {MB_CURR,11}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,9}, {MB_CURR,12}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,9}, {MB_CURR,12}, {MB_CURR,11}, {MB_CURR,14} } } }; |
| |
| static const neighbour_t N_B_SUB_PART[4][4][4] = { |
| { { {MB_B,10}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_B,10}, {MB_CURR,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_B,10}, {MB_B,11}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_B,10}, {MB_B,11}, {MB_CURR,0}, {MB_CURR,1} } }, |
| |
| { { {MB_B,14}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_B,14}, {MB_CURR,4}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_B,14}, {MB_B,15}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_B,14}, {MB_B,15}, {MB_CURR,4}, {MB_CURR,5} } }, |
| |
| { { {MB_CURR,2}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,2}, {MB_CURR,8}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,2}, {MB_CURR,3}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,2}, {MB_CURR,3}, {MB_CURR,8}, {MB_CURR,9} } }, |
| |
| { { {MB_CURR,6}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,6}, {MB_CURR,12}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,6}, {MB_CURR,7}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,6}, {MB_CURR,7}, {MB_CURR,12}, {MB_CURR,13} } } }; |
| |
| static const neighbour_t N_C_SUB_PART[4][4][4] = { |
| { { {MB_B,14}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_B,14}, {MB_NA,4}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_B,11}, {MB_B,14}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_B,11}, {MB_B,14}, {MB_CURR,1}, {MB_NA,4} } }, |
| |
| { { {MB_C,10}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_C,10}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_B,15}, {MB_C,10}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_B,15}, {MB_C,10}, {MB_CURR,5}, {MB_NA,0} } }, |
| |
| { { {MB_CURR,6}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,6}, {MB_NA,12}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,3}, {MB_CURR,6}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,3}, {MB_CURR,6}, {MB_CURR,9}, {MB_NA,12} } }, |
| |
| { { {MB_NA,2}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_NA,2}, {MB_NA,8}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,7}, {MB_NA,2}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,7}, {MB_NA,2}, {MB_CURR,13}, {MB_NA,8} } } }; |
| |
| static const neighbour_t N_D_SUB_PART[4][4][4] = { |
| { { {MB_D,15}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_D,15}, {MB_A,5}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_D,15}, {MB_B,10}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_D,15}, {MB_B,10}, {MB_A,5}, {MB_CURR,0} } }, |
| |
| { { {MB_B,11}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_B,11}, {MB_CURR,1}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_B,11}, {MB_B,14}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_B,11}, {MB_B,14}, {MB_CURR,1}, {MB_CURR,4} } }, |
| |
| { { {MB_A,7}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_A,7}, {MB_A,13}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_A,7}, {MB_CURR,2}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_A,7}, {MB_CURR,2}, {MB_A,13}, {MB_CURR,8} } }, |
| |
| { { {MB_CURR,3}, {MB_NA,0}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,3}, {MB_CURR,9}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,3}, {MB_CURR,6}, {MB_NA,0}, {MB_NA,0} }, |
| { {MB_CURR,3}, {MB_CURR,6}, {MB_CURR,9}, {MB_CURR,12} } } }; |
| |
| |
| #ifdef H264DEC_OMXDL |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdInterPrediction |
| |
| Functional description: |
| Processes one inter macroblock. Performs motion vector prediction |
| and reconstructs prediction macroblock. Writes the final macroblock |
| (prediction + residual) into the output image (currImage) |
| |
| Inputs: |
| pMb pointer to macroblock specific information |
| pMbLayer pointer to current macroblock data from stream |
| dpb pointer to decoded picture buffer |
| mbNum current macroblock number |
| currImage pointer to output image |
| data pointer where predicted macroblock will be stored |
| |
| Outputs: |
| pMb structure is updated with current macroblock |
| currImage current macroblock is written into image |
| data prediction is stored here |
| |
| Returns: |
| HANTRO_OK success |
| HANTRO_NOK error in motion vector prediction |
| |
| ------------------------------------------------------------------------------*/ |
| u32 h264bsdInterPrediction(mbStorage_t *pMb, macroblockLayer_t *pMbLayer, |
| dpbStorage_t *dpb, u32 mbNum, image_t *currImage, u8 *data) |
| { |
| |
| /* Variables */ |
| |
| u32 i; |
| u32 x, y; |
| u32 colAndRow; |
| subMbPartMode_e subPartMode; |
| image_t refImage; |
| u8 fillBuff[32*21 + 15 + 32]; |
| u8 *pFill; |
| u32 tmp; |
| /* Code */ |
| |
| ASSERT(pMb); |
| ASSERT(h264bsdMbPartPredMode(pMb->mbType) == PRED_MODE_INTER); |
| ASSERT(pMbLayer); |
| |
| /* 16-byte alignment */ |
| pFill = ALIGN(fillBuff, 16); |
| |
| /* set row bits 15:0 */ |
| colAndRow = mbNum / currImage->width; |
| /*set col to bits 31:16 */ |
| colAndRow += (mbNum - colAndRow * currImage->width) << 16; |
| colAndRow <<= 4; |
| |
| refImage.width = currImage->width; |
| refImage.height = currImage->height; |
| |
| switch (pMb->mbType) |
| { |
| case P_Skip: |
| case P_L0_16x16: |
| if (MvPrediction16x16(pMb, &pMbLayer->mbPred, dpb) != HANTRO_OK) |
| return(HANTRO_NOK); |
| refImage.data = pMb->refAddr[0]; |
| tmp = (0<<24) + (0<<16) + (16<<8) + 16; |
| h264bsdPredictSamples(data, pMb->mv, &refImage, |
| colAndRow, tmp, pFill); |
| break; |
| |
| case P_L0_L0_16x8: |
| if ( MvPrediction16x8(pMb, &pMbLayer->mbPred, dpb) != HANTRO_OK) |
| return(HANTRO_NOK); |
| refImage.data = pMb->refAddr[0]; |
| tmp = (0<<24) + (0<<16) + (16<<8) + 8; |
| h264bsdPredictSamples(data, pMb->mv, &refImage, |
| colAndRow, tmp, pFill); |
| |
| refImage.data = pMb->refAddr[2]; |
| tmp = (0<<24) + (8<<16) + (16<<8) + 8; |
| h264bsdPredictSamples(data, pMb->mv+8, &refImage, |
| colAndRow, tmp, pFill); |
| break; |
| |
| case P_L0_L0_8x16: |
| if ( MvPrediction8x16(pMb, &pMbLayer->mbPred, dpb) != HANTRO_OK) |
| return(HANTRO_NOK); |
| refImage.data = pMb->refAddr[0]; |
| tmp = (0<<24) + (0<<16) + (8<<8) + 16; |
| h264bsdPredictSamples(data, pMb->mv, &refImage, |
| colAndRow, tmp, pFill); |
| refImage.data = pMb->refAddr[1]; |
| tmp = (8<<24) + (0<<16) + (8<<8) + 16; |
| h264bsdPredictSamples(data, pMb->mv+4, &refImage, |
| colAndRow, tmp, pFill); |
| break; |
| |
| default: /* P_8x8 and P_8x8ref0 */ |
| if ( MvPrediction8x8(pMb, &pMbLayer->subMbPred, dpb) != HANTRO_OK) |
| return(HANTRO_NOK); |
| for (i = 0; i < 4; i++) |
| { |
| refImage.data = pMb->refAddr[i]; |
| subPartMode = |
| h264bsdSubMbPartMode(pMbLayer->subMbPred.subMbType[i]); |
| x = i & 0x1 ? 8 : 0; |
| y = i < 2 ? 0 : 8; |
| switch (subPartMode) |
| { |
| case MB_SP_8x8: |
| tmp = (x<<24) + (y<<16) + (8<<8) + 8; |
| h264bsdPredictSamples(data, pMb->mv+4*i, &refImage, |
| colAndRow, tmp, pFill); |
| break; |
| |
| case MB_SP_8x4: |
| tmp = (x<<24) + (y<<16) + (8<<8) + 4; |
| h264bsdPredictSamples(data, pMb->mv+4*i, &refImage, |
| colAndRow, tmp, pFill); |
| tmp = (x<<24) + ((y+4)<<16) + (8<<8) + 4; |
| h264bsdPredictSamples(data, pMb->mv+4*i+2, &refImage, |
| colAndRow, tmp, pFill); |
| break; |
| |
| case MB_SP_4x8: |
| tmp = (x<<24) + (y<<16) + (4<<8) + 8; |
| h264bsdPredictSamples(data, pMb->mv+4*i, &refImage, |
| colAndRow, tmp, pFill); |
| tmp = ((x+4)<<24) + (y<<16) + (4<<8) + 8; |
| h264bsdPredictSamples(data, pMb->mv+4*i+1, &refImage, |
| colAndRow, tmp, pFill); |
| break; |
| |
| default: |
| tmp = (x<<24) + (y<<16) + (4<<8) + 4; |
| h264bsdPredictSamples(data, pMb->mv+4*i, &refImage, |
| colAndRow, tmp, pFill); |
| tmp = ((x+4)<<24) + (y<<16) + (4<<8) + 4; |
| h264bsdPredictSamples(data, pMb->mv+4*i+1, &refImage, |
| colAndRow, tmp, pFill); |
| tmp = (x<<24) + ((y+4)<<16) + (4<<8) + 4; |
| h264bsdPredictSamples(data, pMb->mv+4*i+2, &refImage, |
| colAndRow, tmp, pFill); |
| tmp = ((x+4)<<24) + ((y+4)<<16) + (4<<8) + 4; |
| h264bsdPredictSamples(data, pMb->mv+4*i+3, &refImage, |
| colAndRow, tmp, pFill); |
| break; |
| } |
| } |
| break; |
| } |
| |
| /* if decoded flag > 1 -> mb has already been successfully decoded and |
| * written to output -> do not write again */ |
| if (pMb->decoded > 1) |
| return HANTRO_OK; |
| |
| return(HANTRO_OK); |
| } |
| |
| #else /* H264DEC_OMXDL */ |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdInterPrediction |
| |
| Functional description: |
| Processes one inter macroblock. Performs motion vector prediction |
| and reconstructs prediction macroblock. Writes the final macroblock |
| (prediction + residual) into the output image (currImage) |
| |
| Inputs: |
| pMb pointer to macroblock specific information |
| pMbLayer pointer to current macroblock data from stream |
| dpb pointer to decoded picture buffer |
| mbNum current macroblock number |
| currImage pointer to output image |
| data pointer where predicted macroblock will be stored |
| |
| Outputs: |
| pMb structure is updated with current macroblock |
| currImage current macroblock is written into image |
| data prediction is stored here |
| |
| Returns: |
| HANTRO_OK success |
| HANTRO_NOK error in motion vector prediction |
| |
| ------------------------------------------------------------------------------*/ |
| u32 h264bsdInterPrediction(mbStorage_t *pMb, macroblockLayer_t *pMbLayer, |
| dpbStorage_t *dpb, u32 mbNum, image_t *currImage, u8 *data) |
| { |
| |
| /* Variables */ |
| |
| u32 i; |
| u32 x, y; |
| u32 row, col; |
| subMbPartMode_e subPartMode; |
| image_t refImage; |
| |
| /* Code */ |
| |
| ASSERT(pMb); |
| ASSERT(h264bsdMbPartPredMode(pMb->mbType) == PRED_MODE_INTER); |
| ASSERT(pMbLayer); |
| |
| row = mbNum / currImage->width; |
| col = mbNum - row * currImage->width; |
| row *= 16; |
| col *= 16; |
| |
| refImage.width = currImage->width; |
| refImage.height = currImage->height; |
| |
| switch (pMb->mbType) |
| { |
| case P_Skip: |
| case P_L0_16x16: |
| if (MvPrediction16x16(pMb, &pMbLayer->mbPred, dpb) != HANTRO_OK) |
| return(HANTRO_NOK); |
| refImage.data = pMb->refAddr[0]; |
| h264bsdPredictSamples(data, pMb->mv, &refImage, col, row, 0, 0, |
| 16, 16); |
| break; |
| |
| case P_L0_L0_16x8: |
| if ( MvPrediction16x8(pMb, &pMbLayer->mbPred, dpb) != HANTRO_OK) |
| return(HANTRO_NOK); |
| refImage.data = pMb->refAddr[0]; |
| h264bsdPredictSamples(data, pMb->mv, &refImage, col, row, 0, 0, |
| 16, 8); |
| refImage.data = pMb->refAddr[2]; |
| h264bsdPredictSamples(data, pMb->mv+8, &refImage, col, row, 0, 8, |
| 16, 8); |
| break; |
| |
| case P_L0_L0_8x16: |
| if ( MvPrediction8x16(pMb, &pMbLayer->mbPred, dpb) != HANTRO_OK) |
| return(HANTRO_NOK); |
| refImage.data = pMb->refAddr[0]; |
| h264bsdPredictSamples(data, pMb->mv, &refImage, col, row, 0, 0, |
| 8, 16); |
| refImage.data = pMb->refAddr[1]; |
| h264bsdPredictSamples(data, pMb->mv+4, &refImage, col, row, 8, 0, |
| 8, 16); |
| break; |
| |
| default: /* P_8x8 and P_8x8ref0 */ |
| if ( MvPrediction8x8(pMb, &pMbLayer->subMbPred, dpb) != HANTRO_OK) |
| return(HANTRO_NOK); |
| for (i = 0; i < 4; i++) |
| { |
| refImage.data = pMb->refAddr[i]; |
| subPartMode = |
| h264bsdSubMbPartMode(pMbLayer->subMbPred.subMbType[i]); |
| x = i & 0x1 ? 8 : 0; |
| y = i < 2 ? 0 : 8; |
| switch (subPartMode) |
| { |
| case MB_SP_8x8: |
| h264bsdPredictSamples(data, pMb->mv+4*i, &refImage, |
| col, row, x, y, 8, 8); |
| break; |
| |
| case MB_SP_8x4: |
| h264bsdPredictSamples(data, pMb->mv+4*i, &refImage, |
| col, row, x, y, 8, 4); |
| h264bsdPredictSamples(data, pMb->mv+4*i+2, &refImage, |
| col, row, x, y+4, 8, 4); |
| break; |
| |
| case MB_SP_4x8: |
| h264bsdPredictSamples(data, pMb->mv+4*i, &refImage, |
| col, row, x, y, 4, 8); |
| h264bsdPredictSamples(data, pMb->mv+4*i+1, &refImage, |
| col, row, x+4, y, 4, 8); |
| break; |
| |
| default: |
| h264bsdPredictSamples(data, pMb->mv+4*i, &refImage, |
| col, row, x, y, 4, 4); |
| h264bsdPredictSamples(data, pMb->mv+4*i+1, &refImage, |
| col, row, x+4, y, 4, 4); |
| h264bsdPredictSamples(data, pMb->mv+4*i+2, &refImage, |
| col, row, x, y+4, 4, 4); |
| h264bsdPredictSamples(data, pMb->mv+4*i+3, &refImage, |
| col, row, x+4, y+4, 4, 4); |
| break; |
| } |
| } |
| break; |
| } |
| |
| /* if decoded flag > 1 -> mb has already been successfully decoded and |
| * written to output -> do not write again */ |
| if (pMb->decoded > 1) |
| return HANTRO_OK; |
| |
| if (pMb->mbType != P_Skip) |
| { |
| h264bsdWriteOutputBlocks(currImage, mbNum, data, |
| pMbLayer->residual.level); |
| } |
| else |
| { |
| h264bsdWriteMacroblock(currImage, data); |
| } |
| |
| return(HANTRO_OK); |
| } |
| #endif /* H264DEC_OMXDL */ |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: MvPrediction16x16 |
| |
| Functional description: |
| Motion vector prediction for 16x16 partition mode |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 MvPrediction16x16(mbStorage_t *pMb, mbPred_t *mbPred, dpbStorage_t *dpb) |
| { |
| |
| /* Variables */ |
| |
| mv_t mv; |
| mv_t mvPred; |
| interNeighbour_t a[3]; /* A, B, C */ |
| u32 refIndex; |
| u8 *tmp; |
| u32 *tmpMv1, *tmpMv2; |
| |
| /* Code */ |
| |
| refIndex = mbPred->refIdxL0[0]; |
| |
| GetInterNeighbour(pMb->sliceId, pMb->mbA, a, 5); |
| GetInterNeighbour(pMb->sliceId, pMb->mbB, a+1, 10); |
| /*lint --e(740) Unusual pointer cast (incompatible indirect types) */ |
| tmpMv1 = (u32*)(&a[0].mv); /* we test just that both MVs are zero */ |
| /*lint --e(740) */ |
| tmpMv2 = (u32*)(&a[1].mv); /* i.e. a[0].mv.hor == 0 && a[0].mv.ver == 0 */ |
| if (pMb->mbType == P_Skip && |
| (!a[0].available || !a[1].available || |
| ( a[0].refIndex == 0 && ((u32)(*tmpMv1) == 0) ) || |
| ( a[1].refIndex == 0 && ((u32)(*tmpMv2) == 0) ))) |
| { |
| mv.hor = mv.ver = 0; |
| } |
| else |
| { |
| mv = mbPred->mvdL0[0]; |
| GetInterNeighbour(pMb->sliceId, pMb->mbC, a+2, 10); |
| if (!a[2].available) |
| { |
| GetInterNeighbour(pMb->sliceId, pMb->mbD, a+2, 15); |
| } |
| |
| GetPredictionMv(&mvPred, a, refIndex); |
| |
| mv.hor += mvPred.hor; |
| mv.ver += mvPred.ver; |
| |
| /* horizontal motion vector range [-2048, 2047.75] */ |
| if ((u32)(i32)(mv.hor+8192) >= (16384)) |
| return(HANTRO_NOK); |
| |
| /* vertical motion vector range [-512, 511.75] |
| * (smaller for low levels) */ |
| if ((u32)(i32)(mv.ver+2048) >= (4096)) |
| return(HANTRO_NOK); |
| } |
| |
| tmp = h264bsdGetRefPicData(dpb, refIndex); |
| if (tmp == NULL) |
| return(HANTRO_NOK); |
| |
| pMb->mv[0] = pMb->mv[1] = pMb->mv[2] = pMb->mv[3] = |
| pMb->mv[4] = pMb->mv[5] = pMb->mv[6] = pMb->mv[7] = |
| pMb->mv[8] = pMb->mv[9] = pMb->mv[10] = pMb->mv[11] = |
| pMb->mv[12] = pMb->mv[13] = pMb->mv[14] = pMb->mv[15] = mv; |
| |
| pMb->refPic[0] = refIndex; |
| pMb->refPic[1] = refIndex; |
| pMb->refPic[2] = refIndex; |
| pMb->refPic[3] = refIndex; |
| pMb->refAddr[0] = tmp; |
| pMb->refAddr[1] = tmp; |
| pMb->refAddr[2] = tmp; |
| pMb->refAddr[3] = tmp; |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: MvPrediction16x8 |
| |
| Functional description: |
| Motion vector prediction for 16x8 partition mode |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 MvPrediction16x8(mbStorage_t *pMb, mbPred_t *mbPred, dpbStorage_t *dpb) |
| { |
| |
| /* Variables */ |
| |
| mv_t mv; |
| mv_t mvPred; |
| interNeighbour_t a[3]; /* A, B, C */ |
| u32 refIndex; |
| u8 *tmp; |
| |
| /* Code */ |
| |
| mv = mbPred->mvdL0[0]; |
| refIndex = mbPred->refIdxL0[0]; |
| |
| GetInterNeighbour(pMb->sliceId, pMb->mbB, a+1, 10); |
| |
| if (a[1].refIndex == refIndex) |
| mvPred = a[1].mv; |
| else |
| { |
| GetInterNeighbour(pMb->sliceId, pMb->mbA, a, 5); |
| GetInterNeighbour(pMb->sliceId, pMb->mbC, a+2, 10); |
| if (!a[2].available) |
| { |
| GetInterNeighbour(pMb->sliceId, pMb->mbD, a+2, 15); |
| } |
| |
| GetPredictionMv(&mvPred, a, refIndex); |
| |
| } |
| mv.hor += mvPred.hor; |
| mv.ver += mvPred.ver; |
| |
| /* horizontal motion vector range [-2048, 2047.75] */ |
| if ((u32)(i32)(mv.hor+8192) >= (16384)) |
| return(HANTRO_NOK); |
| |
| /* vertical motion vector range [-512, 511.75] (smaller for low levels) */ |
| if ((u32)(i32)(mv.ver+2048) >= (4096)) |
| return(HANTRO_NOK); |
| |
| tmp = h264bsdGetRefPicData(dpb, refIndex); |
| if (tmp == NULL) |
| return(HANTRO_NOK); |
| |
| pMb->mv[0] = pMb->mv[1] = pMb->mv[2] = pMb->mv[3] = |
| pMb->mv[4] = pMb->mv[5] = pMb->mv[6] = pMb->mv[7] = mv; |
| pMb->refPic[0] = refIndex; |
| pMb->refPic[1] = refIndex; |
| pMb->refAddr[0] = tmp; |
| pMb->refAddr[1] = tmp; |
| |
| mv = mbPred->mvdL0[1]; |
| refIndex = mbPred->refIdxL0[1]; |
| |
| GetInterNeighbour(pMb->sliceId, pMb->mbA, a, 13); |
| if (a[0].refIndex == refIndex) |
| mvPred = a[0].mv; |
| else |
| { |
| a[1].available = HANTRO_TRUE; |
| a[1].refIndex = pMb->refPic[0]; |
| a[1].mv = pMb->mv[0]; |
| |
| /* c is not available */ |
| GetInterNeighbour(pMb->sliceId, pMb->mbA, a+2, 7); |
| |
| GetPredictionMv(&mvPred, a, refIndex); |
| |
| } |
| mv.hor += mvPred.hor; |
| mv.ver += mvPred.ver; |
| |
| /* horizontal motion vector range [-2048, 2047.75] */ |
| if ((u32)(i32)(mv.hor+8192) >= (16384)) |
| return(HANTRO_NOK); |
| |
| /* vertical motion vector range [-512, 511.75] (smaller for low levels) */ |
| if ((u32)(i32)(mv.ver+2048) >= (4096)) |
| return(HANTRO_NOK); |
| |
| tmp = h264bsdGetRefPicData(dpb, refIndex); |
| if (tmp == NULL) |
| return(HANTRO_NOK); |
| |
| pMb->mv[8] = pMb->mv[9] = pMb->mv[10] = pMb->mv[11] = |
| pMb->mv[12] = pMb->mv[13] = pMb->mv[14] = pMb->mv[15] = mv; |
| pMb->refPic[2] = refIndex; |
| pMb->refPic[3] = refIndex; |
| pMb->refAddr[2] = tmp; |
| pMb->refAddr[3] = tmp; |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: MvPrediction8x16 |
| |
| Functional description: |
| Motion vector prediction for 8x16 partition mode |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 MvPrediction8x16(mbStorage_t *pMb, mbPred_t *mbPred, dpbStorage_t *dpb) |
| { |
| |
| /* Variables */ |
| |
| mv_t mv; |
| mv_t mvPred; |
| interNeighbour_t a[3]; /* A, B, C */ |
| u32 refIndex; |
| u8 *tmp; |
| |
| /* Code */ |
| |
| mv = mbPred->mvdL0[0]; |
| refIndex = mbPred->refIdxL0[0]; |
| |
| GetInterNeighbour(pMb->sliceId, pMb->mbA, a, 5); |
| |
| if (a[0].refIndex == refIndex) |
| mvPred = a[0].mv; |
| else |
| { |
| GetInterNeighbour(pMb->sliceId, pMb->mbB, a+1, 10); |
| GetInterNeighbour(pMb->sliceId, pMb->mbB, a+2, 14); |
| if (!a[2].available) |
| { |
| GetInterNeighbour(pMb->sliceId, pMb->mbD, a+2, 15); |
| } |
| |
| GetPredictionMv(&mvPred, a, refIndex); |
| |
| } |
| mv.hor += mvPred.hor; |
| mv.ver += mvPred.ver; |
| |
| /* horizontal motion vector range [-2048, 2047.75] */ |
| if ((u32)(i32)(mv.hor+8192) >= (16384)) |
| return(HANTRO_NOK); |
| |
| /* vertical motion vector range [-512, 511.75] (smaller for low levels) */ |
| if ((u32)(i32)(mv.ver+2048) >= (4096)) |
| return(HANTRO_NOK); |
| |
| tmp = h264bsdGetRefPicData(dpb, refIndex); |
| if (tmp == NULL) |
| return(HANTRO_NOK); |
| |
| pMb->mv[0] = pMb->mv[1] = pMb->mv[2] = pMb->mv[3] = |
| pMb->mv[8] = pMb->mv[9] = pMb->mv[10] = pMb->mv[11] = mv; |
| pMb->refPic[0] = refIndex; |
| pMb->refPic[2] = refIndex; |
| pMb->refAddr[0] = tmp; |
| pMb->refAddr[2] = tmp; |
| |
| mv = mbPred->mvdL0[1]; |
| refIndex = mbPred->refIdxL0[1]; |
| |
| GetInterNeighbour(pMb->sliceId, pMb->mbC, a+2, 10); |
| if (!a[2].available) |
| { |
| GetInterNeighbour(pMb->sliceId, pMb->mbB, a+2, 11); |
| } |
| if (a[2].refIndex == refIndex) |
| mvPred = a[2].mv; |
| else |
| { |
| a[0].available = HANTRO_TRUE; |
| a[0].refIndex = pMb->refPic[0]; |
| a[0].mv = pMb->mv[0]; |
| |
| GetInterNeighbour(pMb->sliceId, pMb->mbB, a+1, 14); |
| |
| GetPredictionMv(&mvPred, a, refIndex); |
| |
| } |
| mv.hor += mvPred.hor; |
| mv.ver += mvPred.ver; |
| |
| /* horizontal motion vector range [-2048, 2047.75] */ |
| if ((u32)(i32)(mv.hor+8192) >= (16384)) |
| return(HANTRO_NOK); |
| |
| /* vertical motion vector range [-512, 511.75] (smaller for low levels) */ |
| if ((u32)(i32)(mv.ver+2048) >= (4096)) |
| return(HANTRO_NOK); |
| |
| tmp = h264bsdGetRefPicData(dpb, refIndex); |
| if (tmp == NULL) |
| return(HANTRO_NOK); |
| |
| pMb->mv[4] = pMb->mv[5] = pMb->mv[6] = pMb->mv[7] = |
| pMb->mv[12] = pMb->mv[13] = pMb->mv[14] = pMb->mv[15] = mv; |
| pMb->refPic[1] = refIndex; |
| pMb->refPic[3] = refIndex; |
| pMb->refAddr[1] = tmp; |
| pMb->refAddr[3] = tmp; |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: MvPrediction8x8 |
| |
| Functional description: |
| Motion vector prediction for 8x8 partition mode |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 MvPrediction8x8(mbStorage_t *pMb, subMbPred_t *subMbPred, dpbStorage_t *dpb) |
| { |
| |
| /* Variables */ |
| |
| u32 i, j; |
| u32 numSubMbPart; |
| |
| /* Code */ |
| |
| for (i = 0; i < 4; i++) |
| { |
| numSubMbPart = h264bsdNumSubMbPart(subMbPred->subMbType[i]); |
| pMb->refPic[i] = subMbPred->refIdxL0[i]; |
| pMb->refAddr[i] = h264bsdGetRefPicData(dpb, subMbPred->refIdxL0[i]); |
| if (pMb->refAddr[i] == NULL) |
| return(HANTRO_NOK); |
| for (j = 0; j < numSubMbPart; j++) |
| { |
| if (MvPrediction(pMb, subMbPred, i, j) != HANTRO_OK) |
| return(HANTRO_NOK); |
| } |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: MvPrediction |
| |
| Functional description: |
| Perform motion vector prediction for sub-partition |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 MvPrediction(mbStorage_t *pMb, subMbPred_t *subMbPred, u32 mbPartIdx, |
| u32 subMbPartIdx) |
| { |
| |
| /* Variables */ |
| |
| mv_t mv, mvPred; |
| u32 refIndex; |
| subMbPartMode_e subMbPartMode; |
| const neighbour_t *n; |
| mbStorage_t *nMb; |
| interNeighbour_t a[3]; /* A, B, C */ |
| |
| /* Code */ |
| |
| mv = subMbPred->mvdL0[mbPartIdx][subMbPartIdx]; |
| subMbPartMode = h264bsdSubMbPartMode(subMbPred->subMbType[mbPartIdx]); |
| refIndex = subMbPred->refIdxL0[mbPartIdx]; |
| |
| n = N_A_SUB_PART[mbPartIdx][subMbPartMode]+subMbPartIdx; |
| nMb = h264bsdGetNeighbourMb(pMb, n->mb); |
| GetInterNeighbour(pMb->sliceId, nMb, a, n->index); |
| |
| n = N_B_SUB_PART[mbPartIdx][subMbPartMode]+subMbPartIdx; |
| nMb = h264bsdGetNeighbourMb(pMb, n->mb); |
| GetInterNeighbour(pMb->sliceId, nMb, a+1, n->index); |
| |
| n = N_C_SUB_PART[mbPartIdx][subMbPartMode]+subMbPartIdx; |
| nMb = h264bsdGetNeighbourMb(pMb, n->mb); |
| GetInterNeighbour(pMb->sliceId, nMb, a+2, n->index); |
| |
| if (!a[2].available) |
| { |
| n = N_D_SUB_PART[mbPartIdx][subMbPartMode]+subMbPartIdx; |
| nMb = h264bsdGetNeighbourMb(pMb, n->mb); |
| GetInterNeighbour(pMb->sliceId, nMb, a+2, n->index); |
| } |
| |
| GetPredictionMv(&mvPred, a, refIndex); |
| |
| mv.hor += mvPred.hor; |
| mv.ver += mvPred.ver; |
| |
| /* horizontal motion vector range [-2048, 2047.75] */ |
| if (((u32)(i32)(mv.hor+8192) >= (16384))) |
| return(HANTRO_NOK); |
| |
| /* vertical motion vector range [-512, 511.75] (smaller for low levels) */ |
| if (((u32)(i32)(mv.ver+2048) >= (4096))) |
| return(HANTRO_NOK); |
| |
| switch (subMbPartMode) |
| { |
| case MB_SP_8x8: |
| pMb->mv[4*mbPartIdx] = mv; |
| pMb->mv[4*mbPartIdx + 1] = mv; |
| pMb->mv[4*mbPartIdx + 2] = mv; |
| pMb->mv[4*mbPartIdx + 3] = mv; |
| break; |
| |
| case MB_SP_8x4: |
| pMb->mv[4*mbPartIdx + 2*subMbPartIdx] = mv; |
| pMb->mv[4*mbPartIdx + 2*subMbPartIdx + 1] = mv; |
| break; |
| |
| case MB_SP_4x8: |
| pMb->mv[4*mbPartIdx + subMbPartIdx] = mv; |
| pMb->mv[4*mbPartIdx + subMbPartIdx + 2] = mv; |
| break; |
| |
| case MB_SP_4x4: |
| pMb->mv[4*mbPartIdx + subMbPartIdx] = mv; |
| break; |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: MedianFilter |
| |
| Functional description: |
| Median filtering for motion vector prediction |
| |
| ------------------------------------------------------------------------------*/ |
| |
| i32 MedianFilter(i32 a, i32 b, i32 c) |
| { |
| |
| /* Variables */ |
| |
| i32 max,min,med; |
| |
| /* Code */ |
| |
| max = min = med = a; |
| if (b > max) |
| { |
| max = b; |
| } |
| else if (b < min) |
| { |
| min = b; |
| } |
| if (c > max) |
| { |
| med = max; |
| } |
| else if (c < min) |
| { |
| med = min; |
| } |
| else |
| { |
| med = c; |
| } |
| |
| return(med); |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: GetInterNeighbour |
| |
| Functional description: |
| Get availability, reference index and motion vector of a neighbour |
| |
| ------------------------------------------------------------------------------*/ |
| |
| void GetInterNeighbour(u32 sliceId, mbStorage_t *nMb, |
| interNeighbour_t *n, u32 index) |
| { |
| |
| n->available = HANTRO_FALSE; |
| n->refIndex = 0xFFFFFFFF; |
| n->mv.hor = n->mv.ver = 0; |
| |
| if (nMb && (sliceId == nMb->sliceId)) |
| { |
| u32 tmp; |
| mv_t tmpMv; |
| |
| tmp = nMb->mbType; |
| n->available = HANTRO_TRUE; |
| /* MbPartPredMode "inlined" */ |
| if (tmp <= P_8x8ref0) |
| { |
| tmpMv = nMb->mv[index]; |
| tmp = nMb->refPic[index>>2]; |
| n->refIndex = tmp; |
| n->mv = tmpMv; |
| } |
| } |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: GetPredictionMv |
| |
| Functional description: |
| Compute motion vector predictor based on neighbours A, B and C |
| |
| ------------------------------------------------------------------------------*/ |
| |
| void GetPredictionMv(mv_t *mv, interNeighbour_t *a, u32 refIndex) |
| { |
| |
| if ( a[1].available || a[2].available || !a[0].available) |
| { |
| u32 isA, isB, isC; |
| isA = (a[0].refIndex == refIndex) ? HANTRO_TRUE : HANTRO_FALSE; |
| isB = (a[1].refIndex == refIndex) ? HANTRO_TRUE : HANTRO_FALSE; |
| isC = (a[2].refIndex == refIndex) ? HANTRO_TRUE : HANTRO_FALSE; |
| |
| if (((u32)isA+(u32)isB+(u32)isC) != 1) |
| { |
| mv->hor = (i16)MedianFilter(a[0].mv.hor, a[1].mv.hor, a[2].mv.hor); |
| mv->ver = (i16)MedianFilter(a[0].mv.ver, a[1].mv.ver, a[2].mv.ver); |
| } |
| else if (isA) |
| *mv = a[0].mv; |
| else if (isB) |
| *mv = a[1].mv; |
| else |
| *mv = a[2].mv; |
| } |
| else |
| { |
| *mv = a[0].mv; |
| } |
| |
| } |
| |
| |
