12 |
#include "../utils/timer.h" |
#include "../utils/timer.h" |
13 |
#include "motion.h" |
#include "motion.h" |
14 |
|
|
|
#ifndef ABS |
|
|
#define ABS(X) (((X)>0)?(X):-(X)) |
|
|
#endif |
|
|
#ifndef SIGN |
|
|
#define SIGN(X) (((X)>0)?1:-1) |
|
|
#endif |
|
|
|
|
15 |
#ifndef RSHIFT |
#ifndef RSHIFT |
16 |
#define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b)) |
#define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b)) |
17 |
#endif |
#endif |
166 |
} |
} |
167 |
} |
} |
168 |
|
|
|
|
|
|
static __inline void |
|
|
compensate16x16_interpolate_ro(int16_t * const dct_codes, |
|
|
const uint8_t * const cur, |
|
|
const uint8_t * const ref, |
|
|
const uint8_t * const refh, |
|
|
const uint8_t * const refv, |
|
|
const uint8_t * const refhv, |
|
|
uint8_t * const tmp, |
|
|
const uint32_t x, const uint32_t y, |
|
|
const int32_t dx, const int32_t dy, |
|
|
const int32_t stride, |
|
|
const int quarterpel) |
|
|
{ |
|
|
const uint8_t * ptr; |
|
|
|
|
|
if(quarterpel) { |
|
|
if ((dx&3) | (dy&3)) { |
|
|
interpolate16x16_quarterpel(tmp - y * stride - x, |
|
|
(uint8_t *) ref, tmp + 32, |
|
|
tmp + 64, tmp + 96, x, y, dx, dy, stride, 0); |
|
|
ptr = tmp; |
|
|
} else ptr = ref + (y + dy/4)*stride + x + dx/4; // fullpixel position |
|
|
|
|
|
} else ptr = get_ref(ref, refh, refv, refhv, x, y, 1, dx, dy, stride); |
|
|
|
|
|
transfer_8to16subro(dct_codes, cur + y * stride + x, |
|
|
ptr, stride); |
|
|
transfer_8to16subro(dct_codes+64, cur + y * stride + x + 8, |
|
|
ptr + 8, stride); |
|
|
transfer_8to16subro(dct_codes+128, cur + y * stride + x + 8*stride, |
|
|
ptr + 8*stride, stride); |
|
|
transfer_8to16subro(dct_codes+192, cur + y * stride + x + 8*stride+8, |
|
|
ptr + 8*stride + 8, stride); |
|
|
|
|
|
} |
|
|
|
|
|
|
|
169 |
/* XXX: slow, inelegant... */ |
/* XXX: slow, inelegant... */ |
170 |
static void |
static void |
171 |
interpolate18x18_switch(uint8_t * const cur, |
interpolate18x18_switch(uint8_t * const cur, |
250 |
int32_t dx; |
int32_t dx; |
251 |
int32_t dy; |
int32_t dy; |
252 |
|
|
|
|
|
253 |
uint8_t * const tmp = refv->u; |
uint8_t * const tmp = refv->u; |
254 |
|
|
255 |
if ( (!reduced_resolution) && (mb->mode == MODE_NOT_CODED) ) { /* quick copy for early SKIP */ |
if ( (!reduced_resolution) && (mb->mode == MODE_NOT_CODED) ) { /* quick copy for early SKIP */ |
311 |
refv->y, refhv->y, tmp, 16 * i, 16 * j, dx, dy, |
refv->y, refhv->y, tmp, 16 * i, 16 * j, dx, dy, |
312 |
edged_width, quarterpel, reduced_resolution, rounding); |
edged_width, quarterpel, reduced_resolution, rounding); |
313 |
|
|
314 |
dx /= (int)(1 + quarterpel); |
if (quarterpel) { dx /= 2; dy /= 2; } |
|
dy /= (int)(1 + quarterpel); |
|
315 |
|
|
316 |
dx = (dx >> 1) + roundtab_79[dx & 0x3]; |
dx = (dx >> 1) + roundtab_79[dx & 0x3]; |
317 |
dy = (dy >> 1) + roundtab_79[dy & 0x3]; |
dy = (dy >> 1) + roundtab_79[dy & 0x3]; |
323 |
for (k = 0; k < 4; k++) { |
for (k = 0; k < 4; k++) { |
324 |
dx = mvs[k].x; |
dx = mvs[k].x; |
325 |
dy = mvs[k].y; |
dy = mvs[k].y; |
326 |
sumx += dx / (1 + quarterpel); |
sumx += quarterpel ? dx/2 : dx; |
327 |
sumy += dy / (1 + quarterpel); |
sumy += quarterpel ? dy/2 : dy; |
328 |
|
|
329 |
if (reduced_resolution){ |
if (reduced_resolution){ |
330 |
dx = RRV_MV_SCALEUP(dx); |
dx = RRV_MV_SCALEUP(dx); |
363 |
const uint32_t edged_width = pParam->edged_width; |
const uint32_t edged_width = pParam->edged_width; |
364 |
int32_t dx, dy, b_dx, b_dy, sumx, sumy, b_sumx, b_sumy; |
int32_t dx, dy, b_dx, b_dy, sumx, sumy, b_sumx, b_sumy; |
365 |
int k; |
int k; |
366 |
const int quarterpel = pParam->vol_flags & XVID_QUARTERPEL; |
const int quarterpel = pParam->vol_flags & XVID_VOL_QUARTERPEL; |
367 |
const uint8_t * ptr1, * ptr2; |
const uint8_t * ptr1, * ptr2; |
368 |
uint8_t * const tmp = f_refv->u; |
uint8_t * const tmp = f_refv->u; |
369 |
const VECTOR * const fmvs = (quarterpel ? mb->qmvs : mb->mvs); |
const VECTOR * const fmvs = (quarterpel ? mb->qmvs : mb->mvs); |
389 |
case MODE_BACKWARD: |
case MODE_BACKWARD: |
390 |
b_dx = bmvs->x; b_dy = bmvs->y; |
b_dx = bmvs->x; b_dy = bmvs->y; |
391 |
|
|
392 |
compensate16x16_interpolate_ro(&dct_codes[0 * 64], cur->y, b_ref->y, b_refh->y, |
compensate16x16_interpolate(&dct_codes[0 * 64], cur->y, b_ref->y, b_refh->y, |
393 |
b_refv->y, b_refhv->y, tmp, 16 * i, 16 * j, b_dx, |
b_refv->y, b_refhv->y, tmp, 16 * i, 16 * j, b_dx, |
394 |
b_dy, edged_width, quarterpel); |
b_dy, edged_width, quarterpel, 0, 0); |
395 |
|
|
396 |
if (quarterpel) { b_dx /= 2; b_dy /= 2; } |
if (quarterpel) { b_dx /= 2; b_dy /= 2; } |
397 |
|
|
450 |
|
|
451 |
break; |
break; |
452 |
|
|
453 |
default: // MODE_DIRECT |
default: // MODE_DIRECT (or MODE_DIRECT_NONE_MV in case of bframes decoding) |
454 |
sumx = sumy = b_sumx = b_sumy = 0; |
sumx = sumy = b_sumx = b_sumy = 0; |
455 |
|
|
456 |
for (k = 0; k < 4; k++) { |
for (k = 0; k < 4; k++) { |
548 |
if (num_wp==2) { |
if (num_wp==2) { |
549 |
gmc->dyF = -gmc->dxG; |
gmc->dyF = -gmc->dxG; |
550 |
gmc->dyG = gmc->dxF; |
gmc->dyG = gmc->dxF; |
551 |
} |
} else if (num_wp==3) { |
|
else if (num_wp==3) { |
|
552 |
gmc->beta = log2bin(gmc->H-1); |
gmc->beta = log2bin(gmc->H-1); |
553 |
gmc->Hs = (1 << gmc->beta); |
gmc->Hs = (1 << gmc->beta); |
554 |
gmc->dyF = RDIV( 8*gmc->Hs*du2, gmc->H ); |
gmc->dyF = RDIV( 8*gmc->Hs*du2, gmc->H ); |
558 |
gmc->dxG <<= (gmc->beta - gmc->alpha); |
gmc->dxG <<= (gmc->beta - gmc->alpha); |
559 |
gmc->alpha = gmc->beta; |
gmc->alpha = gmc->beta; |
560 |
gmc->Ws = 1<< gmc->beta; |
gmc->Ws = 1<< gmc->beta; |
561 |
} |
} else { |
|
else { |
|
562 |
gmc->dyF <<= gmc->alpha - gmc->beta; |
gmc->dyF <<= gmc->alpha - gmc->beta; |
563 |
gmc->dyG <<= gmc->alpha - gmc->beta; |
gmc->dyG <<= gmc->alpha - gmc->beta; |
564 |
} |
} |
590 |
VECTOR avgMV; |
VECTOR avgMV; |
591 |
|
|
592 |
for (mj=0;mj<(unsigned int)mb_height;mj++) |
for (mj=0;mj<(unsigned int)mb_height;mj++) |
593 |
for (mi=0;mi<(unsigned int)mb_width; mi++) |
for (mi = 0; mi < (unsigned int)mb_width; mi++) { |
594 |
{ |
|
595 |
avgMV = generate_GMCimageMB(gmc_data, pRef, mi, mj, |
avgMV = generate_GMCimageMB(gmc_data, pRef, mi, mj, |
596 |
stride, stride2, quarterpel, rounding, pGMC); |
stride, stride2, quarterpel, rounding, pGMC); |
597 |
|
|
643 |
|
|
644 |
Fj = gmc_data->Fo + dyF*mj*16 + dxF*mi*16; |
Fj = gmc_data->Fo + dyF*mj*16 + dxF*mi*16; |
645 |
Gj = gmc_data->Go + dyG*mj*16 + dxG*mi*16; |
Gj = gmc_data->Go + dyG*mj*16 + dxG*mi*16; |
646 |
for (J=16; J>0; --J) |
|
647 |
{ |
for (J = 16; J > 0; --J) { |
648 |
int32_t Fi, Gi; |
int32_t Fi, Gi; |
649 |
|
|
650 |
Fi = Fj; Fj += dyF; |
Fi = Fj; Fj += dyF; |
651 |
Gi = Gj; Gj += dyG; |
Gi = Gj; Gj += dyG; |
652 |
for (I=-16; I<0; ++I) |
for (I = -16; I < 0; ++I) { |
|
{ |
|
653 |
int32_t F, G; |
int32_t F, G; |
654 |
uint32_t ri, rj; |
uint32_t ri, rj; |
655 |
|
|
685 |
dstY[I] = (uint8_t)f0; |
dstY[I] = (uint8_t)f0; |
686 |
} |
} |
687 |
} |
} |
688 |
|
|
689 |
dstY += stride; |
dstY += stride; |
690 |
} |
} |
691 |
|
|
694 |
|
|
695 |
Fj = gmc_data->cFo + dyF*4 *mj*8 + dxF*4 *mi*8; |
Fj = gmc_data->cFo + dyF*4 *mj*8 + dxF*4 *mi*8; |
696 |
Gj = gmc_data->cGo + dyG*4 *mj*8 + dxG*4 *mi*8; |
Gj = gmc_data->cGo + dyG*4 *mj*8 + dxG*4 *mi*8; |
697 |
for (J=8; J>0; --J) |
|
698 |
{ |
for (J = 8; J > 0; --J) { |
699 |
int32_t Fi, Gi; |
int32_t Fi, Gi; |
700 |
Fi = Fj; Fj += 4*dyF; |
Fi = Fj; Fj += 4*dyF; |
701 |
Gi = Gj; Gj += 4*dyG; |
Gi = Gj; Gj += 4*dyG; |
702 |
|
|
703 |
for (I=-8; I<0; ++I) |
for (I = -8; I < 0; ++I) { |
|
{ |
|
704 |
int32_t F, G; |
int32_t F, G; |
705 |
uint32_t ri, rj; |
uint32_t ri, rj; |
706 |
|
|
870 |
return; |
return; |
871 |
} |
} |
872 |
|
|
|
|
|
|
|
|
873 |
void |
void |
874 |
generate_GMCimage( const GMC_DATA *const gmc_data, // [input] precalculated data |
generate_GMCimage( const GMC_DATA *const gmc_data, // [input] precalculated data |
875 |
const IMAGE *const pRef, // [input] |
const IMAGE *const pRef, // [input] |
889 |
VECTOR avgMV; |
VECTOR avgMV; |
890 |
|
|
891 |
for (mj=0;mj<mb_height;mj++) |
for (mj=0;mj<mb_height;mj++) |
892 |
for (mi=0;mi<mb_width; mi++) |
for (mi = 0;mi < mb_width; mi++) { |
893 |
{ |
|
894 |
avgMV = generate_GMCimageMB(gmc_data, pRef, mi, mj, |
avgMV = generate_GMCimageMB(gmc_data, pRef, mi, mj, |
895 |
stride, stride2, quarterpel, rounding, pGMC); |
stride, stride2, quarterpel, rounding, pGMC); |
896 |
|
|