81 |
static __inline uint32_t |
static __inline uint32_t |
82 |
d_mv_bits(int x, int y, const VECTOR pred, const uint32_t iFcode, const int qpel, const int rrv) |
d_mv_bits(int x, int y, const VECTOR pred, const uint32_t iFcode, const int qpel, const int rrv) |
83 |
{ |
{ |
84 |
int xb, yb; |
int bits; |
85 |
x = qpel ? x<<1 : x; |
const int q = (1 << (iFcode - 1)) - 1; |
86 |
y = qpel ? y<<1 : y; |
|
87 |
|
x <<= qpel; |
88 |
|
y <<= qpel; |
89 |
if (rrv) { x = RRV_MV_SCALEDOWN(x); y = RRV_MV_SCALEDOWN(y); } |
if (rrv) { x = RRV_MV_SCALEDOWN(x); y = RRV_MV_SCALEDOWN(y); } |
90 |
|
|
91 |
x -= pred.x; |
x -= pred.x; |
92 |
y -= pred.y; |
bits = (x != 0 ? iFcode:0); |
93 |
|
x = abs(x); |
94 |
if (x) { |
x += q; |
|
x = ABS(x); |
|
|
x += (1 << (iFcode - 1)) - 1; |
|
95 |
x >>= (iFcode - 1); |
x >>= (iFcode - 1); |
96 |
if (x > 32) x = 32; |
bits += mvtab[x]; |
97 |
xb = mvtab[x] + iFcode; |
|
98 |
} else xb = 1; |
y -= pred.y; |
99 |
|
bits += (y != 0 ? iFcode:0); |
100 |
if (y) { |
y = abs(y); |
101 |
y = ABS(y); |
y += q; |
|
y += (1 << (iFcode - 1)) - 1; |
|
102 |
y >>= (iFcode - 1); |
y >>= (iFcode - 1); |
103 |
if (y > 32) y = 32; |
bits += mvtab[y]; |
104 |
yb = mvtab[y] + iFcode; |
|
105 |
} else yb = 1; |
return bits; |
|
return xb + yb; |
|
106 |
} |
} |
107 |
|
|
108 |
static int32_t ChromaSAD2(int fx, int fy, int bx, int by, const SearchData * const data) |
static int32_t ChromaSAD2(int fx, int fy, int bx, int by, const SearchData * const data) |
247 |
ref1 = GetReferenceB(halfpel_x, halfpel_y, dir, data); |
ref1 = GetReferenceB(halfpel_x, halfpel_y, dir, data); |
248 |
ref1 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth; |
ref1 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth; |
249 |
switch( ((x&1)<<1) + (y&1) ) { |
switch( ((x&1)<<1) + (y&1) ) { |
250 |
case 0: // pure halfpel position |
case 3: // x and y in qpel resolution - the "corners" (top left/right and |
251 |
return (uint8_t *) ref1; |
// bottom left/right) during qpel refinement |
252 |
|
ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data); |
253 |
|
ref3 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data); |
254 |
|
ref4 = GetReferenceB(x - halfpel_x, y - halfpel_y, dir, data); |
255 |
|
ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth; |
256 |
|
ref3 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth; |
257 |
|
ref4 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth; |
258 |
|
interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding); |
259 |
break; |
break; |
260 |
|
|
261 |
case 1: // x halfpel, y qpel - top or bottom during qpel refinement |
case 1: // x halfpel, y qpel - top or bottom during qpel refinement |
270 |
interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8); |
interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8); |
271 |
break; |
break; |
272 |
|
|
273 |
default: // x and y in qpel resolution - the "corners" (top left/right and |
default: // pure halfpel position |
274 |
// bottom left/right) during qpel refinement |
return (uint8_t *) ref1; |
275 |
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; |
|
276 |
} |
} |
277 |
return Reference; |
return Reference; |
278 |
} |
} |
317 |
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); |
318 |
break; |
break; |
319 |
|
|
320 |
case 0: // pure halfpel position |
default: // pure halfpel position |
321 |
return (uint8_t *) ref1; |
return (uint8_t *) ref1; |
322 |
} |
} |
323 |
return Reference; |
return Reference; |
377 |
{ |
{ |
378 |
int32_t sad; uint32_t t; |
int32_t sad; uint32_t t; |
379 |
const uint8_t * Reference; |
const uint8_t * Reference; |
380 |
|
VECTOR * current; |
381 |
|
|
382 |
if ( (x > data->max_dx) || (x < data->min_dx) |
if ( (x > data->max_dx) || (x < data->min_dx) |
383 |
|| (y > data->max_dy) || (y < data->min_dy) ) return; |
|| (y > data->max_dy) || (y < data->min_dy) ) return; |
384 |
|
|
385 |
if (!data->qpel_precision) Reference = GetReference(x, y, data); |
if (!data->qpel_precision) { |
386 |
else Reference = Interpolate8x8qpel(x, y, 0, 0, data); |
Reference = GetReference(x, y, data); |
387 |
|
current = data->currentMV; |
388 |
|
} else { // x and y are in 1/4 precision |
389 |
|
Reference = Interpolate8x8qpel(x, y, 0, 0, data); |
390 |
|
current = data->currentQMV; |
391 |
|
} |
392 |
|
|
393 |
sad = sad8(data->Cur, Reference, data->iEdgedWidth); |
sad = sad8(data->Cur, Reference, data->iEdgedWidth); |
394 |
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, 0); |
397 |
|
|
398 |
if (sad < *(data->iMinSAD)) { |
if (sad < *(data->iMinSAD)) { |
399 |
*(data->iMinSAD) = sad; |
*(data->iMinSAD) = sad; |
400 |
data->currentMV->x = x; data->currentMV->y = y; |
current->x = x; current->y = y; |
401 |
*dir = Direction; |
*dir = Direction; |
402 |
} |
} |
403 |
} |
} |
409 |
uint32_t t; |
uint32_t t; |
410 |
const uint8_t * Reference; |
const uint8_t * Reference; |
411 |
|
|
412 |
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 |
413 |
(x > data->max_dx) || (x < data->min_dx) |
(x > data->max_dx) || (x < data->min_dx) |
414 |
|| (y > data->max_dy) || (y < data->min_dy) ) return; |
|| (y > data->max_dy) || (y < data->min_dy) ) return; |
415 |
|
|
444 |
uint32_t t; |
uint32_t t; |
445 |
VECTOR * current; |
VECTOR * current; |
446 |
|
|
447 |
if ( (x > data->max_dx) | ( x < data->min_dx) |
if ( (x > data->max_dx) || ( x < data->min_dx) |
448 |
| (y > data->max_dy) | (y < data->min_dy) ) return; |
|| (y > data->max_dy) || (y < data->min_dy) ) return; |
449 |
|
|
450 |
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 |
451 |
|
|
616 |
const uint8_t *ReferenceB; |
const uint8_t *ReferenceB; |
617 |
VECTOR mvs, b_mvs; |
VECTOR mvs, b_mvs; |
618 |
|
|
619 |
if (( x > 31) | ( x < -32) | ( y > 31) | (y < -32)) return; |
if (( x > 31) || ( x < -32) || ( y > 31) || (y < -32)) return; |
620 |
|
|
621 |
mvs.x = data->directmvF[0].x + x; |
mvs.x = data->directmvF[0].x + x; |
622 |
b_mvs.x = ((x == 0) ? |
b_mvs.x = ((x == 0) ? |
628 |
data->directmvB[0].y |
data->directmvB[0].y |
629 |
: mvs.y - data->referencemv[0].y); |
: mvs.y - data->referencemv[0].y); |
630 |
|
|
631 |
if ( (mvs.x > data->max_dx) | (mvs.x < data->min_dx) |
if ( (mvs.x > data->max_dx) || (mvs.x < data->min_dx) |
632 |
| (mvs.y > data->max_dy) | (mvs.y < data->min_dy) |
|| (mvs.y > data->max_dy) || (mvs.y < data->min_dy) |
633 |
| (b_mvs.x > data->max_dx) | (b_mvs.x < data->min_dx) |
|| (b_mvs.x > data->max_dx) || (b_mvs.x < data->min_dx) |
634 |
| (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; |
635 |
|
|
636 |
if (data->qpel) { |
if (data->qpel) { |
637 |
xcf = 4*(mvs.x/2); ycf = 4*(mvs.y/2); |
xcf = 4*(mvs.x/2); ycf = 4*(mvs.y/2); |
665 |
CheckCandidateBits16(const int x, const int y, const int Direction, int * const dir, const SearchData * const data) |
CheckCandidateBits16(const int x, const int y, const int Direction, int * const dir, const SearchData * const data) |
666 |
{ |
{ |
667 |
|
|
668 |
static int16_t in[64], coeff[64]; |
int16_t *in = data->dctSpace, *coeff = data->dctSpace + 64; |
669 |
int32_t bits = 0, sum; |
int32_t bits = 0, sum; |
670 |
VECTOR * current; |
VECTOR * current; |
671 |
const uint8_t * ptr; |
const uint8_t * ptr; |
727 |
} |
} |
728 |
} |
} |
729 |
|
|
730 |
bits += cbpy_tab[15-(cbp>>2)].len; |
bits += xvid_cbpy_tab[15-(cbp>>2)].len; |
731 |
bits += mcbpc_inter_tab[(MODE_INTER & 7) | ((cbp & 3) << 3)].len; |
bits += mcbpc_inter_tab[(MODE_INTER & 7) | ((cbp & 3) << 3)].len; |
732 |
|
|
733 |
if (bits < data->iMinSAD[0]) { |
if (bits < data->iMinSAD[0]) { |
750 |
CheckCandidateBits8(const int x, const int y, const int Direction, int * const dir, const SearchData * const data) |
CheckCandidateBits8(const int x, const int y, const int Direction, int * const dir, const SearchData * const data) |
751 |
{ |
{ |
752 |
|
|
753 |
static int16_t in[64], coeff[64]; |
int16_t *in = data->dctSpace, *coeff = data->dctSpace + 64; |
754 |
int32_t sum, bits; |
int32_t sum, bits; |
755 |
VECTOR * current; |
VECTOR * current; |
756 |
const uint8_t * ptr; |
const uint8_t * ptr; |
956 |
const uint32_t stride, const uint32_t iQuant, int rrv) |
const uint32_t stride, const uint32_t iQuant, int rrv) |
957 |
|
|
958 |
{ |
{ |
959 |
|
int offset = (x + y*stride)*8; |
960 |
if(!rrv) { |
if(!rrv) { |
961 |
uint32_t sadC = sad8(current->u + x*8 + y*stride*8, |
uint32_t sadC = sad8(current->u + offset, |
962 |
reference->u + x*8 + y*stride*8, stride); |
reference->u + offset, stride); |
963 |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0; |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0; |
964 |
sadC += sad8(current->v + (x + y*stride)*8, |
sadC += sad8(current->v + offset, |
965 |
reference->v + (x + y*stride)*8, stride); |
reference->v + offset, stride); |
966 |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0; |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0; |
967 |
return 1; |
return 1; |
968 |
|
|
969 |
} else { |
} else { |
970 |
uint32_t sadC = sad16(current->u + x*16 + y*stride*16, |
uint32_t sadC = sad16(current->u + 2*offset, |
971 |
reference->u + x*16 + y*stride*16, stride, 256*4096); |
reference->u + 2*offset, stride, 256*4096); |
972 |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0; |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0; |
973 |
sadC += sad16(current->v + (x + y*stride)*16, |
sadC += sad16(current->v + 2*offset, |
974 |
reference->v + (x + y*stride)*16, stride, 256*4096); |
reference->v + 2*offset, stride, 256*4096); |
975 |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0; |
if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0; |
976 |
return 1; |
return 1; |
977 |
} |
} |
1017 |
VECTOR currentMV[5]; |
VECTOR currentMV[5]; |
1018 |
VECTOR currentQMV[5]; |
VECTOR currentQMV[5]; |
1019 |
int32_t iMinSAD[5]; |
int32_t iMinSAD[5]; |
1020 |
|
DECLARE_ALIGNED_MATRIX(dct_space, 2, 64, int16_t, CACHE_LINE); |
1021 |
SearchData Data; |
SearchData Data; |
1022 |
memset(&Data, 0, sizeof(SearchData)); |
memset(&Data, 0, sizeof(SearchData)); |
1023 |
Data.iEdgedWidth = iEdgedWidth; |
Data.iEdgedWidth = iEdgedWidth; |
1027 |
Data.temp = temp; |
Data.temp = temp; |
1028 |
Data.iFcode = current->fcode; |
Data.iFcode = current->fcode; |
1029 |
Data.rounding = pParam->m_rounding_type; |
Data.rounding = pParam->m_rounding_type; |
1030 |
Data.qpel = current->vol_flags & XVID_VOL_QUARTERPEL; |
Data.qpel = (current->vol_flags & XVID_VOL_QUARTERPEL ? 1:0); |
1031 |
Data.chroma = MotionFlags & XVID_ME_CHROMA16; |
Data.chroma = MotionFlags & XVID_ME_CHROMA16; |
1032 |
Data.rrv = current->vop_flags & XVID_VOP_REDUCED; |
Data.rrv = (current->vop_flags & XVID_VOP_REDUCED ? 1:0); |
1033 |
|
Data.dctSpace = dct_space; |
1034 |
|
|
1035 |
if ((current->vop_flags & XVID_VOP_REDUCED)) { |
if ((current->vop_flags & XVID_VOP_REDUCED)) { |
1036 |
mb_width = (pParam->width + 31) / 32; |
mb_width = (pParam->width + 31) / 32; |
1102 |
} |
} |
1103 |
|
|
1104 |
if (current->vol_flags & XVID_VOL_GMC ) /* GMC only for S(GMC)-VOPs */ |
if (current->vol_flags & XVID_VOL_GMC ) /* GMC only for S(GMC)-VOPs */ |
|
{ |
|
1105 |
current->warp = GlobalMotionEst( pMBs, pParam, current, reference, pRefH, pRefV, pRefHV); |
current->warp = GlobalMotionEst( pMBs, pParam, current, reference, pRefH, pRefV, pRefHV); |
1106 |
} |
|
1107 |
return 0; |
return 0; |
1108 |
} |
} |
1109 |
|
|
1181 |
int mode = MODE_INTER; |
int mode = MODE_INTER; |
1182 |
|
|
1183 |
if (!(VopFlags & XVID_VOP_MODEDECISION_BITS)) { //normal, fast, SAD-based mode decision |
if (!(VopFlags & XVID_VOP_MODEDECISION_BITS)) { //normal, fast, SAD-based mode decision |
|
// int intra = 0; |
|
1184 |
int sad; |
int sad; |
1185 |
int InterBias = MV16_INTER_BIAS; |
int InterBias = MV16_INTER_BIAS; |
1186 |
if (inter4v == 0 || Data->iMinSAD[0] < Data->iMinSAD[1] + Data->iMinSAD[2] + |
if (inter4v == 0 || Data->iMinSAD[0] < Data->iMinSAD[1] + Data->iMinSAD[2] + |
1187 |
Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant) { |
Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant) { |
1188 |
mode = 0; //inter |
mode = MODE_INTER; |
1189 |
sad = Data->iMinSAD[0]; |
sad = Data->iMinSAD[0]; |
1190 |
} else { |
} else { |
1191 |
mode = MODE_INTER4V; |
mode = MODE_INTER4V; |
1213 |
dev16(Data->Cur + 8*Data->iEdgedWidth, Data->iEdgedWidth) + |
dev16(Data->Cur + 8*Data->iEdgedWidth, Data->iEdgedWidth) + |
1214 |
dev16(Data->Cur+8+8*Data->iEdgedWidth, Data->iEdgedWidth); |
dev16(Data->Cur+8+8*Data->iEdgedWidth, Data->iEdgedWidth); |
1215 |
|
|
1216 |
if (deviation < (sad - InterBias)) return MODE_INTRA;// intra |
if (deviation < (sad - InterBias)) return MODE_INTRA; |
1217 |
} |
} |
1218 |
return mode; |
return mode; |
1219 |
|
|
1234 |
if (bits == 0) return MODE_INTER; // quick stop |
if (bits == 0) return MODE_INTER; // quick stop |
1235 |
|
|
1236 |
if (inter4v) { |
if (inter4v) { |
1237 |
int inter4v = CountMBBitsInter4v(Data, pMB, pMBs, x, y, pParam, MotionFlags, backup); |
int bits_inter4v = CountMBBitsInter4v(Data, pMB, pMBs, x, y, pParam, MotionFlags, backup); |
1238 |
if (inter4v < bits) { Data->iMinSAD[0] = bits = inter4v; mode = MODE_INTER4V; } |
if (bits_inter4v < bits) { Data->iMinSAD[0] = bits = bits_inter4v; mode = MODE_INTER4V; } |
1239 |
} |
} |
1240 |
|
|
1241 |
|
|
1293 |
|
|
1294 |
if (pMB->dquant != 0) inter4v = 0; |
if (pMB->dquant != 0) inter4v = 0; |
1295 |
|
|
1296 |
for(i = 0; i < 5; i++) |
memset(Data->currentMV, 0, 5*sizeof(VECTOR)); |
|
Data->currentMV[i].x = Data->currentMV[i].y = 0; |
|
1297 |
|
|
1298 |
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); |
1299 |
else Data->predMV = pmv[0]; |
else Data->predMV = pmv[0]; |
1715 |
|
|
1716 |
for (k = 0; k < 4; k++) { |
for (k = 0; k < 4; k++) { |
1717 |
dy += Data->directmvF[k].y / div; |
dy += Data->directmvF[k].y / div; |
1718 |
dx += Data->directmvF[0].x / div; |
dx += Data->directmvF[k].x / div; |
1719 |
b_dy += Data->directmvB[0].y / div; |
b_dy += Data->directmvB[k].y / div; |
1720 |
b_dx += Data->directmvB[0].x / div; |
b_dx += Data->directmvB[k].x / div; |
1721 |
} |
} |
1722 |
|
|
1723 |
dy = (dy >> 3) + roundtab_76[dy & 0xf]; |
dy = (dy >> 3) + roundtab_76[dy & 0xf]; |
1737 |
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, |
1738 |
stride); |
stride); |
1739 |
|
|
1740 |
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) { |
1741 |
|
pMB->mode = MODE_DIRECT_NONE_MV; //skipped |
1742 |
|
for (k = 0; k < 4; k++) { |
1743 |
|
pMB->qmvs[k] = pMB->mvs[k]; |
1744 |
|
pMB->b_qmvs[k] = pMB->b_mvs[k]; |
1745 |
|
} |
1746 |
|
} |
1747 |
} |
} |
1748 |
|
|
1749 |
static __inline uint32_t |
static __inline uint32_t |
2558 |
int cbp = 0, bits = 0, t = 0, i, iDirection; |
int cbp = 0, bits = 0, t = 0, i, iDirection; |
2559 |
SearchData Data2, *Data8 = &Data2; |
SearchData Data2, *Data8 = &Data2; |
2560 |
int sumx = 0, sumy = 0; |
int sumx = 0, sumy = 0; |
2561 |
int16_t in[64], coeff[64]; |
int16_t *in = Data->dctSpace, *coeff = Data->dctSpace + 64; |
2562 |
|
|
2563 |
memcpy(Data8, Data, sizeof(SearchData)); |
memcpy(Data8, Data, sizeof(SearchData)); |
2564 |
CheckCandidate = CheckCandidateBits8; |
CheckCandidate = CheckCandidateBits8; |
2685 |
bits += CodeCoeffInter_CalcBits(coeff, scan_tables[0]); |
bits += CodeCoeffInter_CalcBits(coeff, scan_tables[0]); |
2686 |
cbp |= 1 << (5 - 5); |
cbp |= 1 << (5 - 5); |
2687 |
} |
} |
2688 |
bits += cbpy_tab[15-(cbp>>2)].len; |
bits += xvid_cbpy_tab[15-(cbp>>2)].len; |
2689 |
bits += mcbpc_inter_tab[(MODE_INTER4V & 7) | ((cbp & 3) << 3)].len; |
bits += mcbpc_inter_tab[(MODE_INTER4V & 7) | ((cbp & 3) << 3)].len; |
2690 |
} |
} |
2691 |
} |
} |
2700 |
int bits = 1; //this one is ac/dc prediction flag. always 1. |
int bits = 1; //this one is ac/dc prediction flag. always 1. |
2701 |
int cbp = 0, i, t, dc = 0, b_dc = 1024; |
int cbp = 0, i, t, dc = 0, b_dc = 1024; |
2702 |
const uint32_t iQuant = Data->lambda16; |
const uint32_t iQuant = Data->lambda16; |
2703 |
int16_t in[64], coeff[64]; |
int16_t *in = Data->dctSpace, * coeff = Data->dctSpace + 64; |
2704 |
|
|
2705 |
for(i = 0; i < 4; i++) { |
for(i = 0; i < 4; i++) { |
2706 |
uint32_t iDcScaler = get_dc_scaler(iQuant, 1); |
uint32_t iDcScaler = get_dc_scaler(iQuant, 1); |
2748 |
bits += t = CodeCoeffIntra_CalcBits(coeff, scan_tables[0]) + dcc_tab[coeff[0] + 255].len; |
bits += t = CodeCoeffIntra_CalcBits(coeff, scan_tables[0]) + dcc_tab[coeff[0] + 255].len; |
2749 |
if (t != 0) cbp |= 1 << (5 - 5); |
if (t != 0) cbp |= 1 << (5 - 5); |
2750 |
|
|
2751 |
bits += cbpy_tab[cbp>>2].len; |
bits += xvid_cbpy_tab[cbp>>2].len; |
2752 |
bits += mcbpc_inter_tab[(MODE_INTRA & 7) | ((cbp & 3) << 3)].len; |
bits += mcbpc_inter_tab[(MODE_INTRA & 7) | ((cbp & 3) << 3)].len; |
2753 |
} |
} |
2754 |
} |
} |