249 |
ref1 = GetReferenceB(halfpel_x, halfpel_y, dir, data); |
ref1 = GetReferenceB(halfpel_x, halfpel_y, dir, data); |
250 |
ref1 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth; |
ref1 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth; |
251 |
switch( ((x&1)<<1) + (y&1) ) { |
switch( ((x&1)<<1) + (y&1) ) { |
252 |
case 0: // pure halfpel position |
case 3: // x and y in qpel resolution - the "corners" (top left/right and |
253 |
return (uint8_t *) ref1; |
// bottom left/right) during qpel refinement |
254 |
|
ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data); |
255 |
|
ref3 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data); |
256 |
|
ref4 = GetReferenceB(x - halfpel_x, y - halfpel_y, dir, data); |
257 |
|
ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth; |
258 |
|
ref3 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth; |
259 |
|
ref4 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth; |
260 |
|
interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding); |
261 |
break; |
break; |
262 |
|
|
263 |
case 1: // x halfpel, y qpel - top or bottom during qpel refinement |
case 1: // x halfpel, y qpel - top or bottom during qpel refinement |
272 |
interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8); |
interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8); |
273 |
break; |
break; |
274 |
|
|
275 |
default: // x and y in qpel resolution - the "corners" (top left/right and |
default: // pure halfpel position |
276 |
// bottom left/right) during qpel refinement |
return (uint8_t *) ref1; |
277 |
ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data); |
|
|
ref3 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data); |
|
|
ref4 = GetReferenceB(x - halfpel_x, y - halfpel_y, dir, data); |
|
|
ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth; |
|
|
ref3 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth; |
|
|
ref4 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth; |
|
|
interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding); |
|
|
break; |
|
278 |
} |
} |
279 |
return Reference; |
return Reference; |
280 |
} |
} |
319 |
interpolate8x8_avg2(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, iEdgedWidth, rounding, 8); |
interpolate8x8_avg2(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, iEdgedWidth, rounding, 8); |
320 |
break; |
break; |
321 |
|
|
322 |
case 0: // pure halfpel position |
default: // pure halfpel position |
323 |
return (uint8_t *) ref1; |
return (uint8_t *) ref1; |
324 |
} |
} |
325 |
return Reference; |
return Reference; |
405 |
uint32_t t; |
uint32_t t; |
406 |
const uint8_t * Reference; |
const uint8_t * Reference; |
407 |
|
|
408 |
if ( (!(x&1) && x !=0) || (!(y&1) && y !=0) || //non-zero integer value |
if ( (!(x&1) && x !=0) || (!(y&1) && y !=0) || //non-zero even value |
409 |
(x > data->max_dx) || (x < data->min_dx) |
(x > data->max_dx) || (x < data->min_dx) |
410 |
|| (y > data->max_dy) || (y < data->min_dy) ) return; |
|| (y > data->max_dy) || (y < data->min_dy) ) return; |
411 |
|
|
440 |
uint32_t t; |
uint32_t t; |
441 |
VECTOR * current; |
VECTOR * current; |
442 |
|
|
443 |
if ( (x > data->max_dx) | ( x < data->min_dx) |
if ( (x > data->max_dx) || ( x < data->min_dx) |
444 |
| (y > data->max_dy) | (y < data->min_dy) ) return; |
|| (y > data->max_dy) || (y < data->min_dy) ) return; |
445 |
|
|
446 |
if (data->rrv && (!(x&1) && x !=0) | (!(y&1) && y !=0) ) return; //non-zero even value |
if (data->rrv && (!(x&1) && x !=0) | (!(y&1) && y !=0) ) return; //non-zero even value |
447 |
|
|
506 |
const uint8_t *ReferenceF, *ReferenceB; |
const uint8_t *ReferenceF, *ReferenceB; |
507 |
VECTOR *current; |
VECTOR *current; |
508 |
|
|
509 |
if ( (xf > data->max_dx) || (xf < data->min_dx) |
if ((xf > data->max_dx) || (xf < data->min_dx) || |
510 |
|| (yf > data->max_dy) || (yf < data->min_dy) ) return; |
(yf > data->max_dy) || (yf < data->min_dy)) |
511 |
|
return; |
512 |
|
|
513 |
if (!data->qpel_precision) { |
if (!data->qpel_precision) { |
514 |
ReferenceF = GetReference(xf, yf, data); |
ReferenceF = GetReference(xf, yf, data); |
566 |
data->directmvB[k].y |
data->directmvB[k].y |
567 |
: mvs.y - data->referencemv[k].y); |
: mvs.y - data->referencemv[k].y); |
568 |
|
|
569 |
if ( (mvs.x > data->max_dx) || (mvs.x < data->min_dx) |
if ((mvs.x > data->max_dx) || (mvs.x < data->min_dx) || |
570 |
|| (mvs.y > data->max_dy) || (mvs.y < data->min_dy) |
(mvs.y > data->max_dy) || (mvs.y < data->min_dy) || |
571 |
|| (b_mvs.x > data->max_dx) || (b_mvs.x < data->min_dx) |
(b_mvs.x > data->max_dx) || (b_mvs.x < data->min_dx) || |
572 |
|| (b_mvs.y > data->max_dy) || (b_mvs.y < data->min_dy) ) return; |
(b_mvs.y > data->max_dy) || (b_mvs.y < data->min_dy) ) |
573 |
|
return; |
574 |
|
|
575 |
if (data->qpel) { |
if (data->qpel) { |
576 |
xcf += mvs.x/2; ycf += mvs.y/2; |
xcf += mvs.x/2; ycf += mvs.y/2; |
612 |
const uint8_t *ReferenceB; |
const uint8_t *ReferenceB; |
613 |
VECTOR mvs, b_mvs; |
VECTOR mvs, b_mvs; |
614 |
|
|
615 |
if (( x > 31) | ( x < -32) | ( y > 31) | (y < -32)) return; |
if (( x > 31) || ( x < -32) || ( y > 31) || (y < -32)) return; |
616 |
|
|
617 |
mvs.x = data->directmvF[0].x + x; |
mvs.x = data->directmvF[0].x + x; |
618 |
b_mvs.x = ((x == 0) ? |
b_mvs.x = ((x == 0) ? |
624 |
data->directmvB[0].y |
data->directmvB[0].y |
625 |
: mvs.y - data->referencemv[0].y); |
: mvs.y - data->referencemv[0].y); |
626 |
|
|
627 |
if ( (mvs.x > data->max_dx) | (mvs.x < data->min_dx) |
if ( (mvs.x > data->max_dx) || (mvs.x < data->min_dx) |
628 |
| (mvs.y > data->max_dy) | (mvs.y < data->min_dy) |
|| (mvs.y > data->max_dy) || (mvs.y < data->min_dy) |
629 |
| (b_mvs.x > data->max_dx) | (b_mvs.x < data->min_dx) |
|| (b_mvs.x > data->max_dx) || (b_mvs.x < data->min_dx) |
630 |
| (b_mvs.y > data->max_dy) | (b_mvs.y < data->min_dy) ) return; |
|| (b_mvs.y > data->max_dy) || (b_mvs.y < data->min_dy) ) return; |
631 |
|
|
632 |
if (data->qpel) { |
if (data->qpel) { |
633 |
xcf = 4*(mvs.x/2); ycf = 4*(mvs.y/2); |
xcf = 4*(mvs.x/2); ycf = 4*(mvs.y/2); |
952 |
const uint32_t stride, const uint32_t iQuant, int rrv) |
const uint32_t stride, const uint32_t iQuant, int rrv) |
953 |
|
|
954 |
{ |
{ |
955 |
|
int offset = (x + y*stride)*8; |
956 |
if(!rrv) { |
if(!rrv) { |
957 |
uint32_t sadC = sad8(current->u + x*8 + y*stride*8, |
uint32_t sadC = sad8(current->u + offset, |
958 |
reference->u + x*8 + y*stride*8, stride); |
reference->u + offset, stride); |
959 |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0; |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0; |
960 |
sadC += sad8(current->v + (x + y*stride)*8, |
sadC += sad8(current->v + offset, |
961 |
reference->v + (x + y*stride)*8, stride); |
reference->v + offset, stride); |
962 |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0; |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0; |
963 |
return 1; |
return 1; |
964 |
|
|
965 |
} else { |
} else { |
966 |
uint32_t sadC = sad16(current->u + x*16 + y*stride*16, |
uint32_t sadC = sad16(current->u + 2*offset, |
967 |
reference->u + x*16 + y*stride*16, stride, 256*4096); |
reference->u + 2*offset, stride, 256*4096); |
968 |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0; |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0; |
969 |
sadC += sad16(current->v + (x + y*stride)*16, |
sadC += sad16(current->v + 2*offset, |
970 |
reference->v + (x + y*stride)*16, stride, 256*4096); |
reference->v + 2*offset, stride, 256*4096); |
971 |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0; |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0; |
972 |
return 1; |
return 1; |
973 |
} |
} |
1180 |
int mode = MODE_INTER; |
int mode = MODE_INTER; |
1181 |
|
|
1182 |
if (!(GlobalFlags & XVID_MODEDECISION_BITS)) { //normal, fast, SAD-based mode decision |
if (!(GlobalFlags & XVID_MODEDECISION_BITS)) { //normal, fast, SAD-based mode decision |
|
// int intra = 0; |
|
1183 |
int sad; |
int sad; |
1184 |
int InterBias = MV16_INTER_BIAS; |
int InterBias = MV16_INTER_BIAS; |
1185 |
if (inter4v == 0 || Data->iMinSAD[0] < Data->iMinSAD[1] + Data->iMinSAD[2] + |
if (inter4v == 0 || Data->iMinSAD[0] < Data->iMinSAD[1] + Data->iMinSAD[2] + |
1186 |
Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant) { |
Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant) { |
1187 |
mode = 0; //inter |
mode = MODE_INTER; |
1188 |
sad = Data->iMinSAD[0]; |
sad = Data->iMinSAD[0]; |
1189 |
} else { |
} else { |
1190 |
mode = MODE_INTER4V; |
mode = MODE_INTER4V; |
1212 |
dev16(Data->Cur + 8*Data->iEdgedWidth, Data->iEdgedWidth) + |
dev16(Data->Cur + 8*Data->iEdgedWidth, Data->iEdgedWidth) + |
1213 |
dev16(Data->Cur+8+8*Data->iEdgedWidth, Data->iEdgedWidth); |
dev16(Data->Cur+8+8*Data->iEdgedWidth, Data->iEdgedWidth); |
1214 |
|
|
1215 |
if (deviation < (sad - InterBias)) return MODE_INTRA;// intra |
if (deviation < (sad - InterBias)) return MODE_INTRA; |
1216 |
} |
} |
1217 |
return mode; |
return mode; |
1218 |
|
|
1233 |
if (bits == 0) return MODE_INTER; // quick stop |
if (bits == 0) return MODE_INTER; // quick stop |
1234 |
|
|
1235 |
if (inter4v) { |
if (inter4v) { |
1236 |
int inter4v = CountMBBitsInter4v(Data, pMB, pMBs, x, y, pParam, MotionFlags, backup); |
int bits_inter4v = CountMBBitsInter4v(Data, pMB, pMBs, x, y, pParam, MotionFlags, backup); |
1237 |
if (inter4v < bits) { Data->iMinSAD[0] = bits = inter4v; mode = MODE_INTER4V; } |
if (bits_inter4v < bits) { Data->iMinSAD[0] = bits = bits_inter4v; mode = MODE_INTER4V; } |
1238 |
} |
} |
1239 |
|
|
1240 |
|
|
1292 |
|
|
1293 |
if (pMB->dquant != NO_CHANGE) inter4v = 0; |
if (pMB->dquant != NO_CHANGE) inter4v = 0; |
1294 |
|
|
1295 |
for(i = 0; i < 5; i++) |
memset(Data->currentMV, 0, 5*sizeof(VECTOR)); |
|
Data->currentMV[i].x = Data->currentMV[i].y = 0; |
|
1296 |
|
|
1297 |
if (Data->qpel) Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, 0); |
if (Data->qpel) Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, 0); |
1298 |
else Data->predMV = pmv[0]; |
else Data->predMV = pmv[0]; |
1714 |
|
|
1715 |
for (k = 0; k < 4; k++) { |
for (k = 0; k < 4; k++) { |
1716 |
dy += Data->directmvF[k].y / div; |
dy += Data->directmvF[k].y / div; |
1717 |
dx += Data->directmvF[0].x / div; |
dx += Data->directmvF[k].x / div; |
1718 |
b_dy += Data->directmvB[0].y / div; |
b_dy += Data->directmvB[k].y / div; |
1719 |
b_dx += Data->directmvB[0].x / div; |
b_dx += Data->directmvB[k].x / div; |
1720 |
} |
} |
1721 |
|
|
1722 |
dy = (dy >> 3) + roundtab_76[dy & 0xf]; |
dy = (dy >> 3) + roundtab_76[dy & 0xf]; |
1736 |
b_Ref->v + (y*8 + b_dy/2) * stride + x*8 + b_dx/2, |
b_Ref->v + (y*8 + b_dy/2) * stride + x*8 + b_dx/2, |
1737 |
stride); |
stride); |
1738 |
|
|
1739 |
if (sum < 2 * MAX_CHROMA_SAD_FOR_SKIP * pMB->quant) pMB->mode = MODE_DIRECT_NONE_MV; //skipped |
if (sum < 2 * MAX_CHROMA_SAD_FOR_SKIP * pMB->quant) { |
1740 |
|
pMB->mode = MODE_DIRECT_NONE_MV; //skipped |
1741 |
|
for (k = 0; k < 4; k++) { |
1742 |
|
pMB->qmvs[k] = pMB->mvs[k]; |
1743 |
|
pMB->b_qmvs[k] = pMB->b_mvs[k]; |
1744 |
|
} |
1745 |
|
} |
1746 |
} |
} |
1747 |
|
|
1748 |
static __inline uint32_t |
static __inline uint32_t |