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

[mtt] Fix counting the number of reference pixles and implement WAIP adjustment

Browse source
This commit is contained in:
Joose Sainio 2022-11-21 09:15:43 +02:00 committed by Marko Viitanen
parent b893a9268c
commit 5875dc1ef4
4 changed files with 31 additions and 16 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
src/cu.c
View file

@ -364,18 +364,18 @@ int uvg_count_available_edge_cus(const cu_loc_t* const cu_loc, const lcu_t* cons
if ((left && cu_loc->x == 0) || (!left && cu_loc->y == 0)) {
return 0;
}
if (left && cu_loc->local_x == 0) return (LCU_CU_WIDTH - cu_loc->local_y) / 4;
if (!left && cu_loc->local_y == 0) return (LCU_CU_WIDTH - cu_loc->local_x) / 4;
if (left && cu_loc->local_x == 0) return (LCU_WIDTH - cu_loc->local_y) / 4;
if (!left && cu_loc->local_y == 0) return (cu_loc->width) / 2;
int amount = 0;
if(left) {
while (LCU_GET_CU_AT_PX(lcu, cu_loc->local_x - TR_MIN_WIDTH, cu_loc->local_y + amount * TR_MIN_WIDTH)->type != CU_NOTSET) {
amount++;
while (LCU_GET_CU_AT_PX(lcu, cu_loc->local_x - TR_MIN_WIDTH, cu_loc->local_y + amount)->type != CU_NOTSET && (cu_loc->local_y + amount) < LCU_WIDTH) {
amount += TR_MIN_WIDTH;
}
return amount;
return amount / TR_MIN_WIDTH;
}
while (LCU_GET_CU_AT_PX(lcu, cu_loc->local_x + amount * TR_MIN_WIDTH, cu_loc->local_y - TR_MIN_WIDTH)->type != CU_NOTSET) {
amount++;
while (LCU_GET_CU_AT_PX(lcu, cu_loc->local_x + amount, cu_loc->local_y - TR_MIN_WIDTH)->type != CU_NOTSET && cu_loc->local_x + amount < LCU_WIDTH) {
amount += TR_MIN_WIDTH;
}
return amount;
return amount / TR_MIN_WIDTH;
}

23
src/intra.c
View file

@ -936,6 +936,21 @@ static void intra_predict_regular(
uint8_t multi_ref_index = color == COLOR_Y ? multi_ref_idx : 0;
uint8_t isp = color == COLOR_Y ? isp_mode : 0;
// Wide angle correction
int8_t pred_mode = mode;
if (!is_isp && width != height) {
if (mode > 1 && mode <= 66) {
const int modeShift[] = { 0, 6, 10, 12, 14, 15 };
const int deltaSize = abs(log2_width - log2_height);
if (width > height && mode < 2 + modeShift[deltaSize]) {
pred_mode += (66 - 1);
}
else if (height > width && mode > 66 - modeShift[deltaSize]) {
pred_mode -= (66 - 1);
}
}
}
const uvg_intra_ref *used_ref = &refs->ref;
if (cfg->intra_smoothing_disabled || color != COLOR_Y || mode == 1 || (width == 4 && height == 4) || multi_ref_index || isp_mode /*ISP_TODO: replace this fake ISP check*/) {
// For chroma, DC and 4x4 blocks, always use unfiltered reference.
@ -949,11 +964,11 @@ static void intra_predict_regular(
// to being either vertical or horizontal.
static const int uvg_intra_hor_ver_dist_thres[8] = {24, 24, 24, 14, 2, 0, 0, 0 };
int filter_threshold = uvg_intra_hor_ver_dist_thres[(log2_width + log2_height) >> 1];
int dist_from_vert_or_hor = MIN(abs(mode - 50), abs(mode - 18));
int dist_from_vert_or_hor = MIN(abs(pred_mode - 50), abs(pred_mode - 18));
if (dist_from_vert_or_hor > filter_threshold) {
static const int16_t modedisp2sampledisp[32] = { 0, 1, 2, 3, 4, 6, 8, 10, 12, 14, 16, 18, 20, 23, 26, 29, 32, 35, 39, 45, 51, 57, 64, 73, 86, 102, 128, 171, 256, 341, 512, 1024 };
const int_fast8_t mode_disp = (mode >= 34) ? mode - 50 : 18 - mode;
const int_fast8_t mode_disp = (pred_mode >= 34) ? pred_mode - 50 : 18 - pred_mode;
const int_fast8_t sample_disp = (mode_disp < 0 ? -1 : 1) * modedisp2sampledisp[abs(mode_disp)];
if ((abs(sample_disp) & 0x1F) == 0) {
used_ref = &refs->filtered_ref;
@ -970,7 +985,7 @@ static void intra_predict_regular(
} else if (mode == 1) {
intra_pred_dc(cu_loc, color, used_ref->top, used_ref->left, dst, multi_ref_index);
} else {
uvg_angular_pred(cu_loc, mode, color, used_ref->top, used_ref->left, dst, multi_ref_index, isp);
uvg_angular_pred(cu_loc, pred_mode, color, used_ref->top, used_ref->left, dst, multi_ref_index, isp);
}
// pdpc
@ -1463,7 +1478,7 @@ void uvg_intra_build_reference_inner(
}
}
else {
const int num_cus = uvg_count_available_edge_cus(cu_loc, lcu, true);
const int num_cus = uvg_count_available_edge_cus(cu_loc, lcu, false);
px_available_top = is_dual_tree || !is_chroma ? num_cus * 4 : num_cus * 2;
}

2
src/strategies/generic/intra-generic.c
View file

@ -68,7 +68,7 @@ static void uvg_angular_pred_generic(
// Log2_dim 1 is possible with ISP blocks
assert((log2_width >= 1 && log2_width <= 5) && (log2_height >= 1 && log2_height <= 5));
assert(intra_mode >= 2 && intra_mode <= 66);
// assert(intra_mode >= 2 && intra_mode <= 66);
static const int16_t modedisp2sampledisp[32] = { 0, 1, 2, 3, 4, 6, 8, 10, 12, 14, 16, 18, 20, 23, 26, 29, 32, 35, 39, 45, 51, 57, 64, 73, 86, 102, 128, 171, 256, 341, 512, 1024 };
static const int16_t modedisp2invsampledisp[32] = { 0, 16384, 8192, 5461, 4096, 2731, 2048, 1638, 1365, 1170, 1024, 910, 819, 712, 630, 565, 512, 468, 420, 364, 321, 287, 256, 224, 191, 161, 128, 96, 64, 48, 32, 16 }; // (512 * 32) / sampledisp

6
src/strategies/generic/quant-generic.c
View file

@ -375,7 +375,7 @@ int uvg_quant_cbcr_residual_generic(
//}
const int temp = cur_cu->joint_cb_cr * (state->frame->jccr_sign ? -1 : 1);
// Get quantized reconstruction. (residual + pred_in -> rec_out)
for (int y = 0; y < width; y++) {
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
if (temp == 2) {
u_residual[x + y * width] = combined_residual[x + y * width];
@ -404,7 +404,7 @@ int uvg_quant_cbcr_residual_generic(
}
}
}
for (int y = 0; y < width; ++y) {
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
int16_t u_val = u_residual[x + y * width] + u_pred_in[x + y * in_stride];
u_rec_out[x + y * out_stride] = (uvg_pixel)CLIP(0, PIXEL_MAX, u_val);
@ -417,7 +417,7 @@ int uvg_quant_cbcr_residual_generic(
// With no coeffs and rec_out == pred_int we skip copying the coefficients
// because the reconstruction is just the prediction.
for (int y = 0; y < width; ++y) {
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
u_rec_out[x + y * out_stride] = u_pred_in[x + y * in_stride];
v_rec_out[x + y * out_stride] = v_pred_in[x + y * in_stride];