ref: 7d0cb59987f5c5c70cf55e35e65aa6b7a5bc460e
dir: /src/h264bsd_inter_prediction.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
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
------------------------------------------------------------------------------*/
static 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] = mv;
pMb->mv[1] = mv;
pMb->mv[2] = mv;
pMb->mv[3] = mv;
pMb->mv[4] = mv;
pMb->mv[5] = mv;
pMb->mv[6] = mv;
pMb->mv[7] = mv;
pMb->mv[8] = mv;
pMb->mv[9] = mv;
pMb->mv[10] = mv;
pMb->mv[11] = mv;
pMb->mv[12] = mv;
pMb->mv[13] = mv;
pMb->mv[14] = mv;
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
------------------------------------------------------------------------------*/
static 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] = mv;
pMb->mv[1] = mv;
pMb->mv[2] = mv;
pMb->mv[3] = mv;
pMb->mv[4] = mv;
pMb->mv[5] = mv;
pMb->mv[6] = mv;
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] = mv;
pMb->mv[9] = mv;
pMb->mv[10] = mv;
pMb->mv[11] = mv;
pMb->mv[12] = mv;
pMb->mv[13] = mv;
pMb->mv[14] = mv;
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
------------------------------------------------------------------------------*/
static 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] = mv;
pMb->mv[1] = mv;
pMb->mv[2] = mv;
pMb->mv[3] = mv;
pMb->mv[8] = mv;
pMb->mv[9] = mv;
pMb->mv[10] = mv;
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] = mv;
pMb->mv[5] = mv;
pMb->mv[6] = mv;
pMb->mv[7] = mv;
pMb->mv[12] = mv;
pMb->mv[13] = mv;
pMb->mv[14] = mv;
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
------------------------------------------------------------------------------*/
static 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
------------------------------------------------------------------------------*/
static 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
------------------------------------------------------------------------------*/
static i32 MedianFilter(i32 a, i32 b, i32 c)
{
/* Variables */
i32 max,min,med;
/* Code */
max = min = 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
------------------------------------------------------------------------------*/
static 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
------------------------------------------------------------------------------*/
static 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;
}
}