block.c
来自「the newest JM software by h.264 JVT offi」· C语言 代码 · 共 2,206 行 · 第 1/5 页
C
2,206 行
/*!
*************************************************************************************
* \file block.c
*
* \brief
* Process one block
*
* \author
* Main contributors (see contributors.h for copyright, address and affiliation details)
* - Inge Lille-Langoy <inge.lille-langoy@telenor.com>
* - Rickard Sjoberg <rickard.sjoberg@era.ericsson.se>
* - Stephan Wenger <stewe@cs.tu-berlin.de>
* - Jani Lainema <jani.lainema@nokia.com>
* - Detlev Marpe <marpe@hhi.de>
* - Thomas Wedi <wedi@tnt.uni-hannover.de>
* - Ragip Kurceren <ragip.kurceren@nokia.com>
* - Greg Conklin <gregc@real.com>
*************************************************************************************
*/
#include "contributors.h"
#include <math.h>
#include "global.h"
#include "enc_statistics.h"
#include "memalloc.h"
#include "image.h"
#include "mb_access.h"
#include "block.h"
#include "vlc.h"
#include "transform.h"
#include "mc_prediction.h"
#include "q_offsets.h"
#include "q_matrix.h"
#include "quant4x4.h"
#include "quantChroma.h"
// Notation for comments regarding prediction and predictors.
// The pels of the 4x4 block are labelled a..p. The predictor pels above
// are labelled A..H, from the left I..P, and from above left X, as follows:
//
// X A B C D E F G H
// I a b c d
// J e f g h
// K i j k l
// L m n o p
//
// Predictor array index definitions
#define P_X (PredPel[0])
#define P_A (PredPel[1])
#define P_B (PredPel[2])
#define P_C (PredPel[3])
#define P_D (PredPel[4])
#define P_E (PredPel[5])
#define P_F (PredPel[6])
#define P_G (PredPel[7])
#define P_H (PredPel[8])
#define P_I (PredPel[9])
#define P_J (PredPel[10])
#define P_K (PredPel[11])
#define P_L (PredPel[12])
//! array used to find expencive coefficients
static const byte COEFF_COST4x4[2][16] =
{
{3,2,2,1,1,1,0,0,0,0,0,0,0,0,0,0},
{9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9}
};
static const byte SCAN_YUV420 [4][2] =
{
{0,0},
{0,1},
{0,2},
{0,3}
};
//! single scan pattern
static const byte SCAN_YUV422 [8][2] =
{
{0,0},{0,1},
{1,0},{0,2},
{0,3},{1,1},
{1,2},{1,3}
};
//! look up tables for FRExt-chroma support
static const unsigned char hor_offset[4][4][4] = {
{
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0}
},
{
{0, 4, 0, 4},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0}
},
{
{0, 4, 0, 4},
{0, 4, 0, 4},
{0, 0, 0, 0},
{0, 0, 0, 0}
},
{
{0, 4, 0, 4},
{8,12, 8,12},
{0, 4, 0, 4},
{8,12, 8,12}
}
};
static const unsigned char ver_offset[4][4][4] = {
{
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0}
},
{
{0, 0, 4, 4},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0}
},
{
{0, 0, 4, 4},
{8, 8,12,12},
{0, 0, 0, 0},
{0, 0, 0, 0}
},
{
{0, 0, 4, 4},
{0, 0, 4, 4},
{8, 8,12,12},
{8, 8,12,12}
}
};
static const int A[4][4] = {
{ 16, 20, 16, 20},
{ 20, 25, 20, 25},
{ 16, 20, 16, 20},
{ 20, 25, 20, 25}
};
static unsigned char cbp_blk_chroma[8][4] = {
{16, 17, 18, 19},
{20, 21, 22, 23},
{24, 25, 26, 27},
{28, 29, 30, 31},
{32, 33, 34, 35},
{36, 37, 38, 39},
{40, 41, 42, 43},
{44, 45, 46, 47}
};
//! single scan pattern
const byte SNGL_SCAN[16][2] =
{
{0,0},{1,0},{0,1},{0,2},
{1,1},{2,0},{3,0},{2,1},
{1,2},{0,3},{1,3},{2,2},
{3,1},{3,2},{2,3},{3,3}
};
//! field scan pattern
const byte FIELD_SCAN[16][2] =
{
{0,0},{0,1},{1,0},{0,2},
{0,3},{1,1},{1,2},{1,3},
{2,0},{2,1},{2,2},{2,3},
{3,0},{3,1},{3,2},{3,3}
};
// global pointers for 4x4 quantization parameters
extern int ****ptLevelOffset4x4;
static int **levelscale = NULL, **leveloffset = NULL;
static int **invlevelscale = NULL;
static int **levelscale_sp = NULL, **leveloffset_sp = NULL;
static int **invlevelscale_sp = NULL;
static int **fadjust4x4 = NULL;
static int **fadjust2x2 = NULL;
static int **fadjust4x2 = NULL; // note that this is in fact 2x4 but the coefficients have been transposed for better memory access
static int **levelscaleDC = NULL, **leveloffsetDC = NULL;
static int **invlevelscaleDC = NULL;
static int **M1 = NULL;
static int **M4 = NULL;
//For residual DPCM
static int Residual_DPCM_4x4_for_Intra16x16(int **mb_ores, int ipmode);
static int Inv_Residual_DPCM_4x4_for_Intra16x16(int **mb_ores, int ipmode);
static int Residual_DPCM_4x4(int ipmode, int **mb_ores, int **mb_rres, int block_y, int block_x);
static int Inv_Residual_DPCM_4x4(int **m7, int block_y, int block_x);
int allocate_block_mem(void)
{
int alloc_size = 0;
alloc_size += get_mem2Dint(&M4, BLOCK_SIZE, BLOCK_SIZE);
alloc_size += get_mem2Dint(&M1, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
return (alloc_size);
}
void free_block_mem(void)
{
free_mem2Dint(M1);
free_mem2Dint(M4);
}
/*!
************************************************************************
* \brief
* Make intra 4x4 prediction according to all 9 prediction modes.
* The routine uses left and upper neighbouring points from
* previous coded blocks to do this (if available). Notice that
* inaccessible neighbouring points are signalled with a negative
* value in the predmode array .
*
* \par Input:
* Starting point of current 4x4 block image posision
*
* \par Output:
* none
************************************************************************
*/
void intrapred_4x4(Macroblock *currMB, ColorPlane pl, int img_x,int img_y, int *left_available, int *up_available, int *all_available)
{
int i,j;
int s0;
imgpel PredPel[13]; // array of predictor pels
imgpel **img_enc = enc_picture->p_curr_img;
imgpel *img_pel;
imgpel **cur_pred;
imgpel ***curr_mpr_4x4 = img->mpr_4x4[pl];
unsigned int dc_pred_value = img->dc_pred_value;
int ioff = (img_x & 15);
int joff = (img_y & 15);
PixelPos pix_a[4];
PixelPos pix_b, pix_c, pix_d;
int block_available_up;
int block_available_left;
int block_available_up_left;
int block_available_up_right;
int *mb_size = img->mb_size[IS_LUMA];
for (i=0;i<4;i++)
{
getNeighbour(currMB, ioff -1 , joff +i , mb_size, &pix_a[i]);
}
getNeighbour(currMB, ioff , joff -1 , mb_size, &pix_b);
getNeighbour(currMB, ioff +4 , joff -1 , mb_size, &pix_c);
getNeighbour(currMB, ioff -1 , joff -1 , mb_size, &pix_d);
pix_c.available = pix_c.available && !((ioff==4) && ((joff==4)||(joff==12)));
if (params->UseConstrainedIntraPred)
{
for (i=0, block_available_left=1; i<4;i++)
block_available_left &= pix_a[i].available ? img->intra_block[pix_a[i].mb_addr]: 0;
block_available_up = pix_b.available ? img->intra_block [pix_b.mb_addr] : 0;
block_available_up_right = pix_c.available ? img->intra_block [pix_c.mb_addr] : 0;
block_available_up_left = pix_d.available ? img->intra_block [pix_d.mb_addr] : 0;
}
else
{
block_available_left = pix_a[0].available;
block_available_up = pix_b.available;
block_available_up_right = pix_c.available;
block_available_up_left = pix_d.available;
}
*left_available = block_available_left;
*up_available = block_available_up;
*all_available = block_available_up && block_available_left && block_available_up_left;
i = (img_x & 15);
j = (img_y & 15);
// form predictor pels
if (block_available_up)
{
img_pel = &img_enc[pix_b.pos_y][pix_b.pos_x];
P_A = *(img_pel++);
P_B = *(img_pel++);
P_C = *(img_pel++);
P_D = *(img_pel);
}
else
{
P_A = P_B = P_C = P_D = dc_pred_value;
}
if (block_available_up_right)
{
img_pel = &img_enc[pix_c.pos_y][pix_c.pos_x];
P_E = *(img_pel++);
P_F = *(img_pel++);
P_G = *(img_pel++);
P_H = *(img_pel);
}
else
{
P_E = P_F = P_G = P_H = P_D;
}
if (block_available_left)
{
P_I = img_enc[pix_a[0].pos_y][pix_a[0].pos_x];
P_J = img_enc[pix_a[1].pos_y][pix_a[1].pos_x];
P_K = img_enc[pix_a[2].pos_y][pix_a[2].pos_x];
P_L = img_enc[pix_a[3].pos_y][pix_a[3].pos_x];
}
else
{
P_I = P_J = P_K = P_L = dc_pred_value;
}
if (block_available_up_left)
{
P_X = img_enc[pix_d.pos_y][pix_d.pos_x];
}
else
{
P_X = dc_pred_value;
}
for(i=0;i<9;i++)
curr_mpr_4x4[i][0][0]=-1;
///////////////////////////////
// make DC prediction
///////////////////////////////
s0 = 0;
if (block_available_up && block_available_left)
{
// no edge
s0 = (P_A + P_B + P_C + P_D + P_I + P_J + P_K + P_L + 4) >> (BLOCK_SHIFT + 1);
}
else if (!block_available_up && block_available_left)
{
// upper edge
s0 = (P_I + P_J + P_K + P_L + 2) >> BLOCK_SHIFT;;
}
else if (block_available_up && !block_available_left)
{
// left edge
s0 = (P_A + P_B + P_C + P_D + 2) >> BLOCK_SHIFT;
}
else //if (!block_available_up && !block_available_left)
{
// top left corner, nothing to predict from
s0 = dc_pred_value;
}
// store DC prediction
cur_pred = curr_mpr_4x4[DC_PRED];
for (j=0; j < BLOCK_SIZE; j++)
{
for (i=0; i < BLOCK_SIZE; i++)
cur_pred[j][i] = (imgpel) s0;
}
///////////////////////////////
// make horiz and vert prediction
///////////////////////////////
//Mode vertical
cur_pred = curr_mpr_4x4[VERT_PRED];
for (i=0; i < BLOCK_SIZE; i++)
{
cur_pred[0][i] =
cur_pred[1][i] =
cur_pred[2][i] =
cur_pred[3][i] = (imgpel) (&P_A)[i];
}
if(!block_available_up)
cur_pred [0][0]=-1;
//Mode horizontal
cur_pred = curr_mpr_4x4[HOR_PRED];
for (i=0; i < BLOCK_SIZE; i++)
{
cur_pred[i][0] =
cur_pred[i][1] =
cur_pred[i][2] =
cur_pred[i][3] = (imgpel) (&P_I)[i];
}
if(!block_available_left)
cur_pred[0][0]=-1;
if (block_available_up)
{
// Mode DIAG_DOWN_LEFT_PRED
cur_pred = curr_mpr_4x4[DIAG_DOWN_LEFT_PRED];
cur_pred[0][0] = (imgpel) ((P_A + P_C + ((P_B)<<1) + 2) >> 2);
cur_pred[0][1] =
cur_pred[1][0] = (imgpel) ((P_B + P_D + ((P_C)<<1) + 2) >> 2);
cur_pred[0][2] =
cur_pred[1][1] =
cur_pred[2][0] = (imgpel) ((P_C + P_E + ((P_D)<<1) + 2) >> 2);
cur_pred[0][3] =
cur_pred[1][2] =
cur_pred[2][1] =
cur_pred[3][0] = (imgpel) ((P_D + P_F + ((P_E)<<1) + 2) >> 2);
cur_pred[1][3] =
cur_pred[2][2] =
cur_pred[3][1] = (imgpel) ((P_E + P_G + ((P_F)<<1) + 2) >> 2);
cur_pred[2][3] =
cur_pred[3][2] = (imgpel) ((P_F + P_H + ((P_G)<<1) + 2) >> 2);
cur_pred[3][3] = (imgpel) ((P_G + 3*(P_H) + 2) >> 2);
// Mode VERT_LEFT_PRED
cur_pred = curr_mpr_4x4[VERT_LEFT_PRED];
cur_pred[0][0] = (imgpel) ((P_A + P_B + 1) >> 1);
cur_pred[0][1] =
cur_pred[2][0] = (imgpel) ((P_B + P_C + 1) >> 1);
cur_pred[0][2] =
cur_pred[2][1] = (imgpel) ((P_C + P_D + 1) >> 1);
cur_pred[0][3] =
cur_pred[2][2] = (imgpel) ((P_D + P_E + 1) >> 1);
cur_pred[2][3] = (imgpel) ((P_E + P_F + 1) >> 1);
cur_pred[1][0] = (imgpel) ((P_A + ((P_B)<<1) + P_C + 2) >> 2);
cur_pred[1][1] =
cur_pred[3][0] = (imgpel) ((P_B + ((P_C)<<1) + P_D + 2) >> 2);
cur_pred[1][2] =
cur_pred[3][1] = (imgpel) ((P_C + ((P_D)<<1) + P_E + 2) >> 2);
cur_pred[1][3] =
cur_pred[3][2] = (imgpel) ((P_D + ((P_E)<<1) + P_F + 2) >> 2);
cur_pred[3][3] = (imgpel) ((P_E + ((P_F)<<1) + P_G + 2) >> 2);
}
⌨️ 快捷键说明
复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?