static __inline void
MBTrans8to16(const MBParam * const pParam,
const FRAMEINFO * const frame,
const MACROBLOCK * const pMB,
const uint32_t x_pos,
const uint32_t y_pos,
int16_t data[6 * 64])
{
uint32_t stride = pParam->edged_width;
uint32_t stride2 = stride / 2;
uint32_t next_block = stride * 8;
uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
const IMAGE * const pCurrent = &frame->image;
/* Image pointers */
pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
/* Do the transfer */
start_timer();
transfer_8to16copy(&data[0 * 64], pY_Cur, stride);
transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);
transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);
transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);
transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);
transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);
stop_transfer_timer();
}
static __inline void
MBTrans16to8(const MBParam * const pParam,
const FRAMEINFO * const frame,
const MACROBLOCK * const pMB,
const uint32_t x_pos,
const uint32_t y_pos,
int16_t data[6 * 64],
const uint32_t add, /* Must be 1 or 0 */
const uint8_t cbp)
{
uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
uint32_t stride = pParam->edged_width;
uint32_t stride2 = stride / 2;
uint32_t next_block = stride * 8;
const IMAGE * const pCurrent = &frame->image;
/* Array of function pointers, indexed by [add] */
transfer_operation_16to8_t * const functions[2] =
{
(transfer_operation_16to8_t*)transfer_16to8copy,
(transfer_operation_16to8_t*)transfer_16to8add,
};
transfer_operation_16to8_t *transfer_op = NULL;
/* Image pointers */
pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
if (pMB->field_dct) {
next_block = stride;
stride *= 2;
}
/* Operation function */
transfer_op = functions[add];
/* Do the operation */
start_timer();
if (cbp&32) transfer_op(pY_Cur, &data[0 * 64], stride);
if (cbp&16) transfer_op(pY_Cur + 8, &data[1 * 64], stride);
if (cbp& 8) transfer_op(pY_Cur + next_block, &data[2 * 64], stride);
if (cbp& 4) transfer_op(pY_Cur + next_block + 8, &data[3 * 64], stride);
if (cbp& 2) transfer_op(pU_Cur, &data[4 * 64], stride2);
if (cbp& 1) transfer_op(pV_Cur, &data[5 * 64], stride2);
stop_transfer_timer();
}
void
decoder_mbintra(DECODER * dec,
MACROBLOCK * pMB,
const uint32 x_pos,
const uint32 y_pos,
const uint32 acpred_flag,
const uint32 cbp,
Bitstream * bs,
const uint32 quant, const uint32 intra_dc_threshold)
{
uint32 stride = dec->edged_width;
uint32 stride2 = stride / 2;
uint32 next_block = stride * 8;
uint32 i,j;
uint32 iQuant = pMB->quant;
uint8 *pY_Cur, *pU_Cur, *pV_Cur;
pY_Cur = dec->cur.y + (y_pos << 4) * stride + (x_pos << 4);
pU_Cur = dec->cur.u + (y_pos << 3) * stride2 + (x_pos << 3);
pV_Cur = dec->cur.v + (y_pos << 3) * stride2 + (x_pos << 3);
memset(block, 0, 6 * 64 * sizeof(int16));
int16* tmpBlock = NULL;
for (i = 0; i < 6; i++)
{
uint32 iDcScaler = get_dc_scaler(iQuant, (i < 4) ? 1 : 0);
int16 predictors[8];
int start_coeff;
start_timer();
predict_acdc(dec->mbs, x_pos, y_pos, dec->mb_width, i,
&block[i * 64], iQuant, iDcScaler, predictors,
dec->slice);
if (!acpred_flag)
{
pMB->acpred_directions[i] = 0;
}
stop_prediction_timer();
if (quant < intra_dc_threshold)
{
int dc_size;
int dc_dif;
dc_size =
i < 4 ? get_dc_size_lum(bs) : get_dc_size_chrom(bs);
dc_dif = dc_size ? get_dc_dif(bs, dc_size) : 0;
if (dc_size > 8)
{
BitstreamSkip(bs, 1); // marker
}
block[i * 64] = dc_dif;
start_coeff = 1;
}
else
{
start_coeff = 0;
}
start_timer();
if (cbp & (1 << (5 - i))) // coded
{
get_intra_block(bs, &block[i * 64],
pMB->acpred_directions[i], start_coeff);
}
stop_coding_timer();
start_timer();
add_acdc(pMB, i, &block[i * 64], iDcScaler, predictors);
stop_prediction_timer();
start_timer();
dequant_intra(&data[i * 64], &block[i * 64], iQuant, iDcScaler);
stop_iquant_timer();
/*start_timer();
idct(&data[i * 64]);
stop_idct_timer();*/
if(tmpBlock!=NULL)
{
start_timer();
idct_dual(tmpBlock, &data[i * 64]);
stop_idct_timer();
tmpBlock = NULL;
}
else
{
tmpBlock = &data[i * 64];
}
}
start_timer();
transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
transfer_16to8copy(pY_Cur + 8 + next_block, &data[3 * 64], stride);
transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
stop_transfer_timer();
#if 0
printf("(%d,%d)\n",x_pos,y_pos);
printf("pY_Cur = [\n");
for (j = 0; j < 8; j++)
for (i = 0; i < 8; i++)
printf(((i+1)%8)? "%5d " : "%5d\n", pY_Cur[j * stride + i]);
printf("\n");
printf("pY_Cur + 8 = [\n");
for (j = 0; j < 8; j++)
for (i = 0; i < 8; i++)
printf(((i+1)%8)? "%5d " : "%5d\n", (pY_Cur+8)[j * stride + i]);
printf("\n");
printf("pY_Cur+ next_block = [\n");
for (j = 0; j < 8; j++)
for (i = 0; i < 8; i++)
printf(((i+1)%8)? "%5d " : "%5d\n", (pY_Cur+ next_block)[j * stride + i]);
printf("\n");
printf("pY_Cur+ next_block +8= [\n");
for (j = 0; j < 8; j++)
for (i = 0; i < 8; i++)
printf(((i+1)%8)? "%5d " : "%5d\n", (pY_Cur+ next_block+8)[j * stride + i]);
printf("\n");
#endif
}
