From 2e8f008de4562013d5de09ffda0a5b359ac09dda Mon Sep 17 00:00:00 2001 From: siivonek Date: Wed, 24 Aug 2022 16:15:03 +0300 Subject: [PATCH] [isp] Redo call hierarchy to include x, y coordinates. --- src/encode_coding_tree.c | 29 +++++------ src/intra.c | 9 ++-- src/rdo.c | 19 ++++--- src/rdo.h | 3 +- src/search.c | 51 ++++++++++--------- src/search_inter.c | 3 +- src/search_intra.c | 28 +++++----- src/strategies/avx2/encode_coding_tree-avx2.h | 4 +- .../generic/encode_coding_tree-generic.c | 21 +++++--- .../generic/encode_coding_tree-generic.h | 3 +- src/strategies/strategies-encode.h | 3 +- src/transform.c | 18 ++++--- src/transform.h | 3 +- 13 files changed, 104 insertions(+), 90 deletions(-) diff --git a/src/encode_coding_tree.c b/src/encode_coding_tree.c index 238e6fae..3c2d1947 100644 --- a/src/encode_coding_tree.c +++ b/src/encode_coding_tree.c @@ -465,10 +465,8 @@ void uvg_encode_last_significant_xy(cabac_data_t * const cabac, static void encode_chroma_tu( encoder_state_t* const state, - int x, - int y, + cu_loc_t *cu_loc, int depth, - const uint8_t width_c, cu_info_t* cur_pu, int8_t* scan_idx, lcu_coeff_t* coeff, @@ -476,9 +474,10 @@ static void encode_chroma_tu( enum uvg_tree_type tree_type) { - int height_c = width_c; // TODO: height for non-square blocks - int x_local = ((x >> (tree_type != UVG_CHROMA_T)) & ~3) % LCU_WIDTH_C; - int y_local = ((y >> (tree_type != UVG_CHROMA_T)) & ~3) % LCU_WIDTH_C; + int width_c = cu_loc->chroma_width; + //int height_c = cu_loc->chroma_height; + int x_local = ((cu_loc->x >> (tree_type != UVG_CHROMA_T)) & ~3) % LCU_WIDTH_C; + int y_local = ((cu_loc->y >> (tree_type != UVG_CHROMA_T)) & ~3) % LCU_WIDTH_C; cabac_data_t* const cabac = &state->cabac; *scan_idx = uvg_get_scan_order(cur_pu->type, cur_pu->intra.mode_chroma, depth); if(!joint_chroma){ @@ -486,13 +485,14 @@ static void encode_chroma_tu( const coeff_t *coeff_v = &coeff->v[xy_to_zorder(LCU_WIDTH_C, x_local, y_local)]; if (cbf_is_set(cur_pu->cbf, depth, COLOR_U)) { + // ISP_TODO: do these checks need height? if(state->encoder_control->cfg.trskip_enable && width_c <= (1 << state->encoder_control->cfg.trskip_max_size)){ cabac->cur_ctx = &cabac->ctx.transform_skip_model_chroma; // HEVC only supports transform_skip for Luma // TODO: transform skip for chroma blocks CABAC_BIN(cabac, (cur_pu->tr_skip >> COLOR_U) & 1, "transform_skip_flag"); } - uvg_encode_coeff_nxn(state, &state->cabac, coeff_u, width_c, height_c, COLOR_U, *scan_idx, cur_pu, NULL); + uvg_encode_coeff_nxn(state, &state->cabac, coeff_u, cu_loc, COLOR_U, *scan_idx, cur_pu, NULL); } if (cbf_is_set(cur_pu->cbf, depth, COLOR_V)) { @@ -500,7 +500,7 @@ static void encode_chroma_tu( cabac->cur_ctx = &cabac->ctx.transform_skip_model_chroma; CABAC_BIN(cabac, (cur_pu->tr_skip >> COLOR_V) & 1, "transform_skip_flag"); } - uvg_encode_coeff_nxn(state, &state->cabac, coeff_v, width_c, height_c, COLOR_V, *scan_idx, cur_pu, NULL); + uvg_encode_coeff_nxn(state, &state->cabac, coeff_v, cu_loc, COLOR_V, *scan_idx, cur_pu, NULL); } } else { @@ -509,7 +509,7 @@ static void encode_chroma_tu( cabac->cur_ctx = &cabac->ctx.transform_skip_model_chroma; CABAC_BIN(cabac, 0, "transform_skip_flag"); } - uvg_encode_coeff_nxn(state, &state->cabac, coeff_uv, width_c, height_c, COLOR_V, *scan_idx, cur_pu, NULL); + uvg_encode_coeff_nxn(state, &state->cabac, coeff_uv, cu_loc, COLOR_V, *scan_idx, cur_pu, NULL); } } @@ -561,8 +561,7 @@ static void encode_transform_unit( uvg_encode_coeff_nxn(state, cabac, coeff_y, - width, - height, + cu_loc, 0, scan_idx, (cu_info_t * )cur_pu, @@ -589,7 +588,7 @@ static void encode_transform_unit( cbf_is_set(cur_pu->cbf, depth, COLOR_V); if ((chroma_cbf_set || joint_chroma) && last_split) { //Need to drop const to get lfnst constraints - encode_chroma_tu(state, x, y, depth, width_c, (cu_info_t*)cur_pu, &scan_idx, coeff, joint_chroma, tree_type); + encode_chroma_tu(state, cu_loc, depth, (cu_info_t*)cur_pu, &scan_idx, coeff, joint_chroma, tree_type); } } @@ -1630,12 +1629,12 @@ void uvg_encode_coding_tree( int split_limit = split_type == ISP_MODE_NO_ISP ? 1 : uvg_get_isp_split_num(cu_width, cu_height, split_type); for (int i = 0; i < split_limit; ++i) { - cu_loc_t loc; - uvg_get_isp_split_loc(&loc, x, y, cu_width, cu_height, i, split_type); + cu_loc_t split_loc; + uvg_get_isp_split_loc(&split_loc, x, y, cu_width, cu_height, i, split_type); // Check if last split to write chroma bool last_split = (i + 1) == split_limit; - encode_transform_coeff(state, &loc, depth, 0, 0, 0, 0, coeff, tree_type, last_split); + encode_transform_coeff(state, &split_loc, depth, 0, 0, 0, 0, coeff, tree_type, last_split); } } diff --git a/src/intra.c b/src/intra.c index 700657d9..123b82ae 100644 --- a/src/intra.c +++ b/src/intra.c @@ -1520,6 +1520,7 @@ int uvg_get_isp_split_num(const int width, const int height, const int split_typ void uvg_get_isp_split_loc(cu_loc_t *loc, const int x, const int y, const int block_w, const int block_h, const int split_idx, const int split_type) { assert((split_idx >= 0 && split_idx <= 3) && "ISP split index must be in [0, 3]."); + assert((split_type == ISP_MODE_NO_ISP && split_idx > 0) && "Trying to ISP split when split type = NO_ISP."); int part_dim = block_w; if (split_type != ISP_MODE_NO_ISP) { part_dim = uvg_get_isp_split_dim(block_w, block_h, split_type); @@ -1698,12 +1699,12 @@ void uvg_intra_recon_cu( int split_limit = uvg_get_isp_split_num(width, height, split_type); for (int i = 0; i < split_limit; ++i) { - cu_loc_t loc; - uvg_get_isp_split_loc(&loc, x, y, width, height, i, split_type); + cu_loc_t split_loc; + uvg_get_isp_split_loc(&split_loc, x, y, width, height, i, split_type); - intra_recon_tb_leaf(state, &loc, lcu, COLOR_Y, search_data, tree_type); + intra_recon_tb_leaf(state, &split_loc, lcu, COLOR_Y, search_data, tree_type); uvg_quantize_lcu_residual(state, true, false, false, - &loc, depth, cur_cu, lcu, + &split_loc, depth, cur_cu, lcu, false, tree_type); search_data->best_isp_cbfs |= cbf_is_set(cur_cu->cbf, depth, COLOR_Y) << (i++); } diff --git a/src/rdo.c b/src/rdo.c index 160cc0bc..c467dc94 100644 --- a/src/rdo.c +++ b/src/rdo.c @@ -297,15 +297,17 @@ out: static INLINE double get_coeff_cabac_cost( const encoder_state_t * const state, const coeff_t *coeff, - int32_t width, - int32_t height, + cu_loc_t *cu_loc, color_t color, int8_t scan_mode, int8_t tr_skip, cu_info_t* cur_tu) { + const int width = cu_loc->width; + const int height = cu_loc->height; // Make sure there are coeffs present bool found = false; + // ISP_TODO: this needs to be two separate x, y loops? for (int i = 0; i < width * height; i++) { if (coeff[i] != 0) { found = 1; @@ -331,8 +333,7 @@ static INLINE double get_coeff_cabac_cost( uvg_encode_coeff_nxn((encoder_state_t*) state, &cabac_copy, coeff, - width, - height, + cu_loc, color, scan_mode, cur_tu, @@ -394,8 +395,7 @@ double uvg_get_coeff_cost( const encoder_state_t * const state, const coeff_t *coeff, cu_info_t* cur_tu, - int32_t width, - int32_t height, + cu_loc_t *cu_loc, color_t color, int8_t scan_mode, int8_t tr_skip) @@ -403,6 +403,9 @@ double uvg_get_coeff_cost( uint8_t save_cccs = state->encoder_control->cfg.fastrd_sampling_on; uint8_t check_accuracy = state->encoder_control->cfg.fastrd_accuracy_check_on; + const int width = color == COLOR_Y ? cu_loc->width : cu_loc->chroma_width; + const int height = color == COLOR_Y ? cu_loc->height : cu_loc->chroma_height; + if (state->qp < state->encoder_control->cfg.fast_residual_cost_limit && state->qp < MAX_FAST_COEFF_COST_QP && !tr_skip) { // TODO: do we need to assert(0) out of the fast-estimation branch if we @@ -415,13 +418,13 @@ double uvg_get_coeff_cost( uint64_t weights = uvg_fast_coeff_get_weights(state); uint32_t fast_cost = uvg_fast_coeff_cost(coeff, width, height, weights); if (check_accuracy) { - double ccc = get_coeff_cabac_cost(state, coeff, width, height, color, scan_mode, tr_skip, cur_tu); + double ccc = get_coeff_cabac_cost(state, coeff, cu_loc, color, scan_mode, tr_skip, cur_tu); save_accuracy(state->qp, ccc, fast_cost); } return fast_cost; } } else { - double ccc = get_coeff_cabac_cost(state, coeff, width, height, color, scan_mode, tr_skip, cur_tu); + double ccc = get_coeff_cabac_cost(state, coeff, cu_loc, color, scan_mode, tr_skip, cur_tu); if (save_cccs) { save_ccc(state->qp, coeff, width * width, ccc); } diff --git a/src/rdo.h b/src/rdo.h index 88a6548b..c9b88df3 100644 --- a/src/rdo.h +++ b/src/rdo.h @@ -73,8 +73,7 @@ double uvg_get_coeff_cost( const encoder_state_t * const state, const coeff_t *coeff, cu_info_t* cur_tu, - int32_t width, - int32_t height, + cu_loc_t *cu_loc, color_t color, int8_t scan_mode, int8_t tr_skip); diff --git a/src/search.c b/src/search.c index 2824994d..293a807f 100644 --- a/src/search.c +++ b/src/search.c @@ -316,6 +316,9 @@ double uvg_cu_rd_cost_luma(const encoder_state_t *const state, const int skip_residual_coding = pred_cu->skipped || (pred_cu->type != CU_INTRA && pred_cu->cbf == 0); cabac_data_t* cabac = (cabac_data_t *)&state->search_cabac; + cu_loc_t loc; + uvg_cu_loc_ctor(&loc, x_px, y_px, width, height); + // cur_cu is used for TU parameters. cu_info_t *const tr_cu = LCU_GET_CU_AT_PX(lcu, x_px, y_px); @@ -383,24 +386,22 @@ double uvg_cu_rd_cost_luma(const encoder_state_t *const state, if (pred_cu->type == CU_INTER || pred_cu->intra.isp_mode == ISP_MODE_NO_ISP) { const coeff_t* coeffs = &lcu->coeff.y[xy_to_zorder(LCU_WIDTH, x_px, y_px)]; - coeff_bits += uvg_get_coeff_cost(state, coeffs, NULL, width, height, 0, luma_scan_mode, pred_cu->tr_idx == MTS_SKIP); + coeff_bits += uvg_get_coeff_cost(state, coeffs, NULL, &loc, 0, luma_scan_mode, pred_cu->tr_idx == MTS_SKIP); } else { int split_type = pred_cu->intra.isp_mode; int split_limit = uvg_get_isp_split_num(width, height, split_type); for (int i = 0; i < split_limit; ++i) { - cu_loc_t loc; - uvg_get_isp_split_loc(&loc, x_px, y_px, width, height, i, split_type); - const int part_x = loc.x; - const int part_y = loc.y; - const int part_w = loc.width; - const int part_h = loc.height; + cu_loc_t split_loc; + uvg_get_isp_split_loc(&split_loc, x_px, y_px, width, height, i, split_type); + const int part_x = split_loc.x; + const int part_y = split_loc.y; // TODO: maybe just pass the cu_loc_t to these functions const coeff_t* coeffs = &lcu->coeff.y[xy_to_zorder(LCU_WIDTH, part_x, part_y)]; - coeff_bits += uvg_get_coeff_cost(state, coeffs, NULL, part_w, part_h, 0, luma_scan_mode, pred_cu->tr_idx == MTS_SKIP); + coeff_bits += uvg_get_coeff_cost(state, coeffs, NULL, &split_loc, 0, luma_scan_mode, pred_cu->tr_idx == MTS_SKIP); } } } @@ -421,6 +422,9 @@ double uvg_cu_rd_cost_chroma(const encoder_state_t *const state, cu_info_t *const tr_cu = LCU_GET_CU_AT_PX(lcu, x_px, y_px); const int skip_residual_coding = pred_cu->skipped || (pred_cu->type != CU_INTRA && pred_cu->cbf == 0); + cu_loc_t loc; + uvg_cu_loc_ctor(&loc, x_px, y_px, width, height); + double tr_tree_bits = 0; double coeff_bits = 0; @@ -491,11 +495,11 @@ double uvg_cu_rd_cost_chroma(const encoder_state_t *const state, const int index = xy_to_zorder(LCU_WIDTH_C, lcu_px.x, lcu_px.y); if((pred_cu->joint_cb_cr & 3) == 0){ - coeff_bits += uvg_get_coeff_cost(state, &lcu->coeff.u[index], NULL, width, height, 2, scan_order, 0); - coeff_bits += uvg_get_coeff_cost(state, &lcu->coeff.v[index], NULL, width, height, 2, scan_order, 0); + coeff_bits += uvg_get_coeff_cost(state, &lcu->coeff.u[index], NULL, &loc, 2, scan_order, 0); + coeff_bits += uvg_get_coeff_cost(state, &lcu->coeff.v[index], NULL, &loc, 2, scan_order, 0); } else { - coeff_bits += uvg_get_coeff_cost(state, &lcu->coeff.joint_uv[index], NULL, width, height, 2, scan_order, 0); + coeff_bits += uvg_get_coeff_cost(state, &lcu->coeff.joint_uv[index], NULL, &loc, 2, scan_order, 0); } } @@ -518,6 +522,9 @@ static double cu_rd_cost_tr_split_accurate( const int width = LCU_WIDTH >> depth; const int height = width; // TODO: height for non-square blocks + cu_loc_t loc; + uvg_cu_loc_ctor(&loc, x_px, y_px, width, height); + const int skip_residual_coding = pred_cu->skipped || (pred_cu->type != CU_INTRA && pred_cu->cbf == 0); // cur_cu is used for TU parameters. cu_info_t* const tr_cu = LCU_GET_CU_AT_PX(lcu, x_px, y_px); @@ -622,24 +629,22 @@ static double cu_rd_cost_tr_split_accurate( if (pred_cu->type == CU_INTER || pred_cu->intra.isp_mode == ISP_MODE_NO_ISP) { const coeff_t* coeffs = &lcu->coeff.y[xy_to_zorder(LCU_WIDTH, x_px, y_px)]; - coeff_bits += uvg_get_coeff_cost(state, coeffs, tr_cu, width, height, 0, luma_scan_mode, pred_cu->tr_idx == MTS_SKIP); + coeff_bits += uvg_get_coeff_cost(state, coeffs, tr_cu, &loc, 0, luma_scan_mode, pred_cu->tr_idx == MTS_SKIP); } else { int split_type = pred_cu->intra.isp_mode; int split_limit = uvg_get_isp_split_num(width, height, split_type); for (int i = 0; i < split_limit; ++i) { - cu_loc_t loc; - uvg_get_isp_split_loc(&loc, x_px, y_px, width, height, i, split_type); - const int part_x = loc.x; - const int part_y = loc.y; - const int part_w = loc.width; - const int part_h = loc.height; + cu_loc_t split_loc; + uvg_get_isp_split_loc(&split_loc, x_px, y_px, width, height, i, split_type); + const int part_x = split_loc.x; + const int part_y = split_loc.y; // TODO: maybe just pass the cu_loc_t to these functions const coeff_t* coeffs = &lcu->coeff.y[xy_to_zorder(LCU_WIDTH, part_x, part_y)]; - coeff_bits += uvg_get_coeff_cost(state, coeffs, tr_cu, part_w, part_h, 0, luma_scan_mode, pred_cu->tr_idx == MTS_SKIP); + coeff_bits += uvg_get_coeff_cost(state, coeffs, tr_cu, &split_loc, 0, luma_scan_mode, pred_cu->tr_idx == MTS_SKIP); } } } @@ -691,8 +696,8 @@ static double cu_rd_cost_tr_split_accurate( if(chroma_can_use_tr_skip && cb_flag_v) { CABAC_FBITS_UPDATE(cabac, &cabac->ctx.transform_skip_model_chroma, tr_cu->tr_skip & 4, tr_tree_bits, "transform_skip_flag"); } - coeff_bits += uvg_get_coeff_cost(state, &lcu->coeff.u[index], tr_cu, chroma_width, chroma_height, COLOR_U, scan_order, tr_cu->tr_skip & 2); - coeff_bits += uvg_get_coeff_cost(state, &lcu->coeff.v[index], tr_cu, chroma_width, chroma_height, COLOR_V, scan_order, tr_cu->tr_skip & 4); + coeff_bits += uvg_get_coeff_cost(state, &lcu->coeff.u[index], tr_cu, &loc, COLOR_U, scan_order, tr_cu->tr_skip & 2); + coeff_bits += uvg_get_coeff_cost(state, &lcu->coeff.v[index], tr_cu, &loc, COLOR_V, scan_order, tr_cu->tr_skip & 4); } else { @@ -709,11 +714,11 @@ static double cu_rd_cost_tr_split_accurate( if (chroma_can_use_tr_skip) { CABAC_FBITS_UPDATE(cabac, &cabac->ctx.transform_skip_model_chroma, tr_cu->tr_skip & 2, tr_tree_bits, "transform_skip_flag"); } - coeff_bits += uvg_get_coeff_cost(state, &lcu->coeff.joint_uv[index], tr_cu, chroma_width, chroma_height, COLOR_U, scan_order, 0); + coeff_bits += uvg_get_coeff_cost(state, &lcu->coeff.joint_uv[index], tr_cu, &loc, COLOR_U, scan_order, 0); } } - if (uvg_is_lfnst_allowed(state, tr_cu, width, width, x_px, y_px, tree_type, depth == 4 || tree_type == UVG_CHROMA_T ? COLOR_UV : COLOR_Y, lcu)) { + if (uvg_is_lfnst_allowed(state, tr_cu, width, height, x_px, y_px, tree_type, depth == 4 || tree_type == UVG_CHROMA_T ? COLOR_UV : COLOR_Y, lcu)) { const int lfnst_idx = (depth != 4 && tree_type != UVG_CHROMA_T) ? tr_cu->lfnst_idx : tr_cu->cr_lfnst_idx; CABAC_FBITS_UPDATE( cabac, diff --git a/src/search_inter.c b/src/search_inter.c index e2013c6a..93598ff2 100644 --- a/src/search_inter.c +++ b/src/search_inter.c @@ -2243,8 +2243,7 @@ void uvg_cu_cost_inter_rd2(encoder_state_t * const state, depth, lcu, &cabac_copy, - width, - width, + &loc, index, 0, cur_cu, diff --git a/src/search_intra.c b/src/search_intra.c index cf25936d..5f0b3669 100644 --- a/src/search_intra.c +++ b/src/search_intra.c @@ -1495,11 +1495,16 @@ int8_t uvg_search_intra_chroma_rdo( { const bool reconstruct_chroma = (depth != 4) || (x_px & 4 && y_px & 4); - int log2_width = MAX(LOG2_LCU_WIDTH - depth - 1, 2); - int8_t width = 1 << log2_width; - int8_t height = 1 << log2_width; - const cu_loc_t loc = { x_px & ~7, y_px & ~7, width, height, width, height }; + const int luma_width = LCU_WIDTH >> depth; + const int luma_height = LCU_WIDTH >> depth; // TODO: height + int log2_width = MAX(LOG2_LCU_WIDTH - depth - 1, 2); + + cu_loc_t loc; + uvg_cu_loc_ctor(&loc, x_px & ~7, y_px & ~7, luma_width, luma_height); + + const int chroma_width = loc.chroma_width; + const int chroma_height = loc.chroma_height; uvg_intra_references refs[2]; const vector2d_t luma_px = { x_px & ~7, y_px & ~7 }; const vector2d_t pic_px = { @@ -1576,26 +1581,25 @@ int8_t uvg_search_intra_chroma_rdo( &lcu->ref.u[offset], u_pred, u_resi, - width, - height, + chroma_width, + chroma_height, LCU_WIDTH_C, - width); + chroma_width); uvg_generate_residual( &lcu->ref.v[offset], v_pred, v_resi, - width, - height, + chroma_width, + chroma_height, LCU_WIDTH_C, - width); + chroma_width); uvg_chorma_ts_out_t chorma_ts_out; uvg_chroma_transform_search( state, depth, lcu, &temp_cabac, - width, - height, + &loc, offset, mode, pred_cu, diff --git a/src/strategies/avx2/encode_coding_tree-avx2.h b/src/strategies/avx2/encode_coding_tree-avx2.h index 9fc75c8a..fa4ec8d5 100644 --- a/src/strategies/avx2/encode_coding_tree-avx2.h +++ b/src/strategies/avx2/encode_coding_tree-avx2.h @@ -38,14 +38,14 @@ * Functions for writing the coding quadtree and related syntax. */ +#include "cu.h" #include "encoderstate.h" #include "global.h" void uvg_encode_coeff_nxn_avx2(encoder_state_t * const state, cabac_data_t * const cabac, const coeff_t *coeff, - uint8_t width, - uint8_t height, + cu_loc_t *loc, uint8_t type, int8_t scan_mode, int8_t tr_skip, diff --git a/src/strategies/generic/encode_coding_tree-generic.c b/src/strategies/generic/encode_coding_tree-generic.c index 242e86bc..756cd6d6 100644 --- a/src/strategies/generic/encode_coding_tree-generic.c +++ b/src/strategies/generic/encode_coding_tree-generic.c @@ -54,13 +54,16 @@ void uvg_encode_coeff_nxn_generic(encoder_state_t * const state, cabac_data_t * const cabac, const coeff_t *coeff, - uint8_t width, - uint8_t height, + cu_loc_t *cu_loc, uint8_t color, int8_t scan_mode, cu_info_t* cur_cu, - double* bits_out) { - + double* bits_out) +{ + const int x = cu_loc->x; + const int y = cu_loc->y; + const int width = color == COLOR_Y ? cu_loc->width : cu_loc->chroma_width; + const int height = color == COLOR_Y ? cu_loc->height : cu_loc->chroma_height; //const encoder_control_t * const encoder = state->encoder_control; //int c1 = 1; uint8_t last_coeff_x = 0; @@ -91,10 +94,12 @@ void uvg_encode_coeff_nxn_generic(encoder_state_t * const state, unsigned scan_cg_last = (unsigned)-1; unsigned scan_pos_last = (unsigned)-1; - for (int i = 0; i < width * height; i++) { - if (coeff[scan[i]]) { - scan_pos_last = i; - sig_coeffgroup_flag[scan_cg[i >> log2_cg_size]] = 1; + for (int j = 0; j < height; j++) { + for (int i = 0; i < width; i++) { + if (coeff[scan[i + j * width]]) { + scan_pos_last = i + j * width; + sig_coeffgroup_flag[scan_cg[(i + j * width) >> log2_cg_size]] = 1; + } } } scan_cg_last = scan_pos_last >> log2_cg_size; diff --git a/src/strategies/generic/encode_coding_tree-generic.h b/src/strategies/generic/encode_coding_tree-generic.h index bcf51f15..09255deb 100644 --- a/src/strategies/generic/encode_coding_tree-generic.h +++ b/src/strategies/generic/encode_coding_tree-generic.h @@ -44,8 +44,7 @@ void uvg_encode_coeff_nxn_generic(encoder_state_t * const state, cabac_data_t * const cabac, const coeff_t *coeff, - uint8_t width, - uint8_t height, + cu_loc_t *loc, uint8_t color, int8_t scan_mode, cu_info_t* cur_cu, diff --git a/src/strategies/strategies-encode.h b/src/strategies/strategies-encode.h index f503eb73..2bffacca 100644 --- a/src/strategies/strategies-encode.h +++ b/src/strategies/strategies-encode.h @@ -49,8 +49,7 @@ typedef unsigned (encode_coeff_nxn_func)(encoder_state_t * const state, cabac_data_t * const cabac, const coeff_t *coeff, - uint8_t width, - uint8_t heigth, + cu_loc_t *loc, uint8_t color, int8_t scan_mode, cu_info_t* cur_cu, diff --git a/src/transform.c b/src/transform.c index ffe3c05b..b9fabd65 100644 --- a/src/transform.c +++ b/src/transform.c @@ -483,8 +483,7 @@ void uvg_chroma_transform_search( int depth, lcu_t* const lcu, cabac_data_t* temp_cabac, - int8_t width, - int8_t height, + cu_loc_t *cu_loc, const int offset, const uint8_t mode, cu_info_t* pred_cu, @@ -499,6 +498,9 @@ void uvg_chroma_transform_search( ALIGNED(64) uint8_t u_recon[LCU_WIDTH_C * LCU_WIDTH_C * 5]; ALIGNED(64) coeff_t v_coeff[LCU_WIDTH_C * LCU_WIDTH_C * 2]; ALIGNED(64) uint8_t v_recon[LCU_WIDTH_C * LCU_WIDTH_C * 5]; + const int width = cu_loc->chroma_width; + const int height = cu_loc->chroma_height; + uvg_transform2d( state->encoder_control, u_resi, u_coeff, width, height, COLOR_U, pred_cu ); @@ -689,8 +691,7 @@ void uvg_chroma_transform_search( state, u_quant_coeff, pred_cu, - width, - height, + cu_loc, COLOR_U, scan_order, transforms[i] == CHROMA_TS); @@ -706,8 +707,7 @@ void uvg_chroma_transform_search( state, v_quant_coeff, pred_cu, - width, - height, + cu_loc, COLOR_V, scan_order, transforms[i] == CHROMA_TS); @@ -1161,6 +1161,8 @@ static void quantize_tr_residual( // Pointers to current location in arrays with quantized coefficients. coeff_t *coeff = NULL; + // ISP_TODO: use temp coeff array size MAX_TR_WIDTH^2 instead of coeff pointers + // ISP_TODO: inside temp coeff array, entries are in the old order. PÖTKÖ switch (color) { case COLOR_Y: pred = &lcu->rec.y[offset]; @@ -1272,9 +1274,9 @@ static void quantize_tr_residual( cbf_clear(&cur_pu->cbf, depth, color); if (has_coeffs) { + // ISP_TODO: copy coeffs into CU order instead of pötkö cbf_set(&cur_pu->cbf, depth, color); - } - + } // ISP_TODO: if no coeffs, mem set width * height amount of coeffs to zero } /** diff --git a/src/transform.h b/src/transform.h index f8f81da6..69a9450f 100644 --- a/src/transform.h +++ b/src/transform.h @@ -103,8 +103,7 @@ void uvg_chroma_transform_search( int depth, lcu_t* const lcu, cabac_data_t* temp_cabac, - int8_t width, - int8_t height, + cu_loc_t *cu_loc, const int offset, const uint8_t mode, cu_info_t* pred_cu,