--- a/videoeditorengine/h263decoder/src/bma.cpp Fri Jan 29 14:08:33 2010 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1846 +0,0 @@
-/*
-* Copyright (c) 2010 Ixonos Plc.
-* All rights reserved.
-* This component and the accompanying materials are made available
-* under the terms of the "Eclipse Public License v1.0"
-* which accompanies this distribution, and is available
-* at the URL "http://www.eclipse.org/legal/epl-v10.html".
-*
-* Initial Contributors:
-* Nokia Corporation - Initial contribution
-*
-* Contributors:
-* Ixonos Plc
-*
-* Description:
-* Implementation for MPEG4(H263) video transcoder.
-* Block matching algorithms for MPEG4(H263) video transcoder.
-*
-*/
-
-
-
-#include "biblin.h"
-#include "common.h"
-#include "h263dconfig.h"
-#include "decmbdct.h"
-#include "vdxint.h"
-
-/*
- * Constants/definitions
- */
-
-#define DIAMOND_SEARCH_NUMBER 2
-
-
-const tVLCTable sCBPCIType[9] =
-{
- {0x01,0x01}, {0x01,0x03}, {0x02,0x03}, {0x03,0x03},
- {0x01,0x04}, {0x01,0x06}, {0x02,0x06}, {0x03,0x06},
- {0x01,0x09}
-};
-
-const tVLCTable sCBPCPType[21] =
-{
- {0x01,0x01}, {0x03,0x04}, {0x02,0x04}, {0x05,0x06},
- {0x03,0x03}, {0x07,0x07}, {0x06,0x07}, {0x05,0x09},
- {0x02,0x03}, {0x05,0x07}, {0x04,0x07}, {0x05,0x08},
- {0x03,0x05}, {0x04,0x08}, {0x03,0x08}, {0x03,0x07},
- {0x04,0x06}, {0x04,0x09}, {0x03,0x09}, {0x02,0x09},
- {0x01,0x09}
-};
-
-const tVLCTable sCBPY[16] =
-{
- {0x03,0x04}, {0x05,0x05}, {0x04,0x05}, {0x09,0x04},
- {0x03,0x05}, {0x07,0x04}, {0x02,0x06}, {0x0b,0x04},
- {0x02,0x05}, {0x03,0x06}, {0x05,0x04}, {0x0a,0x04},
- {0x04,0x04}, {0x08,0x04}, {0x06,0x04}, {0x03,0x02}
-};
-
-const unsigned int sDquant[5] =
-{
- 0x01, 0x00, (unsigned int)NOT_VALID, 0x02, 0x03
-};
-
-const tVLCTable sMVTab[33] =
-{
- {0x01,0x01}, {0x02,0x03}, {0x02,0x04}, {0x02,0x05},
- {0x06,0x07}, {0x0a,0x08}, {0x08,0x08}, {0x06,0x08},
- {0x16,0x0a}, {0x14,0x0a}, {0x12,0x0a}, {0x22,0x0b},
- {0x20,0x0b}, {0x1e,0x0b}, {0x1c,0x0b}, {0x1a,0x0b},
- {0x18,0x0b}, {0x16,0x0b}, {0x14,0x0b}, {0x12,0x0b},
- {0x10,0x0b}, {0x0e,0x0b}, {0x0c,0x0b}, {0x0a,0x0b},
- {0x08,0x0b}, {0x0e,0x0c}, {0x0c,0x0c}, {0x0a,0x0c},
- {0x08,0x0c}, {0x06,0x0c}, {0x04,0x0c}, {0x06,0x0d},
- {0x04,0x0d}
-};
-
-const int32 sFixedQuantScale1[32]=
-{
- 0x0000, 0x7fff, 0x3fff, 0x2aaa,
- 0x1fff, 0x1999, 0x1555, 0x1249,
- 0x0fff, 0x0e38, 0x0ccc, 0x0ba2,
- 0x0aaa, 0x09d8, 0x0924, 0x0888,
- 0x07ff, 0x0787, 0x071c, 0x06bc,
- 0x0666, 0x0618, 0x05d1, 0x1590,
- 0x0555, 0x051e, 0x04ec, 0x04bd,
- 0x0492, 0x0469, 0x0444, 0x0421
-};
-
-const u_int16 sPrePostMult[64] =
-{
- 0x8000, 0xb18a, 0xa73d, 0x9683,
- 0x8000, 0x9683, 0xa73d, 0xb18a,
- 0xb18a, 0xf641, 0xe7f7, 0xd0c3,
- 0xb18a, 0xd0c3, 0xe7f7, 0xf641,
- 0xa73d, 0xe7f7, 0xda82, 0xc4a7,
- 0xa73d, 0xc4a7, 0xda82, 0xe7f7,
- 0x9683, 0xd0c3, 0xc4a7, 0xb0fb,
- 0x9683, 0xb0fb, 0xc4a7, 0xd0c3,
- 0x8000, 0xb18a, 0xa73d, 0x9683,
- 0x8000, 0x9683, 0xa73d, 0xb18a,
- 0x9683, 0xd0c3, 0xc4a7, 0xb0fb,
- 0x9683, 0xb0fb, 0xc4a7, 0xd0c3,
- 0xa73d, 0xe7f7, 0xda82, 0xc4a7,
- 0xa73d, 0xc4a7, 0xda82, 0xe7f7,
- 0xb18a, 0xf641, 0xe7f7, 0xd0c3,
- 0xb18a, 0xd0c3, 0xe7f7, 0xf641
-};
-
-
-
-/*
- * Function Declarations
- */
-int32 vlbCodeACCoeffsSVHWithZigZag(int32 coeffStart, int16* block, bibBuffer_t * outBuf,
- int32 svh, int32 lastPos);
-void vlbPutBits(bibBuffer_t *base, int32 numBits, u_int32 value);
-
-
-
-/*
- * Function Definitions
- */
-
-/* {{-output"vbmGetH263IMCBPC.txt"}} */
-/*
-* vbmGetH263IMCBPC
-*
-* Parameters:
-* vopCodingType coding type (INTER/INTRA) for the VOP
-* dQuant quantization parameter
-* colorEffect indicates color effect to be aplpied (e.g., black & white)
-* cbpy cbpy value for the macro block
-* mcbpcVal computed mcbpc value for the macro block
-* length length of the computed mcbpc value codeword
-*
-* Function:
-* This function evaluates the mcpbc codeword for INTRA macro block
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmGetH263IMCBPC(int dQuant, int vopCodingType, int /*colorEffect*/,
- int cbpy, int& mcbpcVal, int& length)
-{
- int index;
- int len, mcbpc;
-
- if(vopCodingType == 1 /* VDX_VOP_TYPE_P */)
- {
- index = (dQuant == 0 ? 12 : 16) + mcbpcVal;
- len = sCBPCPType[index].length + sCBPY[cbpy].length + 1;
- mcbpc = (sCBPCPType[index].code << sCBPY[cbpy].length) | sCBPY[cbpy].code;
- mcbpcVal = mcbpc;
- length = len;
- }
- else
- {
- index = (dQuant == 0 ? 0 : 4) + mcbpcVal;
- len = sCBPCIType[index].length + sCBPY[cbpy].length ;
- mcbpc = (sCBPCIType[index].code << sCBPY[cbpy].length) | sCBPY[cbpy].code;
- mcbpcVal = mcbpc;
- length = len;
- }
-}
-
-
-
-/* {{-output"vbmGetH263PMCBPC.txt"}} */
-/*
-* vbmGetH263PMCBPC
-*
-* Parameters:
-* dQuant quantization parameter
-* colorEffect indicates color effect to be aplpied (e.g., black & white)
-* cbpy cbpy value for the macro block
-* mcbpcVal computed mcbpc value for the macro block
-* length length of the computed mcbpc value codeword
-*
-* Function:
-* This function evaluates the mcpbc codeword for INTER macro block
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmGetH263PMCBPC(int dQuant, int /*colorEffect*/, int cbpy, int& mcbpcVal, int& length)
-{
- int index;
- int len, mcbpc;
- cbpy = (~cbpy) & 0xf;
-
- /* only ONE MV in baseline H263 */
- index = (dQuant == 0 ? 0 : 4) + mcbpcVal;
- len = sCBPCPType[index].length + sCBPY[cbpy].length;
- mcbpc = (sCBPCPType[index].code << sCBPY[cbpy].length) | sCBPY[cbpy].code;
- mcbpcVal = mcbpc;
- length = len;
-}
-
-
-
-/* {{-output"vbmEncodeMVDifferential.txt"}} */
-/*
-* vbmEncodeMVDifferential
-*
-* Parameters:
-* outBuf output buffer
-* mvdx motion vector difference value in horizontal direction, in half-pixel unit
-* mvdy motion vector difference value in vertical direction, in half-pixel unit
-* fCode Fcode value
-*
-* Function:
-* This function encodes the MV difference after prediction into the bitstream
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmEncodeMVDifferential(int32 mvdx, int32 mvdy, int32 fCode,
- bibBuffer_t * outBuf)
-{
- int32 mvd[2];
- u_int32 i;
- int32 temp;
- int32 motioncode;
- int32 motionresidual;
- int32 rsize = fCode - 1;
- u_int32 f = 1 << rsize;
- int32 high = 32 * f - 1;
- int32 low = -32 * (int32) f;
- int32 range = 64 *f;
-
- mvd[0] = mvdx;
- mvd[1] = mvdy;
-
- for(i = 0; i < 2; i++)
- {
- if (mvd[i] < low)
- {
- mvd[i] += range;
- }
- else
- {
- if (mvd[i] > high)
- {
- mvd[i] -= range;
- }
- }
- temp = ABS(mvd[i]) -1 + f;
- motioncode = temp >> rsize;
- if(mvd[i] >= 0)
- {
- vlbPutBits(outBuf, sMVTab[motioncode].length, sMVTab[motioncode].code);
- }
- else
- {
- vlbPutBits(outBuf, sMVTab[motioncode].length, (sMVTab[motioncode].code) ^ 1);
- }
- if (rsize != 0 && motioncode != 0)
- {
- motionresidual = temp & (f - 1);
- vlbPutBits(outBuf, rsize, motionresidual);
- }
- }
- return;
-}
-
-
-
-
-/* {{-output"vbmMedian3.txt"}} */
-/*
-* vbmMedian3
-*
-* Parameters:
-* s1 pointer to the first vector
-* s2 pointer to the second vector
-* s3 pointer to the third vector
-* med pointer to store the median vector
-*
-* Function:
-* This function finds the median of three vectors
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmMedian3(int16 *s1, int16 *s2, int16 *s3, tMotionVector *med)
-{
- int32 temp1;
- int32 temp2;
- int32 temp3;
-
- temp1 = s1[0];
- temp2 = s2[0];
- temp3 = s3[0];
-
- if (temp1 > temp2)
- {
- temp1 += temp2;
- temp2 = temp1 - temp2;
- temp1 -= temp2;
- }
- if (temp2 > temp3)
- {
- temp2 += temp3;
- temp3 = temp2 - temp3;
- temp2 -= temp3;
- }
- if (temp1 > temp2)
- {
- temp1 += temp2;
- temp2 = temp1 - temp2;
- temp1 -= temp2;
- }
-
- med->mvx = (int16) temp2;
- temp1 = s1[1];
- temp2 = s2[1];
- temp3 = s3[1];
-
- if (temp1 > temp2)
- {
- temp1 += temp2;
- temp2 = temp1 - temp2;
- temp1 -= temp2;
- }
- if (temp2 > temp3)
- {
- temp2 += temp3;
- temp3 = temp2 - temp3;
- temp2 -= temp3;
- }
- if (temp1 > temp2)
- {
- temp1 += temp2;
- temp2 = temp1 - temp2;
- temp1 -= temp2;
- }
- med->mvy = (int16) temp2;
-
- return;
-}
-
-
-
-/* {{-output"vbmMvPrediction.txt"}} */
-/*
-* vbmMvPrediction
-*
-* Parameters:
-* mbi macro block info needed for processing
-* predMV pointer to motion vector predictors
-* mbinWidth number of MBs per row
-* mBCnt mecro block number
-*
-* Function:
-* This function performs prediction of MV based on adjacent blocks
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmMvPrediction(tMBInfo *mbi, int32 mBCnt, tMotionVector *predMV, int32 mbinWidth)
-{
- int16 p[3][2];
- int32 zeroFound = 0;
- int32 zeroPredictors = 0;
-
- if (mBCnt % mbinWidth == 0)
- {
- p[0][0] = 0;
- p[0][1] = 0;
- zeroPredictors++;
- }
- else
- {
- p[0][0] = (mbi - 1)->MV[0][0];
- p[0][1] = (mbi - 1)->MV[0][1];
- }
-
- if (mBCnt / mbinWidth == 0)
- {
- p[1][0] = 0;
- p[1][1] = 0;
- zeroPredictors++;
- zeroFound += 1;
- }
- else
- {
- p[1][0] = (mbi - mbinWidth)->MV[0][0];
- p[1][1] = (mbi - mbinWidth)->MV[0][1];
- }
-
- if ((mBCnt / mbinWidth == 0) ||
- ((mBCnt % mbinWidth) == (mbinWidth - 1)))
- {
- p[2][0] = 0;
- p[2][1] = 0;
- zeroPredictors++;
- zeroFound += 2;
- }
- else
- {
- p[2][0] = (mbi - mbinWidth + 1)->MV[0][0];
- p[2][1] = (mbi - mbinWidth + 1)->MV[0][1];
- }
-
- if (zeroPredictors == 3)
- {
- predMV->mvx = 0;
- predMV->mvy = 0;
- }
- else if (zeroPredictors == 2)
- {
- predMV->mvx = p[zeroFound^3][0];
- predMV->mvy = p[zeroFound^3][1];
- }
- else
- {
- vbmMedian3(p[0], p[1], p[2], predMV);
- }
- return;
-}
-
-
-
-/* {{-output"vbmMBSAD.txt"}} */
-/*
-* vbmMBSAD
-*
-* Parameters:
-* refFrame pointer to reference frame
-* currMB pointer to current MB
-* mv pointer to store the SAD and having motion vector
-* mbPos pointer to macroblock position structure
-* vopWidth width of frame/VOP
-* yWidth width of luminance frame
-*
-* Function:
-* This function computes the SAD (Sum of Absolute Difference)
-* for a macroblock for integer motion vector
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmMBSAD(tPixel* refFrame, u_int32 vopWidth, tPixel* currMB, u_int32 yWidth,
- tMotionVector* mv, const tMBPosition* mbPos)
-{
- u_int32 sad = 0;
- tPixel* refPos;
- tPixel* currPos;
- int32 row;
- int32 col;
-
- refPos = refFrame + (mbPos->y + mv->mvy) * vopWidth + (mbPos->x + mv->mvx);
- currPos = currMB;
-
- for(row = 0; row < MB_SIZE; row++)
- {
- col = row & 0x1;
- for(; col < MB_SIZE; col+= 2)
- {
- sad += ABS(*(refPos + col) - *(currPos + col));
- }
- refPos += vopWidth;
- currPos += yWidth;
- }
- mv->SAD = (sad << 1);
- return;
-}
-
-
-
-/* {{-output"vbmMVOutsideBound.txt"}} */
-/*
-* vbmMVOutsideBound
-*
-* Parameters:
-* mbPos pointer to macroblock position structure
-* bestMV pointer to store the best match motion vector
-* halfPixel flag to indicate whether half pel search is needed
-*
-* Function:
-* This function checks whether the MV is within valid range
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-tBool vbmMVOutsideBound(tMBPosition *mbPos, tMotionVector* bestMV, tBool halfPixel)
-{
- int32 xLeft;
- int32 xRight;
- int32 yTop;
- int32 yBottom;
-
- xLeft = (mbPos->x << halfPixel) + bestMV->mvx;
- xRight = (mbPos->x << halfPixel) + (MB_SIZE << halfPixel) + bestMV->mvx;
- yTop = (mbPos->y << halfPixel) + bestMV->mvy;
- yBottom = (mbPos->y << halfPixel) + (MB_SIZE << halfPixel) + bestMV->mvy;
-
- if (halfPixel)
- {
- return ((xLeft < mbPos->LeftBound) ||
- (xRight > mbPos->RightBound) ||
- (yTop < mbPos->TopBound) ||
- (yBottom > mbPos->BottomBound) ||
- ((bestMV->mvx) < -32 || (bestMV->mvx) > 31) ||
- ((bestMV->mvy) < -32 || (bestMV->mvy) > 31)
- );
- }
- else
- {
- return ((xLeft < mbPos->LeftBound) ||
- (xRight > mbPos->RightBound) ||
- (yTop < mbPos->TopBound) ||
- (yBottom > mbPos->BottomBound)||
- ((bestMV->mvx) < -16 || (bestMV->mvx) > 15) ||
- ((bestMV->mvy) < -16 || (bestMV->mvy) > 15)
- );
- }
-}
-
-
-
-/* {{-output"vbmEstimateBestPredictor.txt"}} */
-/*
-* vbmEstimateBestPredictor
-*
-* Parameters:
-* refFrame pointer to reference frame
-* currMB pointer to current MB
-* initPred pointer to predictor motion vectors, pixel unit
-* mbPos pointer to macroblock position structure
-* vopWidth width of frame/VOP
-* yWidth width of luminance frame
-* bestMV pointer to store the best match motion vector
-* noofPredictors number of predictors
-*
-* Function:
-* This function estimates the best predictor among the set
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmEstimateBestPredictor(tPixel* refFrame, u_int32 vopWidth, tPixel* currMB, u_int32 yWidth,
- tMotionVector* initPred, tMBPosition* mbPos,
- int32 noOfPredictors, tMotionVector* bestMV)
-{
- int32 i;
- bestMV->SAD = 65535;
- for(i = 0; i < noOfPredictors; i++)
- {
- if (vbmMVOutsideBound(mbPos, (initPred + i), 0))
- {
- initPred[i].SAD = 65535;
- }
- else
- {
- vbmMBSAD(refFrame, vopWidth, currMB, yWidth, (initPred + i), mbPos);
- }
- if(initPred[i].SAD < bestMV->SAD)
- {
- bestMV->SAD = initPred[i].SAD;
- bestMV->mvx = initPred[i].mvx;
- bestMV->mvy = initPred[i].mvy;
- }
- }
-
- return;
-}
-
-
-
-/* {{-output"vbmEstimateBound.txt"}} */
-/*
-* vbmEstimateBound
-*
-* Parameters:
-* mbPos pointer to macroblock position structure
-* vopWidth width of frame/VOP
-* vopHeight height of frame/VOP
-* searchRange search range
-*
-* Function:
-* This function evaluates the bounds for a macroblock BM search
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmEstimateBound(tMBPosition *mbPos,u_int32 vopWidth, u_int32 vopHeight, int32 searchRange)
-{
- mbPos->LeftBound = mbPos->x - searchRange;
- mbPos->RightBound = mbPos->x + 16 + searchRange;
- mbPos->TopBound = mbPos->y - searchRange;
- mbPos->BottomBound = mbPos->y + 16 + searchRange;
-
- if(mbPos->LeftBound < 0)
- {
- mbPos->LeftBound = 0;
- }
- if(mbPos->RightBound > (int32)vopWidth)
- {
- mbPos->RightBound = vopWidth;
- }
- if(mbPos->TopBound < 0 )
- {
- mbPos->TopBound = 0;
- }
- if(mbPos->BottomBound > (int32)vopHeight)
- {
- mbPos->BottomBound = vopHeight;
- }
-
- return;
-}
-
-
-
-/* {{-output"vbmEstimateBoundHalfPel.txt"}} */
-/*
-* vbmEstimateBoundHalfPel
-*
-* Parameters:
-* mbPos pointer to macroblock position structure
-* vopWidth width of frame/VOP
-* vopHeight height of frame/VOP
-*
-* Function:
-* This function evaluates the bounds for a macroblock BM search in half pel accuracy
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmEstimateBoundHalfPel(tMBPosition *mbPos, u_int32 vopWidth, u_int32 vopHeight)
-{
- mbPos->LeftBound = 0;
- mbPos->RightBound = (vopWidth << 1);
- mbPos->TopBound = 0;
- mbPos->BottomBound = (vopHeight << 1);
- return;
-}
-
-
-
-/* {{-output"vbmSmallDiamondSearch.txt"}} */
-/*
-* vbmSmallDiamondSearch
-*
-* Parameters:
-* refFrame pointer to reference frame
-* currMB pointer to current MB
-* initPred pointer to predictor motion vectors, pixel unit
-* mbPos pointer to macroblock position structure
-* vopWidth width of frame/VOP
-* yWidth width of luminance frame
-* bestMV pointer to store the best match motion vector
-* Function:
-* This function performs motion estimation for a macroblock using small diamond search
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmSmallDiamondSearch(tPixel* refFrame, tPixel* currMB, tMotionVector *initPred,
- tMotionVector* bestMV, u_int32 vopWidth, tMBPosition* mbPos,
- u_int32 yWidth)
-{
- u_int8 locateSDS[5][5] =
- {
- {0,0,0,0,0},
- {0,1,1,0,1},
- {0,1,1,1,0},
- {0,0,1,1,1},
- {0,1,0,1,1}
- };
- u_int32 i;
- int32 stepCount;
- int32 flag=1;
- int32 position=0;
-
- //form the diamond shap search pattern
- stepCount = 1;
- initPred[0].SAD = bestMV->SAD;
- initPred[1].mvx = (int16)(bestMV->mvx + 1);
- initPred[1].mvy = bestMV->mvy;
- initPred[2].mvx = bestMV->mvx;
- initPred[2].mvy = (int16)(bestMV->mvy - 1);
- initPred[3].mvx = (int16)(bestMV->mvx - 1);
- initPred[3].mvy = bestMV->mvy;
- initPred[4].mvx = bestMV->mvx;
- initPred[4].mvy = (int16)(bestMV->mvy + 1);
-
- for(i = 1; i < 5; i++)
- {
- if(vbmMVOutsideBound(mbPos, &initPred[i], 0) )
- {
- initPred[i].SAD = 65535;
- }
- else
- {
- vbmMBSAD(refFrame, vopWidth, currMB, yWidth, (initPred + i), mbPos);
- }
- if(initPred[i].SAD < bestMV->SAD)
- {
- bestMV->SAD = initPred[i].SAD;
- bestMV->mvx = initPred[i].mvx;
- bestMV->mvy = initPred[i].mvy;
- position = i;
- }
- }
-
- /* the minimum SAD falls in the center */
- if(bestMV->SAD == initPred[0].SAD)
- {
- return;
- }
-
- while(flag)
- {
- stepCount++;
- initPred[0].SAD = bestMV->SAD;
- initPred[1].mvx = (int16)(bestMV->mvx + 1);
- initPred[1].mvy = bestMV->mvy;
- initPred[2].mvx = bestMV->mvx;
- initPred[2].mvy = (int16)(bestMV->mvy - 1);
- initPred[3].mvx = (int16)(bestMV->mvx - 1);
- initPred[3].mvy = bestMV->mvy;
- initPred[4].mvx = bestMV->mvx;
- initPred[4].mvy = (int16)(bestMV->mvy + 1);
-
- for(i = 1; i < 5; i++)
- {
- if(locateSDS[position][i] != 0)
- {
- if(vbmMVOutsideBound(mbPos, &initPred[i],0))
- {
- initPred[i].SAD = 65535;
- }
- else
- {
- vbmMBSAD(refFrame, vopWidth, currMB, yWidth, (initPred + i), mbPos);
- if(initPred[i].SAD < bestMV->SAD)
- {
- bestMV->mvx = initPred[i].mvx;
- bestMV->mvy = initPred[i].mvy;
- bestMV->SAD = initPred[i].SAD;
- position = i;
- }
- }
- }
- }
- if(bestMV->SAD == initPred[0].SAD)
- {
- break;
- }
- if(stepCount > DIAMOND_SEARCH_NUMBER) // we only do 2 diamond search here
- {
- break;
- }
- }
-
- return;
-}
-
-
-
-/* {{-output"vbmSADHalfPel.txt"}} */
-/*
-* vbmSADHalfPel
-*
-* Parameters:
-* refFrame pointer to reference frame
-* currMB pointer to current MB
-* mbPos pointer to macroblock position structure
-* vopWidth width of frame/VOP
-* yWidth width of luminance frame
-* mv pointer to motion vector
-* roundingControl rounding control value
-* blockSize block size
-* Function:
-* This function evaluates SAD for a macroblock/block for half pel motion vector
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmSADHalfPel(tPixel* refFrame, u_int32 vopWidth, tPixel* currMB, u_int32 yWidth,
- tMotionVector* mv, const tMBPosition* mbPos, tBool roundingControl,
- int32 blockSize)
-{
- u_int32 sad = 0;
- tPixel* refPos;
- tPixel* currPos;
- int32 row;
- int32 col;
- int32 extendedVOPWidth;
- int32 temp;
-
- extendedVOPWidth = vopWidth ;
- refPos = refFrame + (mbPos->y + (mv->mvy >> 1)) * extendedVOPWidth +
- (mbPos->x + (mv->mvx >> 1));
- currPos = currMB;
-
- if(mv->mvy & 1)
- {
- if(mv->mvx & 1)
- {
- /* Both horizontal and vertical components are having half pel */
- for(row = 0; row < blockSize; row++)
- {
- col = row & 0x1;
- for(; col < blockSize; col += 2)
- {
- temp = (refPos[col] + refPos[col + 1] +
- refPos[col + extendedVOPWidth] +
- refPos[col + extendedVOPWidth + 1] +
- 2 -roundingControl) >> 2;
- sad += ABS(temp - currPos[col]);
- }
- refPos += extendedVOPWidth;
- currPos += yWidth;
- }
- mv->SAD = (sad << 1);
- }
- else
- {
- /* Vertical component is having half pel */
- for(row = 0; row < blockSize; row++)
- {
- col = row & 0x1;
- for(; col < blockSize; col += 2)
- {
- temp = (refPos[col] + refPos[col + extendedVOPWidth]+
- 1 -roundingControl) >> 1;
- sad += ABS(temp - currPos[col]);
- }
- refPos += extendedVOPWidth;
- currPos += yWidth;
- }
- mv->SAD = (sad << 1);
- }
- }
- else
- {
- if(mv->mvx & 1)
- {
- /* Horizontal component is having half pel */
- for(row = 0; row < blockSize; row++)
- {
- col = row & 0x1;
- for(; col < blockSize; col += 2)
- {
- temp = (refPos[col] + refPos[col + 1] +
- 1 -roundingControl) >> 1;
- sad += ABS(temp - currPos[col]);
- }
- refPos += extendedVOPWidth;
- currPos += yWidth;
- }
- mv->SAD = (sad << 1);
- }
- else
- {
- /* Both horizontal and vertical components are integer pel */
- for(row = 0; row < blockSize; row++)
- {
- col = row & 0x1;
- for(; col < blockSize; col += 2)
- {
- sad += ABS(refPos[col] - currPos[col]);
- }
- refPos += extendedVOPWidth;
- currPos += yWidth;
- }
- mv->SAD = (sad << 1);
- }
- }
-
- return;
-}
-
-
-
-
-/* {{-output"vbmHalfPelSearchMB.txt"}} */
-/*
-* vbmHalfPelSearchMB
-*
-* Parameters:
-* refFrame pointer to reference frame
-* currMB pointer to current MB
-* mbPos pointer to macroblock position structure
-* vopWidth width of frame/VOP
-* yWidth width of luminance frame
-* initPred pointer to predictor motion vectors, pixel unit
-* bestMV pointer to store the best match motion vector
-* Function:
-* This function evaluates the half pel motion vector for a 16x16 block using
-* the integer pel motion vector
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmHalfPelSearchMB(tPixel* refFrame, u_int32 vopWidth, tPixel* currMB,
- u_int32 yWidth, tMotionVector* initPred,
- tMotionVector* bestMV, tMBPosition* mbPos)
-{
- int32 i;
- int32 position=0;
-
- initPred[0].SAD = bestMV->SAD;
- initPred[1].mvx = (int16)(bestMV->mvx + 1);
- initPred[1].mvy = bestMV->mvy;
- initPred[2].mvx = bestMV->mvx;
- initPred[2].mvy = (int16)(bestMV->mvy - 1);
- initPred[3].mvx = (int16)(bestMV->mvx - 1);
- initPred[3].mvy = bestMV->mvy;
- initPred[4].mvx = bestMV->mvx;
- initPred[4].mvy = (int16)(bestMV->mvy + 1);
-
- for(i = 1; i < 5; i++)
- {
- if(vbmMVOutsideBound(mbPos, &initPred[i], 1))
- {
- initPred[i].SAD = 65535;
- }
- else
- {
- vbmSADHalfPel(refFrame, vopWidth, currMB, yWidth,
- (initPred + i), mbPos,(tBool)(0), 16);
- }
-
- if(initPred[i].SAD < bestMV->SAD)
- {
- bestMV->mvx = initPred[i].mvx;
- bestMV->mvy = initPred[i].mvy;
- bestMV->SAD = initPred[i].SAD;
- position = i;
- }
- }
-
- if(1)
- {
- if(bestMV->SAD == initPred[0].SAD)
- {
- return;
- }
- else
- {
- switch(position)
- {
- case 1: case 3:
- initPred[5].mvx = bestMV->mvx;
- initPred[5].mvy = (int16)(bestMV->mvy - 1);
- initPred[6].mvx = bestMV->mvx;
- initPred[6].mvy = (int16)(bestMV->mvy + 1);
- break;
-
- case 2: case 4:
- initPred[5].mvx = (int16)(bestMV->mvx - 1);
- initPred[5].mvy = bestMV->mvy;
- initPred[6].mvx = (int16)(bestMV->mvx + 1);
- initPred[6].mvy = bestMV->mvy;
- break;
-
- default:
- break;
- }
-
- for(i = 5; i < 7; i++)
- {
-
- if(vbmMVOutsideBound(mbPos, &initPred[i],1))
- {
- initPred[i].SAD = 65535;
- }
- else
- {
- vbmSADHalfPel(refFrame, vopWidth, currMB, yWidth,
- (initPred + i), mbPos, (tBool)0, 16);
- }
- if(initPred[i].SAD < bestMV->SAD)
- {
- bestMV->mvx = initPred[i].mvx;
- bestMV->mvy = initPred[i].mvy;
- bestMV->SAD = initPred[i].SAD;
- }
- }
- }
- }
-
- return;
-}
-
-
-
-/* {{-output"vbmMEMBSpatioTemporalSearch.txt"}} */
-/*
-* vbmMEMBSpatioTemporalSearch
-*
-* Parameters:
-* refFrame pointer to reference frame
-* currMB pointer to current MB
-* mbPos pointer to macroblock position structure
-* vopWidth width of frame/VOP
-* vopHeight height of frame/VOP
-* yWidth width of luminance frame
-* initPred pointer to predictor motion vectors, pixel unit
-* bestMV pointer to store the best match motion vector
-* noOfPredictors number of MV predictors
-* searchRange search range
-* minSAD minimum SAD
-* Function:
-* This function performs motion estimation for a macroblock using
-* spatio-temporal correlation based search
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-int32 vbmMEMBSpatioTemporalSearch(tPixel* refFrame, u_int32 vopWidth, u_int32 vopHeight,
- tPixel* currMB, u_int32 yWidth, tMBPosition* mbPos,
- tMotionVector *initPred, int32 noOfPredictors,
- tMotionVector* bestMV, int32 searchRange, u_int32 minSAD)
-{
- /* estimate the bound of MV for current MB */
- vbmEstimateBound(mbPos, vopWidth, vopHeight, searchRange);
-
- /* get the best MV predictor from the candidates set */
- vbmEstimateBestPredictor(refFrame, vopWidth, currMB, yWidth, initPred, mbPos, noOfPredictors, bestMV);
-
- if(bestMV->SAD >= minSAD)
- {
- /* from the MV predictor, starts the small diamond search */
- vbmSmallDiamondSearch(refFrame, currMB, initPred, bestMV, vopWidth, mbPos, yWidth);
- }
-
- /* adjustment for half-pixel search */
- bestMV->mvx <<= 1;
- bestMV->mvy <<= 1;
-
- /* MV bound in half-pixel */
- vbmEstimateBoundHalfPel(mbPos,vopWidth, vopHeight);
-
- /* starts the half-pixel search around the integer-pixel MV */
- vbmHalfPelSearchMB(refFrame, vopWidth, currMB, yWidth,
- initPred, bestMV, mbPos);
-
- return bestMV->SAD;
-}
-
-
-
-/* {{-output"vbmRowDCT.txt"}} */
-/*
-* vbmRowDCT
-*
-* Parameters:
-* block array of 64 block coefficients
-* Function:
-* This function performs row DCT of 8x8 block of data elements
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmRowDCT(int16 *block)
-{
- int32 coeff0, coeff1, coeff2, coeff3;
- int32 coeff4, coeff5, coeff6, coeff7;
- int32 temp;
- u_int16 count;
- int32 rowStartIndex;
-
- for(count = 0; count < BLOCK_SIZE; count++)
- {
- rowStartIndex = count << LOG_BLOCK_WIDTH;
-
- /* Stage 1 and up scaling of the input data to improve precision */
- coeff0 = (block[rowStartIndex] + block[rowStartIndex + 7]) <<
- DCT_KEPT_PRECISION;
- coeff7 = (block[rowStartIndex] - block[rowStartIndex + 7]) <<
- DCT_KEPT_PRECISION;
-
- coeff1 = (block[rowStartIndex + 1] + block[rowStartIndex + 6]) <<
- DCT_KEPT_PRECISION;
- coeff6 = (block[rowStartIndex + 1] - block[rowStartIndex + 6]) <<
- DCT_KEPT_PRECISION;
-
- coeff2 = (block[rowStartIndex + 2] + block[rowStartIndex + 5]) <<
- DCT_KEPT_PRECISION;
- coeff5 = (block[rowStartIndex + 2] - block[rowStartIndex + 5]) <<
- DCT_KEPT_PRECISION;
-
- coeff3 = (block[rowStartIndex + 3] + block[rowStartIndex + 4]) <<
- DCT_KEPT_PRECISION;
- coeff4 = (block[rowStartIndex + 3] - block[rowStartIndex + 4]) <<
- DCT_KEPT_PRECISION;
-
- /* Stage 2 */
- temp = coeff0 + coeff3;
- coeff3 = coeff0 - coeff3;
- coeff0 = temp;
-
- temp = coeff1 + coeff2;
- coeff2 = coeff1 - coeff2;
- coeff1 = temp;
-
- temp = ((coeff6 - coeff5) * COS_PI_BY_4 + DCT_ROUND) >> DCT_PRECISION;
- coeff6 = ((coeff6 + coeff5) * COS_PI_BY_4 + DCT_ROUND) >> DCT_PRECISION;
- coeff5 = temp;
-
- /* Stage 3 */
- temp = coeff0 + coeff1;
- coeff1 = coeff0 - coeff1;
- coeff0 = temp;
-
- temp = ((coeff2 * TAN_PI_BY_8 + DCT_ROUND) >> DCT_PRECISION) + coeff3;
- coeff3 = ((coeff3 * TAN_PI_BY_8 + DCT_ROUND) >> DCT_PRECISION) - coeff2;
- coeff2 = temp;
-
- temp = coeff4 + coeff5;
- coeff5 = coeff4 - coeff5;
- coeff4 = temp;
-
- temp = coeff7 - coeff6;
- coeff7 = coeff7 + coeff6;
- coeff6 = temp;
-
- /* Stage 4 */
- temp = ((coeff4 * TAN_PI_BY_16 + DCT_ROUND) >> DCT_PRECISION) + coeff7;
- coeff7 = ((coeff7 * TAN_PI_BY_16 + DCT_ROUND) >> DCT_PRECISION) - coeff4;
- coeff4 = temp;
-
- temp = coeff5 + ((coeff6 * TAN_3PI_BY_16 + DCT_ROUND) >> DCT_PRECISION);
- coeff6 = coeff6 - ((coeff5 * TAN_3PI_BY_16 + DCT_ROUND) >> DCT_PRECISION);
- coeff5 = temp;
-
- block[rowStartIndex] = (int16)coeff0;
- block[rowStartIndex + 4] = (int16)coeff1;
- block[rowStartIndex + 2] = (int16)coeff2;
- block[rowStartIndex + 6] = (int16)coeff3;
- block[rowStartIndex + 1] = (int16)coeff4;
- block[rowStartIndex + 5] = (int16)coeff5;
- block[rowStartIndex + 3] = (int16)coeff6;
- block[rowStartIndex + 7] = (int16)coeff7;
- }
-
- return;
-}
-
-
-
-/* {{-output"vbmDCTQuantInterSVH.txt"}} */
-/*
-* vbmDCTQuantInterSVH
-*
-* Parameters:
-* block array of 64 block coefficients
-* mbi contains info about MB quantization scale and coding type
-* lastPosition indicates last non zero coefficient
-* Function:
-* This function performs DCT of a 8x8 block of data elements and
-* quantizes the DCT coefficients with short video header flag set
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmDCTQuantInterSVH(int16 *block, tMBInfo *mbi, int32* lastPosition)
-{
- int32 coeff0, coeff1, coeff2, coeff3;
- int32 coeff4, coeff5, coeff6, coeff7;
- int32 temp;
- u_int16 count;
- int32 sign;
-
- vbmRowDCT(block);
-
- for(count = 0; count < BLOCK_SIZE; count++)
- {
- /* Stage 1 */
- coeff0 = block[count] + block[count + 56];
- coeff7 = block[count] - block[count + 56];
-
- coeff1 = block[count + 8] + block[count + 48];
- coeff6 = block[count + 8] - block[count + 48];
-
- coeff2 = block[count + 16] + block[count + 40];
- coeff5 = block[count + 16] - block[count + 40];
-
- coeff3 = block[count + 24] + block[count + 32];
- coeff4 = block[count + 24] - block[count + 32];
-
- /* Stage 2 */
- temp = coeff0 + coeff3;
- coeff3 = coeff0 - coeff3;
- coeff0 = temp;
-
- temp = coeff1 + coeff2;
- coeff2 = coeff1 - coeff2;
- coeff1 = temp;
-
- temp = ((coeff6 - coeff5) * COS_PI_BY_4 + DCT_ROUND) >> DCT_PRECISION;
- coeff6 = ((coeff6 + coeff5) * COS_PI_BY_4 + DCT_ROUND) >> DCT_PRECISION;
- coeff5 = temp;
-
- /* Stage 3 */
- temp = coeff0 + coeff1;
- coeff1 = coeff0 - coeff1;
- coeff0 = temp;
-
- temp = ((coeff2 * TAN_PI_BY_8 + DCT_ROUND) >> DCT_PRECISION) + coeff3;
- coeff3 = ((coeff3 * TAN_PI_BY_8 + DCT_ROUND) >> DCT_PRECISION) - coeff2;
- coeff2 = temp;
-
- temp = coeff4 + coeff5;
- coeff5 = coeff4 - coeff5;
- coeff4 = temp;
-
- temp = coeff7 - coeff6;
- coeff7 = coeff7 + coeff6;
- coeff6 = temp;
-
- /* Stage 4 */
- temp = ((coeff4 * TAN_PI_BY_16 + DCT_ROUND) >> DCT_PRECISION) + coeff7;
- coeff7 = ((coeff7 * TAN_PI_BY_16 + DCT_ROUND) >> DCT_PRECISION) - coeff4;
- coeff4 = temp;
-
- temp = coeff5 + ((coeff6 * TAN_3PI_BY_16 + DCT_ROUND) >> DCT_PRECISION);
- coeff6 = coeff6 - ((coeff5 * TAN_3PI_BY_16 + DCT_ROUND) >> DCT_PRECISION);
- coeff5 = temp;
-
- block[count] = (int16) ( (coeff0* sPrePostMult[count] +
- DCT_ROUND_PLUS_KEPT) >> DCT_PRECISION_PLUS_KEPT);
- block[count + 32] = (int16) ((coeff1* sPrePostMult[count+32] +
- DCT_ROUND_PLUS_KEPT) >> DCT_PRECISION_PLUS_KEPT);
- block[count + 16] = (int16) ((coeff2* sPrePostMult[count+16] +
- DCT_ROUND_PLUS_KEPT) >> DCT_PRECISION_PLUS_KEPT);
- block[count + 48] = (int16) ((coeff3* sPrePostMult[count+48] +
- DCT_ROUND_PLUS_KEPT) >> DCT_PRECISION_PLUS_KEPT);
- block[count + 8] = (int16) ((coeff4* sPrePostMult[count+8] +
- DCT_ROUND_PLUS_KEPT) >> DCT_PRECISION_PLUS_KEPT);
- block[count + 40] = (int16) ((coeff5* sPrePostMult[count+40] +
- DCT_ROUND_PLUS_KEPT) >> DCT_PRECISION_PLUS_KEPT);
- block[count + 24] = (int16) ((coeff6* sPrePostMult[count+24] +
- DCT_ROUND_PLUS_KEPT) >> DCT_PRECISION_PLUS_KEPT);
- block[count + 56] = (int16) ((coeff7* sPrePostMult[count+56] +
- DCT_ROUND_PLUS_KEPT) >> DCT_PRECISION_PLUS_KEPT);
-
- coeff1 = mbi->QuantScale;
- temp= count;
- while(temp<64)
- {
- coeff0 = (int32) block[temp];
- if (coeff0 >= 0) {
- sign = 1;
- }
- else{
- sign = -1;
- }
- coeff0 = sign * coeff0;
-
- if (coeff0 < ((coeff1 * 5 ) >> 1))
- {
- block[temp] = 0;
- }
- else
- {
- coeff0 -= (coeff1 >> 1);
- coeff0 += 1;
- coeff0 *= sFixedQuantScale1[coeff1];
- coeff0 >>= FIXED_PT_BITS;
- coeff0 *= sign;
-
- if (coeff0 > MAX_SAT_VAL_SVH)
- {
- coeff0 = MAX_SAT_VAL_SVH;
- }
- else if (coeff0 < MIN_SAT_VAL_SVH)
- {
- coeff0 = MIN_SAT_VAL_SVH;
- }
-
- block[temp] = (int16) coeff0;
- if( temp > (*lastPosition)) *lastPosition = temp;
- }
- temp = temp+8;
- }
- }
-
- return;
-}
-
-
-
-/* {{-output"vbmCBPYInter.txt"}} */
-/*
-* vbmCBPYInter
-*
-* Parameters:
-* mbi contains info about MB quantization scale and coding type
-* lastPosition indicates last non zero coefficient
-* Function:
-* This function evaluates the coded bit pattern of the Inter MB
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmCBPYInter(tMBInfo *mbi, int32* lastPosition)
-{
- int32 blkCnt;
-
- mbi->CodedBlockPattern = 0;
- for (blkCnt = 0; blkCnt < 6; blkCnt++)
- {
- mbi->CodedBlockPattern <<= 1;
-
- if(lastPosition[blkCnt] != -1)
- {
- mbi->CodedBlockPattern |= 1;
- }
- }
-
- return;
-}
-
-
-
-/* {{-output"vbmCBPYInter.txt"}} */
-/*
-* vbmCBPYInter
-*
-* Parameters:
-* refFrame reference frame
-* currBlockPos current block
-* block block for storing the difference between predicted and
-* actual pixel values.
-* mv motion vector for the block in half pixel unit
-* x x-coordinate for the first pixel of block
-* y y-coordinate for the first pixel of block
-* refFrameWidth width of the reference frame
-* curFrameWidth width of current Frame
-* extendVopSize extension of the frame width
-* Function:
-* This function finds the predicted block from the reference frame and
-* copies the predicted frame into the current frame
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-int32 vbmPredictBlock(tPixel *refFrame, int32 refFrameWidth, u_int32 extendVopSize,
- tPixel *currBlockPos, int32 curFrameWidth,
- int16 *block, tMotionVector *mv, int32 x, int32 y)
-{
- int32 count1, count2;
- u_int8 *tempFrame, *tempFrame1, *tempFrame2;
- int32 tempVal, sad;
- int32 extframeWidth;
- extframeWidth = refFrameWidth + 2 * extendVopSize; /* Because of padding */
-
- /*
- * Since the frame is appended by 8 rows and 8 colums on all sides
- * 0,0 of referenceframe will now be frameStartPoint
- */
-
- tempFrame = refFrame + extframeWidth * extendVopSize + extendVopSize
- + ((y + (mv->mvy >> 1)) * extframeWidth) + x + (mv->mvx >> 1);
- tempFrame2 = currBlockPos;
-
- if (mv->mvy & 1) /* Motion vector of y has half pel accuracy */
- {
- if (mv->mvx & 1) /* MV has half pel value in both coordinates */
- {
- tempFrame1 = tempFrame + extframeWidth;
- sad=0;
- for (count1 = 0; count1 < BLOCK_SIZE; count1++)
- {
- count2 = 0;
- tempVal = (tempFrame[count2]
- + tempFrame[count2 + 1]
- + tempFrame1[count2]
- + tempFrame1[count2 + 1]+ 2) >> 2;
-
- block[count2] = (int16)(tempFrame2[count2] - tempVal);
- sad+=ABS(block[count2]);
- tempVal = (tempFrame[count2 + 1]
- + tempFrame[count2 + 2]
- + tempFrame1[count2 + 1]
- + tempFrame1[count2 + 2]+ 2) >> 2;
-
- block[count2 + 1] = (int16)(tempFrame2[count2 + 1] - tempVal);
- sad+=ABS(block[count2+1]);
- tempVal = (tempFrame[count2 + 2]
- + tempFrame[count2 + 3]
- + tempFrame1[count2 + 2]
- + tempFrame1[count2 + 3]+ 2) >> 2;
-
- block[count2 + 2] = (int16)(tempFrame2[count2 + 2] - tempVal);
- sad+=ABS(block[count2+2]);
- tempVal = (tempFrame[count2 + 3]
- + tempFrame[count2 + 4]
- + tempFrame1[count2 + 3]
- + tempFrame1[count2 + 4]+ 2) >> 2;
-
- block[count2 + 3] = (int16)(tempFrame2[count2 + 3] - tempVal);
- sad+=ABS(block[count2+3]);
- tempVal = (tempFrame[count2 + 4]
- + tempFrame[count2 + 5]
- + tempFrame1[count2 + 4]
- + tempFrame1[count2 + 5]+ 2) >> 2;
-
- block[count2 + 4] = (int16)(tempFrame2[count2 + 4] - tempVal);
- sad+=ABS(block[count2+4]);
- tempVal = (tempFrame[count2 + 5]
- + tempFrame[count2 + 6]
- + tempFrame1[count2 + 5]
- + tempFrame1[count2 + 6]+ 2) >> 2;
-
- block[count2 + 5] = (int16)(tempFrame2[count2 + 5] - tempVal);
- sad+=ABS(block[count2+5]);
- tempVal = (tempFrame[count2+ 6]
- + tempFrame[count2 + 7]
- + tempFrame1[count2 + 6]
- + tempFrame1[count2 + 7]+ 2) >> 2;
-
- block[count2 + 6] = (int16)(tempFrame2[count2 + 6] - tempVal);
- sad+=ABS(block[count2+6]);
- tempVal = (tempFrame[count2 + 7]
- + tempFrame[count2 + 8]
- + tempFrame1[count2 + 7]
- + tempFrame1[count2 + 8]+ 2) >> 2;
-
- block[count2 + 7] = (int16)(tempFrame2[count2 + 7] - tempVal);
- sad+=ABS(block[count2+7]);
- block += BLOCK_SIZE;
- tempFrame += extframeWidth;
- tempFrame1 += extframeWidth;
- tempFrame2 += curFrameWidth;
- }
- }
- else /* MV has half pel only in y direction */
- {
- tempFrame1 = tempFrame + extframeWidth;
- sad=0;
- for (count1 = 0; count1 < BLOCK_SIZE; count1++)
- {
- count2 = 0;
- tempVal = (tempFrame[count2]
- + tempFrame1[count2]+ 1) >> 1;
-
- block[count2] = (int16)(tempFrame2[count2] - tempVal);
- sad+=ABS(block[count2]);
- tempVal = (tempFrame[count2 + 1]
- + tempFrame1[count2 + 1]+ 1) >> 1;
-
- block[count2 + 1] = (int16)(tempFrame2[count2 + 1] - tempVal);
- sad+=ABS(block[count2+1]);
- tempVal = (tempFrame[count2 + 2]
- + tempFrame1[count2 + 2]+ 1) >> 1;
-
- block[count2 + 2] = (int16)(tempFrame2[count2 + 2] - tempVal);
- sad+=ABS(block[count2+2]);
- tempVal = (tempFrame[count2 + 3]+ tempFrame1[count2 + 3]+1) >> 1;
-
- block[count2 + 3] = (int16)(tempFrame2[count2 + 3] - tempVal);
- sad+=ABS(block[count2+3]);
- tempVal = (tempFrame[count2 + 4]
- + tempFrame1[count2 + 4]+ 1) >> 1;
-
- block[count2 + 4] = (int16)(tempFrame2[count2 + 4] - tempVal);
- sad+=ABS(block[count2+4]);
- tempVal = (tempFrame[count2 + 5]
- + tempFrame1[count2 + 5]+ 1) >> 1;
-
- block[count2 + 5] = (int16)(tempFrame2[count2 + 5] - tempVal);
- sad+=ABS(block[count2+5]);
- tempVal = (tempFrame[count2+ 6]
- + tempFrame1[count2 + 6]+ 1) >> 1;
-
- block[count2 + 6] = (int16)(tempFrame2[count2 + 6] - tempVal);
- sad+=ABS(block[count2+6]);
- tempVal = (tempFrame[count2 + 7]
- + tempFrame1[count2 + 7]+ 1) >> 1;
-
- block[count2 + 7] = (int16)(tempFrame2[count2 + 7] - tempVal);
- sad+=ABS(block[count2+7]);
- block += BLOCK_SIZE;
- tempFrame += extframeWidth;
- tempFrame1 += extframeWidth;
- tempFrame2 += curFrameWidth;
- }
- }
- }
- else
- {
- if (mv->mvx & 1) /* MV has half pel only in x direction */
- {
- sad=0;
- for (count1 = 0; count1 < BLOCK_SIZE; count1++)
- {
- count2 = 0;
- tempVal = (tempFrame[count2]
- + tempFrame[count2 + 1]+1) >> 1;
-
- block[count2] = (int16)(tempFrame2[count2] - tempVal);
- sad+=ABS(block[count2]);
- tempVal = (tempFrame[count2 + 1]
- + tempFrame[count2 + 2]+ 1) >> 1;
-
- block[count2 + 1] = (int16)(tempFrame2[count2 + 1] - tempVal);
- sad+=ABS(block[count2+1]);
- tempVal = (tempFrame[count2 + 2]
- + tempFrame[count2 + 3]+ 1) >> 1;
-
- block[count2 + 2] = (int16)(tempFrame2[count2 + 2] - tempVal);
- sad+=ABS(block[count2+2]);
- tempVal = (tempFrame[count2 + 3]
- + tempFrame[count2 + 4]+1) >> 1;
-
- block[count2 + 3] = (int16)(tempFrame2[count2 + 3] - tempVal);
- sad+=ABS(block[count2+3]);
- tempVal = (tempFrame[count2 + 4]
- + tempFrame[count2 + 5]+ 1) >> 1;
-
- block[count2 + 4] = (int16)(tempFrame2[count2 + 4] - tempVal);
- sad+=ABS(block[count2+4]);
- tempVal = (tempFrame[count2 + 5]
- + tempFrame[count2 + 6]+ 1) >> 1;
-
- block[count2 + 5] = (int16)(tempFrame2[count2 + 5] - tempVal);
- sad+=ABS(block[count2+5]);
- tempVal = (tempFrame[count2+ 6]
- + tempFrame[count2 + 7]
- + 1) >> 1;
-
- block[count2 + 6] = (int16)(tempFrame2[count2 + 6] - tempVal);
- sad+=ABS(block[count2+6]);
- tempVal = (tempFrame[count2 + 7]
- + tempFrame[count2 + 8]+ 1) >> 1;
-
- block[count2 + 7] = (int16)(tempFrame2[count2 + 7] - tempVal);
- sad+=ABS(block[count2+7]);
- block += BLOCK_SIZE;
- tempFrame += extframeWidth;
- tempFrame2 += curFrameWidth;
- }
- }
- else /* MV has full pel accuracy in both coordinates */
- {
- sad=0;
- for (count1 = 0; count1 < BLOCK_SIZE; count1++)
- {
- for (count2 = 0; count2 < BLOCK_SIZE; count2++)
- {
- block[count2] = (int16)(tempFrame2[count2]- tempFrame[count2]);
- sad+=ABS(block[count2]);
- }
- block += BLOCK_SIZE;
- tempFrame += extframeWidth;
- tempFrame2 += curFrameWidth;
- }
- }
- }
- return sad;
-}
-
-
-
-
-/* {{-output"vbmPutInterMBSVH.txt"}} */
-/*
-* vbmPutInterMBSVH
-*
-* Parameters:
-* outBuf pointer to the output bit-stream buffer structure
-* mbData pointer to the macro block data structure
-* mbi pointer to macro block information structure.
-* numTextureBits pointer to store the number of bits needed to encode macro block
-* predMV pointer to the predicted motion vector data
-* lastPos pointer to last non-zero position of each block in the macro block
-* colorEffect color effect applied
-* Function:
-* This function encodes INTER macroblock in SVH mode
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmPutInterMBSVH(tMacroblockData* mbData, tMBInfo* mbi, bibBuffer_t *outBuf,
- int32 *numTextureBits, tMotionVector* predMV, int32* lastPos,
- int16 colorEffect)
-{
- int32 dQuant;
- int32 mcbpcVal;
- int32 index;
- int32 cbpy;
- int32 textureBits;
- int16* coeff;
- int32 len;
-
- vlbPutBits(outBuf, 1, mbi->SkippedMB);
- if(mbi->SkippedMB == ON)
- {
- *numTextureBits = 0;
- return;
- }
-
- dQuant = mbi->dQuant;
- mcbpcVal = colorEffect? 0 : (mbi->CodedBlockPattern & 3);
- cbpy = (~((mbi->CodedBlockPattern >> 2) & 0xf)) & 0xf;
-
- /* only ONE MV in baseline H263 */
- index = (dQuant == 0 ? 0 : 4) + mcbpcVal;
- len = sCBPCPType[index].length + sCBPY[cbpy].length;
- mcbpcVal = (sCBPCPType[index].code << sCBPY[cbpy].length) | sCBPY[cbpy].code;
-
- vlbPutBits(outBuf, len, mcbpcVal);
-
- if(dQuant != 0)
- {
- vlbPutBits(outBuf, 2, sDquant[dQuant + 2]);
- }
-
- /* encode motion vectors */
- {
- vbmEncodeMVDifferential(mbi->MV[0][0] - predMV[0].mvx,
- mbi->MV[0][1] - predMV[0].mvy,
- 1, outBuf);
- }
-
- /* encode texture coefficents */
- textureBits = 0;
- cbpy = 32;
- for (index = 0; index < (colorEffect ? 4 : 6); index++)
- {
- if(cbpy & mbi->CodedBlockPattern)
- {
- coeff = mbData->Data + index * 64;
- textureBits += vlbCodeACCoeffsSVHWithZigZag(0, coeff, outBuf, ON, lastPos[index]);
- }
- cbpy >>= 1;
- }
- *numTextureBits = textureBits;
-
- return;
-}
-
-/*
-*******************************************************************************
-Name : vbmPutInterMB
-Description : INTER macroblock is encoded here.
-Parameter :
- mbData: Pointer to the macro block data structure
- mbi: Pointer to the macro block information structure.
- vopData: Pointer to the VOP data structure.
- currFrame: Pointer to the current frame data
- mbNo: The number macro block being encoded.
- numTextureBits:Pointer to store the number of bits taken to encode the macro block.
- prevQuant: Pointer to the quantization sacle.
- blockSAD: Pointer to store the block SAD values.
- outBuf: Pointer to the output bit-stream buffer structure
- mvi: Pointer to the MV array
-Return Value : void
-*******************************************************************************
-*/
-/* {{-output"vbmPutInterMB.txt"}} */
-/*
-* vbmPutInterMB
-*
-* Parameters:
-* outBuf pointer to the output bit-stream buffer structure
-* mbPos pointer to macroblock position structure
-* paramMB pointer to macroblock parameters structure
-* initPred pointer to predictor motion vectors, pixel unit
-* noOfPredictors number of MV predictors
-* numTextureBits pointer to store the number of bits needed to encode macro block
-* colorEffect color effect applied
-* vopWidth width of frame/VOP
-* vopHeight height of frame/VOP
-* mbsinfo pointer to macro block information structure
-* searchRange search range
-* Function:
-* This function encodes INTER macroblock
-*
-* Returns:
-* Nothing.
-*
-* Error codes:
-* None.
-*
-*/
-void vbmPutInterMB(tMBPosition* mbPos, bibBuffer_t *outBuf, dmdPParam_t *paramMB,
- tMotionVector *initPred, int32 noOfPredictors, u_int32 vopWidth,
- u_int32 vopHeight,int32 searchRange, int32 mbNo,
- int32* numTextureBits, int16 colorEffect, tMBInfo *mbsinfo)
-{
- int32 blkCnt;
- tMotionVector predMV[4];
- int32 lastPosition[6] = {-1,-1,-1,-1,-1,-1};
- tPixel *currBlockPos = NULL;
- tMotionVector bestMV;
- tMacroblockData mbData;
- tMBInfo *mbi = mbsinfo + mbNo;
- mbi->SkippedMB = OFF;
- u_int32 yWidth = paramMB->uvWidth * 2;
-
- bestMV.mvx = 0;
- bestMV.mvy = 0;
- bestMV.SAD = MB_SIZE * MB_SIZE / 2; // quich search stop threshold
-
- vbmMEMBSpatioTemporalSearch(paramMB->refY, vopWidth,vopHeight,paramMB->currYMBInFrame, yWidth,
- mbPos, initPred, noOfPredictors, &bestMV,
- searchRange, bestMV.SAD);
-
- /* update MV buffer */
- mbi->MV[0][0] = bestMV.mvx;
- mbi->MV[0][1] = bestMV.mvy;
- mbi->SAD = bestMV.SAD;
- currBlockPos = paramMB->currYMBInFrame;
-
- for (blkCnt= 0; blkCnt < 4; blkCnt++)
- {
- int blkPosX, blkPosY;
- blkPosX = (blkCnt & 1) ? mbPos->x + 8 : mbPos->x;
- blkPosY = (blkCnt & 2) ? mbPos->y + 8 : mbPos->y;
-
- vbmPredictBlock(paramMB->refY, vopWidth, 0, currBlockPos, yWidth,
- &mbData.Data[blkCnt * BLOCK_COEFF_SIZE],
- &bestMV, blkPosX, blkPosY);
- vbmDCTQuantInterSVH(&mbData.Data[blkCnt * BLOCK_COEFF_SIZE],
- mbi, &(lastPosition[blkCnt]));
- currBlockPos += 8;
- if (blkCnt & 1)
- currBlockPos += 8 * yWidth - 16;
- }
-
- if (!colorEffect)
- {
- /* Find the Chrominance Block Motion vectors */
- tMotionVector lChrMv;
-
- lChrMv.mvx = (int16)(bestMV.mvx % 4 == 0 ? bestMV.mvx >> 1 : (bestMV.mvx >> 1) | 1);
- lChrMv.mvy = (int16)(bestMV.mvy % 4 == 0 ? bestMV.mvy >> 1 : (bestMV.mvy >> 1) | 1);
- blkCnt = 4; /* U */
- vbmPredictBlock(paramMB->refU, paramMB->uvWidth, 0, paramMB->currUBlkInFrame, paramMB->uvWidth,
- &mbData.Data[blkCnt * BLOCK_COEFF_SIZE],
- &lChrMv, mbPos->x >> 1, mbPos->y >> 1);
- vbmDCTQuantInterSVH(&mbData.Data[blkCnt * BLOCK_COEFF_SIZE],
- mbi, &(lastPosition[blkCnt]));
- blkCnt = 5; /* V */
- vbmPredictBlock(paramMB->refV, paramMB->uvWidth, 0, paramMB->currVBlkInFrame, paramMB->uvWidth,
- &mbData.Data[blkCnt * BLOCK_COEFF_SIZE],
- &lChrMv, mbPos->x >> 1, mbPos->y >> 1);
- vbmDCTQuantInterSVH(&mbData.Data[blkCnt * BLOCK_COEFF_SIZE],
- mbi, &(lastPosition[blkCnt]));
- }
-
- vbmCBPYInter(mbi, lastPosition);
- if((mbi->CodedBlockPattern == 0) &&
- (mbi->MV[0][0] == 0) && (mbi->MV[0][1] == 0))
- {
- mbi->SkippedMB = ON;
- }
- else //(mbi->SkippedMB == OFF)
- {
- vbmMvPrediction(mbi, mbNo, predMV, vopWidth / MB_SIZE);
- }
- vbmPutInterMBSVH(&mbData, mbi, outBuf,
- numTextureBits, predMV, lastPosition, colorEffect);
-
- return;
-}
-
-
-/* End of bma.cpp */
-