--- estimation_pvop.c 2003/09/10 22:18:59 1.1.2.1 +++ estimation_pvop.c 2006/02/24 08:46:22 1.19 @@ -21,7 +21,7 @@ * along with this program ; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * - * $Id: estimation_pvop.c,v 1.1.2.1 2003/09/10 22:18:59 edgomez Exp $ + * $Id: estimation_pvop.c,v 1.19 2006/02/24 08:46:22 syskin Exp $ * ****************************************************************************/ @@ -39,63 +39,67 @@ #include "motion.h" #include "sad.h" #include "motion_inlines.h" +#include "motion_smp.h" + static const int xvid_me_lambda_vec8[32] = - { 0 ,(int)(1.00235 * NEIGH_TEND_8X8 + 0.5), - (int)(1.15582 + NEIGH_TEND_8X8 + 0.5), (int)(1.31976*NEIGH_TEND_8X8 + 0.5), - (int)(1.49591*NEIGH_TEND_8X8 + 0.5), (int)(1.68601*NEIGH_TEND_8X8 + 0.5), - (int)(1.89187*NEIGH_TEND_8X8 + 0.5), (int)(2.11542*NEIGH_TEND_8X8 + 0.5), - (int)(2.35878*NEIGH_TEND_8X8 + 0.5), (int)(2.62429*NEIGH_TEND_8X8 + 0.5), - (int)(2.91455*NEIGH_TEND_8X8 + 0.5), (int)(3.23253*NEIGH_TEND_8X8 + 0.5), - (int)(3.58158*NEIGH_TEND_8X8 + 0.5), (int)(3.96555*NEIGH_TEND_8X8 + 0.5), - (int)(4.38887*NEIGH_TEND_8X8 + 0.5), (int)(4.85673*NEIGH_TEND_8X8 + 0.5), - (int)(5.37519*NEIGH_TEND_8X8 + 0.5), (int)(5.95144*NEIGH_TEND_8X8 + 0.5), - (int)(6.59408*NEIGH_TEND_8X8 + 0.5), (int)(7.31349*NEIGH_TEND_8X8 + 0.5), - (int)(8.12242*NEIGH_TEND_8X8 + 0.5), (int)(9.03669*NEIGH_TEND_8X8 + 0.5), - (int)(10.0763*NEIGH_TEND_8X8 + 0.5), (int)(11.2669*NEIGH_TEND_8X8 + 0.5), - (int)(12.6426*NEIGH_TEND_8X8 + 0.5), (int)(14.2493*NEIGH_TEND_8X8 + 0.5), - (int)(16.1512*NEIGH_TEND_8X8 + 0.5), (int)(18.442*NEIGH_TEND_8X8 + 0.5), - (int)(21.2656*NEIGH_TEND_8X8 + 0.5), (int)(24.8580*NEIGH_TEND_8X8 + 0.5), - (int)(29.6436*NEIGH_TEND_8X8 + 0.5), (int)(36.4949*NEIGH_TEND_8X8 + 0.5) + { 0 ,(int)(1.0 * NEIGH_TEND_8X8 + 0.5), + (int)(2.0*NEIGH_TEND_8X8 + 0.5), (int)(3.0*NEIGH_TEND_8X8 + 0.5), + (int)(4.0*NEIGH_TEND_8X8 + 0.5), (int)(5.0*NEIGH_TEND_8X8 + 0.5), + (int)(6.0*NEIGH_TEND_8X8 + 0.5), (int)(7.0*NEIGH_TEND_8X8 + 0.5), + (int)(8.0*NEIGH_TEND_8X8 + 0.5), (int)(9.0*NEIGH_TEND_8X8 + 0.5), + (int)(10.0*NEIGH_TEND_8X8 + 0.5), (int)(11.0*NEIGH_TEND_8X8 + 0.5), + (int)(12.0*NEIGH_TEND_8X8 + 0.5), (int)(13.0*NEIGH_TEND_8X8 + 0.5), + (int)(14.0*NEIGH_TEND_8X8 + 0.5), (int)(15.0*NEIGH_TEND_8X8 + 0.5), + (int)(16.0*NEIGH_TEND_8X8 + 0.5), (int)(17.0*NEIGH_TEND_8X8 + 0.5), + (int)(18.0*NEIGH_TEND_8X8 + 0.5), (int)(19.0*NEIGH_TEND_8X8 + 0.5), + (int)(20.0*NEIGH_TEND_8X8 + 0.5), (int)(21.0*NEIGH_TEND_8X8 + 0.5), + (int)(22.0*NEIGH_TEND_8X8 + 0.5), (int)(23.0*NEIGH_TEND_8X8 + 0.5), + (int)(24.0*NEIGH_TEND_8X8 + 0.5), (int)(25.0*NEIGH_TEND_8X8 + 0.5), + (int)(26.0*NEIGH_TEND_8X8 + 0.5), (int)(27.0*NEIGH_TEND_8X8 + 0.5), + (int)(28.0*NEIGH_TEND_8X8 + 0.5), (int)(29.0*NEIGH_TEND_8X8 + 0.5), + (int)(30.0*NEIGH_TEND_8X8 + 0.5), (int)(31.0*NEIGH_TEND_8X8 + 0.5) }; static void -CheckCandidate16(const int x, const int y, const SearchData * const data, const unsigned int Direction) +CheckCandidate16(const int x, const int y, SearchData * const data, const unsigned int Direction) { - int xc, yc; const uint8_t * Reference; + int32_t sad, xc, yc; uint32_t t; VECTOR * current; - int32_t sad; uint32_t t; if ( (x > data->max_dx) || (x < data->min_dx) || (y > data->max_dy) || (y < data->min_dy) ) return; - if (!data->qpel_precision) { + if (data->qpel_precision) { /* x and y are in 1/4 precision */ + Reference = xvid_me_interpolate16x16qpel(x, y, 0, data); + current = data->currentQMV; + xc = x/2; yc = y/2; + } else { Reference = GetReference(x, y, data); current = data->currentMV; xc = x; yc = y; - } else { /* x and y are in 1/4 precision */ - Reference = xvid_me_interpolate16x16qpel(x, y, 0, data); - xc = x/2; yc = y/2; /* for chroma sad */ - current = data->currentQMV; } sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp); - t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0); + t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision); - sad += (data->lambda16 * t * sad)>>10; - data->temp[0] += (data->lambda8 * t * (data->temp[0] + NEIGH_8X8_BIAS))>>10; + sad += (data->lambda16 * t); + data->temp[0] += (data->lambda8 * t); - if (data->chroma && sad < data->iMinSAD[0]) + if (data->chroma) { + if (sad >= data->iMinSAD[0]) goto no16; sad += xvid_me_ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3], (yc >> 1) + roundtab_79[yc & 0x3], data); + } if (sad < data->iMinSAD[0]) { data->iMinSAD[0] = sad; current[0].x = x; current[0].y = y; - *data->dir = Direction; + data->dir = Direction; } +no16: if (data->temp[0] < data->iMinSAD[1]) { data->iMinSAD[1] = data->temp[0]; current[1].x = x; current[1].y = y; } if (data->temp[1] < data->iMinSAD[2]) { @@ -107,66 +111,7 @@ } static void -CheckCandidate16_subpel(const int x, const int y, const SearchData * const data, const unsigned int Direction) -{ - int xc, yc; - const uint8_t *Reference; - VECTOR *current, *current2; - int32_t sad; uint32_t t; - - if ( (x > data->max_dx) || (x < data->min_dx) - || (y > data->max_dy) || (y < data->min_dy) ) return; - - if (!data->qpel_precision) { - Reference = GetReference(x, y, data); - current = data->currentMV; - current2 = data->currentMV2; - xc = x; yc = y; - } else { /* x and y are in 1/4 precision */ - Reference = xvid_me_interpolate16x16qpel(x, y, 0, data); - xc = x/2; yc = y/2; /* for chroma sad */ - current = data->currentQMV; - current2 = data->currentQMV2; - } - - sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp); - t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0); - - sad += (data->lambda16 * t * sad)>>10; - data->temp[0] += (data->lambda8 * t * (data->temp[0] + NEIGH_8X8_BIAS))>>10; - - if (data->chroma && sad < data->iMinSAD[0]) - sad += xvid_me_ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3], - (yc >> 1) + roundtab_79[yc & 0x3], data); - - if (data->temp[0] < data->iMinSAD[1]) { - data->iMinSAD[1] = data->temp[0]; current[1].x = x; current[1].y = y; } - if (data->temp[1] < data->iMinSAD[2]) { - data->iMinSAD[2] = data->temp[1]; current[2].x = x; current[2].y = y; } - if (data->temp[2] < data->iMinSAD[3]) { - data->iMinSAD[3] = data->temp[2]; current[3].x = x; current[3].y = y; } - if (data->temp[3] < data->iMinSAD[4]) { - data->iMinSAD[4] = data->temp[3]; current[4].x = x; current[4].y = y; } - - if (sad < data->iMinSAD[0]) { - *(data->iMinSAD2) = *(data->iMinSAD); - current2->x = current->x; current2->y = current->y; - - data->iMinSAD[0] = sad; - current[0].x = x; current[0].y = y; - *data->dir = Direction; - return; - } - - if (sad < *(data->iMinSAD2)) { - *(data->iMinSAD2) = sad; - current2->x = x; current2->y = y; - *data->dir = Direction; - } -} - -static void -CheckCandidate8(const int x, const int y, const SearchData * const data, const unsigned int Direction) +CheckCandidate8(const int x, const int y, SearchData * const data, const unsigned int Direction) { int32_t sad; uint32_t t; const uint8_t * Reference; @@ -184,176 +129,30 @@ } sad = sad8(data->Cur, Reference, data->iEdgedWidth); - t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0); + t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision); - sad += (data->lambda8 * t * (sad+NEIGH_8X8_BIAS))>>10; + sad += (data->lambda8 * t); if (sad < *(data->iMinSAD)) { *(data->iMinSAD) = sad; current->x = x; current->y = y; - *data->dir = Direction; - } -} - -static void -CheckCandidate32(const int x, const int y, const SearchData * const data, const unsigned int Direction) -{ - uint32_t t; - const uint8_t * Reference; - int sad; - - if ( (!(x&1) && x !=0) || (!(y&1) && y !=0) || /* non-zero even value */ - (x > data->max_dx) || (x < data->min_dx) - || (y > data->max_dy) || (y < data->min_dy) ) return; - - Reference = GetReference(x, y, data); - t = d_mv_bits(x, y, data->predMV, data->iFcode, 0, 1); - - sad = sad32v_c(data->Cur, Reference, data->iEdgedWidth, data->temp); - - sad += (data->lambda16 * t * sad) >> 10; - data->temp[0] += (data->lambda8 * t * (data->temp[0] + NEIGH_8X8_BIAS))>>10; - - if (sad < data->iMinSAD[0]) { - data->iMinSAD[0] = sad; - data->currentMV[0].x = x; data->currentMV[0].y = y; - *data->dir = Direction; - } - - if (data->temp[0] < data->iMinSAD[1]) { - data->iMinSAD[1] = data->temp[0]; data->currentMV[1].x = x; data->currentMV[1].y = y; } - if (data->temp[1] < data->iMinSAD[2]) { - data->iMinSAD[2] = data->temp[1]; data->currentMV[2].x = x; data->currentMV[2].y = y; } - if (data->temp[2] < data->iMinSAD[3]) { - data->iMinSAD[3] = data->temp[2]; data->currentMV[3].x = x; data->currentMV[3].y = y; } - if (data->temp[3] < data->iMinSAD[4]) { - data->iMinSAD[4] = data->temp[3]; data->currentMV[4].x = x; data->currentMV[4].y = y; } -} - -static void -SubpelRefine_Fast(SearchData * data, CheckFunc * CheckCandidate) -{ -/* Do a half-pel or q-pel refinement */ - VECTOR centerMV; - VECTOR second_best; - int best_sad = *data->iMinSAD; - int xo, yo, xo2, yo2; - int size = 2; - CheckFunc *backupFunc = CheckCandidate; - - if(data->qpel_precision) - size = 1; - - centerMV = *data->currentMV; - *data->iMinSAD = 256 * 4096; - - CHECK_CANDIDATE(centerMV.x, centerMV.y - size, 0); - CHECK_CANDIDATE(centerMV.x + size, centerMV.y - size, 0); - CHECK_CANDIDATE(centerMV.x + size, centerMV.y, 0); - CHECK_CANDIDATE(centerMV.x + size, centerMV.y + size, 0); - - CHECK_CANDIDATE(centerMV.x, centerMV.y + size, 0); - CHECK_CANDIDATE(centerMV.x - size, centerMV.y + size, 0); - CHECK_CANDIDATE(centerMV.x - size, centerMV.y, 0); - CHECK_CANDIDATE(centerMV.x - size, centerMV.y - size, 0); - - second_best = *data->currentMV; - - if(data->qpel_precision) { - second_best.x *= 2; second_best.y *= 2; - } - - data->currentMV[0] = centerMV; - *data->iMinSAD = best_sad; - - centerMV = data->qpel_precision ? *data->currentQMV : *data->currentMV; - - xo = centerMV.x; - yo = centerMV.y; - xo2 = second_best.x; - yo2 = second_best.y; - - CheckCandidate = CheckCandidate16_subpel; - *data->iMinSAD2 = 256 * 4096; - - if (yo == yo2) - { - CHECK_CANDIDATE((xo+xo2)>>1, yo, 0); - CHECK_CANDIDATE(xo, yo-1, 0); - CHECK_CANDIDATE(xo, yo+1, 0); - - if(best_sad <= *data->iMinSAD2) - goto ende; - - if(data->currentQMV[0].x == data->currentQMV2[0].x) { - CHECK_CANDIDATE((xo+xo2)>>1, yo-1, 0); - CHECK_CANDIDATE((xo+xo2)>>1, yo+1, 0); - goto ende; - } - else { - CHECK_CANDIDATE((xo+xo2)>>1, - (data->currentQMV[0].x == xo) ? data->currentQMV[0].y : data->currentQMV2[0].y, - 0); - goto ende; - } - } - - if (xo == xo2) - { - CHECK_CANDIDATE(xo, (yo+yo2)>>1, 0); - CHECK_CANDIDATE(xo-1, yo, 0); - CHECK_CANDIDATE(xo+1, yo, 0); - - if(best_sad < *data->iMinSAD2) - goto ende; - - if(data->currentQMV[0].y == data->currentQMV2[0].y) { - CHECK_CANDIDATE(xo-1, (yo+yo2)>>1, 0); - CHECK_CANDIDATE(xo+1, (yo+yo2)>>1, 0); - goto ende; - } - else { - CHECK_CANDIDATE((data->currentQMV[0].y == yo) ? data->currentQMV[0].x : data->currentQMV2[0].x, (yo+yo2)>>1, 0); - goto ende; - } + data->dir = Direction; } - - CHECK_CANDIDATE(xo, (yo+yo2)>>1, 0); - CHECK_CANDIDATE((xo+xo2)>>1, yo, 0); - - if(best_sad <= *data->iMinSAD2) - goto ende; - - CHECK_CANDIDATE((xo+xo2)>>1, (yo+yo2)>>1, 0); - -ende: - CheckCandidate = backupFunc; } int xvid_me_SkipDecisionP(const IMAGE * current, const IMAGE * reference, const int x, const int y, - const uint32_t stride, const uint32_t iQuant, int rrv) + const uint32_t stride, const uint32_t iQuant) { int offset = (x + y*stride)*8; - if(!rrv) { - uint32_t sadC = sad8(current->u + offset, - reference->u + offset, stride); - if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0; - sadC += sad8(current->v + offset, - reference->v + offset, stride); - if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0; - return 1; - - } else { - uint32_t sadC = sad16(current->u + 2*offset, - reference->u + 2*offset, stride, 256*4096); - if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0; - sadC += sad16(current->v + 2*offset, - reference->v + 2*offset, stride, 256*4096); - if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0; - return 1; - } + uint32_t sadC = sad8(current->u + offset, + reference->u + offset, stride); + if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0; + sadC += sad8(current->v + offset, + reference->v + offset, stride); + if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0; + return 1; } /* @@ -369,13 +168,12 @@ * [3]: topright neighbour's SAD */ -static __inline int +static __inline void get_pmvdata2(const MACROBLOCK * const mbs, const int mb_width, const int bound, const int x, const int y, - const int block, VECTOR * const pmv, int32_t * const psad) { @@ -385,27 +183,9 @@ int lpos, tpos, rpos; int num_cand = 0, last_cand = 1; - switch (block) { - case 0: - lx = x - 1; ly = y; lz = 1; - tx = x; ty = y - 1; tz = 2; - rx = x + 1; ry = y - 1; rz = 2; - break; - case 1: - lx = x; ly = y; lz = 0; - tx = x; ty = y - 1; tz = 3; - rx = x + 1; ry = y - 1; rz = 2; - break; - case 2: - lx = x - 1; ly = y; lz = 3; - tx = x; ty = y; tz = 0; - rx = x; ry = y; rz = 1; - break; - default: - lx = x; ly = y; lz = 2; - tx = x; ty = y; tz = 0; - rx = x; ry = y; rz = 1; - } + lx = x - 1; ly = y; lz = 1; + tx = x; ty = y - 1; tz = 2; + rx = x + 1; ry = y - 1; rz = 2; lpos = lx + ly * mb_width; rpos = rx + ry * mb_width; @@ -442,29 +222,24 @@ } /* original pmvdata() compatibility hack */ - if (x == 0 && y == 0 && block == 0) { + if (x == 0 && y == 0) { pmv[0] = pmv[1] = pmv[2] = pmv[3] = zeroMV; psad[0] = 0; psad[1] = psad[2] = psad[3] = MV_MAX_ERROR; - return 0; + return; } /* if only one valid candidate preictor, the invalid candiates are set to the canidate */ if (num_cand == 1) { pmv[0] = pmv[last_cand]; psad[0] = psad[last_cand]; -#if 0 - return MVequal(pmv[0], zeroMV); /* no point calculating median mv and minimum sad */ -#endif - - /* original pmvdata() compatibility hack */ - return y==0 && block <= 1 ? 0 : MVequal(pmv[0], zeroMV); + return; } if ((MVequal(pmv[1], pmv[2])) && (MVequal(pmv[1], pmv[3]))) { pmv[0] = pmv[1]; psad[0] = MIN(MIN(psad[1], psad[2]), psad[3]); - return 1; + return; } /* set median, minimum */ @@ -478,7 +253,6 @@ psad[0] = MIN(MIN(psad[1], psad[2]), psad[3]); - return 0; } @@ -494,7 +268,8 @@ const IMAGE * const pCurrent, const IMAGE * const pRef, const IMAGE * const vGMC, - const int coding_type) + const int coding_type, + const int skip_sad) { int mode = MODE_INTER; int mcsel = 0; @@ -520,9 +295,9 @@ } /* final skip decision, a.k.a. "the vector you found, really that good?" */ - if (skip_possible && (pMB->sad16 < (int)iQuant * MAX_SAD00_FOR_SKIP)) - if ( (100*sad)/(pMB->sad16+1) > FINAL_SKIP_THRESH) - if (Data->chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, Data->iEdgedWidth/2, iQuant, Data->rrv)) { + if (skip_possible && (skip_sad < (int)iQuant * MAX_SAD00_FOR_SKIP)) + if ( (100*skip_sad)/(pMB->sad16+1) > FINAL_SKIP_THRESH) + if (Data->chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, Data->iEdgedWidth/2, iQuant)) { mode = MODE_NOT_CODED; sad = 0; } @@ -547,36 +322,22 @@ /* intra decision */ - if (iQuant > 8) InterBias += 100 * (iQuant - 8); /* to make high quants work */ + if (iQuant > 10) InterBias += 60 * (iQuant - 10); /* to make high quants work */ if (y != 0) if ((pMB - pParam->mb_width)->mode == MODE_INTRA ) InterBias -= 80; if (x != 0) if ((pMB - 1)->mode == MODE_INTRA ) InterBias -= 80; if (Data->chroma) InterBias += 50; /* dev8(chroma) ??? <-- yes, we need dev8 (no big difference though) */ - if (Data->rrv) InterBias *= 4; if (InterBias < sad) { - int32_t deviation; - if (!Data->rrv) - deviation = dev16(Data->Cur, Data->iEdgedWidth); - else - deviation = dev16(Data->Cur, Data->iEdgedWidth) + /* dev32() */ - dev16(Data->Cur+16, Data->iEdgedWidth) + - dev16(Data->Cur + 16*Data->iEdgedWidth, Data->iEdgedWidth) + - dev16(Data->Cur+16+16*Data->iEdgedWidth, Data->iEdgedWidth); - + int32_t deviation = dev16(Data->Cur, Data->iEdgedWidth); if (deviation < (sad - InterBias)) mode = MODE_INTRA; } pMB->cbp = 63; pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = sad; - if (Data->rrv) { - Data->currentMV[0].x = RRV_MV_SCALEDOWN(Data->currentMV[0].x); - Data->currentMV[0].y = RRV_MV_SCALEDOWN(Data->currentMV[0].y); - } - if (mode == MODE_INTER && mcsel == 0) { pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = Data->currentMV[0]; @@ -590,7 +351,7 @@ pMB->pmvs[0].y = Data->currentMV[0].y - Data->predMV.y; } - } else if (mode == MODE_INTER ) { // but mcsel == 1 + } else if (mode == MODE_INTER ) { /* but mcsel == 1 */ pMB->mcsel = 1; if (Data->qpel) { @@ -610,10 +371,8 @@ static __inline void PreparePredictionsP(VECTOR * const pmv, int x, int y, int iWcount, - int iHcount, const MACROBLOCK * const prevMB, int rrv) + int iHcount, const MACROBLOCK * const prevMB) { - /* this function depends on get_pmvdata which means that it sucks. It should get the predictions by itself */ - if (rrv) { iWcount /= 2; iHcount /= 2; } if ( (y != 0) && (x < (iWcount-1)) ) { /* [5] top-right neighbour */ pmv[5].x = EVEN(pmv[3].x); @@ -638,18 +397,10 @@ pmv[6].x = EVEN((prevMB+1+iWcount)->mvs[0].x); /* [6] right-down neighbour in last frame */ pmv[6].y = EVEN((prevMB+1+iWcount)->mvs[0].y); } else pmv[6].x = pmv[6].y = 0; - - if (rrv) { - int i; - for (i = 0; i < 7; i++) { - pmv[i].x = RRV_MV_SCALEUP(pmv[i].x); - pmv[i].y = RRV_MV_SCALEUP(pmv[i].y); - } - } } static void -Search8(const SearchData * const OldData, +Search8(SearchData * const OldData, const int x, const int y, const uint32_t MotionFlags, const MBParam * const pParam, @@ -659,82 +410,87 @@ SearchData * const Data) { int i = 0; - CheckFunc * CheckCandidate; - Data->iMinSAD = OldData->iMinSAD + 1 + block; - Data->currentMV = OldData->currentMV + 1 + block; - Data->currentQMV = OldData->currentQMV + 1 + block; + VECTOR vbest_q; int32_t sbest_q; + *Data->iMinSAD = *(OldData->iMinSAD + 1 + block); + *Data->currentMV = *(OldData->currentMV + 1 + block); + *Data->currentQMV = *(OldData->currentQMV + 1 + block); if(Data->qpel) { Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block); if (block != 0) i = d_mv_bits( Data->currentQMV->x, Data->currentQMV->y, - Data->predMV, Data->iFcode, 0, 0); + Data->predMV, Data->iFcode, 0); } else { Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block); if (block != 0) i = d_mv_bits( Data->currentMV->x, Data->currentMV->y, - Data->predMV, Data->iFcode, 0, Data->rrv); + Data->predMV, Data->iFcode, 0); } - *(Data->iMinSAD) += (Data->lambda8 * i * (*Data->iMinSAD + NEIGH_8X8_BIAS))>>10; + *(Data->iMinSAD) += (Data->lambda8 * i); if (MotionFlags & (XVID_ME_EXTSEARCH8|XVID_ME_HALFPELREFINE8|XVID_ME_QUARTERPELREFINE8)) { - if (Data->rrv) i = 16; else i = 8; + vbest_q = Data->currentQMV[0]; + sbest_q = Data->iMinSAD[0]; - Data->RefP[0] = OldData->RefP[0] + i * ((block&1) + Data->iEdgedWidth*(block>>1)); - Data->RefP[1] = OldData->RefP[1] + i * ((block&1) + Data->iEdgedWidth*(block>>1)); - Data->RefP[2] = OldData->RefP[2] + i * ((block&1) + Data->iEdgedWidth*(block>>1)); - Data->RefP[3] = OldData->RefP[3] + i * ((block&1) + Data->iEdgedWidth*(block>>1)); - Data->Cur = OldData->Cur + i * ((block&1) + Data->iEdgedWidth*(block>>1)); + Data->RefP[0] = OldData->RefP[0] + 8 * ((block&1) + Data->iEdgedWidth*(block>>1)); + Data->RefP[1] = OldData->RefP[1] + 8 * ((block&1) + Data->iEdgedWidth*(block>>1)); + Data->RefP[2] = OldData->RefP[2] + 8 * ((block&1) + Data->iEdgedWidth*(block>>1)); + Data->RefP[3] = OldData->RefP[3] + 8 * ((block&1) + Data->iEdgedWidth*(block>>1)); + + Data->Cur = OldData->Cur + 8 * ((block&1) + Data->iEdgedWidth*(block>>1)); Data->qpel_precision = 0; get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 3, - pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, Data->rrv); - - if (!Data->rrv) CheckCandidate = CheckCandidate8; - else CheckCandidate = CheckCandidate16no4v; + pParam->width, pParam->height, Data->iFcode - Data->qpel, 1); if (MotionFlags & XVID_ME_EXTSEARCH8 && (!(MotionFlags & XVID_ME_EXTSEARCH_RD))) { - int32_t temp_sad = *(Data->iMinSAD); /* store current MinSAD */ MainSearchFunc *MainSearchPtr; if (MotionFlags & XVID_ME_USESQUARES8) MainSearchPtr = xvid_me_SquareSearch; else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND8) MainSearchPtr = xvid_me_AdvDiamondSearch; else MainSearchPtr = xvid_me_DiamondSearch; - MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, 255, CheckCandidate); - - if(*(Data->iMinSAD) < temp_sad) { - Data->currentQMV->x = 2 * Data->currentMV->x; /* update our qpel vector */ - Data->currentQMV->y = 2 * Data->currentMV->y; - } + MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, 255, CheckCandidate8); } - if (MotionFlags & XVID_ME_HALFPELREFINE8) { - int32_t temp_sad = *(Data->iMinSAD); /* store current MinSAD */ + if(!Data->qpel) { + /* halfpel mode */ + if (MotionFlags & XVID_ME_HALFPELREFINE8) + /* perform halfpel refine of current best vector */ + xvid_me_SubpelRefine(Data->currentMV[0], Data, CheckCandidate8, 0); + } else { + /* qpel mode */ + Data->currentQMV->x = 2*Data->currentMV->x; + Data->currentQMV->y = 2*Data->currentMV->y; + + if(MotionFlags & XVID_ME_FASTREFINE8) { + /* fast */ + get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 3, + pParam->width, pParam->height, Data->iFcode, 2); + FullRefine_Fast(Data, CheckCandidate8, 0); + } else if(MotionFlags & XVID_ME_QUARTERPELREFINE8) { + /* full */ + if (MotionFlags & XVID_ME_HALFPELREFINE8) { + xvid_me_SubpelRefine(Data->currentMV[0], Data, CheckCandidate8, 0); /* hpel part */ + Data->currentQMV->x = 2*Data->currentMV->x; + Data->currentQMV->y = 2*Data->currentMV->y; + } - xvid_me_SubpelRefine(Data, CheckCandidate); /* perform halfpel refine of current best vector */ + get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 3, + pParam->width, pParam->height, Data->iFcode, 2); + Data->qpel_precision = 1; - 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; + xvid_me_SubpelRefine(Data->currentQMV[0], Data, CheckCandidate8, 0); /* qpel part */ } } - if (Data->qpel && MotionFlags & XVID_ME_QUARTERPELREFINE8) { - Data->qpel_precision = 1; - get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 3, - pParam->width, pParam->height, Data->iFcode, 2, 0); - xvid_me_SubpelRefine(Data, CheckCandidate); - } - } + if (sbest_q <= Data->iMinSAD[0]) /* we have not found a better match */ + Data->currentQMV[0] = vbest_q; - if (Data->rrv) { - Data->currentMV->x = RRV_MV_SCALEDOWN(Data->currentMV->x); - Data->currentMV->y = RRV_MV_SCALEDOWN(Data->currentMV->y); } - if(Data->qpel) { + if(Data->qpel) { pMB->pmvs[block].x = Data->currentQMV->x - Data->predMV.x; pMB->pmvs[block].y = Data->currentQMV->y - Data->predMV.y; pMB->qmvs[block] = *Data->currentQMV; @@ -743,6 +499,10 @@ pMB->pmvs[block].y = Data->currentMV->y - Data->predMV.y; } + *(OldData->iMinSAD + 1 + block) = *Data->iMinSAD; + *(OldData->currentMV + 1 + block) = *Data->currentMV; + *(OldData->currentQMV + 1 + block) = *Data->currentQMV; + pMB->mvs[block] = *Data->currentMV; pMB->sad8[block] = 4 * *Data->iMinSAD; } @@ -772,36 +532,35 @@ CheckFunc * CheckCandidate; get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4, - pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, Data->rrv); + pParam->width, pParam->height, Data->iFcode - Data->qpel, 1); - get_pmvdata2(pMBs, pParam->mb_width, 0, x, y, 0, pmv, Data->temp); + get_pmvdata2(pMBs, pParam->mb_width, 0, x, y, pmv, Data->temp); - Data->temp[5] = Data->temp[6] = 0; /* chroma-sad cache */ - i = Data->rrv ? 2 : 1; - Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16*i; - Data->CurV = pCur->v + (x + y * (Data->iEdgedWidth/2)) * 8*i; - Data->CurU = pCur->u + (x + y * (Data->iEdgedWidth/2)) * 8*i; - - Data->RefP[0] = pRef->y + (x + Data->iEdgedWidth*y) * 16*i; - Data->RefP[2] = pRefH + (x + Data->iEdgedWidth*y) * 16*i; - Data->RefP[1] = pRefV + (x + Data->iEdgedWidth*y) * 16*i; - Data->RefP[3] = pRefHV + (x + Data->iEdgedWidth*y) * 16*i; - Data->RefP[4] = pRef->u + (x + y * (Data->iEdgedWidth/2)) * 8*i; - Data->RefP[5] = pRef->v + (x + y * (Data->iEdgedWidth/2)) * 8*i; + Data->chromaX = Data->chromaY = 0; /* chroma-sad cache */ + Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16; + Data->CurV = pCur->v + (x + y * (Data->iEdgedWidth/2)) * 8; + Data->CurU = pCur->u + (x + y * (Data->iEdgedWidth/2)) * 8; + + Data->RefP[0] = pRef->y + (x + Data->iEdgedWidth*y) * 16; + Data->RefP[2] = pRefH + (x + Data->iEdgedWidth*y) * 16; + Data->RefP[1] = pRefV + (x + Data->iEdgedWidth*y) * 16; + Data->RefP[3] = pRefHV + (x + Data->iEdgedWidth*y) * 16; + Data->RefP[4] = pRef->u + (x + y * (Data->iEdgedWidth/2)) * 8; + Data->RefP[5] = pRef->v + (x + y * (Data->iEdgedWidth/2)) * 8; Data->lambda16 = xvid_me_lambda_vec16[pMB->quant]; Data->lambda8 = xvid_me_lambda_vec8[pMB->quant]; Data->qpel_precision = 0; - *Data->dir = 0; + Data->dir = 0; memset(Data->currentMV, 0, 5*sizeof(VECTOR)); if (Data->qpel) Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, 0); else Data->predMV = pmv[0]; - i = d_mv_bits(0, 0, Data->predMV, Data->iFcode, 0, 0); - Data->iMinSAD[0] = pMB->sad16 + ((Data->lambda16 * i * pMB->sad16)>>10); - Data->iMinSAD[1] = pMB->sad8[0] + ((Data->lambda8 * i * (pMB->sad8[0]+NEIGH_8X8_BIAS)) >> 10); + i = d_mv_bits(0, 0, Data->predMV, Data->iFcode, 0); + Data->iMinSAD[0] = pMB->sad16 + (Data->lambda16 * i); + Data->iMinSAD[1] = pMB->sad8[0] + (Data->lambda8 * i); Data->iMinSAD[2] = pMB->sad8[1]; Data->iMinSAD[3] = pMB->sad8[2]; Data->iMinSAD[4] = pMB->sad8[3]; @@ -814,12 +573,10 @@ threshA = 512; PreparePredictionsP(pmv, x, y, pParam->mb_width, pParam->mb_height, - prevMBs + x + y * pParam->mb_width, Data->rrv); + prevMBs + x + y * pParam->mb_width); - if (!Data->rrv) { - if (inter4v) CheckCandidate = CheckCandidate16; - else CheckCandidate = CheckCandidate16no4v; /* for extra speed */ - } else CheckCandidate = CheckCandidate32; + if (inter4v) CheckCandidate = CheckCandidate16; + else CheckCandidate = CheckCandidate16no4v; /* for extra speed */ /* main loop. checking all predictions (but first, which is 0,0 and has been checked in MotionEstimation())*/ @@ -836,7 +593,7 @@ else { MainSearchFunc * MainSearchPtr; - int mask = make_mask(pmv, i, *Data->dir); // all vectors pmv[0..i-1] have been checked + int mask = make_mask(pmv, i, Data->dir); /* all vectors pmv[0..i-1] have been checked */ if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = xvid_me_SquareSearch; else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = xvid_me_AdvDiamondSearch; @@ -851,18 +608,19 @@ if (MotionFlags & XVID_ME_EXTSEARCH16) { int32_t bSAD; VECTOR startMV = Data->predMV, backupMV = Data->currentMV[0]; - if (Data->rrv) { - startMV.x = RRV_MV_SCALEUP(startMV.x); - startMV.y = RRV_MV_SCALEUP(startMV.y); + if (Data->qpel) { + startMV.x /= 2; + startMV.y /= 2; } if (!(MVequal(startMV, backupMV))) { bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR; CheckCandidate(startMV.x, startMV.y, Data, 255); - MainSearchPtr(startMV.x, startMV.y, Data, 255, CheckCandidate); + xvid_me_DiamondSearch(startMV.x, startMV.y, Data, 255, CheckCandidate); if (bSAD < Data->iMinSAD[0]) { Data->currentMV[0] = backupMV; - Data->iMinSAD[0] = bSAD; } + Data->iMinSAD[0] = bSAD; + } } backupMV = Data->currentMV[0]; @@ -871,7 +629,7 @@ bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR; CheckCandidate(startMV.x, startMV.y, Data, 255); - MainSearchPtr(startMV.x, startMV.y, Data, 255, CheckCandidate); + xvid_me_DiamondSearch(startMV.x, startMV.y, Data, 255, CheckCandidate); if (bSAD < Data->iMinSAD[0]) { Data->currentMV[0] = backupMV; Data->iMinSAD[0] = bSAD; @@ -880,27 +638,43 @@ } } - if (MotionFlags & XVID_ME_HALFPELREFINE16) - xvid_me_SubpelRefine(Data, CheckCandidate); - - 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 (Data->qpel) { - get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4, - pParam->width, pParam->height, Data->iFcode, 2, 0); - Data->qpel_precision = 1; - if (MotionFlags & XVID_ME_QUARTERPELREFINE16) { - if(MotionFlags & XVID_ME_FASTREFINE16) - SubpelRefine_Fast(Data, CheckCandidate); - else - xvid_me_SubpelRefine(Data, CheckCandidate); + if(!Data->qpel) { + /* halfpel mode */ + if (MotionFlags & XVID_ME_HALFPELREFINE16) + xvid_me_SubpelRefine(Data->currentMV[0], Data, CheckCandidate, 0); + } else { + /* qpel mode */ + + 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(MotionFlags & XVID_ME_FASTREFINE16 && MotionFlags & XVID_ME_QUARTERPELREFINE16) { + /* fast */ + get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4, + pParam->width, pParam->height, Data->iFcode, 2); + FullRefine_Fast(Data, CheckCandidate, 0); + } else { + if(MotionFlags & (XVID_ME_QUARTERPELREFINE16 | XVID_ME_QUARTERPELREFINE16_RD)) { + /* full */ + if (MotionFlags & XVID_ME_HALFPELREFINE16) { + xvid_me_SubpelRefine(Data->currentMV[0], Data, CheckCandidate, 0); /* hpel part */ + for(i = 0; i < 5; i++) { + Data->currentQMV[i].x = 2 * Data->currentMV[i].x; + Data->currentQMV[i].y = 2 * Data->currentMV[i].y; + } + } + get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4, + pParam->width, pParam->height, Data->iFcode, 2); + Data->qpel_precision = 1; + if(MotionFlags & XVID_ME_QUARTERPELREFINE16) + xvid_me_SubpelRefine(Data->currentQMV[0], Data, CheckCandidate, 0); /* qpel part */ + } } } - if (Data->iMinSAD[0] < (int32_t)pMB->quant * 30) + if (Data->iMinSAD[0] < (int32_t)pMB->quant * 30 * ((MotionFlags & XVID_ME_FASTREFINE16) ? 8 : 1)) inter4v = 0; if (inter4v) { @@ -913,7 +687,7 @@ Search8(Data, 2*x + 1, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 3, &Data8); if ((Data->chroma) && (!(VopFlags & XVID_VOP_MODEDECISION_RD))) { - /* chroma is only used for comparsion to INTER. if the comparsion will be done in BITS domain, it will not be used */ + /* chroma is only used for comparison to INTER. if the comparison will be done in RD domain, it will not be used */ int sumx = 0, sumy = 0; if (Data->qpel) @@ -933,6 +707,106 @@ } else Data->iMinSAD[1] = 4096*256; } +static int +InitialSkipDecisionP(int sad00, + const MBParam * pParam, + const FRAMEINFO * current, + MACROBLOCK * pMB, + const MACROBLOCK * prevMB, + int x, int y, + const SearchData * Data, + const IMAGE * const pGMC, + const IMAGE * const pCurrent, + const IMAGE * const pRef, + const uint32_t MotionFlags) +{ + const unsigned int iEdgedWidth = pParam->edged_width; + + int skip_thresh = INITIAL_SKIP_THRESH * \ + (current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1); + int stat_thresh = 0; + + /* initial skip decision */ + if (current->coding_type != S_VOP) { /* no fast SKIP for S(GMC)-VOPs */ + if (pMB->dquant == 0 && sad00 < pMB->quant * skip_thresh) + if (Data->chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, iEdgedWidth/2, pMB->quant)) { + ZeroMacroblockP(pMB, sad00); + pMB->mode = MODE_NOT_CODED; + return 1; + } + } + + if(MotionFlags & XVID_ME_DETECT_STATIC_MOTION) { + VECTOR *cmpMV; + VECTOR staticMV = { 0, 0 }; + const MACROBLOCK * pMBs = current->mbs; + + if (current->coding_type == S_VOP) + cmpMV = &pMB->amv; + else + cmpMV = &staticMV; + + if(x > 0 && y > 0 && x < pParam->mb_width) { + if(MVequal((&pMBs[(x-1) + y * pParam->mb_width])->mvs[0], *cmpMV) && + MVequal((&pMBs[x + (y-1) * pParam->mb_width])->mvs[0], *cmpMV) && + MVequal((&pMBs[(x+1) + (y-1) * pParam->mb_width])->mvs[0], *cmpMV) && + MVequal(prevMB->mvs[0], *cmpMV)) { + stat_thresh = MAX((&pMBs[(x-1) + y * pParam->mb_width])->sad16, + MAX((&pMBs[x + (y-1) * pParam->mb_width])->sad16, + MAX((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16, + prevMB->sad16))); + } else { + stat_thresh = MIN((&pMBs[(x-1) + y * pParam->mb_width])->sad16, + MIN((&pMBs[x + (y-1) * pParam->mb_width])->sad16, + MIN((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16, + prevMB->sad16))); + } + } + } + + /* favorize (0,0) or global vector for cartoons */ + if (current->vop_flags & XVID_VOP_CARTOON) { + if (current->coding_type == S_VOP) { + int32_t iSAD = sad16(pCurrent->y + (x + y * iEdgedWidth) * 16, + pGMC->y + 16*y*iEdgedWidth + 16*x, iEdgedWidth, 65536); + + if (Data->chroma) { + iSAD += sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8, pGMC->u + 8*y*(iEdgedWidth/2) + 8*x, iEdgedWidth/2); + iSAD += sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8, pGMC->v + 8*y*(iEdgedWidth/2) + 8*x, iEdgedWidth/2); + } + + if (iSAD <= stat_thresh) { /* mode decision GMC */ + pMB->mode = MODE_INTER; + pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = iSAD; + pMB->mcsel = 1; + if (Data->qpel) { + pMB->qmvs[0] = pMB->qmvs[1] = pMB->qmvs[2] = pMB->qmvs[3] = pMB->amv; + pMB->mvs[0].x = pMB->mvs[1].x = pMB->mvs[2].x = pMB->mvs[3].x = pMB->amv.x/2; + pMB->mvs[0].y = pMB->mvs[1].y = pMB->mvs[2].y = pMB->mvs[3].y = pMB->amv.y/2; + } else + pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv; + + return 1; + } + } + else if (sad00 < stat_thresh) { + VECTOR predMV; + if (Data->qpel) + predMV = get_qpmv2(current->mbs, pParam->mb_width, 0, x, y, 0); + else + predMV = get_pmv2(current->mbs, pParam->mb_width, 0, x, y, 0); + + ZeroMacroblockP(pMB, sad00); + pMB->cbp = 0x3f; + pMB->pmvs[0].x = - predMV.x; + pMB->pmvs[0].y = - predMV.y; + return 1; + } + } + + return 0; +} + static __inline uint32_t MakeGoodMotionFlags(const uint32_t MotionFlags, const uint32_t VopFlags, const uint32_t VolFlags) { @@ -958,141 +832,290 @@ if (Flags & XVID_ME_QUARTERPELREFINE8_RD) Flags &= ~XVID_ME_QUARTERPELREFINE8; + if (Flags & XVID_ME_QUARTERPELREFINE16_RD) + Flags &= ~XVID_ME_QUARTERPELREFINE16; + if (!(VolFlags & XVID_VOL_QUARTERPEL)) Flags &= ~(XVID_ME_QUARTERPELREFINE16+XVID_ME_QUARTERPELREFINE8+XVID_ME_QUARTERPELREFINE16_RD+XVID_ME_QUARTERPELREFINE8_RD); if (!(VopFlags & XVID_VOP_HALFPEL)) Flags &= ~(XVID_ME_EXTSEARCH16+XVID_ME_HALFPELREFINE16+XVID_ME_HALFPELREFINE8+XVID_ME_HALFPELREFINE16_RD+XVID_ME_HALFPELREFINE8_RD); - if ((VopFlags & XVID_VOP_GREYSCALE) || (VopFlags & XVID_VOP_REDUCED)) + if (VopFlags & XVID_VOP_GREYSCALE) Flags &= ~(XVID_ME_CHROMA_PVOP + XVID_ME_CHROMA_BVOP); + if (Flags & XVID_ME_FASTREFINE8) + Flags &= ~XVID_ME_HALFPELREFINE8_RD; + + if (Flags & XVID_ME_FASTREFINE16) + Flags &= ~XVID_ME_HALFPELREFINE16_RD; + return Flags; } -bool +static __inline void +motionStatsPVOP(int * const MVmax, int * const mvCount, int * const mvSum, + const MACROBLOCK * const pMB, const int qpel) +{ + const VECTOR * const mv = qpel ? pMB->qmvs : pMB->mvs; + int i; + int max = *MVmax; + + switch (pMB->mode) { + case MODE_INTER4V: + *mvCount += 3; + for(i = 3; i; i--) { + if (mv[i].x > max) max = mv[i].x; + else if (-mv[i].x - 1 > max) max = -mv[i].x - 1; + *mvSum += mv[i].x * mv[i].x; + if (mv[i].y > max) max = mv[i].y; + else if (-mv[i].y - 1 > max) max = -mv[i].y - 1; + *mvSum += mv[i].y * mv[i].y; + } + case MODE_INTER: + (*mvCount)++; + *mvSum += mv[0].x * mv[0].x; + *mvSum += mv[0].y * mv[0].y; + if (mv[0].x > max) max = mv[0].x; + else if (-mv[0].x - 1 > max) max = -mv[0].x - 1; + if (mv[0].y > max) max = mv[0].y; + else if (-mv[0].y - 1 > max) max = -mv[0].y - 1; + *MVmax = max; + default: + break; + } +} + +void MotionEstimation(MBParam * const pParam, FRAMEINFO * const current, FRAMEINFO * const reference, const IMAGE * const pRefH, const IMAGE * const pRefV, const IMAGE * const pRefHV, - const IMAGE * const pGMC, + const IMAGE * const pGMC, const uint32_t iLimit) { MACROBLOCK *const pMBs = current->mbs; const IMAGE *const pCurrent = ¤t->image; const IMAGE *const pRef = &reference->image; - uint32_t mb_width = pParam->mb_width; - uint32_t mb_height = pParam->mb_height; + const uint32_t mb_width = pParam->mb_width; + const uint32_t mb_height = pParam->mb_height; const uint32_t iEdgedWidth = pParam->edged_width; const uint32_t MotionFlags = MakeGoodMotionFlags(current->motion_flags, current->vop_flags, current->vol_flags); int stat_thresh = 0; + int MVmax = 0, mvSum = 0, mvCount = 0; uint32_t x, y; - uint32_t iIntra = 0; - int32_t sad00; + int sad00; int skip_thresh = INITIAL_SKIP_THRESH * \ - (current->vop_flags & XVID_VOP_REDUCED ? 4:1) * \ (current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1); + int block = 0; /* some pre-initialized thingies for SearchP */ - int32_t temp[8]; uint32_t dir; - VECTOR currentMV[5]; - VECTOR currentQMV[5]; - VECTOR currentMV2[5]; - VECTOR currentQMV2[5]; - int32_t iMinSAD[5]; - int32_t iMinSAD2[5]; DECLARE_ALIGNED_MATRIX(dct_space, 3, 64, int16_t, CACHE_LINE); SearchData Data; memset(&Data, 0, sizeof(SearchData)); Data.iEdgedWidth = iEdgedWidth; - Data.currentMV = currentMV; - Data.currentQMV = currentQMV; - Data.currentMV2 = currentMV2; - Data.currentQMV2 = currentQMV2; - Data.iMinSAD = iMinSAD; - Data.iMinSAD2 = iMinSAD2; - Data.temp = temp; - Data.dir = &dir; Data.iFcode = current->fcode; Data.rounding = pParam->m_rounding_type; Data.qpel = (current->vol_flags & XVID_VOL_QUARTERPEL ? 1:0); Data.chroma = MotionFlags & XVID_ME_CHROMA_PVOP; - Data.rrv = (current->vop_flags & XVID_VOP_REDUCED) ? 1:0; Data.dctSpace = dct_space; Data.quant_type = !(pParam->vol_flags & XVID_VOL_MPEGQUANT); - - if ((current->vop_flags & XVID_VOP_REDUCED)) { - mb_width = (pParam->width + 31) / 32; - mb_height = (pParam->height + 31) / 32; - Data.qpel = 0; - } + Data.mpeg_quant_matrices = pParam->mpeg_quant_matrices; Data.RefQ = pRefV->u; /* a good place, also used in MC (for similar purpose) */ if (sadInit) (*sadInit) (); for (y = 0; y < mb_height; y++) { for (x = 0; x < mb_width; x++) { - MACROBLOCK *pMB = &pMBs[x + y * pParam->mb_width]; - MACROBLOCK *prevMB = &reference->mbs[x + y * pParam->mb_width]; + MACROBLOCK *pMB = &pMBs[block]; + MACROBLOCK *prevMB = &reference->mbs[block]; + int skip; + block++; - if (!Data.rrv) pMB->sad16 = + pMB->sad16 = sad16v(pCurrent->y + (x + y * iEdgedWidth) * 16, pRef->y + (x + y * iEdgedWidth) * 16, - pParam->edged_width, pMB->sad8 ); + pParam->edged_width, pMB->sad8); - else pMB->sad16 = - sad32v_c(pCurrent->y + (x + y * iEdgedWidth) * 32, - pRef->y + (x + y * iEdgedWidth) * 32, - pParam->edged_width, pMB->sad8 ); + sad00 = 4*MAX(MAX(pMB->sad8[0], pMB->sad8[1]), MAX(pMB->sad8[2], pMB->sad8[3])); if (Data.chroma) { - Data.temp[7] = sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8, + Data.chromaSAD = sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8, pRef->u + x*8 + y*(iEdgedWidth/2)*8, iEdgedWidth/2) + sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8, pRef->v + (x + y*(iEdgedWidth/2))*8, iEdgedWidth/2); - pMB->sad16 += Data.temp[7]; + pMB->sad16 += Data.chromaSAD; + sad00 += Data.chromaSAD; } - sad00 = pMB->sad16; + skip = InitialSkipDecisionP(sad00, pParam, current, pMB, prevMB, x, y, &Data, pGMC, + pCurrent, pRef, MotionFlags); + if (skip) continue; + + SearchP(pRef, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x, + y, MotionFlags, current->vop_flags, + &Data, pParam, pMBs, reference->mbs, pMB); + + if (current->vop_flags & XVID_VOP_MODEDECISION_RD) + xvid_me_ModeDecision_RD(&Data, pMB, pMBs, x, y, pParam, + MotionFlags, current->vop_flags, current->vol_flags, + pCurrent, pRef, pGMC, current->coding_type); + + else if (current->vop_flags & XVID_VOP_FAST_MODEDECISION_RD) + xvid_me_ModeDecision_Fast(&Data, pMB, pMBs, x, y, pParam, + MotionFlags, current->vop_flags, current->vol_flags, + pCurrent, pRef, pGMC, current->coding_type); + else + ModeDecision_SAD(&Data, pMB, pMBs, x, y, pParam, + MotionFlags, current->vop_flags, current->vol_flags, + pCurrent, pRef, pGMC, current->coding_type, sad00); + + + motionStatsPVOP(&MVmax, &mvCount, &mvSum, pMB, Data.qpel); + } + } + + current->fcode = getMinFcode(MVmax); + current->sStat.iMvSum = mvSum; + current->sStat.iMvCount = mvCount; +} + +void +MotionEstimateSMP(SMPmotionData * h) +{ + const MBParam * const pParam = h->pParam; + const FRAMEINFO * const current = h->current; + const FRAMEINFO * const reference = h->reference; + const IMAGE * const pRefH = h->pRefH; + const IMAGE * const pRefV = h->pRefV; + const IMAGE * const pRefHV = h->pRefHV; + const IMAGE * const pGMC = h->pGMC; + uint32_t MotionFlags = MakeGoodMotionFlags(current->motion_flags, + current->vop_flags, + current->vol_flags); + + MACROBLOCK *const pMBs = current->mbs; + const IMAGE *const pCurrent = ¤t->image; + const IMAGE *const pRef = &reference->image; + + const uint32_t mb_width = pParam->mb_width; + const uint32_t mb_height = pParam->mb_height; + const uint32_t iEdgedWidth = pParam->edged_width; + int stat_thresh = 0; + int MVmax = 0, mvSum = 0, mvCount = 0; + int y_step = h->y_step; + int start_y = h->start_y; + + uint32_t x, y; + int sad00; + int skip_thresh = INITIAL_SKIP_THRESH * \ + (current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1); + int block = start_y*mb_width; + int * complete_count_self = h->complete_count_self; + const int * complete_count_above = h->complete_count_above; + int max_mbs; + int current_mb = 0; - /* initial skip decision */ - /* no early skip for GMC (global vector = skip vector is unknown!) */ - if (current->coding_type != S_VOP) { /* no fast SKIP for S(GMC)-VOPs */ - if (pMB->dquant == 0 && sad00 < pMB->quant * skip_thresh) - if (Data.chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, iEdgedWidth/2, pMB->quant, Data.rrv)) { - ZeroMacroblockP(pMB, sad00); - pMB->mode = MODE_NOT_CODED; - continue; + /* some pre-initialized thingies for SearchP */ + DECLARE_ALIGNED_MATRIX(dct_space, 3, 64, int16_t, CACHE_LINE); + SearchData Data; + memset(&Data, 0, sizeof(SearchData)); + Data.iEdgedWidth = iEdgedWidth; + Data.iFcode = current->fcode; + Data.rounding = pParam->m_rounding_type; + Data.qpel = (current->vol_flags & XVID_VOL_QUARTERPEL ? 1:0); + Data.chroma = MotionFlags & XVID_ME_CHROMA_PVOP; + Data.dctSpace = dct_space; + Data.quant_type = !(pParam->vol_flags & XVID_VOL_MPEGQUANT); + Data.mpeg_quant_matrices = pParam->mpeg_quant_matrices; + + /* todo: sort out temp memory space */ + Data.RefQ = h->RefQ; + if (sadInit) (*sadInit) (); + + max_mbs = 0; + + for (y = start_y; y < mb_height; y += y_step) { + if (y == 0) max_mbs = mb_width; /* we can process all blocks of the first row */ + + for (x = 0; x < mb_width; x++) { + + MACROBLOCK *pMB, *prevMB; + int skip; + + pMB = &pMBs[block]; + prevMB = &reference->mbs[block]; + + pMB->sad16 = + sad16v(pCurrent->y + (x + y * iEdgedWidth) * 16, + pRef->y + (x + y * iEdgedWidth) * 16, + pParam->edged_width, pMB->sad8); + + sad00 = 4*MAX(MAX(pMB->sad8[0], pMB->sad8[1]), MAX(pMB->sad8[2], pMB->sad8[3])); + + if (Data.chroma) { + Data.chromaSAD = sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8, + pRef->u + x*8 + y*(iEdgedWidth/2)*8, iEdgedWidth/2) + + sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8, + pRef->v + (x + y*(iEdgedWidth/2))*8, iEdgedWidth/2); + pMB->sad16 += Data.chromaSAD; + sad00 += Data.chromaSAD; + } + + if (current_mb >= max_mbs) { + /* we ME-ed all macroblocks we safely could. grab next portion */ + int above_count = *complete_count_above; /* sync point */ + if (above_count == mb_width) { + /* full line above is ready */ + above_count = mb_width+1; + if (y < mb_height-y_step) { + /* this is not last line, grab a portion of MBs from the next line too */ + above_count += MAX(0, complete_count_above[1] - 1); } + } + + max_mbs = current_mb + above_count - x - 1; + + if (current_mb >= max_mbs) { + /* current workload is zero */ + x--; + sched_yield(); + continue; + } } - if(MotionFlags & XVID_ME_DETECT_STATIC_MOTION) { - if(x > 0 && y > 0 && x < pParam->mb_width) { - if(MVequal((&pMBs[(x-1) + y * pParam->mb_width])->mvs[0], zeroMV) && - MVequal((&pMBs[x + (y-1) * pParam->mb_width])->mvs[0], zeroMV) && - MVequal((&pMBs[(x+1) + (y-1) * pParam->mb_width])->mvs[0], zeroMV) && - MVequal(prevMB->mvs[0], zeroMV)) { - stat_thresh = MAX((&pMBs[(x-1) + y * pParam->mb_width])->sad16, - MAX((&pMBs[x + (y-1) * pParam->mb_width])->sad16, - MAX((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16, - prevMB->sad16))); + skip = InitialSkipDecisionP(sad00, pParam, current, pMB, prevMB, x, y, &Data, pGMC, + pCurrent, pRef, MotionFlags); + if (current_mb >= max_mbs) { + /* we ME-ed all macroblocks we safely could. grab next portion */ + int above_count = *complete_count_above; /* sync point */ + if (above_count == mb_width) { + /* full line above is ready */ + above_count = mb_width+1; + if (y < mb_height-y_step) { + /* this is not last line, grab a portion of MBs from the next line too */ + above_count += MAX(0, complete_count_above[1] - 1); } - } else { - stat_thresh = MIN((&pMBs[(x-1) + y * pParam->mb_width])->sad16, - MIN((&pMBs[x + (y-1) * pParam->mb_width])->sad16, - MIN((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16, - prevMB->sad16))); + } + + max_mbs = current_mb + above_count - x - 1; + + if (current_mb >= max_mbs) { + /* current workload is zero */ + x--; + sched_yield(); + continue; } } - /* favorize (0,0) vector for cartoons */ - if ((current->vop_flags & XVID_VOP_CARTOON) && - ((sad00 < pMB->quant * 4 * skip_thresh) || (sad00 < stat_thresh))) { - ZeroMacroblockP(pMB, sad00); + if (skip) { + current_mb++; + block++; + *complete_count_self = x+1; continue; } @@ -1112,14 +1135,24 @@ else ModeDecision_SAD(&Data, pMB, pMBs, x, y, pParam, MotionFlags, current->vop_flags, current->vol_flags, - pCurrent, pRef, pGMC, current->coding_type); + pCurrent, pRef, pGMC, current->coding_type, sad00); + *complete_count_self = x+1; - if (pMB->mode == MODE_INTRA) - if (++iIntra > iLimit) return 1; + current_mb++; + block++; + + motionStatsPVOP(&MVmax, &mvCount, &mvSum, pMB, Data.qpel); + } + block += (y_step-1)*pParam->mb_width; + complete_count_self++; + complete_count_above++; } - return 0; + + h->MVmax = MVmax; + h->mvSum = mvSum; + h->mvCount = mvCount; }