steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/h264dec/ldecod/src/mb_prediction.c

980 lines
38 KiB
C
Raw Blame History

/*!
*************************************************************************************
* \file mb_prediction.c
*
* \brief
* Macroblock prediction functions
*
* \author
* Main contributors (see contributors.h for copyright, address and affiliation details)
* - Alexis Michael Tourapis <alexismt@ieee.org>
*************************************************************************************
*/
#include "contributors.h"
#include "block.h"
#include "global.h"
#include "mbuffer.h"
#include "elements.h"
#include "errorconcealment.h"
#include "macroblock.h"
#include "fmo.h"
#include "cabac.h"
#include "vlc.h"
#include "image.h"
#include "mb_access.h"
#include "biaridecod.h"
#include "transform8x8.h"
#include "transform.h"
#include "mc_prediction.h"
#include "quant.h"
#include "intra4x4_pred.h"
#include "intra8x8_pred.h"
#include "intra16x16_pred.h"
#include "mv_prediction.h"
#include "mb_prediction.h"
#include "optim.h"
int mb_pred_intra4x4(Macroblock *currMB, ColorPlane curr_plane, VideoImage *image, StorablePicture *dec_picture)
{
Slice *currSlice = currMB->p_Slice;
int yuv = dec_picture->chroma_format_idc - 1;
if (currMB->is_lossless == FALSE)
{
const h264_short_block_t *blocks = currSlice->cof4[curr_plane];
const h264_imgpel_macroblock_row_t *mb_pred=currSlice->mb_pred[curr_plane];
h264_imgpel_macroblock_row_t *mb_rec = currSlice->mb_rec[curr_plane];
int block_x = currMB->block_x;
int block_y = currMB->block_y;
if (intrapred(currMB, curr_plane, 0,0,block_x + 0,block_y + 0) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[0], mb_pred, mb_rec, 0, 0);
copy_image_data_4x4_stride(image, (block_x + 0)<<2, (block_y + 0)<<2, currSlice->mb_rec[curr_plane], 0, 0);
if (intrapred(currMB, curr_plane, 4,0,block_x + 1,block_y + 0) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[1], mb_pred, mb_rec, 4, 0);
copy_image_data_4x4_stride(image, (block_x + 1)<<2, (block_y + 0)<<2, currSlice->mb_rec[curr_plane], 4, 0);
if (intrapred(currMB, curr_plane, 0,4,block_x + 0,block_y + 1) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[2], mb_pred, mb_rec, 0, 4);
copy_image_data_4x4_stride(image, (block_x + 0)<<2, (block_y + 1)<<2, currSlice->mb_rec[curr_plane], 0, 4);
if (intrapred(currMB, curr_plane, 4,4,block_x + 1,block_y + 1) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[3], mb_pred, mb_rec, 4, 4);
copy_image_data_4x4_stride(image, (block_x + 1)<<2, (block_y + 1)<<2, currSlice->mb_rec[curr_plane], 4, 4);
if (intrapred(currMB, curr_plane, 8,0,block_x + 2,block_y + 0) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[4], mb_pred, mb_rec, 8, 0);
copy_image_data_4x4_stride(image, (block_x + 2)<<2, (block_y + 0)<<2, currSlice->mb_rec[curr_plane], 8, 0);
if (intrapred(currMB, curr_plane, 12,0,block_x + 3,block_y + 0) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[5], mb_pred, mb_rec, 12, 0);
copy_image_data_4x4_stride(image, (block_x + 3)<<2, (block_y + 0)<<2, currSlice->mb_rec[curr_plane], 12, 0);
if (intrapred(currMB, curr_plane, 8,4,block_x + 2,block_y + 1) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[6], mb_pred, mb_rec, 8, 4);
copy_image_data_4x4_stride(image, (block_x + 2)<<2, (block_y + 1)<<2, currSlice->mb_rec[curr_plane], 8, 4);
if (intrapred(currMB, curr_plane, 12,4,block_x + 3,block_y + 1) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[7], mb_pred, mb_rec, 12, 4);
copy_image_data_4x4_stride(image, (block_x + 3)<<2, (block_y + 1)<<2, currSlice->mb_rec[curr_plane], 12, 4);
if (intrapred(currMB, curr_plane, 0,8,block_x + 0,block_y + 2) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[8], mb_pred, mb_rec, 0, 8);
copy_image_data_4x4_stride(image, (block_x + 0)<<2, (block_y + 2)<<2, currSlice->mb_rec[curr_plane], 0, 8);
if (intrapred(currMB, curr_plane, 4,8,block_x + 1,block_y + 2) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[9], mb_pred, mb_rec, 4, 8);
copy_image_data_4x4_stride(image, (block_x + 1)<<2, (block_y + 2)<<2, currSlice->mb_rec[curr_plane], 4, 8);
if (intrapred(currMB, curr_plane, 0,12,block_x + 0,block_y + 3) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[10], mb_pred, mb_rec, 0, 12);
copy_image_data_4x4_stride(image, (block_x + 0)<<2, (block_y + 3)<<2, currSlice->mb_rec[curr_plane], 0, 12);
if (intrapred(currMB, curr_plane, 4,12,block_x + 1,block_y + 3) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[11], mb_pred, mb_rec, 4, 12);
copy_image_data_4x4_stride(image, (block_x + 1)<<2, (block_y + 3)<<2, currSlice->mb_rec[curr_plane], 4, 12);
if (intrapred(currMB, curr_plane, 8,8,block_x + 2,block_y + 2) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[12], mb_pred, mb_rec, 8, 8);
copy_image_data_4x4_stride(image, (block_x + 2)<<2, (block_y + 2)<<2, currSlice->mb_rec[curr_plane], 8, 8);
if (intrapred(currMB, curr_plane, 12,8,block_x + 3,block_y + 2) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[13], mb_pred, mb_rec, 12, 8);
copy_image_data_4x4_stride(image, (block_x + 3)<<2, (block_y + 2)<<2, currSlice->mb_rec[curr_plane], 12, 8);
if (intrapred(currMB, curr_plane, 8,12,block_x + 2,block_y + 3) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[14], mb_pred, mb_rec, 8, 12);
copy_image_data_4x4_stride(image, (block_x + 2)<<2, (block_y + 3)<<2, currSlice->mb_rec[curr_plane], 8, 12);
if (intrapred(currMB, curr_plane, 12,12,block_x + 3,block_y + 3) == SEARCH_SYNC) return SEARCH_SYNC;
opt_itrans4x4(blocks[15], mb_pred, mb_rec, 12, 12);
copy_image_data_4x4_stride(image, (block_x + 3)<<2, (block_y + 3)<<2, currSlice->mb_rec[curr_plane], 12, 12);
// benski> prediction might reference other parts of the image reconstructed during this block, so can't just do a single 16x16 image copy
}
else
{ // lossless
h264_imgpel_macroblock_row_t *mb_rec = currSlice->mb_rec[curr_plane];
int block_x = currMB->block_x;
int block_y = currMB->block_y;
if (intrapred(currMB, curr_plane, 0,0,block_x + 0,block_y + 0) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 0, 0);
copy_image_data_4x4_stride(image, (block_x + 0)<<2, (block_y + 0)<<2, currSlice->mb_rec[curr_plane], 0, 0);
if (intrapred(currMB, curr_plane, 4,0,block_x + 1,block_y + 0) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 4, 0);
copy_image_data_4x4_stride(image, (block_x + 1)<<2, (block_y + 0)<<2, currSlice->mb_rec[curr_plane], 4, 0);
if (intrapred(currMB, curr_plane, 0,4,block_x + 0,block_y + 1) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 0, 4);
copy_image_data_4x4_stride(image, (block_x + 0)<<2, (block_y + 1)<<2, currSlice->mb_rec[curr_plane], 0, 4);
if (intrapred(currMB, curr_plane, 4,4,block_x + 1,block_y + 1) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 4, 4);
copy_image_data_4x4_stride(image, (block_x + 1)<<2, (block_y + 1)<<2, currSlice->mb_rec[curr_plane], 4, 4);
if (intrapred(currMB, curr_plane, 8,0,block_x + 2,block_y + 0) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 8, 0);
copy_image_data_4x4_stride(image, (block_x + 2)<<2, (block_y + 0)<<2, currSlice->mb_rec[curr_plane], 8, 0);
if (intrapred(currMB, curr_plane, 12,0,block_x + 3,block_y + 0) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 12, 0);
copy_image_data_4x4_stride(image, (block_x + 3)<<2, (block_y + 0)<<2, currSlice->mb_rec[curr_plane], 12, 0);
if (intrapred(currMB, curr_plane, 8,4,block_x + 2,block_y + 1) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 8, 4);
copy_image_data_4x4_stride(image, (block_x + 2)<<2, (block_y + 1)<<2, currSlice->mb_rec[curr_plane], 8, 4);
if (intrapred(currMB, curr_plane, 12,4,block_x + 3,block_y + 1) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 12, 4);
copy_image_data_4x4_stride(image, (block_x + 3)<<2, (block_y + 1)<<2, currSlice->mb_rec[curr_plane], 12, 4);
if (intrapred(currMB, curr_plane, 0,8,block_x + 0,block_y + 2) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 0, 8);
copy_image_data_4x4_stride(image, (block_x + 0)<<2, (block_y + 2)<<2, currSlice->mb_rec[curr_plane], 0, 8);
if (intrapred(currMB, curr_plane, 4,8,block_x + 1,block_y + 2) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 4, 8);
copy_image_data_4x4_stride(image, (block_x + 1)<<2, (block_y + 2)<<2, currSlice->mb_rec[curr_plane], 4, 8);
if (intrapred(currMB, curr_plane, 0,12,block_x + 0,block_y + 3) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 0, 12);
copy_image_data_4x4_stride(image, (block_x + 0)<<2, (block_y + 3)<<2, currSlice->mb_rec[curr_plane], 0, 12);
if (intrapred(currMB, curr_plane, 4,12,block_x + 1,block_y + 3) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 4, 12);
copy_image_data_4x4_stride(image, (block_x + 1)<<2, (block_y + 3)<<2, currSlice->mb_rec[curr_plane], 4, 12);
if (intrapred(currMB, curr_plane, 8,8,block_x + 2,block_y + 2) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 8, 8);
copy_image_data_4x4_stride(image, (block_x + 2)<<2, (block_y + 2)<<2, currSlice->mb_rec[curr_plane], 8, 8);
if (intrapred(currMB, curr_plane, 12,8,block_x + 3,block_y + 2) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 12, 8);
copy_image_data_4x4_stride(image, (block_x + 3)<<2, (block_y + 2)<<2, currSlice->mb_rec[curr_plane], 12, 8);
if (intrapred(currMB, curr_plane, 8,12,block_x + 2,block_y + 3) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 8, 12);
copy_image_data_4x4_stride(image, (block_x + 2)<<2, (block_y + 3)<<2, currSlice->mb_rec[curr_plane], 8, 12);
if (intrapred(currMB, curr_plane, 12,12,block_x + 3,block_y + 3) == SEARCH_SYNC) return SEARCH_SYNC;
Inv_Residual_trans_4x4(currMB, curr_plane, 12, 12);
copy_image_data_4x4_stride(image, (block_x + 3)<<2, (block_y + 3)<<2, currSlice->mb_rec[curr_plane], 12, 12);
// benski> prediction might reference other parts of the image reconstructed during this block, so can't just do a single 16x16 image copy
}
// chroma decoding *******************************************************
if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444))
{
intra_cr_decoding(currMB, yuv);
}
return 1;
}
int mb_pred_intra16x16(Macroblock *currMB, ColorPlane curr_plane, VideoImage *image, StorablePicture *dec_picture)
{
int yuv = dec_picture->chroma_format_idc - 1;
intrapred16x16(currMB, curr_plane, currMB->i16mode);
currMB->ipmode_DPCM = (char) currMB->i16mode; //For residual DPCM
// =============== 4x4 itrans ================
// -------------------------------------------
iMBtrans4x4(currMB, curr_plane, 0);
// chroma decoding *******************************************************
if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444))
{
intra_cr_decoding(currMB, yuv);
}
return 1;
}
int mb_pred_intra8x8(Macroblock *currMB, ColorPlane curr_plane, VideoImage *image, StorablePicture *dec_picture)
{
Slice *currSlice = currMB->p_Slice;
int yuv = dec_picture->chroma_format_idc - 1;
if (currMB->is_lossless)
{
//PREDICTION
intrapred8x8(currMB, curr_plane, 0, 0);
Inv_Residual_trans_8x8(currMB, curr_plane, 0,0); // use DCT transform and make 8x8 block m7 from prediction block mpr
copy_image_data_8x8_stride2(image, currMB->pix_x + 0 ,currMB->pix_y + 0, currSlice->mb_rec[curr_plane], 0, 0);
intrapred8x8(currMB, curr_plane, 8, 0);
Inv_Residual_trans_8x8(currMB, curr_plane, 8,0); // use DCT transform and make 8x8 block m7 from prediction block mpr
copy_image_data_8x8_stride2(image, currMB->pix_x + 8 ,currMB->pix_y + 0, currSlice->mb_rec[curr_plane], 8, 0);
intrapred8x8(currMB, curr_plane, 0, 8);
Inv_Residual_trans_8x8(currMB, curr_plane, 0,8); // use DCT transform and make 8x8 block m7 from prediction block mpr
copy_image_data_8x8_stride2(image, currMB->pix_x + 0 ,currMB->pix_y + 8, currSlice->mb_rec[curr_plane], 0, 8);
intrapred8x8(currMB, curr_plane, 8, 8);
Inv_Residual_trans_8x8 (currMB, curr_plane, 8,8); // use DCT transform and make 8x8 block m7 from prediction block mpr
copy_image_data_8x8_stride2(image, currMB->pix_x + 8 ,currMB->pix_y + 8, currSlice->mb_rec[curr_plane], 8, 8);
}
else
{
h264_imgpel_macroblock_row_t *mb_rec = currSlice->mb_rec[curr_plane];
h264_imgpel_macroblock_row_t *mb_pred = currSlice->mb_pred[curr_plane];
h264_short_8x8block_t *mb_rres8 = currSlice->mb_rres8[curr_plane];
//PREDICTION
intrapred8x8(currMB, curr_plane, 0, 0);
opt_itrans8x8(mb_rec, mb_pred, mb_rres8[0], 0); // use DCT transform and make 8x8 block m7 from prediction block mpr
copy_image_data_8x8_stride2(image, currMB->pix_x + 0 ,currMB->pix_y + 0, currSlice->mb_rec[curr_plane], 0, 0);
intrapred8x8(currMB, curr_plane, 8, 0);
opt_itrans8x8(mb_rec, mb_pred, mb_rres8[1], 8); // use DCT transform and make 8x8 block m7 from prediction block mpr
copy_image_data_8x8_stride2(image, currMB->pix_x + 8 ,currMB->pix_y + 0, currSlice->mb_rec[curr_plane], 8, 0);
intrapred8x8(currMB, curr_plane, 0, 8);
opt_itrans8x8(mb_rec+8, mb_pred+8, mb_rres8[2], 0); // use DCT transform and make 8x8 block m7 from prediction block mpr
copy_image_data_8x8_stride2(image, currMB->pix_x + 0 ,currMB->pix_y + 8, currSlice->mb_rec[curr_plane], 0, 8);
intrapred8x8(currMB, curr_plane, 8, 8);
opt_itrans8x8(mb_rec+8, mb_pred+8, mb_rres8[3], 8); // use DCT transform and make 8x8 block m7 from prediction block mpr
copy_image_data_8x8_stride2(image, currMB->pix_x + 8 ,currMB->pix_y + 8, currSlice->mb_rec[curr_plane], 8, 8);
}
// chroma decoding *******************************************************
if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444))
{
intra_cr_decoding(currMB, yuv);
}
return 1;
}
static void set_chroma_vector(Macroblock *currMB, int *list_offset)
{
Slice *currSlice = currMB->p_Slice;
VideoParameters *p_Vid = currMB->p_Vid;
if (!currSlice->mb_aff_frame_flag)
{
if(p_Vid->structure == TOP_FIELD)
{
int k,l;
for (l = LIST_0; l <= (LIST_1); l++)
{
for(k = 0; k < p_Vid->listXsize[l]; k++)
{
if(p_Vid->structure != p_Vid->listX[l][k]->structure)
p_Vid->listX[l][k]->chroma_vector_adjustment = -2;
else
p_Vid->listX[l][k]->chroma_vector_adjustment= 0;
}
}
}
else if(p_Vid->structure == BOTTOM_FIELD)
{
int k,l;
for (l = LIST_0; l <= (LIST_1); l++)
{
for(k = 0; k < p_Vid->listXsize[l]; k++)
{
if (p_Vid->structure != p_Vid->listX[l][k]->structure)
p_Vid->listX[l][k]->chroma_vector_adjustment = 2;
else
p_Vid->listX[l][k]->chroma_vector_adjustment= 0;
}
}
}
else
{
int k,l;
for (l = LIST_0; l <= (LIST_1); l++)
{
for(k = 0; k < p_Vid->listXsize[l]; k++)
{
p_Vid->listX[l][k]->chroma_vector_adjustment= 0;
}
}
}
}
else
{
int mb_nr = (currMB->mbAddrX & 0x01);
int k,l;
//////////////////////////
// find out the correct list offsets
if (currMB->mb_field)
{
*list_offset = mb_nr ? 4 : 2;
for (l = LIST_0 + *list_offset; l <= (LIST_1 + *list_offset); l++)
{
for(k = 0; k < p_Vid->listXsize[l]; k++)
{
if(mb_nr == 0 && p_Vid->listX[l][k]->structure == BOTTOM_FIELD)
p_Vid->listX[l][k]->chroma_vector_adjustment = -2;
else if(mb_nr == 1 && p_Vid->listX[l][k]->structure == TOP_FIELD)
p_Vid->listX[l][k]->chroma_vector_adjustment = 2;
else
p_Vid->listX[l][k]->chroma_vector_adjustment= 0;
}
}
}
else
{
for (l = LIST_0; l <= (LIST_1); l++)
{
for(k = 0; k < p_Vid->listXsize[l]; k++)
{
p_Vid->listX[l][k]->chroma_vector_adjustment= 0;
}
}
}
}
p_Vid->max_mb_vmv_r = (p_Vid->structure != FRAME || (currSlice->mb_aff_frame_flag && currMB->mb_field)) ? p_Vid->max_vmv_r >> 1 : p_Vid->max_vmv_r;
}
void mb_pred_skip(Macroblock *currMB, ColorPlane curr_plane, VideoImage *image, StorablePicture *dec_picture)
{
Slice *currSlice = currMB->p_Slice;
VideoParameters *p_Vid = currMB->p_Vid;
int curr_mb_field = ((currSlice->mb_aff_frame_flag)&&(currMB->mb_field));
int list_offset = 0;
set_chroma_vector(currMB, &list_offset);
perform_mc16x16(currMB, curr_plane, dec_picture, LIST_0, list_offset, curr_mb_field);
opt_copy_image_data_16x16_stride(image, currMB->pix_x, currMB->pix_y, currSlice->mb_pred[curr_plane]);
if (dec_picture->chroma_format_idc == YUV420)
{
copy_image_data_8x8_stride(dec_picture->imgUV[0], currMB->pix_c_x, currMB->pix_c_y, currSlice->mb_pred[1]);
copy_image_data_8x8_stride(dec_picture->imgUV[1], currMB->pix_c_x, currMB->pix_c_y, currSlice->mb_pred[2]);
}
else if (dec_picture->chroma_format_idc == YUV422)
{
copy_image_data_stride(dec_picture->imgUV[0], currMB->pix_c_x, currMB->pix_c_y, currSlice->mb_pred[1], 8, 16);
copy_image_data_stride(dec_picture->imgUV[1], currMB->pix_c_x, currMB->pix_c_y, currSlice->mb_pred[2], 8, 16);
}
}
void mb_pred_sp_skip(Macroblock *currMB, ColorPlane curr_plane, VideoImage *image, StorablePicture *dec_picture)
{
Slice *currSlice = currMB->p_Slice;
int curr_mb_field = ((currSlice->mb_aff_frame_flag)&&(currMB->mb_field));
int list_offset = 0;
set_chroma_vector(currMB, &list_offset);
perform_mc16x16(currMB, curr_plane, dec_picture, LIST_0, list_offset, curr_mb_field);
iTransform(currMB, curr_plane, 1);
}
void mb_pred_p_inter8x8(Macroblock *currMB, ColorPlane curr_plane, VideoImage *image, StorablePicture *dec_picture)
{
int block8x8; // needed for ABT
int i=0, j=0,k;
Slice *currSlice = currMB->p_Slice;
VideoParameters *p_Vid = currMB->p_Vid;
int smb = p_Vid->type == SP_SLICE && IS_INTER(currMB);
int curr_mb_field = ((currSlice->mb_aff_frame_flag)&&(currMB->mb_field));
int list_offset = 0;
set_chroma_vector(currMB, &list_offset);
for (block8x8=0; block8x8<4; block8x8++)
{
int mv_mode = currMB->b8mode[block8x8];
int pred_dir = currMB->b8pdir[block8x8];
if (mv_mode == SMB8x8)
{
i = (decode_block_scan[block8x8*4] & 3);
j = block8x8 & ~1;
perform_mc8x8(currMB, curr_plane, dec_picture, pred_dir, i, j, list_offset, curr_mb_field);
}
else if (mv_mode == SMB4x4)
{
int k_start = (block8x8 << 2);
int k_inc = (mv_mode == SMB8x4) ? 2 : 1;
int k_end = (mv_mode == SMB8x8) ? k_start + 1 : ((mv_mode == SMB4x4) ? k_start + 4 : k_start + k_inc + 1);
int block_size_x = (mv_mode == SMB8x4) ? SMB_BLOCK_SIZE : BLOCK_SIZE;
int block_size_y = (mv_mode == SMB4x8) ? SMB_BLOCK_SIZE : BLOCK_SIZE;
for (k = k_start; k < k_end; k += k_inc)
{
i = (decode_block_scan[k] & 3);
j = ((decode_block_scan[k] >> 2) & 3);
perform_mc(currMB, curr_plane, dec_picture, pred_dir, i, j, list_offset, block_size_x, block_size_y, curr_mb_field);
}
}
else
{
int k_start = (block8x8 << 2);
int k_inc = (mv_mode == SMB8x4) ? 2 : 1;
int k_end = k_start + k_inc + 1;
int block_size_x = (mv_mode == SMB8x4) ? SMB_BLOCK_SIZE : BLOCK_SIZE;
int block_size_y = (mv_mode == SMB4x8) ? SMB_BLOCK_SIZE : BLOCK_SIZE;
for (k = k_start; k < k_end; k += k_inc)
{
i = (decode_block_scan[k] & 3);
j = ((decode_block_scan[k] >> 2) & 3);
perform_mc(currMB, curr_plane, dec_picture, pred_dir, i, j, list_offset, block_size_x, block_size_y, curr_mb_field);
}
}
/* generic:
int k_start = (block8x8 << 2);
int k_inc = (mv_mode == SMB8x4) ? 2 : 1;
int k_end = (mv_mode == SMB8x8) ? k_start + 1 : ((mv_mode == SMB4x4) ? k_start + 4 : k_start + k_inc + 1);
int block_size_x = ( mv_mode == SMB8x4 || mv_mode == SMB8x8 ) ? SMB_BLOCK_SIZE : BLOCK_SIZE;
int block_size_y = ( mv_mode == SMB4x8 || mv_mode == SMB8x8 ) ? SMB_BLOCK_SIZE : BLOCK_SIZE;
for (k = k_start; k < k_end; k += k_inc)
{
i = (decode_block_scan[k] & 3);
j = ((decode_block_scan[k] >> 2) & 3);
perform_mc(currMB, curr_plane, dec_picture, pred_dir, i, j, list_offset, block_size_x, block_size_y, curr_mb_field);
}
*/
}
iTransform(currMB, curr_plane, smb);
}
void mb_pred_p_inter16x16(Macroblock *currMB, ColorPlane curr_plane, VideoImage *image, StorablePicture *dec_picture)
{
int smb = (currMB->p_Vid->type == SP_SLICE);
Slice *currSlice = currMB->p_Slice;
int curr_mb_field = ((currSlice->mb_aff_frame_flag)&&(currMB->mb_field));
int list_offset = 0;
set_chroma_vector(currMB, &list_offset);
perform_mc16x16(currMB, curr_plane, dec_picture, currMB->b8pdir[0], list_offset, curr_mb_field);
iTransform(currMB, curr_plane, smb);
}
void mb_pred_p_inter16x8(Macroblock *currMB, ColorPlane curr_plane, VideoImage *image, StorablePicture *dec_picture)
{
int smb = (currMB->p_Vid->type == SP_SLICE);
Slice *currSlice = currMB->p_Slice;
int curr_mb_field = ((currSlice->mb_aff_frame_flag)&&(currMB->mb_field));
int list_offset = 0;
set_chroma_vector(currMB, &list_offset);
perform_mc16x8(currMB, curr_plane, dec_picture, currMB->b8pdir[0], 0, 0, list_offset, curr_mb_field);
perform_mc16x8(currMB, curr_plane, dec_picture, currMB->b8pdir[2], 0, 2, list_offset, curr_mb_field);
iTransform(currMB, curr_plane, smb);
}
void mb_pred_p_inter8x16(Macroblock *currMB, ColorPlane curr_plane, VideoImage *image, StorablePicture *dec_picture)
{
int smb = (currMB->p_Vid->type == SP_SLICE);
Slice *currSlice = currMB->p_Slice;
int curr_mb_field = ((currSlice->mb_aff_frame_flag)&&(currMB->mb_field));
int list_offset = 0;
set_chroma_vector(currMB, &list_offset);
perform_mc8x16(currMB, curr_plane, dec_picture, currMB->b8pdir[0], 0, 0, list_offset, curr_mb_field);
perform_mc8x16(currMB, curr_plane, dec_picture, currMB->b8pdir[1], 2, 0, list_offset, curr_mb_field);
iTransform(currMB, curr_plane, smb);
}
void mb_pred_b_dtemporal(Macroblock *currMB, ColorPlane curr_plane, VideoImage *image, StorablePicture *dec_picture)
{
short ref_idx;
int refList;
PicMotionParams *motion = &dec_picture->motion;
int k;
int block8x8; // needed for ABT
Slice *currSlice = currMB->p_Slice;
VideoParameters *p_Vid = currMB->p_Vid;
int curr_mb_field = ((currSlice->mb_aff_frame_flag)&&(currMB->mb_field));
MotionParams *colocated = &currSlice->p_colocated->frame;
int list_offset = 0;
set_chroma_vector(currMB, &list_offset);
if (currMB->mb_field)
{
if(currMB->mbAddrX & 0x01)
{
colocated = &currSlice->p_colocated->bottom;
}
else
{
colocated = &currSlice->p_colocated->top;
}
}
for (block8x8=0; block8x8<4; block8x8++)
{
int pred_dir = currMB->b8pdir[block8x8];
int k_start = (block8x8 << 2);
int k_end = k_start;
if (p_Vid->active_sps->direct_8x8_inference_flag)
{
k_end ++;
}
else
{
k_end += BLOCK_MULTIPLE;
}
for (k = k_start; k < k_start + BLOCK_MULTIPLE; k ++)
{
int i = (decode_block_scan[k] & 3);
int j = ((decode_block_scan[k] >> 2) & 3);
int i4 = currMB->block_x + i;
int j4 = currMB->block_y + j;
int j6 = currMB->block_y_aff + j;
assert (pred_dir<=2);
refList = (colocated->motion[LIST_0][j6][i4].ref_idx== -1 ? LIST_1 : LIST_0);
ref_idx = colocated->motion[refList][j6][i4].ref_idx;
if(ref_idx==-1) // co-located is intra mode
{
memset( &motion->motion[LIST_0][j4][i4].mv, 0, sizeof(MotionVector));
memset( &motion->motion[LIST_1][j4][i4].mv, 0, sizeof(MotionVector));
motion->motion[LIST_0][j4][i4].ref_idx = 0;
motion->motion[LIST_1][j4][i4].ref_idx = 0;
}
else // co-located skip or inter mode
{
int mapped_idx=0;
int iref;
for (iref=0;iref<imin(currSlice->num_ref_idx_l0_active,p_Vid->listXsize[LIST_0 + list_offset]);iref++)
{
if(p_Vid->structure==0 && curr_mb_field==0)
{
// If the current MB is a frame MB and the colocated is from a field picture,
// then the colocated->ref_pic_id may have been generated from the wrong value of
// frame_poc if it references it's complementary field, so test both POC values
if(p_Vid->listX[0][iref]->top_poc*2 == colocated->motion[refList][j6][i4].ref_pic_id || p_Vid->listX[0][iref]->bottom_poc*2 == colocated->motion[refList][j6][i4].ref_pic_id)
{
mapped_idx=iref;
break;
}
else //! invalid index. Default to zero even though this case should not happen
mapped_idx=INVALIDINDEX;
continue;
}
if (dec_picture->ref_pic_num[p_Vid->current_slice_nr][LIST_0 + list_offset][iref]==colocated->motion[refList][j6][i4].ref_pic_id)
{
mapped_idx=iref;
break;
}
else //! invalid index. Default to zero even though this case should not happen
{
mapped_idx=INVALIDINDEX;
}
}
if (INVALIDINDEX == mapped_idx)
{
error("temporal direct error: colocated block has ref that is unavailable",-1111);
}
else
{
int mv_scale = currSlice->mvscale[LIST_0 + list_offset][mapped_idx];
//! In such case, an array is needed for each different reference.
if (mv_scale == 9999 || p_Vid->listX[LIST_0+list_offset][mapped_idx]->is_long_term)
{
memcpy(&motion->motion[LIST_0][j4][i4].mv, &colocated->motion[refList][j6][i4].mv, sizeof(MotionVector));
memset(&motion->motion[LIST_1][j4][i4].mv, 0, sizeof(MotionVector));
}
else
{
motion->motion[LIST_0][j4][i4].mv[0]= (short) ((mv_scale * colocated->motion[refList][j6][i4].mv[0] + 128 ) >> 8);
motion->motion[LIST_0][j4][i4].mv[1]= (short) ((mv_scale * colocated->motion[refList][j6][i4].mv[1] + 128 ) >> 8);
motion->motion[LIST_1][j4][i4].mv[0]= (short) (motion->motion[LIST_0][j4][i4].mv[0] - colocated->motion[refList][j6][i4].mv[0]);
motion->motion[LIST_1][j4][i4].mv[1]= (short) (motion->motion[LIST_0][j4][i4].mv[1] - colocated->motion[refList][j6][i4].mv[1]);
}
motion->motion[LIST_0][j4][i4].ref_idx = (char) mapped_idx; //p_Vid->listX[1][0]->ref_idx[refList][j4][i4];
motion->motion[LIST_1][j4][i4].ref_idx = 0;
}
}
// store reference picture ID determined by direct mode
motion->motion[LIST_0][j4][i4].ref_pic_id = dec_picture->ref_pic_num[p_Vid->current_slice_nr][LIST_0 + list_offset][(short)motion->motion[LIST_0][j4][i4].ref_idx];
motion->motion[LIST_1][j4][i4].ref_pic_id = dec_picture->ref_pic_num[p_Vid->current_slice_nr][LIST_1 + list_offset][(short)motion->motion[LIST_1][j4][i4].ref_idx];
}
for (k = k_start; k < k_end; k ++)
{
int i = (decode_block_scan[k] & 3);
int j = ((decode_block_scan[k] >> 2) & 3);
if (p_Vid->active_sps->direct_8x8_inference_flag)
perform_mc8x8(currMB, curr_plane, dec_picture, pred_dir, i, j, list_offset, curr_mb_field);
else
perform_mc(currMB, curr_plane, dec_picture, pred_dir, i, j, list_offset, 4, 4, curr_mb_field);
}
}
if (currMB->cbp == 0)
{
opt_copy_image_data_16x16_stride(image, currMB->pix_x, currMB->pix_y, currSlice->mb_pred[curr_plane]);
if ((dec_picture->chroma_format_idc != YUV400) && (dec_picture->chroma_format_idc != YUV444))
{
copy_image_data_stride(dec_picture->imgUV[0], currMB->pix_c_x, currMB->pix_c_y, currSlice->mb_pred[1], p_Vid->mb_size[IS_CHROMA][0], p_Vid->mb_size[IS_CHROMA][1]);
copy_image_data_stride(dec_picture->imgUV[1], currMB->pix_c_x, currMB->pix_c_y, currSlice->mb_pred[2], p_Vid->mb_size[IS_CHROMA][0], p_Vid->mb_size[IS_CHROMA][1]);
}
}
else
iTransform(currMB, curr_plane, 0);
}
void mb_pred_b_inter8x8(Macroblock *currMB, ColorPlane curr_plane, VideoImage *image, StorablePicture *dec_picture)
{
short ref_idx;
int refList;
char l0_rFrame = -1, l1_rFrame = -1;
PicMotionParams *motion = &dec_picture->motion;
short pmvl0[2]={0,0}, pmvl1[2]={0,0};
int block_size_x, block_size_y;
int k;
int block8x8; // needed for ABT
Slice *currSlice = currMB->p_Slice;
VideoParameters *p_Vid = currMB->p_Vid;
int curr_mb_field = ((currSlice->mb_aff_frame_flag)&&(currMB->mb_field));
MotionParams *colocated = &currSlice->p_colocated->frame;
int list_offset = 0;
set_chroma_vector(currMB, &list_offset);
if (currMB->mb_field)
{
if(currMB->mbAddrX & 0x01)
{
colocated = &currSlice->p_colocated->bottom;
}
else
{
colocated = &currSlice->p_colocated->top;
}
}
// prepare direct modes
if (currSlice->direct_spatial_mv_pred_flag && (!(currMB->b8mode[0] && currMB->b8mode[1] && currMB->b8mode[2] && currMB->b8mode[3])))
prepare_direct_params(currMB, dec_picture, pmvl0, pmvl1, &l0_rFrame, &l1_rFrame);
for (block8x8=0; block8x8<4; block8x8++)
{
int mv_mode = currMB->b8mode[block8x8];
int pred_dir = currMB->b8pdir[block8x8];
if ( mv_mode == SMB8x8)
{
int i = (decode_block_scan[block8x8*4] & 3);
int j = ((decode_block_scan[block8x8*4] >> 2) & 3);
perform_mc8x8(currMB, curr_plane, dec_picture, pred_dir, i, j, list_offset, curr_mb_field);
}
else if ( mv_mode == SMB4x4)
{
int k_start = (block8x8 << 2);
for (k = k_start; k < k_start + 4; k ++)
{
int i = (decode_block_scan[k] & 3);
int j = ((decode_block_scan[k] >> 2) & 3);
perform_mc(currMB, curr_plane, dec_picture, pred_dir, i, j, list_offset, BLOCK_SIZE, BLOCK_SIZE, curr_mb_field);
}
}
else if ( mv_mode != BSKIP_DIRECT)
{
int k_start = (block8x8 << 2);
int k_inc = (mv_mode == SMB8x4) ? 2 : 1;
int k_end = (k_start + k_inc + 1);
block_size_x = ( mv_mode == SMB8x4) ? SMB_BLOCK_SIZE : BLOCK_SIZE;
block_size_y = ( mv_mode == SMB4x8) ? SMB_BLOCK_SIZE : BLOCK_SIZE;
for (k = k_start; k < k_end; k += k_inc)
{
int i = (decode_block_scan[k] & 3);
int j = ((decode_block_scan[k] >> 2) & 3);
perform_mc(currMB, curr_plane, dec_picture, pred_dir, i, j, list_offset, block_size_x, block_size_y, curr_mb_field);
}
}
else
{
int k_start = (block8x8 << 2);
// Prepare mvs (needed for deblocking and mv prediction
if (currSlice->direct_spatial_mv_pred_flag)
{
h264_ref_t *ref_pic_num_l0 = dec_picture->ref_pic_num[p_Vid->current_slice_nr][LIST_0 + list_offset];
h264_ref_t *ref_pic_num_l1 = dec_picture->ref_pic_num[p_Vid->current_slice_nr][LIST_1 + list_offset];
for (k = k_start; k < k_start + BLOCK_MULTIPLE; k ++)
{
int i = (decode_block_scan[k] & 3);
int j = ((decode_block_scan[k] >> 2) & 3);
int i4 = currMB->block_x + i;
int j4 = currMB->block_y + j;
int j6 = currMB->block_y_aff + j;
assert (pred_dir<=2);
//===== DIRECT PREDICTION =====
if (l0_rFrame >=0)
{
if (!l0_rFrame && ((!colocated->moving_block[j6][i4]) && (!p_Vid->listX[LIST_1 + list_offset][0]->is_long_term)))
{
motion->motion[LIST_0][j4][i4].mv[0] = 0;
motion->motion[LIST_0][j4][i4].mv[1] = 0;
motion->motion[LIST_0][j4][i4].ref_idx = 0;
}
else
{
motion->motion[LIST_0][j4][i4].mv[0] = pmvl0[0];
motion->motion[LIST_0][j4][i4].mv[1] = pmvl0[1];
motion->motion[LIST_0][j4][i4].ref_idx = l0_rFrame;
}
}
else
{
motion->motion[LIST_0][j4][i4].ref_idx = -1;
motion->motion[LIST_0][j4][i4].mv[0] = 0;
motion->motion[LIST_0][j4][i4].mv[1] = 0;
}
if (l1_rFrame >=0)
{
if (l1_rFrame==0 && ((!colocated->moving_block[j6][i4]) && (!p_Vid->listX[LIST_1 + list_offset][0]->is_long_term)))
{
motion->motion[LIST_1][j4][i4].mv[0] = 0;
motion->motion[LIST_1][j4][i4].mv[1] = 0;
motion->motion[LIST_1][j4][i4].ref_idx = l1_rFrame;
}
else
{
motion->motion[LIST_1][j4][i4].mv[0] = pmvl1[0];
motion->motion[LIST_1][j4][i4].mv[1] = pmvl1[1];
motion->motion[LIST_1][j4][i4].ref_idx = l1_rFrame;
}
}
else
{
motion->motion[LIST_1][j4][i4].mv[0] = 0;
motion->motion[LIST_1][j4][i4].mv[1] = 0;
motion->motion[LIST_1][j4][i4].ref_idx = -1;
}
if (l0_rFrame < 0 && l1_rFrame < 0)
{
motion->motion[LIST_0][j4][i4].ref_idx = 0;
motion->motion[LIST_1][j4][i4].ref_idx = 0;
}
if (motion->motion[LIST_1][j4][i4].ref_idx==-1)
{
pred_dir = 0;
ref_idx = (motion->motion[LIST_0][j4][i4].ref_idx != -1) ? motion->motion[LIST_0][j4][i4].ref_idx : 0;
}
else if (motion->motion[LIST_0][j4][i4].ref_idx==-1)
{
pred_dir = 1;
ref_idx = (motion->motion[LIST_1][j4][i4].ref_idx != -1) ? motion->motion[LIST_1][j4][i4].ref_idx : 0;
}
else
pred_dir = 2;
motion->motion[LIST_0][j4][i4].ref_pic_id = ref_pic_num_l0[(short)motion->motion[LIST_0][j4][i4].ref_idx];
motion->motion[LIST_1][j4][i4].ref_pic_id = ref_pic_num_l1[(short)motion->motion[LIST_1][j4][i4].ref_idx];
}
}
else
{
for (k = k_start; k < k_start + BLOCK_MULTIPLE; k ++)
{
int i = (decode_block_scan[k] & 3);
int j = ((decode_block_scan[k] >> 2) & 3);
int i4 = currMB->block_x + i;
int j4 = currMB->block_y + j;
int j6 = currMB->block_y_aff + j;
assert (pred_dir<=2);
refList = (colocated->motion[LIST_0][j6][i4].ref_idx== -1 ? LIST_1 : LIST_0);
ref_idx = colocated->motion[refList][j6][i4].ref_idx;
if(ref_idx==-1) // co-located is intra mode
{
memset( &motion->motion[LIST_0][j4][i4].mv, 0, sizeof(MotionVector));
memset( &motion->motion[LIST_1][j4][i4].mv, 0, sizeof(MotionVector));
motion->motion[LIST_0][j4][i4].ref_idx = 0;
motion->motion[LIST_1][j4][i4].ref_idx = 0;
}
else // co-located skip or inter mode
{
int mapped_idx=0;
int iref;
for (iref=0;iref<imin(currSlice->num_ref_idx_l0_active,p_Vid->listXsize[LIST_0 + list_offset]);iref++)
{
if(p_Vid->structure==0 && curr_mb_field==0)
{
// If the current MB is a frame MB and the colocated is from a field picture,
// then the colocated->ref_pic_id may have been generated from the wrong value of
// frame_poc if it references it's complementary field, so test both POC values
if(p_Vid->listX[0][iref]->top_poc*2 == colocated->motion[refList][j6][i4].ref_pic_id || p_Vid->listX[0][iref]->bottom_poc*2 == colocated->motion[refList][j6][i4].ref_pic_id)
{
mapped_idx=iref;
break;
}
else //! invalid index. Default to zero even though this case should not happen
mapped_idx=INVALIDINDEX;
continue;
}
if (dec_picture->ref_pic_num[p_Vid->current_slice_nr][LIST_0 + list_offset][iref]==colocated->motion[refList][j6][i4].ref_pic_id)
{
mapped_idx=iref;
break;
}
else //! invalid index. Default to zero even though this case should not happen
{
mapped_idx=INVALIDINDEX;
}
}
if (INVALIDINDEX == mapped_idx)
{
error("temporal direct error: colocated block has ref that is unavailable",-1111);
}
else
{
int mv_scale = currSlice->mvscale[LIST_0 + list_offset][mapped_idx];
//! In such case, an array is needed for each different reference.
if (mv_scale == 9999 || p_Vid->listX[LIST_0+list_offset][mapped_idx]->is_long_term)
{
memcpy(&motion->motion[LIST_0][j4][i4].mv, &colocated->motion[refList][j6][i4].mv, sizeof(MotionVector));
memset(&motion->motion[LIST_1][j4][i4].mv, 0, sizeof(MotionVector));
}
else
{
motion->motion[LIST_0][j4][i4].mv[0]= (short) ((mv_scale * colocated->motion[refList][j6][i4].mv[0] + 128 ) >> 8);
motion->motion[LIST_0][j4][i4].mv[1]= (short) ((mv_scale * colocated->motion[refList][j6][i4].mv[1] + 128 ) >> 8);
motion->motion[LIST_1][j4][i4].mv[0]= (short) (motion->motion[LIST_0][j4][i4].mv[0] - colocated->motion[refList][j6][i4].mv[0]);
motion->motion[LIST_1][j4][i4].mv[1]= (short) (motion->motion[LIST_0][j4][i4].mv[1] - colocated->motion[refList][j6][i4].mv[1]);
}
motion->motion[LIST_0][j4][i4].ref_idx = (char) mapped_idx; //p_Vid->listX[1][0]->ref_idx[refList][j4][i4];
motion->motion[LIST_1][j4][i4].ref_idx = 0;
}
}
// store reference picture ID determined by direct mode
motion->motion[LIST_0][j4][i4].ref_pic_id = dec_picture->ref_pic_num[p_Vid->current_slice_nr][LIST_0 + list_offset][(short)motion->motion[LIST_0][j4][i4].ref_idx];
motion->motion[LIST_1][j4][i4].ref_pic_id = dec_picture->ref_pic_num[p_Vid->current_slice_nr][LIST_1 + list_offset][(short)motion->motion[LIST_1][j4][i4].ref_idx];
}
}
if (p_Vid->active_sps->direct_8x8_inference_flag)
{
int i = (decode_block_scan[k_start] & 3);
int j = ((decode_block_scan[k_start] >> 2) & 3);
perform_mc8x8(currMB, curr_plane, dec_picture, pred_dir, i, j, list_offset, curr_mb_field);
}
else
{
for (k = k_start; k < k_start+BLOCK_MULTIPLE; k ++)
{
int i = (decode_block_scan[k] & 3);
int j = ((decode_block_scan[k] >> 2) & 3);
perform_mc(currMB, curr_plane, dec_picture, pred_dir, i, j, list_offset, BLOCK_SIZE, BLOCK_SIZE, curr_mb_field);
}
}
}
}
iTransform(currMB, curr_plane, 0);
}
/*!
************************************************************************
* \brief
* Copy IPCM coefficients to decoded picture buffer and set parameters for this MB
* (for IPCM CABAC and IPCM CAVLC 28/11/2003)
*
* \author
* Dong Wang <Dong.Wang@bristol.ac.uk>
************************************************************************
*/
void set_chroma_qp(Macroblock* currMB);
static inline void update_qp(Macroblock *currMB, int qp)
{
VideoParameters *p_Vid = currMB->p_Vid;
currMB->qp = qp;
currMB->qp_scaled[0] = qp + p_Vid->bitdepth_luma_qp_scale;
set_chroma_qp(currMB);
currMB->is_lossless = (Boolean) ((currMB->qp_scaled[0] == 0) && (p_Vid->lossless_qpprime_flag == 1));
}
void mb_pred_ipcm(Macroblock *currMB)
{
int i, j, k;
Slice *currSlice = currMB->p_Slice;
VideoParameters *p_Vid = currMB->p_Vid;
StorablePicture *dec_picture = p_Vid->dec_picture;
//Copy coefficients to decoded picture buffer
//IPCM coefficients are stored in currSlice->ipcm which is set in function read_IPCM_coeffs_from_NAL()
for(i = 0; i < MB_BLOCK_SIZE; ++i)
{
for(j = 0;j < MB_BLOCK_SIZE ; ++j)
{
dec_picture->imgY->img[currMB->pix_y + i][currMB->pix_x + j] = (imgpel) currSlice->ipcm[0][i][j];
}
}
if ((dec_picture->chroma_format_idc != YUV400) && !IS_INDEPENDENT(p_Vid))
{
for (k = 0; k < 2; ++k)
{
for(i = 0; i < p_Vid->mb_cr_size_y; ++i)
{
for(j = 0;j < p_Vid->mb_cr_size_x; ++j)
{
dec_picture->imgUV[k]->img[currMB->pix_c_y+i][currMB->pix_c_x + j] = (imgpel) currSlice->ipcm[k + 1][i][j];
}
}
}
}
// for deblocking filter
update_qp(currMB, 0);
// for CAVLC: Set the nz_coeff to 16.
// These parameters are to be used in CAVLC decoding of neighbour blocks
memset(&p_Vid->nz_coeff[currMB->mbAddrX][0][0][0], 16, sizeof(h264_nz_coefficient));
// for CABAC decoding of MB skip flag
currMB->skip_flag = 0;
//for deblocking filter CABAC
currMB->cbp_blk[0] = 0xFFFF;
//For CABAC decoding of Dquant
currSlice->last_dquant = 0;
}
Reference in New Issue View Git Blame Copy Permalink