hashirama/uvg266
1
0
Fork 0
mirror of https://github.com/ultravideo/uvg266.git synced 2024-11-24 02:24:07 +00:00
Code Issues Actions Projects Releases Wiki Activity

Remove redundant variables.

Browse source 
- Redefine LCU_WIDTH to be 64. Stuff will break horribly if it's
  anything else anyway.

- Add LCU_WIDTH_C for chroma LCU width. It should be more readable than the
  constant (LCU_WIDTH >> 1).
This commit is contained in:
Ari Koivula 2014-05-12 10:58:07 +03:00
parent 59e0e98523
commit d9b890de6e
2 changed files with 30 additions and 41 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

66
src/encoder.c
View file

@ -2853,8 +2853,6 @@ static void reconstruct_chroma(const encoder_state * const encoder_state, cu_inf
coefficient *pre_quant_coeff, coefficient *block)
{
int8_t width_c = LCU_WIDTH >> (depth + 1);
const int pred_stride = LCU_WIDTH;
const int recbase_stride = LCU_WIDTH;
int i, y, x;
@ -2865,9 +2863,9 @@ static void reconstruct_chroma(const encoder_state * const encoder_state, cu_inf
for (y = 0; y < width_c; y++) {
for (x = 0; x < width_c; x++) {
int16_t val = block[i++] + pred_u[x + y * (pred_stride >> 1)];
int16_t val = block[i++] + pred_u[x + y * LCU_WIDTH_C];
//TODO: support 10+bits
recbase_u[x + y * (recbase_stride >> 1)] = (uint8_t)CLIP(0, 255, val);
recbase_u[x + y * LCU_WIDTH_C] = (uint8_t)CLIP(0, 255, val);
}
}
}
@ -2902,9 +2900,6 @@ int quantize_residual_chroma(encoder_state * const encoder_state,
const int chroma_depth = (luma_depth == MAX_PU_DEPTH ? luma_depth - 1 : luma_depth);
const int8_t width_c = LCU_WIDTH >> (chroma_depth + 1);
const int pred_stride = LCU_WIDTH;
const int recbase_stride = LCU_WIDTH;
const int32_t coeff_stride = LCU_WIDTH;
const coeff_scan_order_t scan_idx_chroma = get_scan_order(cur_cu->type, cur_cu->intra[0].mode_chroma, luma_depth);
@ -2912,9 +2907,9 @@ int quantize_residual_chroma(encoder_state * const encoder_state,
{
int y, x;
for(y = 0; y < width_c; y++) {
for(x = 0; x < width_c; x++) {
pred_u[x+y*(pred_stride>>1)]=recbase_u[x+y*(recbase_stride>>1)];
for (y = 0; y < width_c; y++) {
for (x = 0; x < width_c; x++) {
pred_u[x + y * LCU_WIDTH_C] = recbase_u[x + y * LCU_WIDTH_C];
}
}
}
@ -2935,7 +2930,7 @@ int quantize_residual_chroma(encoder_state * const encoder_state,
int y, x;
for (y = 0; y < width_c; y++) {
for (x = 0; x < width_c; x++) {
orig_coeff_u[x + y * (coeff_stride>>1)] = coeff_u[i];
orig_coeff_u[x + y * LCU_WIDTH_C] = coeff_u[i];
i++;
}
}
@ -2973,11 +2968,9 @@ void encode_transform_tree(encoder_state * const encoder_state, int32_t x, int32
{
const encoder_control * const encoder = encoder_state->encoder_control;
// we have 64>>depth transform size
int x_local = (x&0x3f), y_local = (y&0x3f);
int32_t x_pu = x_local >> 2;
int32_t y_pu = y_local >> 2;
const vector2d lcu_px = {x & 0x3f, y & 0x3f};
cu_info *cur_cu = &lcu->cu[LCU_CU_OFFSET + (x_local>>3) + (y_local>>3)*LCU_T_CU_WIDTH];
const int pu_index = PU_INDEX(lcu_px.x / 4, lcu_px.y / 4);
cu_info *cur_cu = &lcu->cu[LCU_CU_OFFSET + (lcu_px.x>>3) + (lcu_px.y>>3)*LCU_T_CU_WIDTH];
const int8_t width = LCU_WIDTH>>depth;
int i;
@ -2996,9 +2989,9 @@ void encode_transform_tree(encoder_state * const encoder_state, int32_t x, int32
// Propagate coded block flags from child CUs to parent CU.
if (depth < MAX_DEPTH) {
cu_info *cu_a = &lcu->cu[LCU_CU_OFFSET + ((x_local + offset)>>3) + (y_local>>3) *LCU_T_CU_WIDTH];
cu_info *cu_b = &lcu->cu[LCU_CU_OFFSET + (x_local>>3) + ((y_local+offset)>>3)*LCU_T_CU_WIDTH];
cu_info *cu_c = &lcu->cu[LCU_CU_OFFSET + ((x_local + offset)>>3) + ((y_local+offset)>>3)*LCU_T_CU_WIDTH];
cu_info *cu_a = &lcu->cu[LCU_CU_OFFSET + ((lcu_px.x + offset)>>3) + (lcu_px.y>>3) *LCU_T_CU_WIDTH];
cu_info *cu_b = &lcu->cu[LCU_CU_OFFSET + (lcu_px.x>>3) + ((lcu_px.y+offset)>>3)*LCU_T_CU_WIDTH];
cu_info *cu_c = &lcu->cu[LCU_CU_OFFSET + ((lcu_px.x + offset)>>3) + ((lcu_px.y+offset)>>3)*LCU_T_CU_WIDTH];
if (cbf_is_set(cu_a->cbf.y, depth+1) || cbf_is_set(cu_b->cbf.y, depth+1) || cbf_is_set(cu_c->cbf.y, depth+1)) {
cbf_set(&cur_cu->cbf.y, depth);
}
@ -3016,11 +3009,6 @@ void encode_transform_tree(encoder_state * const encoder_state, int32_t x, int32
{
const int luma_offset = lcu_px.x + lcu_px.y * LCU_WIDTH;
const int32_t recbase_stride = LCU_WIDTH;
const int32_t base_stride = LCU_WIDTH;
const int32_t pred_stride = LCU_WIDTH;
const int32_t coeff_stride = LCU_WIDTH;
// Pointers to current location in arrays with prediction.
pixel *recbase_y = &lcu->rec.y[luma_offset];
// Pointers to current location in arrays with reference.
@ -3047,8 +3035,8 @@ void encode_transform_tree(encoder_state * const encoder_state, int32_t x, int32
// Clear coded block flag structures for depths lower than current depth.
// This should ensure that the CBF data doesn't get corrupted if this function
// is called more than once.
cbf_clear(&cur_cu->cbf.y, depth + PU_INDEX(x >> 2, y >> 2));
if (PU_INDEX(x >> 2, y >> 2) == 0) {
cbf_clear(&cur_cu->cbf.y, depth + pu_index);
if (pu_index == 0) {
cbf_clear(&cur_cu->cbf.u, depth);
cbf_clear(&cur_cu->cbf.v, depth);
}
@ -3057,15 +3045,15 @@ void encode_transform_tree(encoder_state * const encoder_state, int32_t x, int32
if (cur_cu->type == CU_INTRA) {
int chroma_mode = cur_cu->intra[0].mode_chroma;
if (chroma_mode == 36) {
chroma_mode = cur_cu->intra[PU_INDEX(x_pu, y_pu)].mode;
chroma_mode = cur_cu->intra[pu_index].mode;
}
scan_idx_luma = get_scan_order(cur_cu->type, cur_cu->intra[PU_INDEX(x_pu, y_pu)].mode, depth);
scan_idx_luma = get_scan_order(cur_cu->type, cur_cu->intra[pu_index].mode, depth);
}
// Copy Luma and Chroma to the pred-block
for(y = 0; y < width; y++) {
for(x = 0; x < width; x++) {
pred_y[x+y*pred_stride]=recbase_y[x+y*recbase_stride];
pred_y[x+y*LCU_WIDTH]=recbase_y[x+y*LCU_WIDTH];
}
}
@ -3075,8 +3063,8 @@ void encode_transform_tree(encoder_state * const encoder_state, int32_t x, int32
for (y = 0; y < width; y++) {
for (x = 0; x < width; x++) {
block[i] = ((int16_t)base_y[x + y * base_stride]) -
pred_y[x + y * pred_stride];
block[i] = ((int16_t)base_y[x + y * LCU_WIDTH]) -
pred_y[x + y * LCU_WIDTH];
#if OPTIMIZATION_SKIP_RESIDUAL_ON_THRESHOLD
residual_sum += block[i];
#endif
@ -3144,11 +3132,11 @@ void encode_transform_tree(encoder_state * const encoder_state, int32_t x, int32
cost2 += coeffcost2*((int)encoder_state->global->cur_lambda_cost+0.5);
}
cur_cu->intra[PU_INDEX(x_pu, y_pu)].tr_skip = (cost < cost2);
cur_cu->intra[pu_index].tr_skip = (cost < cost2);
}
// Transform and quant residual to coeffs
if(width == 4 && cur_cu->intra[PU_INDEX(x_pu, y_pu)].tr_skip) {
if(width == 4 && cur_cu->intra[pu_index].tr_skip) {
transformskip(encoder, block,pre_quant_coeff,width);
} else {
transform2d(encoder, block,pre_quant_coeff,width,0);
@ -3165,7 +3153,7 @@ void encode_transform_tree(encoder_state * const encoder_state, int32_t x, int32
for (i = 0; i < width * width; i++) {
if (coeff_y[i] != 0) {
// Found one, we can break here
cbf_set(&cur_cu->cbf.y, depth + PU_INDEX(x_pu, y_pu));
cbf_set(&cur_cu->cbf.y, depth + pu_index);
break;
}
}
@ -3176,20 +3164,20 @@ void encode_transform_tree(encoder_state * const encoder_state, int32_t x, int32
int i = 0;
for (y = 0; y < width; y++) {
for (x = 0; x < width; x++) {
orig_coeff_y[x + y * coeff_stride] = coeff_y[i];
orig_coeff_y[x + y * LCU_WIDTH] = coeff_y[i];
i++;
}
}
}
if (cbf_is_set(cur_cu->cbf.y, depth + PU_INDEX(x_pu, y_pu))) {
if (cbf_is_set(cur_cu->cbf.y, depth + pu_index)) {
// Combine inverese quantized coefficients with the prediction to get
// reconstructed image.
//picture_set_block_residual(cur_pic,x_cu,y_cu,depth,1);
int i;
dequant(encoder_state, coeff_y, pre_quant_coeff, width, width, 0, cur_cu->type);
if(width == 4 && cur_cu->intra[PU_INDEX(x_pu, y_pu)].tr_skip) {
if(width == 4 && cur_cu->intra[pu_index].tr_skip) {
itransformskip(encoder, block,pre_quant_coeff,width);
} else {
itransform2d(encoder, block,pre_quant_coeff,width,0);
@ -3199,9 +3187,9 @@ void encode_transform_tree(encoder_state * const encoder_state, int32_t x, int32
for (y = 0; y < width; y++) {
for (x = 0; x < width; x++) {
int val = block[i++] + pred_y[x + y * pred_stride];
int val = block[i++] + pred_y[x + y * LCU_WIDTH];
//TODO: support 10+bits
recbase_y[x + y * recbase_stride] = (pixel)CLIP(0, 255, val);
recbase_y[x + y * LCU_WIDTH] = (pixel)CLIP(0, 255, val);
}
}
}
@ -3209,7 +3197,7 @@ void encode_transform_tree(encoder_state * const encoder_state, int32_t x, int32
// If luma is 4x4, do chroma for the 8x8 luma area when handling the top
// left PU because the coordinates are correct.
if (depth <= MAX_DEPTH || (x_pu % 2 == 0 && y_pu % 2 == 0)) {
if (depth <= MAX_DEPTH || pu_index == 0) {
const int chroma_offset = lcu_px.x / 2 + lcu_px.y / 2 * LCU_WIDTH / 2;
pixel *recbase_u = &lcu->rec.u[chroma_offset];
pixel *recbase_v = &lcu->rec.v[chroma_offset];

5
src/global.h
View file

@ -80,8 +80,9 @@ typedef int16_t coefficient;
/* END OF CONFIG VARIABLES */
#define CU_MIN_SIZE_PIXELS (1 << MIN_SIZE) /*!< pow(2, MIN_SIZE) */
#define LCU_WIDTH (1 << (MAX_DEPTH + MIN_SIZE)) /*!< Largest Coding Unit, spec: CtbSizeY */
#define CU_MIN_SIZE_PIXELS 8 /*!< pow(2, MIN_SIZE) */
#define LCU_WIDTH 64 /*!< Largest Coding Unit, spec: CtbSizeY */
#define LCU_WIDTH_C 32
#if LCU_WIDTH != 64
#error "Kvazaar only support LCU_WIDTH == 64"