--- branches/dev-api-3/xvidcore/src/motion/motion_est.c 2002/10/02 10:16:36 574 +++ branches/dev-api-3/xvidcore/src/motion/motion_est.c 2002/10/17 13:27:22 600 @@ -37,6 +37,7 @@ #include "../prediction/mbprediction.h" #include "../global.h" #include "../utils/timer.h" +#include "../image/interpolate8x8.h" #include "motion_est.h" #include "motion.h" #include "sad.h" @@ -51,6 +52,16 @@ #define CHECK_CANDIDATE(X,Y,D) { \ (*CheckCandidate)((const int)(X),(const int)(Y), (D), &iDirection, data ); } +#define GET_REFERENCE(X, Y, REF) { \ + switch ( (((X)&1)<<1) + ((Y)&1) ) \ + { \ + case 0 : REF = data->Ref + (X)/2 + ((Y)/2)*(data->iEdgedWidth); break; \ + case 1 : REF = data->RefV + (X)/2 + (((Y)-1)/2)*(data->iEdgedWidth); break; \ + case 2 : REF = data->RefH + ((X)-1)/2 + ((Y)/2)*(data->iEdgedWidth); break; \ + default : REF = data->RefHV + ((X)-1)/2 + (((Y)-1)/2)*(data->iEdgedWidth); break; \ + } \ +} + #define iDiamondSize 2 static __inline int @@ -84,7 +95,6 @@ static void CheckCandidate16(const int x, const int y, const int Direction, int * const dir, const SearchData * const data) { - int32_t * const sad = data->temp; int t; const uint8_t * Reference; @@ -98,9 +108,13 @@ default : Reference = data->RefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth); break; } - data->temp[0] = sad16v(data->Cur, Reference, data->iEdgedWidth, sad+1); + data->temp[0] = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp + 1); + + if(data->quarterpel) + t = d_mv_bits(2*x - data->predQMV.x, 2*y - data->predQMV.y, data->iFcode); + else + t = d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode); - t = d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode); data->temp[0] += lambda_vec16[data->iQuant] * t; data->temp[1] += lambda_vec8[data->iQuant] * t; @@ -137,9 +151,14 @@ default : Reference = data->RefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth); break; } - sad = lambda_vec16[data->iQuant] * - d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode); - sad += sad16(data->Cur, Reference, data->iEdgedWidth, 256*4096); + if(data->quarterpel) + sad = lambda_vec16[data->iQuant] * + d_mv_bits(2*x - data->predQMV.x, 2*y - data->predQMV.y, data->iFcode); + else + sad = lambda_vec16[data->iQuant] * + d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode); + + sad += sad16(data->Cur, Reference, data->iEdgedWidth, MV_MAX_ERROR); if (sad < *(data->iMinSAD)) { *(data->iMinSAD) = sad; @@ -148,6 +167,154 @@ } static void +CheckCandidate16_qpel(const int x, const int y, const int Direction, int * const dir, const SearchData * const data) + +// CheckCandidate16 variant which expects x and y in quarter pixel resolution +// Important: This is no general usable routine! x and y must be +/-1 (qpel resolution!) +// around currentMV! +{ + int t; + uint8_t * Reference = (uint8_t *) data->RefQ; + const uint8_t *ref1, *ref2, *ref3, *ref4; + VECTOR halfpelMV = *(data->currentMV); + + int32_t iEdgedWidth = data->iEdgedWidth; + uint32_t rounding = data->rounding; + + if (( x > data->max_dx) || ( x < data->min_dx) + || ( y > data->max_dy) || (y < data->min_dy)) return; + + switch( ((x&1)<<1) + (y&1) ) + { + case 0: // pure halfpel position - shouldn't happen during a refinement step + GET_REFERENCE(halfpelMV.x, halfpelMV.y, (const uint8_t *) Reference); + break; + + case 1: // x halfpel, y qpel - top or bottom during qpel refinement + GET_REFERENCE(halfpelMV.x, halfpelMV.y, ref1); + GET_REFERENCE(halfpelMV.x, y - halfpelMV.y, ref2); + + interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding); + interpolate8x8_avg2(Reference+8, ref1+8, ref2+8, iEdgedWidth, rounding); + interpolate8x8_avg2(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, iEdgedWidth, rounding); + interpolate8x8_avg2(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, iEdgedWidth, rounding); + break; + + case 2: // x qpel, y halfpel - left or right during qpel refinement + GET_REFERENCE(halfpelMV.x, halfpelMV.y, ref1); + GET_REFERENCE(x - halfpelMV.x, halfpelMV.y, ref2); + + interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding); + interpolate8x8_avg2(Reference+8, ref1+8, ref2+8, iEdgedWidth, rounding); + interpolate8x8_avg2(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, iEdgedWidth, rounding); + interpolate8x8_avg2(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, iEdgedWidth, rounding); + break; + + default: // x and y in qpel resolution - the "corners" (top left/right and + // bottom left/right) during qpel refinement + GET_REFERENCE(halfpelMV.x, halfpelMV.y, ref1); + GET_REFERENCE(halfpelMV.x, y - halfpelMV.y, ref2); + GET_REFERENCE(x - halfpelMV.x, halfpelMV.y, ref3); + GET_REFERENCE(x - halfpelMV.x, y - halfpelMV.y, ref4); + + interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding); + interpolate8x8_avg4(Reference+8, ref1+8, ref2+8, ref3+8, ref4+8, iEdgedWidth, rounding); + interpolate8x8_avg4(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, ref3+8*iEdgedWidth, ref4+8*iEdgedWidth, iEdgedWidth, rounding); + interpolate8x8_avg4(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, ref3+8*iEdgedWidth+8, ref4+8*iEdgedWidth+8, iEdgedWidth, rounding); + break; + } + + data->temp[0] = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp+1); + + t = d_mv_bits(x - data->predQMV.x, y - data->predQMV.y, data->iFcode); + data->temp[0] += lambda_vec16[data->iQuant] * t; + data->temp[1] += lambda_vec8[data->iQuant] * t; + + if (data->temp[0] < data->iMinSAD[0]) { + data->iMinSAD[0] = data->temp[0]; + data->currentQMV[0].x = x; data->currentQMV[0].y = y; + /* *dir = Direction;*/ } + + if (data->temp[1] < data->iMinSAD[1]) { + data->iMinSAD[1] = data->temp[1]; data->currentQMV[1].x = x; data->currentQMV[1].y = y; } + if (data->temp[2] < data->iMinSAD[2]) { + data->iMinSAD[2] = data->temp[2]; data->currentQMV[2].x = x; data->currentQMV[2].y = y; } + if (data->temp[3] < data->iMinSAD[3]) { + data->iMinSAD[3] = data->temp[3]; data->currentQMV[3].x = x; data->currentQMV[3].y = y; } + if (data->temp[4] < data->iMinSAD[4]) { + data->iMinSAD[4] = data->temp[4]; data->currentQMV[4].x = x; data->currentQMV[4].y = y; } +} + +static void +CheckCandidate16no4v_qpel(const int x, const int y, const int Direction, int * const dir, const SearchData * const data) + +// CheckCandidate16no4v variant which expects x and y in quarter pixel resolution +// Important: This is no general usable routine! x and y must be +/-1 (qpel resolution!) +// around currentMV! +{ + int32_t sad; + uint8_t * Reference = (uint8_t *) data->RefQ; + const uint8_t *ref1, *ref2, *ref3, *ref4; + VECTOR halfpelMV = *(data->currentMV); + + int32_t iEdgedWidth = data->iEdgedWidth; + uint32_t rounding = data->rounding; + + if (( x > data->max_dx) || ( x < data->min_dx) + || ( y > data->max_dy) || (y < data->min_dy)) return; + + switch( ((x&1)<<1) + (y&1) ) + { + case 0: // pure halfpel position - shouldn't happen during a refinement step + GET_REFERENCE(halfpelMV.x, halfpelMV.y, (const uint8_t *) Reference); + break; + + case 1: // x halfpel, y qpel - top or bottom during qpel refinement + GET_REFERENCE(halfpelMV.x, halfpelMV.y, ref1); + GET_REFERENCE(halfpelMV.x, y - halfpelMV.y, ref2); + + interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding); + interpolate8x8_avg2(Reference+8, ref1+8, ref2+8, iEdgedWidth, rounding); + interpolate8x8_avg2(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, iEdgedWidth, rounding); + interpolate8x8_avg2(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, iEdgedWidth, rounding); + break; + + case 2: // x qpel, y halfpel - left or right during qpel refinement + GET_REFERENCE(halfpelMV.x, halfpelMV.y, ref1); + GET_REFERENCE(x - halfpelMV.x, halfpelMV.y, ref2); + + interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding); + interpolate8x8_avg2(Reference+8, ref1+8, ref2+8, iEdgedWidth, rounding); + interpolate8x8_avg2(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, iEdgedWidth, rounding); + interpolate8x8_avg2(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, iEdgedWidth, rounding); + break; + + default: // x and y in qpel resolution - the "corners" (top left/right and + // bottom left/right) during qpel refinement + GET_REFERENCE(halfpelMV.x, halfpelMV.y, ref1); + GET_REFERENCE(halfpelMV.x, y - halfpelMV.y, ref2); + GET_REFERENCE(x - halfpelMV.x, halfpelMV.y, ref3); + GET_REFERENCE(x - halfpelMV.x, y - halfpelMV.y, ref4); + + interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding); + interpolate8x8_avg4(Reference+8, ref1+8, ref2+8, ref3+8, ref4+8, iEdgedWidth, rounding); + interpolate8x8_avg4(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, ref3+8*iEdgedWidth, ref4+8*iEdgedWidth, iEdgedWidth, rounding); + interpolate8x8_avg4(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, ref3+8*iEdgedWidth+8, ref4+8*iEdgedWidth+8, iEdgedWidth, rounding); + break; + } + + sad = lambda_vec16[data->iQuant] * + d_mv_bits(x - data->predQMV.x, y - data->predQMV.y, data->iFcode); + sad += sad16(data->Cur, Reference, data->iEdgedWidth, MV_MAX_ERROR); + + if (sad < *(data->iMinSAD)) { + *(data->iMinSAD) = sad; + data->currentQMV[0].x = x; data->currentQMV[0].y = y; +// *dir = Direction; + } +} + +static void CheckCandidate16no4vI(const int x, const int y, const int Direction, int * const dir, const SearchData * const data) { int32_t sad; @@ -269,7 +436,7 @@ const uint8_t *ReferenceB; VECTOR mvs, b_mvs; - if (( x > 31) || ( x < -31) || ( y > 31) || (y < -31)) return; + if (( x > 31) || ( x < -32) || ( y > 31) || (y < -32)) return; sad = lambda_vec16[data->iQuant] * d_mv_bits(x, y, 1); @@ -328,7 +495,11 @@ } sad = sad8(data->Cur, Reference, data->iEdgedWidth); - sad += lambda_vec8[data->iQuant] * d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode); + + if(data->quarterpel) + sad += lambda_vec8[data->iQuant] * d_mv_bits(2*x - data->predQMV.x, 2*y - data->predQMV.y, data->iFcode); + else + sad += lambda_vec8[data->iQuant] * d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode); if (sad < *(data->iMinSAD)) { *(data->iMinSAD) = sad; @@ -336,6 +507,64 @@ *dir = Direction; } } +static void +CheckCandidate8_qpel(const int x, const int y, const int Direction, int * const dir, const SearchData * const data) +// CheckCandidate16no4v variant which expects x and y in quarter pixel resolution +// Important: This is no general usable routine! x and y must be +/-1 (qpel resolution!) +// around currentMV! + +{ + int32_t sad; + uint8_t *Reference = (uint8_t *) data->RefQ; + const uint8_t *ref1, *ref2, *ref3, *ref4; + VECTOR halfpelMV = *(data->currentMV); + + int32_t iEdgedWidth = data->iEdgedWidth; + uint32_t rounding = data->rounding; + + if (( x > data->max_dx) || ( x < data->min_dx) + || ( y > data->max_dy) || (y < data->min_dy)) return; + + switch( ((x&1)<<1) + (y&1) ) + { + case 0: // pure halfpel position - shouldn't happen during a refinement step + GET_REFERENCE(halfpelMV.x, halfpelMV.y, (const uint8_t *) Reference); + break; + + case 1: // x halfpel, y qpel - top or bottom during qpel refinement + GET_REFERENCE(halfpelMV.x, halfpelMV.y, ref1); + GET_REFERENCE(halfpelMV.x, y - halfpelMV.y, ref2); + + interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding); + break; + + case 2: // x qpel, y halfpel - left or right during qpel refinement + GET_REFERENCE(halfpelMV.x, halfpelMV.y, ref1); + GET_REFERENCE(x - halfpelMV.x, halfpelMV.y, ref2); + + interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding); + break; + + default: // x and y in qpel resolution - the "corners" (top left/right and + // bottom left/right) during qpel refinement + GET_REFERENCE(halfpelMV.x, halfpelMV.y, ref1); + GET_REFERENCE(halfpelMV.x, y - halfpelMV.y, ref2); + GET_REFERENCE(x - halfpelMV.x, halfpelMV.y, ref3); + GET_REFERENCE(x - halfpelMV.x, y - halfpelMV.y, ref4); + + interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding); + break; + } + + sad = sad8(data->Cur, Reference, data->iEdgedWidth); + sad += lambda_vec8[data->iQuant] * d_mv_bits(x - data->predQMV.x, y - data->predQMV.y, data->iFcode); + + if (sad < *(data->iMinSAD)) { + *(data->iMinSAD) = sad; + data->currentQMV->x = x; data->currentQMV->y = y; + *dir = Direction; } +} + /* CHECK_CANDIATE FUNCTIONS END */ /* MAINSEARCH FUNCTIONS START */ @@ -504,6 +733,28 @@ CHECK_CANDIDATE(backupMV.x, backupMV.y - 1, 0); } + +static void +QuarterpelRefine(const SearchData * const data) +{ +/* Perform quarter pixel refinement*/ + + VECTOR backupMV = *(data->currentQMV); + int iDirection; //not needed + + CHECK_CANDIDATE(backupMV.x - 1, backupMV.y - 1, 0); + CHECK_CANDIDATE(backupMV.x + 1, backupMV.y - 1, 0); + CHECK_CANDIDATE(backupMV.x - 1, backupMV.y + 1, 0); + CHECK_CANDIDATE(backupMV.x + 1, backupMV.y + 1, 0); + + CHECK_CANDIDATE(backupMV.x - 1, backupMV.y, 0); + CHECK_CANDIDATE(backupMV.x + 1, backupMV.y, 0); + + CHECK_CANDIDATE(backupMV.x, backupMV.y + 1, 0); + CHECK_CANDIDATE(backupMV.x, backupMV.y - 1, 0); + +} + static __inline int SkipDecisionP(const IMAGE * current, const IMAGE * reference, const int x, const int y, @@ -530,6 +781,10 @@ pMB->mode = MODE_NOT_CODED; pMB->mvs[0].x = pMB->mvs[1].x = pMB->mvs[2].x = pMB->mvs[3].x = 0; pMB->mvs[0].y = pMB->mvs[1].y = pMB->mvs[2].y = pMB->mvs[3].y = 0; + + pMB->qmvs[0].x = pMB->qmvs[1].x = pMB->qmvs[2].x = pMB->qmvs[3].x = 0; + pMB->qmvs[0].y = pMB->qmvs[1].y = pMB->qmvs[2].y = pMB->qmvs[3].y = 0; + pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = sad; } @@ -551,17 +806,27 @@ uint32_t x, y; uint32_t iIntra = 0; int32_t InterBias, quant = current->quant; + uint8_t *qimage; // some pre-initialized thingies for SearchP int32_t temp[5]; VECTOR currentMV[5]; + VECTOR currentQMV[5]; int32_t iMinSAD[5]; SearchData Data; Data.iEdgedWidth = pParam->edged_width; Data.currentMV = currentMV; + Data.currentQMV = currentQMV; Data.iMinSAD = iMinSAD; Data.temp = temp; Data.iFcode = current->fcode; + Data.rounding = pParam->m_rounding_type; + Data.quarterpel = pParam->m_quarterpel; + + if((qimage = (uint8_t *) malloc(32 * pParam->edged_width)) == NULL) + return 1; // allocate some mem for qpel interpolated blocks + // somehow this is dirty since I think we shouldn't use malloc outside + // encoder_create() - so please fix me! if (sadInit) (*sadInit) (); @@ -592,10 +857,11 @@ if (pMB->sad16 < pMB->quant * INITIAL_SKIP_THRESH) { SkipMacroblockP(pMB, sad00); continue; + sad00 = 256 * 4096; } } else sad00 = 256*4096; // skip not allowed - for final skip decision - SearchP(pRef->y, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x, + SearchP(pRef->y, pRefH->y, pRefV->y, pRefHV->y, qimage, pCurrent, x, y, current->motion_flags, pMB->quant, &Data, pParam, pMBs, reference->mbs, current->global_flags & XVID_INTER4V, pMB); @@ -620,16 +886,19 @@ pParam->edged_width); if (deviation < (pMB->sad16 - InterBias)) { - if (++iIntra >= iLimit) return 1; + if (++iIntra >= iLimit) { free(qimage); return 1; } pMB->mode = MODE_INTRA; pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = zeroMV; + pMB->qmvs[0] = pMB->qmvs[1] = pMB->qmvs[2] = + pMB->qmvs[3] = zeroMV; pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = 0; } } } } + free(qimage); return 0; } @@ -691,6 +960,7 @@ const uint8_t * const pRefH, const uint8_t * const pRefV, const uint8_t * const pRefHV, + const uint8_t * const pRefQ, const IMAGE * const pCur, const int x, const int y, @@ -707,16 +977,20 @@ int i, iDirection = 255, mask, threshA; VECTOR pmv[7]; + Data->predQMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, 0); + get_pmvdata2(pMBs, pParam->mb_width, 0, x, y, 0, pmv, Data->temp); //has to be changed to get_pmv(2)() get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16, - pParam->width, pParam->height, Data->iFcode); + pParam->width, pParam->height, Data->iFcode, pParam->m_quarterpel); Data->predMV = pmv[0]; + Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16; Data->Ref = pRef + (x + Data->iEdgedWidth*y)*16; Data->RefH = pRefH + (x + Data->iEdgedWidth*y) * 16; Data->RefV = pRefV + (x + Data->iEdgedWidth*y) * 16; Data->RefHV = pRefHV + (x + Data->iEdgedWidth*y) * 16; + Data->RefQ = pRefQ; Data->iQuant = iQuant; @@ -731,9 +1005,14 @@ if (inter4v) CheckCandidate = CheckCandidate16; else CheckCandidate = CheckCandidate16no4v; - for(i = 0; i < 5; i++) Data->currentMV[i].x = Data->currentMV[i].y = 0; + for(i = 0; i < 5; i++) + Data->currentMV[i].x = Data->currentMV[i].y = 0; - i = d_mv_bits(Data->predMV.x, Data->predMV.y, Data->iFcode); + if(Data->quarterpel) + i = d_mv_bits(Data->predQMV.x, Data->predQMV.y, Data->iFcode); + else + i = d_mv_bits(Data->predMV.x, Data->predMV.y, Data->iFcode); + Data->iMinSAD[0] = pMB->sad16 + lambda_vec16[iQuant] * i; Data->iMinSAD[1] = pMB->sad8[0] + lambda_vec8[iQuant] * i; Data->iMinSAD[2] = pMB->sad8[1]; @@ -810,6 +1089,24 @@ if (MotionFlags & PMV_HALFPELREFINE16) HalfpelRefine(Data); + for(i = 0; i < 5; i++) { + Data->currentQMV[i].x = 2 * Data->currentMV[i].x; // initialize qpel vectors + Data->currentQMV[i].y = 2 * Data->currentMV[i].y; + } + + if((pParam->m_quarterpel) && (MotionFlags & PMV_QUARTERPELREFINE16)) { + + if(inter4v) + CheckCandidate = CheckCandidate16_qpel; + else + CheckCandidate = CheckCandidate16no4v_qpel; + + get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16, + pParam->width, pParam->height, Data->iFcode, 0); // get real range + + QuarterpelRefine(Data); + } + if (inter4v) { SearchData Data8; Data8.iFcode = Data->iFcode; @@ -829,18 +1126,26 @@ pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = Data->currentMV[0]; + pMB->qmvs[0] = pMB->qmvs[1] + = pMB->qmvs[2] = pMB->qmvs[3] = Data->currentQMV[0]; + pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = Data->iMinSAD[0]; - pMB->pmvs[0].x = Data->currentMV[0].x - Data->predMV.x; - pMB->pmvs[0].y = Data->currentMV[0].y - Data->predMV.y; + if(pParam->m_quarterpel) { + pMB->pmvs[0].x = Data->currentQMV[0].x - Data->predQMV.x; + pMB->pmvs[0].y = Data->currentQMV[0].y - Data->predQMV.y; + } + else { + pMB->pmvs[0].x = Data->currentMV[0].x - Data->predMV.x; + pMB->pmvs[0].y = Data->currentMV[0].y - Data->predMV.y; + } } else { // INTER4V MODE; all other things are already set in Search8 pMB->mode = MODE_INTER4V; pMB->sad16 = Data->iMinSAD[1] + Data->iMinSAD[2] + Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * iQuant; } - } static void @@ -854,14 +1159,26 @@ SearchData * const Data) { Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x/2 , y/2, block); + Data->predQMV = get_qpmv2(pMBs, pParam->mb_width, 0, x/2 , y/2, block); Data->iMinSAD = OldData->iMinSAD + 1 + block; Data->currentMV = OldData->currentMV + 1 + block; + Data->currentQMV = OldData->currentQMV + 1 + block; + Data->quarterpel = OldData->quarterpel; - if (block != 0) - *(Data->iMinSAD) += lambda_vec8[Data->iQuant] * - d_mv_bits( Data->currentMV->x - Data->predMV.x, - Data->currentMV->y - Data->predMV.y, - Data->iFcode); + if(Data->quarterpel) // add d_mv_bits[qpel] everywhere but not in 0 (it's already there) + { + if (block != 0) + *(Data->iMinSAD) += lambda_vec8[Data->iQuant] * + d_mv_bits(Data->currentQMV->x - Data->predQMV.x, + Data->currentQMV->y - Data->predQMV.y, + Data->iFcode); + + } else // add d_mv_bits[hpel] everywhere but not in 0 (it's already there) + if (block != 0) + *(Data->iMinSAD) += lambda_vec8[Data->iQuant] * + d_mv_bits(Data->currentMV->x - Data->predMV.x, + Data->currentMV->y - Data->predMV.y, + Data->iFcode); if (MotionFlags & (PMV_EXTSEARCH8|PMV_HALFPELREFINE8)) { @@ -869,31 +1186,67 @@ Data->RefH = OldData->RefH + 8 * ((block&1) + pParam->edged_width*(block>>1)); Data->RefV = OldData->RefV + 8 * ((block&1) + pParam->edged_width*(block>>1)); Data->RefHV = OldData->RefHV + 8 * ((block&1) + pParam->edged_width*(block>>1)); + Data->RefQ = OldData->RefQ; Data->Cur = OldData->Cur + 8 * ((block&1) + pParam->edged_width*(block>>1)); get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 8, - pParam->width, pParam->height, OldData->iFcode); + pParam->width, pParam->height, OldData->iFcode, pParam->m_quarterpel); CheckCandidate = CheckCandidate8; if (MotionFlags & PMV_EXTSEARCH8) { - + int32_t temp_sad = *(Data->iMinSAD); // store current MinSAD + MainSearchFunc *MainSearchPtr; if (MotionFlags & PMV_USESQUARES8) MainSearchPtr = SquareSearch; else if (MotionFlags & PMV_ADVANCEDDIAMOND8) MainSearchPtr = AdvDiamondSearch; else MainSearchPtr = DiamondSearch; - (*MainSearchPtr)(Data->currentMV->x, Data->currentMV->y, Data, 255); } + (*MainSearchPtr)(Data->currentMV->x, Data->currentMV->y, Data, 255); + + if(*(Data->iMinSAD) < temp_sad) { //found a better match? + Data->currentQMV->x = 2 * Data->currentMV->x; // update our qpel vector + Data->currentQMV->y = 2 * Data->currentMV->y; + } + } + + if (MotionFlags & PMV_HALFPELREFINE8) { + int32_t temp_sad = *(Data->iMinSAD); // store current MinSAD + + HalfpelRefine(Data); // perform halfpel refine of current best vector - if (MotionFlags & PMV_HALFPELREFINE8) HalfpelRefine(Data); + if(*(Data->iMinSAD) < temp_sad) { // we have found a better match + Data->currentQMV->x = 2 * Data->currentMV->x; // update our qpel vector + Data->currentQMV->y = 2 * Data->currentMV->y; + } + } + + if((Data->quarterpel) && (!(Data->currentQMV->x & 1)) && (!(Data->currentQMV->y & 1)) && + (MotionFlags & PMV_QUARTERPELREFINE8)) { + + CheckCandidate = CheckCandidate8_qpel; + + get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 8, + pParam->width, pParam->height, OldData->iFcode, 0); // get real range + + QuarterpelRefine(Data); + } + } + + if(pParam->m_quarterpel) { + pMB->pmvs[block].x = Data->currentQMV->x - Data->predQMV.x; + pMB->pmvs[block].y = Data->currentQMV->y - Data->predQMV.y; + } + else { + pMB->pmvs[block].x = Data->currentMV->x - Data->predMV.x; + pMB->pmvs[block].y = Data->currentMV->y - Data->predMV.y; } - pMB->pmvs[block].x = Data->currentMV->x - Data->predMV.x; - pMB->pmvs[block].y = Data->currentMV->y - Data->predMV.y; pMB->mvs[block] = *(Data->currentMV); - pMB->sad8[block] = 4 * (*Data->iMinSAD); + pMB->qmvs[block] = *(Data->currentQMV); + pMB->sad8[block] = 4 * (*Data->iMinSAD); // Isibaar: why? } /* B-frames code starts here */ @@ -979,7 +1332,7 @@ Data->predMV = *predMV; get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16, - pParam->width, pParam->height, iFcode); + pParam->width, pParam->height, iFcode, pParam->m_quarterpel); pmv[0] = Data->predMV; PreparePredictionsBF(pmv, x, y, pParam->mb_width, pMB, mode_current); @@ -1094,7 +1447,7 @@ // skip decision if (*Data->iMinSAD - 2 * lambda_vec16[Data->iQuant] < (int32_t)Data->iQuant * SKIP_THRESH_B) { - //checking chroma. everything copied from MC + //possible skip - checking chroma. everything copied from MC //this is not full chroma compensation, only it's fullpel approximation. should work though int sum, dx, dy, b_dx, b_dy; @@ -1216,8 +1569,8 @@ fData->currentMV[0] = pMB->mvs[0]; fData->currentMV[1] = pMB->b_mvs[0]; - get_range(&fData->min_dx, &fData->max_dx, &fData->min_dy, &fData->max_dy, x, y, 16, pParam->width, pParam->height, fcode); - get_range(&bData.min_dx, &bData.max_dx, &bData.min_dy, &bData.max_dy, x, y, 16, pParam->width, pParam->height, bcode); + get_range(&fData->min_dx, &fData->max_dx, &fData->min_dy, &fData->max_dy, x, y, 16, pParam->width, pParam->height, fcode, pParam->m_quarterpel); + get_range(&bData.min_dx, &bData.max_dx, &bData.min_dy, &bData.max_dy, x, y, 16, pParam->width, pParam->height, bcode, pParam->m_quarterpel); if (fData->currentMV[0].x > fData->max_dx) fData->currentMV[0].x = fData->max_dx; if (fData->currentMV[0].x < fData->min_dx) fData->currentMV[0].x = fData->min_dy; @@ -1404,59 +1757,101 @@ /* Hinted ME starts here */ -static __inline void -Search8hinted( const SearchData * const OldData, - const int x, const int y, - const uint32_t MotionFlags, - const MBParam * const pParam, - MACROBLOCK * const pMB, - const MACROBLOCK * const pMBs, - const int block) +static void +Search8hinted(const SearchData * const OldData, + const int x, const int y, + const uint32_t MotionFlags, + const MBParam * const pParam, + MACROBLOCK * const pMB, + const MACROBLOCK * const pMBs, + const int block, + SearchData * const Data) { - SearchData Data; + int32_t temp_sad; MainSearchFunc *MainSearchPtr; + Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x/2 , y/2, block); + Data->predQMV = get_qpmv2(pMBs, pParam->mb_width, 0, x/2 , y/2, block); + Data->iMinSAD = OldData->iMinSAD + 1 + block; + Data->currentMV = OldData->currentMV + 1 + block; + Data->currentQMV = OldData->currentQMV + 1 + block; + Data->quarterpel = OldData->quarterpel; - Data.predMV = get_pmv2(pMBs, pParam->mb_width, 0, x/2 , y/2, block); - Data.iMinSAD = OldData->iMinSAD + 1 + block; - Data.currentMV = OldData->currentMV+1+block; - Data.iFcode = OldData->iFcode; - Data.iQuant = OldData->iQuant; - - Data.Ref = OldData->Ref + 8 * ((block&1) + pParam->edged_width*(block>>1)); - Data.RefH = OldData->RefH + 8 * ((block&1) + pParam->edged_width*(block>>1)); - Data.RefV = OldData->RefV + 8 * ((block&1) + pParam->edged_width*(block>>1)); - Data.RefHV = OldData->RefHV + 8 * ((block&1) + pParam->edged_width*(block>>1)); - Data.iEdgedWidth = pParam->edged_width; - Data.Cur = OldData->Cur + 8 * ((block&1) + pParam->edged_width*(block>>1)); - - CheckCandidate = CheckCandidate8; + if (block != 0) { + if(pParam->m_quarterpel) { + *(Data->iMinSAD) += lambda_vec8[Data->iQuant] * + d_mv_bits( Data->currentQMV->x - Data->predQMV.x, + Data->currentQMV->y - Data->predQMV.y, + Data->iFcode); + } + else { + *(Data->iMinSAD) += lambda_vec8[Data->iQuant] * + d_mv_bits( Data->currentMV->x - Data->predMV.x, + Data->currentMV->y - Data->predMV.y, + Data->iFcode); + } + } - if (block != 0) - *(Data.iMinSAD) += lambda_vec8[Data.iQuant] * - d_mv_bits( Data.currentMV->x - Data.predMV.x, - Data.currentMV->y - Data.predMV.y, - Data.iFcode); + Data->Ref = OldData->Ref + 8 * ((block&1) + pParam->edged_width*(block>>1)); + Data->RefH = OldData->RefH + 8 * ((block&1) + pParam->edged_width*(block>>1)); + Data->RefV = OldData->RefV + 8 * ((block&1) + pParam->edged_width*(block>>1)); + Data->RefHV = OldData->RefHV + 8 * ((block&1) + pParam->edged_width*(block>>1)); + Data->RefQ = OldData->RefQ; + Data->Cur = OldData->Cur + 8 * ((block&1) + pParam->edged_width*(block>>1)); + + get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 8, + pParam->width, pParam->height, OldData->iFcode, pParam->m_quarterpel); - get_range(&Data.min_dx, &Data.max_dx, &Data.min_dy, &Data.max_dy, x, y, 8, - pParam->width, pParam->height, OldData->iFcode); - - if (pMB->mode == MODE_INTER4V) { - int dummy; - CheckCandidate8(pMB->mvs[block].x, pMB->mvs[block].y, 0, &dummy, &Data); } + CheckCandidate = CheckCandidate8; + temp_sad = *(Data->iMinSAD); // store current MinSAD + if (MotionFlags & PMV_USESQUARES8) MainSearchPtr = SquareSearch; else if (MotionFlags & PMV_ADVANCEDDIAMOND8) MainSearchPtr = AdvDiamondSearch; else MainSearchPtr = DiamondSearch; - (*MainSearchPtr)(Data.currentMV->x, Data.currentMV->y, &Data, 255); + (*MainSearchPtr)(Data->currentMV->x, Data->currentMV->y, Data, 255); + + if(*(Data->iMinSAD) < temp_sad) { + Data->currentQMV->x = 2 * Data->currentMV->x; // update our qpel vector + Data->currentQMV->y = 2 * Data->currentMV->y; + } + + if (MotionFlags & PMV_HALFPELREFINE8) { + temp_sad = *(Data->iMinSAD); // store current MinSAD + + HalfpelRefine(Data); // perform halfpel refine of current best vector + + if(*(Data->iMinSAD) < temp_sad) { // we have found a better match + Data->currentQMV->x = 2 * Data->currentMV->x; // update our qpel vector + Data->currentQMV->y = 2 * Data->currentMV->y; + } + } + + if((Data->quarterpel) && (!(Data->currentQMV->x & 1)) && (!(Data->currentQMV->y & 1)) && + (MotionFlags & PMV_QUARTERPELREFINE8)) { + + CheckCandidate = CheckCandidate8_qpel; + + get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 8, + pParam->width, pParam->height, OldData->iFcode, 0); // get real range - if (MotionFlags & PMV_HALFPELREFINE8) HalfpelRefine(&Data); + QuarterpelRefine(Data); + } - pMB->pmvs[block].x = Data.currentMV->x - Data.predMV.x; - pMB->pmvs[block].y = Data.currentMV->y - Data.predMV.y; - pMB->mvs[block] = *(Data.currentMV); - pMB->sad8[block] = 4 * (*(Data.iMinSAD)); + if(pParam->m_quarterpel) { + pMB->pmvs[block].x = Data->currentQMV->x - Data->predQMV.x; + pMB->pmvs[block].y = Data->currentQMV->y - Data->predQMV.y; + } + else { + pMB->pmvs[block].x = Data->currentMV->x - Data->predMV.x; + pMB->pmvs[block].y = Data->currentMV->y - Data->predMV.y; + } + + pMB->mvs[block] = *(Data->currentMV); + pMB->qmvs[block] = *(Data->currentQMV); + + pMB->sad8[block] = 4 * (*Data->iMinSAD); } @@ -1465,6 +1860,7 @@ const uint8_t * const pRefH, const uint8_t * const pRefV, const uint8_t * const pRefHV, + const uint8_t * const pRefQ, const IMAGE * const pCur, const int x, const int y, @@ -1482,15 +1878,18 @@ int i, t; MainSearchFunc * MainSearchPtr; + Data->predQMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, 0); Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0); get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16, - pParam->width, pParam->height, Data->iFcode); + pParam->width, pParam->height, Data->iFcode, pParam->m_quarterpel); Data->Cur = pCur->y + (x + y * iEdgedWidth) * 16; Data->Ref = pRef + (x + iEdgedWidth*y)*16; Data->RefH = pRefH + (x + iEdgedWidth*y) * 16; Data->RefV = pRefV + (x + iEdgedWidth*y) * 16; Data->RefHV = pRefHV + (x + iEdgedWidth*y) * 16; + Data->RefQ = pRefQ; + Data->iQuant = iQuant; if (!(MotionFlags & PMV_HALFPEL16)) { @@ -1536,9 +1935,33 @@ if (MotionFlags & PMV_HALFPELREFINE16) HalfpelRefine(Data); - if (inter4v) - for(i = 0; i < 4; i++) - Search8hinted(Data, 2*x+(i&1), 2*y+(i>>1), MotionFlags, pParam, pMB, pMBs, i); + for(i = 0; i < 5; i++) { + Data->currentQMV[i].x = 2 * Data->currentMV[i].x; // initialize qpel vectors + Data->currentQMV[i].y = 2 * Data->currentMV[i].y; + } + + if((pParam->m_quarterpel) && (MotionFlags & PMV_QUARTERPELREFINE16)) { + if(inter4v) + CheckCandidate = CheckCandidate16_qpel; + else + CheckCandidate = CheckCandidate16no4v_qpel; + + get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16, + pParam->width, pParam->height, Data->iFcode, 0); // get real range + + QuarterpelRefine(Data); + } + + if (inter4v) { + SearchData Data8; + Data8.iFcode = Data->iFcode; + Data8.iQuant = Data->iQuant; + Data8.iEdgedWidth = Data->iEdgedWidth; + Search8hinted(Data, 2*x, 2*y, MotionFlags, pParam, pMB, pMBs, 0, &Data8); + Search8hinted(Data, 2*x + 1, 2*y, MotionFlags, pParam, pMB, pMBs, 1, &Data8); + Search8hinted(Data, 2*x, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 2, &Data8); + Search8hinted(Data, 2*x + 1, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 3, &Data8); + } if (!(inter4v) || (Data->iMinSAD[0] < Data->iMinSAD[1] + Data->iMinSAD[2] + Data->iMinSAD[3] + @@ -1576,15 +1999,24 @@ const IMAGE *const pRef = &reference->image; uint32_t x, y; + uint8_t *qimage; int32_t temp[5], quant = current->quant; int32_t iMinSAD[5]; VECTOR currentMV[5]; + VECTOR currentQMV[5]; SearchData Data; Data.iEdgedWidth = pParam->edged_width; Data.currentMV = currentMV; + Data.currentQMV = currentQMV; Data.iMinSAD = iMinSAD; Data.temp = temp; Data.iFcode = current->fcode; + Data.rounding = pParam->m_rounding_type; + + if((qimage = (uint8_t *) malloc(32 * pParam->edged_width)) == NULL) + return; // allocate some mem for qpel interpolated blocks + // somehow this is dirty since I think we shouldn't use malloc outside + // encoder_create() - so please fix me! if (sadInit) (*sadInit) (); @@ -1608,13 +2040,14 @@ pMB->quant = quant; } - SearchPhinted(pRef->y, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x, + SearchPhinted(pRef->y, pRefH->y, pRefV->y, pRefHV->y, qimage, pCurrent, x, y, current->motion_flags, pMB->quant, pParam, pMBs, current->global_flags & XVID_INTER4V, pMB, &Data); } } + free(qimage); } static __inline int @@ -1634,7 +2067,7 @@ *(Data->iMinSAD) = MV_MAX_ERROR; Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0); get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16, - pParam->width, pParam->height, Data->iFcode); + pParam->width, pParam->height, Data->iFcode, pParam->m_quarterpel); Data->Cur = pCur + (x + y * pParam->edged_width) * 16; Data->Ref = pRef + (x + y * pParam->edged_width) * 16; @@ -1711,3 +2144,32 @@ return 0; // B frame } + +int +FindFcode( const MBParam * const pParam, + const FRAMEINFO * const current) +{ + uint32_t x, y; + int max = 0, min = 0, i; + + for (y = 0; y < pParam->mb_height; y++) { + for (x = 0; x < pParam->mb_width; x++) { + + MACROBLOCK *pMB = ¤t->mbs[x + y * pParam->mb_width]; + for(i = 0; i < (pMB->mode == MODE_INTER4V ? 4:1); i++) { + if (pMB->mvs[i].x > max) max = pMB->mvs[i].x; + if (pMB->mvs[i].y > max) max = pMB->mvs[i].y; + + if (pMB->mvs[i].x < min) min = pMB->mvs[i].x; + if (pMB->mvs[i].y < min) min = pMB->mvs[i].y; + } + } + } + + min = -min; + max += 1; + if (min > max) max = min; + + for (i = 1; (max > 32 << (i - 1)); i++); + return i; +}