diff --git a/CMakeLists.txt b/CMakeLists.txt index 8f8dc268..7a57c4d6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -124,7 +124,7 @@ endif() # For visual studio / windows we also need our own pthread implementation and getopt if(MSVC) list(APPEND LIB_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/extras/getopt.c ${CMAKE_CURRENT_SOURCE_DIR}/src/threadwrapper/src/pthread.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/threadwrapper/src/semaphore.cpp) - add_definitions(-DWIN32_LEAN_AND_MEAN -D_WIN32 -DWIN32 -DWIN64) + add_definitions(-DWIN32_LEAN_AND_MEAN -D_WIN32 -DWIN32 -DWIN64 -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_DEPRECATE) endif() if(BUILD_SHARED_LIBS) diff --git a/src/alf.c b/src/alf.c index ff312627..d4630a57 100644 --- a/src/alf.c +++ b/src/alf.c @@ -156,7 +156,7 @@ static void set_ey_from_clip(const alf_covariance *cov, const int* clip, double y[k] = cov->y[k][clip[k]]; for (int l = 0; l < size; l++) { - ee[k][l] = cov->ee[k][l][clip[k]][clip[l]]; + ee[k][l] = (double)cov->ee[k][l][clip[k]][clip[l]]; } } } @@ -346,8 +346,8 @@ static double optimize_filter(const alf_covariance *cov, int* clip, double *f, b ky[k] = cov->y[k][clip[k]]; for (int l = 0; l < size; l++) { - ke[k][l] = cov->ee[k][l][clip[k]][clip[l]]; - ke[l][k] = cov->ee[l][k][clip[l]][clip[k]]; + ke[k][l] = (double)cov->ee[k][l][clip[k]][clip[l]]; + ke[l][k] = (double)cov->ee[l][k][clip[l]][clip[k]]; } gns_solve_by_chol(ke, ky, f, size); @@ -367,8 +367,8 @@ static double optimize_filter(const alf_covariance *cov, int* clip, double *f, b ky[k] = cov->y[k][clip[k]]; for (int l = 0; l < size; l++) { - ke[k][l] = cov->ee[k][l][clip[k]][clip[l]]; - ke[l][k] = cov->ee[l][k][clip[l]][clip[k]]; + ke[k][l] = (double)cov->ee[k][l][clip[k]][clip[l]]; + ke[l][k] = (double)cov->ee[l][k][clip[l]][clip[k]]; } gns_solve_by_chol(ke, ky, f, size); @@ -386,8 +386,8 @@ static double optimize_filter(const alf_covariance *cov, int* clip, double *f, b ky[k] = cov->y[k][clip[k]]; for (int l = 0; l < size; l++) { - ke[k][l] = cov->ee[k][l][clip[k]][clip[l]]; - ke[l][k] = cov->ee[l][k][clip[l]][clip[k]]; + ke[k][l] = (double)cov->ee[k][l][clip[k]][clip[l]]; + ke[l][k] = (double)cov->ee[l][k][clip[l]][clip[k]]; } } @@ -398,8 +398,8 @@ static double optimize_filter(const alf_covariance *cov, int* clip, double *f, b ky[idx_min] = cov->y[idx_min][clip[idx_min]]; for (int l = 0; l < size; l++) { - ke[idx_min][l] = cov->ee[idx_min][l][clip[idx_min]][clip[l]]; - ke[l][idx_min] = cov->ee[l][idx_min][clip[l]][clip[idx_min]]; + ke[idx_min][l] = (double)cov->ee[idx_min][l][clip[idx_min]][clip[l]]; + ke[l][idx_min] = (double)cov->ee[l][idx_min][clip[l]][clip[idx_min]]; } } else @@ -1274,11 +1274,11 @@ static void code_alf_ctu_alternative_ctu(encoder_state_t * const state, uint8_t* ctb_alf_alternative = state->tile->frame->alf_info->ctu_alternative[comp_idx]; unsigned num_ones = ctb_alf_alternative[ctu_rs_addr]; assert(ctb_alf_alternative[ctu_rs_addr] < num_alts); - for (int i = 0; i < num_ones; ++i) { + for (uint32_t i = 0; i < num_ones; ++i) { cabac->cur_ctx = &cabac->ctx.alf_ctb_alternatives[comp_idx - 1]; CABAC_BIN(cabac, 1, "alf_ctb_alternatives"); } - if (num_ones < num_alts - 1) { + if ((int32_t)num_ones < num_alts - 1) { cabac->cur_ctx = &cabac->ctx.alf_ctb_alternatives[comp_idx - 1]; CABAC_BIN(cabac, 0, "alf_ctb_alternatives"); } @@ -1295,7 +1295,7 @@ static void code_alf_ctu_alternatives_component(encoder_state_t * const state, return; uint32_t num_ctus = state->tile->frame->width_in_lcu * state->tile->frame->height_in_lcu; bool* ctb_alf_flag = state->tile->frame->alf_info->ctu_enable_flag[comp_id]; - for (int ctu_idx = 0; ctu_idx < num_ctus; ctu_idx++) + for (uint32_t ctu_idx = 0; ctu_idx < num_ctus; ctu_idx++) { if (ctb_alf_flag[ctu_idx]) { @@ -1916,7 +1916,7 @@ static void derive_cc_alf_filter_coeff(alf_covariance *alf_covariance_frame_cc_a ky[k] = alf_covariance_frame_cc_alf[filter_idx].y[k][0]; for (int l = 0; l < size; l++) { - k_e[k][l] = alf_covariance_frame_cc_alf[filter_idx].ee[k][l][0][0]; + k_e[k][l] = (double)alf_covariance_frame_cc_alf[filter_idx].ee[k][l][0][0]; } } @@ -2312,7 +2312,7 @@ static void derive_cc_alf_filter(encoder_state_t * const state, alf_component_id // compute cost of not filtering uint64_t unfiltered_distortion = 0; - for (int ctb_idx = 0; ctb_idx < num_ctus_in_pic; ctb_idx++) + for (uint32_t ctb_idx = 0; ctb_idx < num_ctus_in_pic; ctb_idx++) { unfiltered_distortion += (uint64_t)alf_covariance_cc_alf[ctb_idx].pix_acc; } @@ -2495,7 +2495,7 @@ static void derive_cc_alf_filter(encoder_state_t * const state, alf_component_id // save best coeff and control bool atleast_one_block_undergoes_fitlering = false; - for (int controlIdx = 0; best_filter_count > 0 && controlIdx < num_ctus_in_pic; controlIdx++) + for (uint32_t controlIdx = 0; best_filter_count > 0 && controlIdx < num_ctus_in_pic; controlIdx++) { if (best_filter_control[controlIdx]) { @@ -2523,7 +2523,7 @@ static void derive_cc_alf_filter(encoder_state_t * const state, alf_component_id uint8_t cur_filter_idc = best_map_filter_idx_to_filter_idc[filter_idx]; if (best_filter_idx_enabled[filter_idx]) { - for (int control_idx = 0; control_idx < num_ctus_in_pic; control_idx++) + for (uint32_t control_idx = 0; control_idx < num_ctus_in_pic; control_idx++) { if (filter_control[control_idx] == (filter_idx + 1)) { @@ -2710,11 +2710,11 @@ static void get_blk_stats_cc_alf(encoder_state_t * const state, { if (0 /*g_alf_wssd*/) { - alf_covariance->ee[k][l][b0][b1] += weight * (e_local[k][b0] * (double)e_local[l][b1]); + alf_covariance->ee[k][l][b0][b1] += (int64_t)(weight * (e_local[k][b0] * (double)e_local[l][b1])); } else { - alf_covariance->ee[k][l][b0][b1] += e_local[k][b0] * (double)e_local[l][b1]; + alf_covariance->ee[k][l][b0][b1] += (int64_t)(e_local[k][b0] * (double)e_local[l][b1]); } } } @@ -2723,11 +2723,11 @@ static void get_blk_stats_cc_alf(encoder_state_t * const state, { if (0 /*g_alf_wssd*/) { - alf_covariance->y[k][b] += weight * (e_local[k][b] * (double)y_local); + alf_covariance->y[k][b] += (int32_t)(weight * (e_local[k][b] * (double)y_local)); } else { - alf_covariance->y[k][b] += e_local[k][b] * (double)y_local; + alf_covariance->y[k][b] += (int32_t)(e_local[k][b] * (double)y_local); } } } @@ -5221,7 +5221,7 @@ void uvg_alf_enc_process(encoder_state_t *const state) bool chroma_scale_x = (chroma_fmt == UVG_CSP_444) ? 0 : 1; bool chroma_scale_y = (chroma_fmt != UVG_CSP_420) ? 0 : 1; int8_t uvg_bit_depth = state->encoder_control->bitdepth; - const int32_t num_ctus_in_pic = state->tile->frame->width_in_lcu * state->tile->frame->height_in_lcu; + const uint32_t num_ctus_in_pic = state->tile->frame->width_in_lcu * state->tile->frame->height_in_lcu; const int8_t input_bitdepth = state->encoder_control->bitdepth; double lambda_chroma_weight = 0.0; @@ -5307,7 +5307,7 @@ void uvg_alf_enc_process(encoder_state_t *const state) // get CTB stats for filtering alf_derive_stats_for_filtering(state, arr_vars.alf_clipping_values); - for (int ctb_iIdx = 0; ctb_iIdx < num_ctus_in_pic; ctb_iIdx++) + for (uint32_t ctb_iIdx = 0; ctb_iIdx < num_ctus_in_pic; ctb_iIdx++) { alf_info->alf_ctb_filter_index[ctb_iIdx] = ALF_NUM_FIXED_FILTER_SETS; } diff --git a/src/cabac.c b/src/cabac.c index 9f33b503..742f92c4 100644 --- a/src/cabac.c +++ b/src/cabac.c @@ -204,7 +204,7 @@ void uvg_cabac_encode_trunc_bin(cabac_data_t * const data, const uint32_t bin_va int thresh; int symbol = bin_value; if (max_value > 256) { - int threshVal = 1 << 8; + uint32_t threshVal = 1 << 8; thresh = 8; while (threshVal <= max_value) { thresh++; @@ -329,11 +329,11 @@ void uvg_cabac_write_coeff_remain(cabac_data_t * const cabac, const uint32_t rem unsigned prefix_length = 0; unsigned code_value = (bins >> rice_param) - cutoff; unsigned suffix_length; - if (code_value >= ((1 << max_prefix_length) - 1)) { + if ((int32_t)code_value >= ((1 << max_prefix_length) - 1)) { prefix_length = max_prefix_length; suffix_length = 15 /*max_log2_tr_dynamic_range*/; } else { - while (code_value > ((2 << prefix_length) - 2)) { + while ((int32_t)code_value > ((2 << prefix_length) - 2)) { prefix_length++; } suffix_length = prefix_length + rice_param + 1; diff --git a/src/cfg.c b/src/cfg.c index 96a24bb1..8549b6ad 100644 --- a/src/cfg.c +++ b/src/cfg.c @@ -1477,18 +1477,18 @@ void uvg_config_process_lp_gop(uvg_config *cfg) // Initialize modulos for testing depth. // The picture belong to the lowest depth in which (poc % modulo) == 0. unsigned depth_modulos[8] = { 0 }; - for (int d = 0; d < gop.d; ++d) { + for (uint32_t d = 0; d < gop.d; ++d) { depth_modulos[gop.d - 1 - d] = 1 << d; } depth_modulos[0] = gop.g; cfg->gop_lowdelay = 1; cfg->gop_len = gop.g; - for (int g = 1; g <= gop.g; ++g) { + for (uint32_t g = 1; g <= gop.g; ++g) { uvg_gop_config *gop_pic = &cfg->gop[g - 1]; // Find gop depth for picture. - int gop_layer = 1; + uint32_t gop_layer = 1; while (gop_layer < gop.d && (g % depth_modulos[gop_layer - 1])) { ++gop_layer; } @@ -1541,7 +1541,7 @@ void uvg_config_process_lp_gop(uvg_config *cfg) gop_pic->qp_factor = 0.4624; // from HM } - for (int g = 0; g < gop.g; ++g) { + for (uint32_t g = 0; g < gop.g; ++g) { uvg_gop_config *gop_pic = &cfg->gop[g]; if (!gop_pic->is_ref) { gop_pic->qp_factor = 0.68 * 1.31; // derived from HM @@ -1915,7 +1915,7 @@ static int validate_hevc_level(uvg_config *const cfg) { cfg->max_bitrate = LEVEL_CONSTRAINTS[lvl_idx].main_bitrate * 1000; } - if (cfg->target_bitrate > cfg->max_bitrate) { + if (cfg->target_bitrate > (int32_t)cfg->max_bitrate) { fprintf(stderr, "%s: target bitrate exceeds %i, which is the maximum %s tier level %g bitrate\n", level_err_prefix, cfg->max_bitrate, cfg->high_tier?"high":"main", lvl); level_error = 1; @@ -1934,14 +1934,14 @@ static int validate_hevc_level(uvg_config *const cfg) { uint32_t max_dimension_squared = 8 * max_lps; // check maximum dimensions - if (cfg->width * cfg->width > max_dimension_squared) { - uint32_t max_dim = sqrtf(max_dimension_squared); + if (cfg->width * cfg->width > (int32_t)max_dimension_squared) { + uint32_t max_dim = (uint32_t)sqrtf((float)max_dimension_squared); fprintf(stderr, "%s: picture width of %i is too large for this level (%g), maximum dimension is %i\n", level_err_prefix, cfg->width, lvl, max_dim); level_error = 1; } - if (cfg->height * cfg->height > max_dimension_squared) { - uint32_t max_dim = sqrtf(max_dimension_squared); + if (cfg->height * cfg->height > (int32_t)max_dimension_squared) { + uint32_t max_dim = (uint32_t)sqrtf((float)max_dimension_squared); fprintf(stderr, "%s: picture height of %i is too large for this level (%g), maximum dimension is %i\n", level_err_prefix, cfg->height, lvl, max_dim); level_error = 1; diff --git a/src/context.c b/src/context.c index 5c92d7d2..c1b1a58f 100644 --- a/src/context.c +++ b/src/context.c @@ -638,7 +638,7 @@ uint32_t uvg_context_get_sig_coeff_group_ts(uint32_t* sig_coeff_group_flag, * \param temp_sum temporary output value used in the next steps * \returns context index for current scan position */ -uint32_t uvg_context_get_sig_ctx_idx_abs(const coeff_t* coeff, int32_t pos_x, int32_t pos_y, +uint32_t uvg_context_get_sig_ctx_idx_abs(const coeff_t* coeff, uint32_t pos_x, uint32_t pos_y, uint32_t height, uint32_t width, int8_t type, int32_t* temp_diag, int32_t* temp_sum) { @@ -796,7 +796,7 @@ unsigned uvg_lrg1_ctx_id_abs_ts(const coeff_t* coeff, int32_t pos_x, int32_t pos * \param height height of the block * \returns context go rice parameter */ -uint32_t uvg_abs_sum(const coeff_t* coeff, int32_t pos_x, int32_t pos_y, +uint32_t uvg_abs_sum(const coeff_t* coeff, uint32_t pos_x, uint32_t pos_y, uint32_t height, uint32_t width, uint32_t baselevel) { #define UPDATE(x) sum+=abs(x)/*-(x?1:0)*/ @@ -838,35 +838,9 @@ uint32_t uvg_abs_sum(const coeff_t* coeff, int32_t pos_x, int32_t pos_y, * \param height height of the block * \returns context go rice parameter */ -uint32_t uvg_go_rice_par_abs(const coeff_t* coeff, int32_t pos_x, int32_t pos_y, +uint32_t uvg_go_rice_par_abs(const coeff_t* coeff, uint32_t pos_x, uint32_t pos_y, uint32_t height, uint32_t width, uint32_t baselevel) { -//#define UPDATE(x) sum+=abs(x)/*-(x?1:0)*/ -// -// const coeff_t* data = coeff + pos_x + pos_y * width; -// int sum = 0; -// if (pos_x < width - 1) -// { -// UPDATE(data[1]); -// if (pos_x < width - 2) -// { -// UPDATE(data[2]); -// } -// if (pos_y < height - 1) -// { -// UPDATE(data[width + 1]); -// } -// } -// if (pos_y < height - 1) -// { -// UPDATE(data[width]); -// if (pos_y < height - 2) -// { -// UPDATE(data[width << 1]); -// } -// } -//#undef UPDATE uint32_t check = uvg_abs_sum(coeff, pos_x, pos_y, height, width, baselevel); - return g_go_rice_pars[check]; - /*return g_go_rice_pars[uvg_abs_sum(coeff, pos_x, pos_y, height, width, baselevel)];*/ + return g_go_rice_pars[check]; } \ No newline at end of file diff --git a/src/context.h b/src/context.h index 43d82c1d..366a438a 100644 --- a/src/context.h +++ b/src/context.h @@ -51,7 +51,7 @@ void uvg_context_copy(encoder_state_t * target_state, const encoder_state_t * so uint32_t uvg_context_get_sig_coeff_group( uint32_t *sig_coeff_group_flag,uint32_t pos_x, uint32_t pos_y,int32_t width); uint32_t uvg_context_get_sig_coeff_group_ts(uint32_t* sig_coeff_group_flag, uint32_t pos_x, uint32_t pos_y, int32_t width); -uint32_t uvg_context_get_sig_ctx_idx_abs(const coeff_t* coeff, int32_t pos_x, int32_t pos_y, +uint32_t uvg_context_get_sig_ctx_idx_abs(const coeff_t* coeff, uint32_t pos_x, uint32_t pos_y, uint32_t height, uint32_t width, int8_t type, int32_t* temp_diag, int32_t* temp_sum); @@ -62,10 +62,10 @@ int32_t uvg_derive_mod_coeff(int rightPixel, int belowPixel, coeff_t absCoeff, i unsigned uvg_lrg1_ctx_id_abs_ts(const coeff_t* coeff, int32_t pos_x, int32_t pos_y, int32_t width, int bdpcm); -uint32_t uvg_abs_sum(const coeff_t* coeff, int32_t pos_x, int32_t pos_y, +uint32_t uvg_abs_sum(const coeff_t* coeff, uint32_t pos_x, uint32_t pos_y, uint32_t height, uint32_t width, uint32_t baselevel); -uint32_t uvg_go_rice_par_abs(const coeff_t* coeff, int32_t pos_x, int32_t pos_y, +uint32_t uvg_go_rice_par_abs(const coeff_t* coeff, uint32_t pos_x, uint32_t pos_y, uint32_t height, uint32_t width, uint32_t baselevel); #define CNU 35 diff --git a/src/encode_coding_tree.c b/src/encode_coding_tree.c index f63a8bef..9a3d7dad 100644 --- a/src/encode_coding_tree.c +++ b/src/encode_coding_tree.c @@ -50,9 +50,9 @@ static bool is_mts_allowed(encoder_state_t * const state, cu_info_t *const pred_cu) { uint32_t ts_max_size = 1 << 2; //cu.cs->sps->getLog2MaxTransformSkipBlockSize(); - const int max_size = 32; // CU::isIntra(cu) ? MTS_INTRA_MAX_CU_SIZE : MTS_INTER_MAX_CU_SIZE; - const int cu_width = LCU_WIDTH >> pred_cu->depth; - const int cu_height = LCU_WIDTH >> pred_cu->depth; + const uint32_t max_size = 32; // CU::isIntra(cu) ? MTS_INTRA_MAX_CU_SIZE : MTS_INTER_MAX_CU_SIZE; + const uint32_t cu_width = LCU_WIDTH >> pred_cu->depth; + const uint32_t cu_height = LCU_WIDTH >> pred_cu->depth; //bool mts_allowed = cu.chType == CHANNEL_TYPE_LUMA && compID == COMPONENT_Y; uint8_t mts_type = state->encoder_control->cfg.mts; @@ -109,7 +109,7 @@ void uvg_encode_ts_residual(encoder_state_t* const state, int8_t scan_mode) { //const encoder_control_t * const encoder = state->encoder_control; //int c1 = 1; - int32_t i; + uint32_t i; int32_t blk_pos; // ToDo: large block support in VVC? uint32_t sig_coeffgroup_flag[32 * 32] = { 0 }; @@ -132,7 +132,7 @@ void uvg_encode_ts_residual(encoder_state_t* const state, unsigned scan_cg_last = (unsigned )-1; //unsigned scan_pos_last = (unsigned )-1; - for (int i = 0; i < width * width; i++) { + for (i = 0; i < width * width; i++) { if (coeff[scan[i]]) { //scan_pos_last = i; sig_coeffgroup_flag[scan_cg[i >> log2_cg_size]] = 1; @@ -227,8 +227,8 @@ void uvg_encode_ts_residual(encoder_state_t* const state, } - int cutoffVal = 2; - int numGtBins = 4; + uint32_t cutoffVal = 2; + uint32_t numGtBins = 4; for (int scanPos = firstSigPos; scanPos <= min_sub_pos && maxCtxBins >= 4; scanPos++) { blk_pos = scan[scanPos]; @@ -239,7 +239,7 @@ void uvg_encode_ts_residual(encoder_state_t* const state, belowPixel = pos_y > 0 ? coeff[pos_x + (pos_y - 1) * width] : 0; absLevel = uvg_derive_mod_coeff(rightPixel, belowPixel, abs(coeff[blk_pos]), 0); cutoffVal = 2; - for (int i = 0; i < numGtBins; i++) + for (i = 0; i < numGtBins; i++) { if (absLevel >= cutoffVal) { diff --git a/src/encoder_state-bitstream.c b/src/encoder_state-bitstream.c index decbb110..60ad7e03 100644 --- a/src/encoder_state-bitstream.c +++ b/src/encoder_state-bitstream.c @@ -981,7 +981,7 @@ static void encoder_state_entry_points_explore(const encoder_state_t * const sta int i; for (i = 0; state->children[i].encoder_control; ++i) { if (state->children[i].is_leaf) { - const int my_length = uvg_bitstream_tell(&state->children[i].stream)/8; + const int my_length = (const int)uvg_bitstream_tell(&state->children[i].stream)/8; ++(*r_count); if (my_length > *r_max_length) { *r_max_length = my_length; @@ -996,7 +996,7 @@ static void encoder_state_write_bitstream_entry_points_write(bitstream_t * const int i; for (i = 0; state->children[i].encoder_control; ++i) { if (state->children[i].is_leaf) { - const int my_length = uvg_bitstream_tell(&state->children[i].stream)/8; + const int my_length = (const int)uvg_bitstream_tell(&state->children[i].stream)/8; ++(*r_count); //Don't write the last one if (*r_count < num_entry_points) { @@ -1144,9 +1144,9 @@ static void uvg_encoder_state_write_bitstream_ref_pic_list( struct bitstream_t* const stream, struct encoder_state_t* const state) { - int j; - int ref_negative = 0; - int ref_positive = 0; + uint32_t j; + uint32_t ref_negative = 0; + uint32_t ref_positive = 0; const encoder_control_t* const encoder = state->encoder_control; if (encoder->cfg.gop_len) { for (j = 0; j < state->frame->ref->used_size; j++) { @@ -1176,7 +1176,7 @@ static void uvg_encoder_state_write_bitstream_ref_pic_list( int8_t found = 0; do { delta_poc = encoder->cfg.gop[state->frame->gop_offset].ref_neg[j + poc_shift]; - for (int i = 0; i < state->frame->ref->used_size; i++) { + for (uint32_t i = 0; i < state->frame->ref->used_size; i++) { if (state->frame->ref->pocs[i] == state->frame->poc - delta_poc) { found = 1; break; @@ -1213,7 +1213,7 @@ static void uvg_encoder_state_write_bitstream_ref_pic_list( int8_t found = 0; do { delta_poc = encoder->cfg.gop[state->frame->gop_offset].ref_pos[j + poc_shift]; - for (int i = 0; i < state->frame->ref->used_size; i++) { + for (uint32_t i = 0; i < state->frame->ref->used_size; i++) { if (state->frame->ref->pocs[i] == state->frame->poc + delta_poc) { found = 1; break; @@ -1336,7 +1336,7 @@ void uvg_encoder_state_write_bitstream_slice_header( int ref_positive = 0; const encoder_control_t* const encoder = state->encoder_control; if (encoder->cfg.gop_len) { - for (int j = 0; j < state->frame->ref->used_size; j++) { + for (uint32_t j = 0; j < state->frame->ref->used_size; j++) { if (state->frame->ref->pocs[j] < state->frame->poc) { ref_negative++; } @@ -1573,7 +1573,7 @@ static void encoder_state_write_bitstream_main(encoder_state_t * const state) //Get bitstream length for stats uint64_t newpos = uvg_bitstream_tell(stream); - state->stats_bitstream_length = (newpos >> 3) - (curpos >> 3); + state->stats_bitstream_length = (uint32_t)((newpos >> 3) - (curpos >> 3)); if (state->frame->num > 0) { state->frame->total_bits_coded = state->previous_encoder_state->frame->total_bits_coded; diff --git a/src/encoder_state-ctors_dtors.c b/src/encoder_state-ctors_dtors.c index b8d5e656..bb1300af 100644 --- a/src/encoder_state-ctors_dtors.c +++ b/src/encoder_state-ctors_dtors.c @@ -362,7 +362,7 @@ int uvg_encoder_state_init(encoder_state_t * const child_state, encoder_state_t //Create sub-encoders { const encoder_control_t * const encoder = child_state->encoder_control; - int child_count = 0; + uint32_t child_count = 0; //We first check the type of this element. //If it's a MAIN, it can allow both slices or tiles as child //If it's a TILE, it can allow slices as child, if its parent is not a slice, or wavefront rows if there is no other children @@ -493,7 +493,7 @@ int uvg_encoder_state_init(encoder_state_t * const child_state, encoder_state_t //Fix children parent (since we changed the address), except for the last one which is not ready yet { - int i, j; + uint32_t i, j; for (i = 0; child_state->children[i].encoder_control && i < child_count; ++i) { for (j = 0; child_state->children[i].children[j].encoder_control; ++j) { child_state->children[i].children[j].parent = &child_state->children[i]; @@ -579,7 +579,6 @@ int uvg_encoder_state_init(encoder_state_t * const child_state, encoder_state_t //Remark: this could be optimized, but since it's run only once, it's better to do it in a understandable way. //By default, the full tile - int i; int lcu_id; int lcu_start = 0; //End is the element AFTER the end (iterate < lcu_end) @@ -599,7 +598,7 @@ int uvg_encoder_state_init(encoder_state_t * const child_state, encoder_state_t child_state->lcu_order = MALLOC(lcu_order_element_t, child_state->lcu_order_count); assert(child_state->lcu_order); - for (i = 0; i < child_state->lcu_order_count; ++i) { + for (uint32_t i = 0; i < child_state->lcu_order_count; ++i) { lcu_id = lcu_start + i; child_state->lcu_order[i].encoder_state = child_state; child_state->lcu_order[i].id = lcu_id; @@ -623,11 +622,11 @@ int uvg_encoder_state_init(encoder_state_t * const child_state, encoder_state_t if (!child_state->lcu_order[i].first_row) { //Find LCU above if (child_state->type == ENCODER_STATE_TYPE_WAVEFRONT_ROW) { - int j; + uint32_t j; //For all previous wavefront rows for (j=0; &child_state->parent->children[j] != child_state && child_state->parent->children[j].encoder_control; ++j) { if (child_state->parent->children[j].wfrow->lcu_offset_y == child_state->wfrow->lcu_offset_y - 1) { - int k; + uint32_t k; for (k=0; k < child_state->parent->children[j].lcu_order_count; ++k) { if (child_state->parent->children[j].lcu_order[k].position.x == child_state->lcu_order[i].position.x) { assert(child_state->parent->children[j].lcu_order[k].position.y == child_state->lcu_order[i].position.y - 1); diff --git a/src/encoderstate.c b/src/encoderstate.c index 5a99e588..a2838da7 100644 --- a/src/encoderstate.c +++ b/src/encoderstate.c @@ -817,7 +817,7 @@ static void encoder_state_worker_encode_lcu_bitstream(void * opaque) pthread_mutex_lock(&state->frame->rc_lock); - const uint32_t bits = uvg_bitstream_tell(&state->stream) - existing_bits; + const uint32_t bits = (const uint32_t)(uvg_bitstream_tell(&state->stream) - existing_bits); state->frame->cur_frame_bits_coded += bits; // This variable is used differently by intra and inter frames and shouldn't // be touched in intra frames here @@ -902,7 +902,7 @@ static void encoder_state_encode_leaf(encoder_state_t * const state) // Encode every LCU in order and perform SAO reconstruction after every // frame is encoded. Deblocking and SAO search is done during LCU encoding. - for (int i = 0; i < state->lcu_order_count; ++i) { + for (uint32_t i = 0; i < state->lcu_order_count; ++i) { encoder_state_worker_encode_lcu_search(&state->lcu_order[i]); // Without alf we can code the bitstream right after each LCU to update cabac contexts if (encoder->cfg.alf_type == 0) { @@ -916,7 +916,7 @@ static void encoder_state_encode_leaf(encoder_state_t * const state) // If ALF was used the bitstream coding was simulated in search, reset the cabac/stream // And write the actual bitstream encoder_state_init_children_after_simulation(state); - for (int i = 0; i < state->lcu_order_count; ++i) { + for (uint32_t i = 0; i < state->lcu_order_count; ++i) { encoder_state_worker_encode_lcu_bitstream(&state->lcu_order[i]); } } @@ -952,7 +952,7 @@ static void encoder_state_encode_leaf(encoder_state_t * const state) ref_state = state->previous_encoder_state; } - for (int i = 0; i < state->lcu_order_count; ++i) { + for (uint32_t i = 0; i < state->lcu_order_count; ++i) { const lcu_order_element_t * const lcu = &state->lcu_order[i]; uvg_threadqueue_free_job(&state->tile->wf_jobs[lcu->id]); @@ -1261,7 +1261,7 @@ void uvg_encoder_create_ref_lists(const encoder_state_t *const state) int num_positive = 0; // Add positive references to L1 list - for (int i = 0; i < state->frame->ref->used_size; i++) { + for (uint32_t i = 0; i < state->frame->ref->used_size; i++) { if (state->frame->ref->pocs[i] > state->frame->poc) { state->frame->ref_LX[1][state->frame->ref_LX_size[1]] = i; state->frame->ref_LX_size[1] += 1; @@ -1275,7 +1275,7 @@ void uvg_encoder_create_ref_lists(const encoder_state_t *const state) (cfg->bipred && (cfg->gop_len == 0 || cfg->gop_lowdelay)); // Add negative references to L0 and L1 lists. - for (int i = 0; i < state->frame->ref->used_size; i++) { + for (uint32_t i = 0; i < state->frame->ref->used_size; i++) { if (state->frame->ref->pocs[i] < state->frame->poc) { state->frame->ref_LX[0][state->frame->ref_LX_size[0]] = i; state->frame->ref_LX_size[0] += 1; @@ -1517,7 +1517,7 @@ static void init_erp_aqp_roi(const encoder_control_t *encoder, uvg_picture *fram // Normalize. lcu_weight = (lcu_weight * frame_height) / (total_weight * lcu_height); - int8_t qp_delta = round(-ERP_AQP_STRENGTH * log2(lcu_weight)); + int8_t qp_delta = (int8_t)(round(-ERP_AQP_STRENGTH * log2(lcu_weight))); if (orig_roi) { // If a ROI array already exists, we copy the existing values to the @@ -1595,7 +1595,7 @@ static void next_roi_frame_from_file(uvg_picture *frame, FILE *file, enum uvg_ro frame->roi.roi_array = dqp_array; if (format == UVG_ROI_TXT) { - for (int i = 0; i < size; ++i) { + for (uint32_t i = 0; i < size; ++i) { int number; // Need a pointer to int for fscanf if (fscanf(file, "%d", &number) != 1) { fprintf(stderr, "Reading ROI file failed.\n"); @@ -1663,8 +1663,8 @@ static void encoder_state_init_new_frame(encoder_state_t * const state, uvg_pict unsigned y_lim = state->tile->frame->height_in_lcu; unsigned id = 0; - for (int y = 0; y < y_lim; ++y) { - for (int x = 0; x < x_lim; ++x) { + for (uint32_t y = 0; y < y_lim; ++y) { + for (uint32_t x = 0; x < x_lim; ++x) { uvg_pixel tmp[LCU_LUMA_SIZE]; int pxl_x = x * LCU_WIDTH; int pxl_y = y * LCU_WIDTH; diff --git a/src/fast_coeff_cost.c b/src/fast_coeff_cost.c index d708fbfd..6fa99b73 100644 --- a/src/fast_coeff_cost.c +++ b/src/fast_coeff_cost.c @@ -35,7 +35,7 @@ #include "encoderstate.h" // Note: Assumes that costs are non-negative, for pretty obvious reasons -static uint16_t to_q88(float f) +static uint16_t to_q88(double f) { return (uint16_t)(f * 256.0f + 0.5f); } diff --git a/src/filter.c b/src/filter.c index 1641109d..7bd27778 100644 --- a/src/filter.c +++ b/src/filter.c @@ -241,17 +241,17 @@ static INLINE void uvg_filter_deblock_chroma(const encoder_control_t * const enc if (part_P_nofilter) { if (large_boundary) { - src[-offset * 3] = m1; - src[-offset * 2] = m2; + src[-offset * 3] = (uvg_pixel)m1; + src[-offset * 2] = (uvg_pixel)m2; } - src[-offset * 1] = m3; + src[-offset * 1] = (uvg_pixel)m3; } if (part_Q_nofilter) { if (large_boundary) { - src[offset * 1] = m5; - src[offset * 2] = m6; + src[offset * 1] = (uvg_pixel)m5; + src[offset * 2] = (uvg_pixel)m6; } - src[0] = m4; + src[0] = (uvg_pixel)m4; } } diff --git a/src/imagelist.c b/src/imagelist.c index ad2de417..f9f06281 100644 --- a/src/imagelist.c +++ b/src/imagelist.c @@ -186,13 +186,13 @@ int uvg_image_list_rem(image_list_t * const list, const unsigned n) } list->used_size--; } else { - int i = n; + uint32_t i = n; // Shift all following pics one backward in the list for (i = n; i < list->used_size - 1; ++i) { list->images[i] = list->images[i + 1]; list->cu_arrays[i] = list->cu_arrays[i + 1]; list->pocs[i] = list->pocs[i + 1]; - for (int j = 0; j < 16; j++) { + for (uint32_t j = 0; j < 16; j++) { list->ref_LXs[i][0][j] = list->ref_LXs[i + 1][0][j]; list->ref_LXs[i][1][j] = list->ref_LXs[i + 1][1][j]; } diff --git a/src/input_frame_buffer.c b/src/input_frame_buffer.c index 66bdea4f..02b54f83 100644 --- a/src/input_frame_buffer.c +++ b/src/input_frame_buffer.c @@ -162,12 +162,12 @@ uvg_picture* uvg_encoder_feed_frame(input_frame_buffer_t *buf, if (!cfg->open_gop && cfg->intra_period > 0) { // Offset the GOP position for each extra I-frame added to the structure // in closed gop case - int num_extra_frames = (buf->num_out - 1) / (cfg->intra_period + 1); + int32_t num_extra_frames = (int32_t)((buf->num_out - 1) / (cfg->intra_period + 1)); gop_offset = (buf->num_out - 1 - num_extra_frames) % cfg->gop_len; } // Index of the first picture in the GOP that is being output. - int gop_start_idx = buf->num_out - 1 - gop_offset; + int32_t gop_start_idx = (int32_t)(buf->num_out - 1 - gop_offset); // Skip pictures until we find an available one. gop_offset += buf->gop_skipped; @@ -179,7 +179,7 @@ uvg_picture* uvg_encoder_feed_frame(input_frame_buffer_t *buf, for (;;) { assert(gop_offset < cfg->gop_len + is_closed_gop ? 1 : 0); idx_out = gop_start_idx + cfg->gop[gop_offset].poc_offset - 1; - if (idx_out < buf->num_in - 1) { + if (idx_out < (int64_t)buf->num_in - 1) { // An available picture found. break; } @@ -191,10 +191,10 @@ uvg_picture* uvg_encoder_feed_frame(input_frame_buffer_t *buf, if (buf->num_out < cfg->gop_len - 1) { // This picture needs a DTS that is less than the PTS of the first // frame so the delay must be applied. - int dts_idx = buf->num_out - 1; + int32_t dts_idx = (int32_t)(buf->num_out - 1); dts_out = buf->pts_buffer[dts_idx % gop_buf_size] + buf->delay; } else { - int dts_idx = buf->num_out - (cfg->gop_len - 1); + int32_t dts_idx = (int32_t)(buf->num_out - (cfg->gop_len - 1)); dts_out = buf->pts_buffer[dts_idx % gop_buf_size] - 1; } } diff --git a/src/inter.c b/src/inter.c index ddaa31df..db000e84 100644 --- a/src/inter.c +++ b/src/inter.c @@ -890,8 +890,8 @@ static void get_temporal_merge_candidates(const encoder_state_t * const state, cu_array_t *ref_cu_array = state->frame->ref->cu_arrays[colocated_ref]; int cu_per_width = ref_cu_array->width / SCU_WIDTH; - uint32_t xColBr = x + width; - uint32_t yColBr = y + height; + int32_t xColBr = x + width; + int32_t yColBr = y + height; // C0 must be available if (xColBr < state->encoder_control->in.width && @@ -911,8 +911,8 @@ static void get_temporal_merge_candidates(const encoder_state_t * const state, } } } - uint32_t xColCtr = x + (width / 2); - uint32_t yColCtr = y + (height / 2); + int32_t xColCtr = x + (width / 2); + int32_t yColCtr = y + (height / 2); // C1 must be inside the LCU, in the center position of current CU if (xColCtr < state->encoder_control->in.width && yColCtr < state->encoder_control->in.height) { @@ -1222,7 +1222,7 @@ static bool add_temporal_candidate(const encoder_state_t *state, // uvg266 always sets collocated_from_l0_flag so the list is L1 when // there are future references. int col_list = reflist; - for (int i = 0; i < state->frame->ref->used_size; i++) { + for (uint32_t i = 0; i < state->frame->ref->used_size; i++) { if (state->frame->ref->pocs[i] > state->frame->poc) { col_list = 1; break; @@ -1778,7 +1778,7 @@ uint8_t uvg_inter_get_merge_cand(const encoder_state_t * const state, mv_cand[candidates].mv[reflist][0] = avg_mv[0]; mv_cand[candidates].mv[reflist][1] = avg_mv[1]; - mv_cand[candidates].ref[reflist] = ref_i; + mv_cand[candidates].ref[reflist] = (uint8_t)ref_i; } // only one MV is valid, take the only one MV else if (ref_i != -1) @@ -1787,7 +1787,7 @@ uint8_t uvg_inter_get_merge_cand(const encoder_state_t * const state, mv_cand[candidates].mv[reflist][0] = mv_i[0]; mv_cand[candidates].mv[reflist][1] = mv_i[1]; - mv_cand[candidates].ref[reflist] = ref_i; + mv_cand[candidates].ref[reflist] = (uint8_t)ref_i; } else if (ref_j != -1) { @@ -1795,7 +1795,7 @@ uint8_t uvg_inter_get_merge_cand(const encoder_state_t * const state, mv_cand[candidates].mv[reflist][0] = mv_j[0]; mv_cand[candidates].mv[reflist][1] = mv_j[1]; - mv_cand[candidates].ref[reflist] = ref_j; + mv_cand[candidates].ref[reflist] = (uint8_t)ref_j; } } @@ -1812,10 +1812,9 @@ uint8_t uvg_inter_get_merge_cand(const encoder_state_t * const state, int num_ref = state->frame->ref->used_size; if (candidates < max_num_cands && state->frame->slicetype == UVG_SLICE_B) { - int j; int ref_negative = 0; int ref_positive = 0; - for (j = 0; j < state->frame->ref->used_size; j++) { + for (uint32_t j = 0; j < state->frame->ref->used_size; j++) { if (state->frame->ref->pocs[j] < state->frame->poc) { ref_negative++; } else { diff --git a/src/ml_classifier_intra_depth_pred.c b/src/ml_classifier_intra_depth_pred.c index bb278960..ce790188 100644 --- a/src/ml_classifier_intra_depth_pred.c +++ b/src/ml_classifier_intra_depth_pred.c @@ -43,7 +43,7 @@ int uvg_tree_predict_merge_depth_1(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 19428.0; *p_nb_bad = 1740.0; - return -1.0000; + return -1; } else if (p_features->sub_variance_0 <= 9.1015) { @@ -51,36 +51,36 @@ int uvg_tree_predict_merge_depth_1(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1166.0; *p_nb_bad = 358.0; - return -1.0000; + return -1; } else { *p_nb_iter = 1049.0; *p_nb_bad = 392.0; - return 1.0000; + return 1; } } else { *p_nb_iter = 9371.0; *p_nb_bad = 1805.0; - return -1.0000; + return -1; } } else if (p_features->sub_variance_2 <= 23.3193) { *p_nb_iter = 1059.0; *p_nb_bad = 329.0; - return 1.0000; + return 1; } else if (p_features->sub_variance_1 <= 30.7348) { *p_nb_iter = 1042.0; *p_nb_bad = 395.0; - return 1.0000; + return 1; } else { *p_nb_iter = 1756.0; *p_nb_bad = 588.0; - return -1.0000; + return -1; } } else if (p_features->merge_variance <= 857.8047) @@ -91,7 +91,7 @@ int uvg_tree_predict_merge_depth_1(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 2006.0; *p_nb_bad = 374.0; - return 1.0000; + return 1; } else if (p_features->neigh_variance_C <= 646.8204) { @@ -103,60 +103,60 @@ int uvg_tree_predict_merge_depth_1(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1208.0; *p_nb_bad = 399.0; - return 1.0000; + return 1; } else if (p_features->var_of_sub_var <= 11832.6635) { *p_nb_iter = 8701.0; *p_nb_bad = 3037.0; - return -1.0000; + return -1; } else if (p_features->neigh_variance_A <= 142.298) { *p_nb_iter = 1025.0; *p_nb_bad = 290.0; - return 1.0000; + return 1; } else if (p_features->variance <= 394.4839) { *p_nb_iter = 1156.0; *p_nb_bad = 489.0; - return 1.0000; + return 1; } else { *p_nb_iter = 1150.0; *p_nb_bad = 503.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 1777.0; *p_nb_bad = 558.0; - return 1.0000; + return 1; } } else { *p_nb_iter = 1587.0; *p_nb_bad = 411.0; - return 1.0000; + return 1; } } else { *p_nb_iter = 1980.0; *p_nb_bad = 474.0; - return 1.0000; + return 1; } } else { *p_nb_iter = 3613.0; *p_nb_bad = 475.0; - return 1.0000; + return 1; } } else { *p_nb_iter = 20926.0; *p_nb_bad = 1873.0; - return 1.0000; + return 1; } } @@ -172,30 +172,30 @@ int uvg_tree_predict_merge_depth_2(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 29253.0; *p_nb_bad = 3837.0; - return -1.0000; + return -1; } else if (p_features->variance <= 20.8711) { *p_nb_iter = 1292.0; *p_nb_bad = 458.0; - return 2.0000; + return 2; } else { *p_nb_iter = 1707.0; *p_nb_bad = 399.0; - return -1.0000; + return -1; } } else if (p_features->var_of_sub_var <= 3300.4034) { *p_nb_iter = 1554.0; *p_nb_bad = 675.0; - return -1.0000; + return -1; } else { *p_nb_iter = 1540.0; *p_nb_bad = 429.0; - return 2.0000; + return 2; } } else if (p_features->merge_variance <= 696.1989) @@ -206,7 +206,7 @@ int uvg_tree_predict_merge_depth_2(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 3473.0; *p_nb_bad = 768.0; - return 2.0000; + return 2; } else if (p_features->neigh_variance_C <= 571.5329) { @@ -216,7 +216,7 @@ int uvg_tree_predict_merge_depth_2(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1887.0; *p_nb_bad = 588.0; - return 2.0000; + return 2; } else if (p_features->neigh_variance_A <= 380.5927) { @@ -224,48 +224,48 @@ int uvg_tree_predict_merge_depth_2(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1686.0; *p_nb_bad = 721.0; - return 2.0000; + return 2; } else if (p_features->neigh_variance_A <= 66.6749) { *p_nb_iter = 1440.0; *p_nb_bad = 631.0; - return 2.0000; + return 2; } else { *p_nb_iter = 5772.0; *p_nb_bad = 2031.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 1791.0; *p_nb_bad = 619.0; - return 2.0000; + return 2; } } else { *p_nb_iter = 1624.0; *p_nb_bad = 494.0; - return 2.0000; + return 2; } } else { *p_nb_iter = 1298.0; *p_nb_bad = 312.0; - return 2.0000; + return 2; } } else { *p_nb_iter = 4577.0; *p_nb_bad = 892.0; - return 2.0000; + return 2; } } else { *p_nb_iter = 21106.0; *p_nb_bad = 2744.0; - return 2.0000; + return 2; } } @@ -279,12 +279,12 @@ int uvg_tree_predict_merge_depth_3(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 29806.0; *p_nb_bad = 3603.0; - return -1.0000; + return -1; } else { *p_nb_iter = 1003.0; *p_nb_bad = 421.0; - return 3.0000; + return 3; } } else if (p_features->merge_variance <= 351.8138) @@ -301,48 +301,48 @@ int uvg_tree_predict_merge_depth_3(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1290.0; *p_nb_bad = 525.0; - return 3.0000; + return 3; } else if (p_features->neigh_variance_B <= 16.9287) { *p_nb_iter = 1045.0; *p_nb_bad = 499.0; - return 3.0000; + return 3; } else { *p_nb_iter = 6901.0; *p_nb_bad = 2494.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 1332.0; *p_nb_bad = 408.0; - return 3.0000; + return 3; } } else { *p_nb_iter = 2929.0; *p_nb_bad = 842.0; - return 3.0000; + return 3; } } else { *p_nb_iter = 2239.0; *p_nb_bad = 572.0; - return 3.0000; + return 3; } } else { *p_nb_iter = 2777.0; *p_nb_bad = 714.0; - return 3.0000; + return 3; } } else { *p_nb_iter = 30678.0; *p_nb_bad = 5409.0; - return 3.0000; + return 3; } } @@ -368,54 +368,54 @@ int uvg_tree_predict_merge_depth_4(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 27398.0; *p_nb_bad = 4665.0; - return -1.0000; + return -1; } else { *p_nb_iter = 1676.0; *p_nb_bad = 795.0; - return 4.0000; + return 4; } } else { *p_nb_iter = 1405.0; *p_nb_bad = 566.0; - return 4.0000; + return 4; } } else { *p_nb_iter = 2827.0; *p_nb_bad = 1173.0; - return 4.0000; + return 4; } } else { *p_nb_iter = 8871.0; *p_nb_bad = 822.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 3162.0; *p_nb_bad = 718.0; - return 4.0000; + return 4; } } else { *p_nb_iter = 6154.0; *p_nb_bad = 1397.0; - return 4.0000; + return 4; } } else { *p_nb_iter = 9385.0; *p_nb_bad = 1609.0; - return 4.0000; + return 4; } } else { *p_nb_iter = 19122.0; *p_nb_bad = 2960.0; - return 4.0000; + return 4; } } @@ -429,13 +429,13 @@ int uvg_tree_predict_split_depth_0(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 25155.0; *p_nb_bad = 2959.0; - return 0.0000; + return 0; } else if (p_features->sub_variance_2 <= 13.2892) { *p_nb_iter = 1080.0; *p_nb_bad = 383.0; - return -1.0000; + return -1; } else if (p_features->variance <= 564.1738) { @@ -443,7 +443,7 @@ int uvg_tree_predict_split_depth_0(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 6067.0; *p_nb_bad = 1699.0; - return 0.0000; + return 0; } else if (p_features->var_of_sub_mean <= 46.2388) { @@ -451,30 +451,30 @@ int uvg_tree_predict_split_depth_0(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1088.0; *p_nb_bad = 377.0; - return -1.0000; + return -1; } else if (p_features->sub_variance_3 <= 61.4213) { *p_nb_iter = 1183.0; *p_nb_bad = 498.0; - return -1.0000; + return -1; } else { *p_nb_iter = 3416.0; *p_nb_bad = 1373.0; - return 0.0000; + return 0; } } else { *p_nb_iter = 3769.0; *p_nb_bad = 1093.0; - return 0.0000; + return 0; } } else { *p_nb_iter = 1036.0; *p_nb_bad = 434.0; - return -1.0000; + return -1; } } else if (p_features->var_of_sub_var <= 98333.8279) @@ -487,42 +487,42 @@ int uvg_tree_predict_split_depth_0(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1323.0; *p_nb_bad = 301.0; - return -1.0000; + return -1; } else if (p_features->var_of_sub_var <= 17347.3971) { *p_nb_iter = 1215.0; *p_nb_bad = 550.0; - return 0.0000; + return 0; } else if (p_features->qp <= 22) { *p_nb_iter = 1000.0; *p_nb_bad = 493.0; - return 0.0000; + return 0; } else { *p_nb_iter = 2640.0; *p_nb_bad = 1121.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 5188.0; *p_nb_bad = 1248.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 2323.0; *p_nb_bad = 274.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 21357.0; *p_nb_bad = 1829.0; - return -1.0000; + return -1; } } @@ -533,7 +533,7 @@ int uvg_tree_predict_split_depth_1(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 32445.0; *p_nb_bad = 4580.0; - return 1.0000; + return 1; } else if (p_features->var_of_sub_var <= 27289.2117) { @@ -541,7 +541,7 @@ int uvg_tree_predict_split_depth_1(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1900.0; *p_nb_bad = 401.0; - return -1.0000; + return -1; } else if (p_features->var_of_sub_var <= 5841.4773) { @@ -549,25 +549,25 @@ int uvg_tree_predict_split_depth_1(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1000.0; *p_nb_bad = 356.0; - return -1.0000; + return -1; } else if (p_features->neigh_variance_A <= 633.8163) { *p_nb_iter = 5279.0; *p_nb_bad = 1961.0; - return 1.0000; + return 1; } else { *p_nb_iter = 1176.0; *p_nb_bad = 527.0; - return -1.0000; + return -1; } } else if (p_features->sub_variance_0 <= 38.3035) { *p_nb_iter = 1251.0; *p_nb_bad = 293.0; - return -1.0000; + return -1; } else if (p_features->neigh_variance_B <= 664.9494) { @@ -575,7 +575,7 @@ int uvg_tree_predict_split_depth_1(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1276.0; *p_nb_bad = 471.0; - return -1.0000; + return -1; } else if (p_features->sub_variance_3 <= 404.3086) { @@ -583,36 +583,36 @@ int uvg_tree_predict_split_depth_1(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1005.0; *p_nb_bad = 435.0; - return -1.0000; + return -1; } else if (p_features->sub_variance_0 <= 282.3064) { *p_nb_iter = 1370.0; *p_nb_bad = 539.0; - return 1.0000; + return 1; } else { *p_nb_iter = 1013.0; *p_nb_bad = 495.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 1000.0; *p_nb_bad = 379.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 2270.0; *p_nb_bad = 679.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 29015.0; *p_nb_bad = 3950.0; - return -1.0000; + return -1; } } @@ -625,13 +625,13 @@ int uvg_tree_predict_split_depth_2(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 23216.0; *p_nb_bad = 1560.0; - return 2.0000; + return 2; } else if (p_features->merge_variance <= 259.6952) { *p_nb_iter = 7470.0; *p_nb_bad = 1902.0; - return 2.0000; + return 2; } else if (p_features->qp <= 27) { @@ -639,18 +639,18 @@ int uvg_tree_predict_split_depth_2(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1138.0; *p_nb_bad = 486.0; - return -1.0000; + return -1; } else { *p_nb_iter = 1619.0; *p_nb_bad = 716.0; - return 2.0000; + return 2; } } else { *p_nb_iter = 2425.0; *p_nb_bad = 861.0; - return 2.0000; + return 2; } } else if (p_features->var_of_sub_var <= 60850.5208) @@ -663,7 +663,7 @@ int uvg_tree_predict_split_depth_2(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1796.0; *p_nb_bad = 586.0; - return -1.0000; + return -1; } else if (p_features->neigh_variance_A <= 493.5849) { @@ -671,42 +671,42 @@ int uvg_tree_predict_split_depth_2(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1326.0; *p_nb_bad = 557.0; - return -1.0000; + return -1; } else if (p_features->variance <= 156.4014) { *p_nb_iter = 1210.0; *p_nb_bad = 563.0; - return -1.0000; + return -1; } else { *p_nb_iter = 1920.0; *p_nb_bad = 817.0; - return 2.0000; + return 2; } } else { *p_nb_iter = 1106.0; *p_nb_bad = 437.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 1001.0; *p_nb_bad = 278.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 13068.0; *p_nb_bad = 3612.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 22705.0; *p_nb_bad = 2687.0; - return -1.0000; + return -1; } } @@ -720,7 +720,7 @@ int uvg_tree_predict_split_depth_3(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 20568.0; *p_nb_bad = 767.0; - return 3.0000; + return 3; } else if (p_features->qp <= 27) { @@ -728,24 +728,24 @@ int uvg_tree_predict_split_depth_3(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1255.0; *p_nb_bad = 206.0; - return 3.0000; + return 3; } else if (p_features->merge_variance <= 375.2185) { *p_nb_iter = 3999.0; *p_nb_bad = 1321.0; - return 3.0000; + return 3; } else { *p_nb_iter = 1786.0; *p_nb_bad = 817.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 5286.0; *p_nb_bad = 737.0; - return 3.0000; + return 3; } } else if (p_features->var_of_sub_var <= 37332.3018) @@ -760,7 +760,7 @@ int uvg_tree_predict_split_depth_3(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1114.0; *p_nb_bad = 346.0; - return -1.0000; + return -1; } else if (p_features->neigh_variance_B <= 221.5469) { @@ -768,53 +768,53 @@ int uvg_tree_predict_split_depth_3(features_s* p_features, double* p_nb_iter, do { *p_nb_iter = 1539.0; *p_nb_bad = 606.0; - return 3.0000; + return 3; } else if (p_features->variance <= 155.5974) { *p_nb_iter = 1298.0; *p_nb_bad = 634.0; - return 3.0000; + return 3; } else { *p_nb_iter = 1076.0; *p_nb_bad = 456.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 1644.0; *p_nb_bad = 639.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 2401.0; *p_nb_bad = 713.0; - return -1.0000; + return -1; } } else if (p_features->merge_variance <= 281.9509) { *p_nb_iter = 1020.0; *p_nb_bad = 262.0; - return 3.0000; + return 3; } else { *p_nb_iter = 1278.0; *p_nb_bad = 594.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 10507.0; *p_nb_bad = 2943.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 25229.0; *p_nb_bad = 3060.0; - return -1.0000; + return -1; } } diff --git a/src/ml_intra_cu_depth_pred.c b/src/ml_intra_cu_depth_pred.c index e9cbd50e..e3866ffd 100644 --- a/src/ml_intra_cu_depth_pred.c +++ b/src/ml_intra_cu_depth_pred.c @@ -43,7 +43,7 @@ static int uvg_tree_predict_merge_depth_1(features_s* p_features, double* p_nb_i { *p_nb_iter = 19428.0; *p_nb_bad = 1740.0; - return -1.0000; + return -1; } else if (p_features->sub_variance_0 <= 9.1015) { @@ -51,36 +51,36 @@ static int uvg_tree_predict_merge_depth_1(features_s* p_features, double* p_nb_i { *p_nb_iter = 1166.0; *p_nb_bad = 358.0; - return -1.0000; + return -1; } else { *p_nb_iter = 1049.0; *p_nb_bad = 392.0; - return 1.0000; + return 1; } } else { *p_nb_iter = 9371.0; *p_nb_bad = 1805.0; - return -1.0000; + return -1; } } else if (p_features->sub_variance_2 <= 23.3193) { *p_nb_iter = 1059.0; *p_nb_bad = 329.0; - return 1.0000; + return 1; } else if (p_features->sub_variance_1 <= 30.7348) { *p_nb_iter = 1042.0; *p_nb_bad = 395.0; - return 1.0000; + return 1; } else { *p_nb_iter = 1756.0; *p_nb_bad = 588.0; - return -1.0000; + return -1; } } else if (p_features->merge_variance <= 857.8047) @@ -91,7 +91,7 @@ static int uvg_tree_predict_merge_depth_1(features_s* p_features, double* p_nb_i { *p_nb_iter = 2006.0; *p_nb_bad = 374.0; - return 1.0000; + return 1; } else if (p_features->neigh_variance_C <= 646.8204) { @@ -103,60 +103,60 @@ static int uvg_tree_predict_merge_depth_1(features_s* p_features, double* p_nb_i { *p_nb_iter = 1208.0; *p_nb_bad = 399.0; - return 1.0000; + return 1; } else if (p_features->var_of_sub_var <= 11832.6635) { *p_nb_iter = 8701.0; *p_nb_bad = 3037.0; - return -1.0000; + return -1; } else if (p_features->neigh_variance_A <= 142.298) { *p_nb_iter = 1025.0; *p_nb_bad = 290.0; - return 1.0000; + return 1; } else if (p_features->variance <= 394.4839) { *p_nb_iter = 1156.0; *p_nb_bad = 489.0; - return 1.0000; + return 1; } else { *p_nb_iter = 1150.0; *p_nb_bad = 503.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 1777.0; *p_nb_bad = 558.0; - return 1.0000; + return 1; } } else { *p_nb_iter = 1587.0; *p_nb_bad = 411.0; - return 1.0000; + return 1; } } else { *p_nb_iter = 1980.0; *p_nb_bad = 474.0; - return 1.0000; + return 1; } } else { *p_nb_iter = 3613.0; *p_nb_bad = 475.0; - return 1.0000; + return 1; } } else { *p_nb_iter = 20926.0; *p_nb_bad = 1873.0; - return 1.0000; + return 1; } } @@ -171,30 +171,30 @@ static int uvg_tree_predict_merge_depth_2(features_s* p_features, double* p_nb_i { *p_nb_iter = 29253.0; *p_nb_bad = 3837.0; - return -1.0000; + return -1; } else if (p_features->variance <= 20.8711) { *p_nb_iter = 1292.0; *p_nb_bad = 458.0; - return 2.0000; + return 2; } else { *p_nb_iter = 1707.0; *p_nb_bad = 399.0; - return -1.0000; + return -1; } } else if (p_features->var_of_sub_var <= 3300.4034) { *p_nb_iter = 1554.0; *p_nb_bad = 675.0; - return -1.0000; + return -1; } else { *p_nb_iter = 1540.0; *p_nb_bad = 429.0; - return 2.0000; + return 2; } } else if (p_features->merge_variance <= 696.1989) @@ -205,7 +205,7 @@ static int uvg_tree_predict_merge_depth_2(features_s* p_features, double* p_nb_i { *p_nb_iter = 3473.0; *p_nb_bad = 768.0; - return 2.0000; + return 2; } else if (p_features->neigh_variance_C <= 571.5329) { @@ -215,7 +215,7 @@ static int uvg_tree_predict_merge_depth_2(features_s* p_features, double* p_nb_i { *p_nb_iter = 1887.0; *p_nb_bad = 588.0; - return 2.0000; + return 2; } else if (p_features->neigh_variance_A <= 380.5927) { @@ -223,48 +223,48 @@ static int uvg_tree_predict_merge_depth_2(features_s* p_features, double* p_nb_i { *p_nb_iter = 1686.0; *p_nb_bad = 721.0; - return 2.0000; + return 2; } else if (p_features->neigh_variance_A <= 66.6749) { *p_nb_iter = 1440.0; *p_nb_bad = 631.0; - return 2.0000; + return 2; } else { *p_nb_iter = 5772.0; *p_nb_bad = 2031.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 1791.0; *p_nb_bad = 619.0; - return 2.0000; + return 2; } } else { *p_nb_iter = 1624.0; *p_nb_bad = 494.0; - return 2.0000; + return 2; } } else { *p_nb_iter = 1298.0; *p_nb_bad = 312.0; - return 2.0000; + return 2; } } else { *p_nb_iter = 4577.0; *p_nb_bad = 892.0; - return 2.0000; + return 2; } } else { *p_nb_iter = 21106.0; *p_nb_bad = 2744.0; - return 2.0000; + return 2; } } @@ -278,12 +278,12 @@ static int uvg_tree_predict_merge_depth_3(features_s* p_features, double* p_nb_i { *p_nb_iter = 29806.0; *p_nb_bad = 3603.0; - return -1.0000; + return -1; } else { *p_nb_iter = 1003.0; *p_nb_bad = 421.0; - return 3.0000; + return 3; } } else if (p_features->merge_variance <= 351.8138) @@ -300,48 +300,48 @@ static int uvg_tree_predict_merge_depth_3(features_s* p_features, double* p_nb_i { *p_nb_iter = 1290.0; *p_nb_bad = 525.0; - return 3.0000; + return 3; } else if (p_features->neigh_variance_B <= 16.9287) { *p_nb_iter = 1045.0; *p_nb_bad = 499.0; - return 3.0000; + return 3; } else { *p_nb_iter = 6901.0; *p_nb_bad = 2494.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 1332.0; *p_nb_bad = 408.0; - return 3.0000; + return 3; } } else { *p_nb_iter = 2929.0; *p_nb_bad = 842.0; - return 3.0000; + return 3; } } else { *p_nb_iter = 2239.0; *p_nb_bad = 572.0; - return 3.0000; + return 3; } } else { *p_nb_iter = 2777.0; *p_nb_bad = 714.0; - return 3.0000; + return 3; } } else { *p_nb_iter = 30678.0; *p_nb_bad = 5409.0; - return 3.0000; + return 3; } } @@ -367,54 +367,54 @@ static int uvg_tree_predict_merge_depth_4(features_s* p_features, double* p_nb_i { *p_nb_iter = 27398.0; *p_nb_bad = 4665.0; - return -1.0000; + return -1; } else { *p_nb_iter = 1676.0; *p_nb_bad = 795.0; - return 4.0000; + return 4; } } else { *p_nb_iter = 1405.0; *p_nb_bad = 566.0; - return 4.0000; + return 4; } } else { *p_nb_iter = 2827.0; *p_nb_bad = 1173.0; - return 4.0000; + return 4; } } else { *p_nb_iter = 8871.0; *p_nb_bad = 822.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 3162.0; *p_nb_bad = 718.0; - return 4.0000; + return 4; } } else { *p_nb_iter = 6154.0; *p_nb_bad = 1397.0; - return 4.0000; + return 4; } } else { *p_nb_iter = 9385.0; *p_nb_bad = 1609.0; - return 4.0000; + return 4; } } else { *p_nb_iter = 19122.0; *p_nb_bad = 2960.0; - return 4.0000; + return 4; } } @@ -428,13 +428,13 @@ static int uvg_tree_predict_split_depth_0(features_s* p_features, double* p_nb_i { *p_nb_iter = 25155.0; *p_nb_bad = 2959.0; - return 0.0000; + return 0; } else if (p_features->sub_variance_2 <= 13.2892) { *p_nb_iter = 1080.0; *p_nb_bad = 383.0; - return -1.0000; + return -1; } else if (p_features->variance <= 564.1738) { @@ -442,7 +442,7 @@ static int uvg_tree_predict_split_depth_0(features_s* p_features, double* p_nb_i { *p_nb_iter = 6067.0; *p_nb_bad = 1699.0; - return 0.0000; + return 0; } else if (p_features->var_of_sub_mean <= 46.2388) { @@ -450,30 +450,30 @@ static int uvg_tree_predict_split_depth_0(features_s* p_features, double* p_nb_i { *p_nb_iter = 1088.0; *p_nb_bad = 377.0; - return -1.0000; + return -1; } else if (p_features->sub_variance_3 <= 61.4213) { *p_nb_iter = 1183.0; *p_nb_bad = 498.0; - return -1.0000; + return -1; } else { *p_nb_iter = 3416.0; *p_nb_bad = 1373.0; - return 0.0000; + return 0; } } else { *p_nb_iter = 3769.0; *p_nb_bad = 1093.0; - return 0.0000; + return 0; } } else { *p_nb_iter = 1036.0; *p_nb_bad = 434.0; - return -1.0000; + return -1; } } else if (p_features->var_of_sub_var <= 98333.8279) @@ -486,42 +486,42 @@ static int uvg_tree_predict_split_depth_0(features_s* p_features, double* p_nb_i { *p_nb_iter = 1323.0; *p_nb_bad = 301.0; - return -1.0000; + return -1; } else if (p_features->var_of_sub_var <= 17347.3971) { *p_nb_iter = 1215.0; *p_nb_bad = 550.0; - return 0.0000; + return 0; } else if (p_features->qp <= 22) { *p_nb_iter = 1000.0; *p_nb_bad = 493.0; - return 0.0000; + return 0; } else { *p_nb_iter = 2640.0; *p_nb_bad = 1121.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 5188.0; *p_nb_bad = 1248.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 2323.0; *p_nb_bad = 274.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 21357.0; *p_nb_bad = 1829.0; - return -1.0000; + return -1; } } @@ -532,7 +532,7 @@ static int uvg_tree_predict_split_depth_1(features_s* p_features, double* p_nb_i { *p_nb_iter = 32445.0; *p_nb_bad = 4580.0; - return 1.0000; + return 1; } else if (p_features->var_of_sub_var <= 27289.2117) { @@ -540,7 +540,7 @@ static int uvg_tree_predict_split_depth_1(features_s* p_features, double* p_nb_i { *p_nb_iter = 1900.0; *p_nb_bad = 401.0; - return -1.0000; + return -1; } else if (p_features->var_of_sub_var <= 5841.4773) { @@ -548,25 +548,25 @@ static int uvg_tree_predict_split_depth_1(features_s* p_features, double* p_nb_i { *p_nb_iter = 1000.0; *p_nb_bad = 356.0; - return -1.0000; + return -1; } else if (p_features->neigh_variance_A <= 633.8163) { *p_nb_iter = 5279.0; *p_nb_bad = 1961.0; - return 1.0000; + return 1; } else { *p_nb_iter = 1176.0; *p_nb_bad = 527.0; - return -1.0000; + return -1; } } else if (p_features->sub_variance_0 <= 38.3035) { *p_nb_iter = 1251.0; *p_nb_bad = 293.0; - return -1.0000; + return -1; } else if (p_features->neigh_variance_B <= 664.9494) { @@ -574,7 +574,7 @@ static int uvg_tree_predict_split_depth_1(features_s* p_features, double* p_nb_i { *p_nb_iter = 1276.0; *p_nb_bad = 471.0; - return -1.0000; + return -1; } else if (p_features->sub_variance_3 <= 404.3086) { @@ -582,36 +582,36 @@ static int uvg_tree_predict_split_depth_1(features_s* p_features, double* p_nb_i { *p_nb_iter = 1005.0; *p_nb_bad = 435.0; - return -1.0000; + return -1; } else if (p_features->sub_variance_0 <= 282.3064) { *p_nb_iter = 1370.0; *p_nb_bad = 539.0; - return 1.0000; + return 1; } else { *p_nb_iter = 1013.0; *p_nb_bad = 495.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 1000.0; *p_nb_bad = 379.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 2270.0; *p_nb_bad = 679.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 29015.0; *p_nb_bad = 3950.0; - return -1.0000; + return -1; } } @@ -624,13 +624,13 @@ static int uvg_tree_predict_split_depth_2(features_s* p_features, double* p_nb_i { *p_nb_iter = 23216.0; *p_nb_bad = 1560.0; - return 2.0000; + return 2; } else if (p_features->merge_variance <= 259.6952) { *p_nb_iter = 7470.0; *p_nb_bad = 1902.0; - return 2.0000; + return 2; } else if (p_features->qp <= 27) { @@ -638,18 +638,18 @@ static int uvg_tree_predict_split_depth_2(features_s* p_features, double* p_nb_i { *p_nb_iter = 1138.0; *p_nb_bad = 486.0; - return -1.0000; + return -1; } else { *p_nb_iter = 1619.0; *p_nb_bad = 716.0; - return 2.0000; + return 2; } } else { *p_nb_iter = 2425.0; *p_nb_bad = 861.0; - return 2.0000; + return 2; } } else if (p_features->var_of_sub_var <= 60850.5208) @@ -662,7 +662,7 @@ static int uvg_tree_predict_split_depth_2(features_s* p_features, double* p_nb_i { *p_nb_iter = 1796.0; *p_nb_bad = 586.0; - return -1.0000; + return -1; } else if (p_features->neigh_variance_A <= 493.5849) { @@ -670,42 +670,42 @@ static int uvg_tree_predict_split_depth_2(features_s* p_features, double* p_nb_i { *p_nb_iter = 1326.0; *p_nb_bad = 557.0; - return -1.0000; + return -1; } else if (p_features->variance <= 156.4014) { *p_nb_iter = 1210.0; *p_nb_bad = 563.0; - return -1.0000; + return -1; } else { *p_nb_iter = 1920.0; *p_nb_bad = 817.0; - return 2.0000; + return 2; } } else { *p_nb_iter = 1106.0; *p_nb_bad = 437.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 1001.0; *p_nb_bad = 278.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 13068.0; *p_nb_bad = 3612.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 22705.0; *p_nb_bad = 2687.0; - return -1.0000; + return -1; } } @@ -719,7 +719,7 @@ static int uvg_tree_predict_split_depth_3(features_s* p_features, double* p_nb_i { *p_nb_iter = 20568.0; *p_nb_bad = 767.0; - return 3.0000; + return 3; } else if (p_features->qp <= 27) { @@ -727,24 +727,24 @@ static int uvg_tree_predict_split_depth_3(features_s* p_features, double* p_nb_i { *p_nb_iter = 1255.0; *p_nb_bad = 206.0; - return 3.0000; + return 3; } else if (p_features->merge_variance <= 375.2185) { *p_nb_iter = 3999.0; *p_nb_bad = 1321.0; - return 3.0000; + return 3; } else { *p_nb_iter = 1786.0; *p_nb_bad = 817.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 5286.0; *p_nb_bad = 737.0; - return 3.0000; + return 3; } } else if (p_features->var_of_sub_var <= 37332.3018) @@ -759,7 +759,7 @@ static int uvg_tree_predict_split_depth_3(features_s* p_features, double* p_nb_i { *p_nb_iter = 1114.0; *p_nb_bad = 346.0; - return -1.0000; + return -1; } else if (p_features->neigh_variance_B <= 221.5469) { @@ -767,54 +767,54 @@ static int uvg_tree_predict_split_depth_3(features_s* p_features, double* p_nb_i { *p_nb_iter = 1539.0; *p_nb_bad = 606.0; - return 3.0000; + return 3; } else if (p_features->variance <= 155.5974) { *p_nb_iter = 1298.0; *p_nb_bad = 634.0; - return 3.0000; + return 3; } else { *p_nb_iter = 1076.0; *p_nb_bad = 456.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 1644.0; *p_nb_bad = 639.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 2401.0; *p_nb_bad = 713.0; - return -1.0000; + return -1; } } else if (p_features->merge_variance <= 281.9509) { *p_nb_iter = 1020.0; *p_nb_bad = 262.0; - return 3.0000; + return 3; } else { *p_nb_iter = 1278.0; *p_nb_bad = 594.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 10507.0; *p_nb_bad = 2943.0; - return -1.0000; + return -1; } } else { *p_nb_iter = 25229.0; *p_nb_bad = 3060.0; - return -1.0000; + return -1; } } @@ -965,7 +965,7 @@ static INLINE double vect_variance_blck_int8(const uvg_pixel* _mat_src, size_t _ */ static INLINE void features_var_avg_blck(uvg_pixel* arr_luma_px, uint32_t i_xLcu, uint32_t i_yLcu, uint32_t i_xBlck, uint32_t i_yBlck, uint8_t i_blockSize, - int32_t i_width, int32_t i_height, + uint32_t i_width, uint32_t i_height, double* p_average, double* p_variance) { uint32_t iXMax = CR_XMAX(i_xLcu, i_blockSize + i_xBlck, i_width); diff --git a/src/rate_control.c b/src/rate_control.c index ca2215a5..67570565 100644 --- a/src/rate_control.c +++ b/src/rate_control.c @@ -148,7 +148,7 @@ void uvg_free_rc_data() { * \param[in,out] beta beta parameter to update */ static void update_parameters(uint32_t bits, - uint32_t pixels, + uint64_t pixels, double lambda_real, double *alpha, double *beta) @@ -392,7 +392,7 @@ static double pic_allocate_bits(encoder_state_t * const state) static int8_t lambda_to_qp(const double lambda) { - const int8_t qp = 4.2005 * log(lambda) + 13.7223 + 0.5; + const int8_t qp = (const int8_t)(4.2005 * log(lambda) + 13.7223 + 0.5); return CLIP_TO_QP(qp); } @@ -613,21 +613,21 @@ static double get_ctu_bits(encoder_state_t * const state, vector2d_t pos) { pthread_mutex_lock(&state->frame->rc_lock); double bits_left = state->frame->cur_pic_target_bits - state->frame->cur_frame_bits_coded; double weighted_bits_left = (bits_left * window + (bits_left - state->frame->i_bits_left)*cus_left) / window; - avg_bits = mad * weighted_bits_left / state->frame->remaining_weight; + avg_bits = (int32_t)(mad * weighted_bits_left / state->frame->remaining_weight); state->frame->remaining_weight -= mad; state->frame->i_bits_left -= state->frame->cur_pic_target_bits * mad / state->frame->icost; pthread_mutex_unlock(&state->frame->rc_lock); } else { - avg_bits = state->frame->cur_pic_target_bits * ((double)state->frame->lcu_stats[index].pixels / - (state->encoder_control->in.height * state->encoder_control->in.width)); + avg_bits = (int32_t)(state->frame->cur_pic_target_bits * ((double)state->frame->lcu_stats[index].pixels / + (state->encoder_control->in.height * state->encoder_control->in.width))); } } else { double total_weight = 0; // In case wpp is used only the ctus of the current frame are safe to use const int used_ctu_count = MIN(4, (encoder->cfg.wpp ? (pos.y + 1) * encoder->in.width_in_lcu : num_ctu) - index); - int target_bits = 0; + int32_t target_bits = 0; double best_lambda = 0.0; double temp_lambda = state->frame->lambda; double taylor_e3 = 0.0; @@ -635,12 +635,12 @@ static double get_ctu_bits(encoder_state_t * const state, vector2d_t pos) { int last_ctu = index + used_ctu_count; for (int i = index; i < last_ctu; i++) { - target_bits += state->frame->lcu_stats[i].weight; + target_bits += (int32_t)state->frame->lcu_stats[i].weight; } pthread_mutex_lock(&state->frame->rc_lock); total_weight = state->frame->remaining_weight; - target_bits = MAX(target_bits + state->frame->cur_pic_target_bits - state->frame->cur_frame_bits_coded - (int)total_weight, 10); + target_bits = (int32_t)MAX(target_bits + state->frame->cur_pic_target_bits - state->frame->cur_frame_bits_coded - (int)total_weight, 10); pthread_mutex_unlock(&state->frame->rc_lock); //just similar with the process at frame level, details can refer to the function uvg_estimate_pic_lambda @@ -812,8 +812,8 @@ static double qp_to_lambda(encoder_state_t* const state, int qp) pos.x + state->tile->lcu_offset_x, pos.y + state->tile->lcu_offset_y }; - int id = lcu.x + lcu.y * state->tile->frame->width_in_lcu; - int aq_offset = round(state->frame->aq_offsets[id]); + int32_t id = lcu.x + lcu.y * state->tile->frame->width_in_lcu; + int32_t aq_offset = (int32_t)round(state->frame->aq_offsets[id]); state->qp += aq_offset; // Maximum delta QP is clipped according to ITU T-REC-H.265 specification chapter 7.4.9.10 Transform unit semantics // Clipping range is a function of bit depth @@ -916,7 +916,7 @@ void uvg_update_after_picture(encoder_state_t * const state) { if (state->frame->is_irap && encoder->cfg.intra_bit_allocation) { double lnbpp = log(pow(state->frame->icost / pixels, BETA1)); pthread_mutex_lock(&state->frame->new_ratecontrol->intra_lock); - double diff_lambda = state->frame->new_ratecontrol->intra_beta * log(state->frame->cur_frame_bits_coded) - log(state->frame->cur_pic_target_bits); + double diff_lambda = (double)(state->frame->new_ratecontrol->intra_beta * log((double)state->frame->cur_frame_bits_coded) - log((double)state->frame->cur_pic_target_bits)); diff_lambda = CLIP(-0.125, 0.125, 0.25*diff_lambda); @@ -1162,8 +1162,8 @@ void uvg_set_lcu_lambda_and_qp(encoder_state_t * const state, pos.x + state->tile->lcu_offset_x, pos.y + state->tile->lcu_offset_y }; - int id = lcu_pos.x + lcu_pos.y * state->tile->frame->width_in_lcu; - int aq_offset = round(state->frame->aq_offsets[id]); + int32_t id = lcu_pos.x + lcu_pos.y * state->tile->frame->width_in_lcu; + int32_t aq_offset = (int32_t)round(state->frame->aq_offsets[id]); state->qp += aq_offset; // Maximum delta QP is clipped according to ITU T-REC-H.265 specification chapter 7.4.9.10 Transform unit semantics // Clipping range is a function of bit depth diff --git a/src/rdo.c b/src/rdo.c index 8bad55a5..e233743c 100644 --- a/src/rdo.c +++ b/src/rdo.c @@ -453,7 +453,7 @@ INLINE int32_t uvg_get_ic_rate(encoder_state_t * const state, { uint32_t symbol = (abs_level == 0 ? go_rice_zero : abs_level <= go_rice_zero ? abs_level - 1 : abs_level); uint32_t length; - const int threshold = COEF_REMAIN_BIN_REDUCTION; + const uint32_t threshold = COEF_REMAIN_BIN_REDUCTION; if (symbol < (threshold << abs_go_rice)) { length = symbol >> abs_go_rice; @@ -464,7 +464,7 @@ INLINE int32_t uvg_get_ic_rate(encoder_state_t * const state, uint32_t prefixLength = 0; uint32_t suffix = (symbol >> abs_go_rice) - COEF_REMAIN_BIN_REDUCTION; - while ((prefixLength < maximumPrefixLength) && (suffix > ((2 << prefixLength) - 2))) + while ((prefixLength < maximumPrefixLength) && ((int32_t)suffix > ((2 << prefixLength) - 2))) { prefixLength++; } @@ -476,7 +476,7 @@ INLINE int32_t uvg_get_ic_rate(encoder_state_t * const state, else { length = abs_go_rice; symbol = symbol - (threshold << abs_go_rice); - while (symbol >= (1 << length)) + while ((int32_t)symbol >= (1 << length)) { symbol -= (1 << (length++)); } @@ -498,7 +498,7 @@ INLINE int32_t uvg_get_ic_rate(encoder_state_t * const state, uint32_t prefixLength = 0; uint32_t suffix = (symbol >> abs_go_rice) - COEF_REMAIN_BIN_REDUCTION; - while ((prefixLength < maximumPrefixLength) && (suffix > ((2 << prefixLength) - 2))) + while ((prefixLength < maximumPrefixLength) && ((int32_t)suffix > ((2 << prefixLength) - 2))) { prefixLength++; } @@ -689,7 +689,7 @@ void uvg_rdoq_sign_hiding( // This somehow scales quant_delta into fractional bits. Instead of the bits // being multiplied by lambda, the residual is divided by it, or something // like that. - const int64_t rd_factor = (inv_quant * inv_quant * (1 << (2 * (qp_scaled / 6))) + const int64_t rd_factor = (const int64_t)(inv_quant * inv_quant * (1 << (2 * (qp_scaled / 6))) / lambda / 16 / (1 << (2 * (ctrl->bitdepth - 8))) + 0.5); const int last_cg = (last_pos - 1) >> LOG2_SCAN_SET_SIZE; @@ -858,7 +858,7 @@ static INLINE int x_get_ic_rate_ts(const uint32_t abs_level, uint32_t length; const int threshold = COEF_REMAIN_BIN_REDUCTION; - if (symbol < (threshold << rice_par)) + if ((int32_t)symbol < (threshold << rice_par)) { length = symbol >> rice_par; rate += (length + 1 + rice_par) << CTX_FRAC_BITS; @@ -870,7 +870,7 @@ static INLINE int x_get_ic_rate_ts(const uint32_t abs_level, uint32_t prefixLength = 0; uint32_t suffix = (symbol >> rice_par) - COEF_REMAIN_BIN_REDUCTION; - while ((prefixLength < maximumPrefixLength) && (suffix > ((2 << prefixLength) - 2))) + while ((prefixLength < maximumPrefixLength) && ((int32_t)suffix > ((2 << prefixLength) - 2))) { prefixLength++; } @@ -883,7 +883,7 @@ static INLINE int x_get_ic_rate_ts(const uint32_t abs_level, { length = rice_par; symbol = symbol - (threshold << rice_par); - while (symbol >= (1 << length)) + while ((int32_t)symbol >= (1 << length)) { symbol -= (1 << (length++)); } @@ -906,14 +906,14 @@ static INLINE int x_get_ic_rate_ts(const uint32_t abs_level, (*num_ctx_bins) += 2; - int cutoffVal = 2; + uint32_t cutoffVal = 2; if (abs_level >= cutoffVal) { uint32_t symbol = (abs_level - cutoffVal) >> 1; uint32_t length; const int threshold = COEF_REMAIN_BIN_REDUCTION; - if (symbol < (threshold << rice_par)) + if ((int32_t)symbol < (threshold << rice_par)) { length = symbol >> rice_par; rate += (length + 1 + rice_par) << CTX_FRAC_BITS; @@ -925,7 +925,7 @@ static INLINE int x_get_ic_rate_ts(const uint32_t abs_level, uint32_t prefixLength = 0; uint32_t suffix = (symbol >> rice_par) - COEF_REMAIN_BIN_REDUCTION; - while ((prefixLength < maximumPrefixLength) && (suffix > ((2 << prefixLength) - 2))) + while ((prefixLength < maximumPrefixLength) && ((int32_t)suffix > ((2 << prefixLength) - 2))) { prefixLength++; } @@ -938,7 +938,7 @@ static INLINE int x_get_ic_rate_ts(const uint32_t abs_level, { length = rice_par; symbol = symbol - (threshold << rice_par); - while (symbol >= (1 << length)) + while ((int32_t)symbol >= (1 << length)) { symbol -= (1 << (length++)); } @@ -969,7 +969,7 @@ static INLINE int x_get_ic_rate_ts(const uint32_t abs_level, rate += CTX_ENTROPY_BITS(frac_bits_sign, (abs_level - 2) & 1); // frac_bits_par.intBits[(abs_level - 2) & 1]; num_ctx_bins += 2; - int cutoffVal = 2; + uint32_t cutoffVal = 2; const int numGtBins = 4; for (int i = 0; i < numGtBins; i++) { @@ -977,7 +977,7 @@ static INLINE int x_get_ic_rate_ts(const uint32_t abs_level, { const uint16_t ctxGtX = cutoffVal >> 1; // const BinFracBits* fracBitsGtX = fracBitsAccess.getFracBitsArray(ctxGtX); - unsigned gtX = (abs_level >= (cutoffVal + 2)); + unsigned gtX = ((int32_t)abs_level >= (cutoffVal + 2)); rate += CTX_ENTROPY_BITS(&frac_bits_gtx_ctx[ctxGtX], gtX);// fracBitsGtX.intBits[gtX]; num_ctx_bins++; } @@ -988,7 +988,7 @@ static INLINE int x_get_ic_rate_ts(const uint32_t abs_level, { uint32_t symbol = (abs_level - cutoffVal) >> 1; uint32_t length; - const int threshold = COEF_REMAIN_BIN_REDUCTION; + const uint32_t threshold = COEF_REMAIN_BIN_REDUCTION; if (symbol < (threshold << rice_par)) { length = symbol >> rice_par; @@ -1001,7 +1001,7 @@ static INLINE int x_get_ic_rate_ts(const uint32_t abs_level, uint32_t prefixLength = 0; uint32_t suffix = (symbol >> rice_par) - COEF_REMAIN_BIN_REDUCTION; - while ((prefixLength < maximumPrefixLength) && (suffix > ((2 << prefixLength) - 2))) + while ((prefixLength < maximumPrefixLength) && ((int32_t)suffix > ((2 << prefixLength) - 2))) { prefixLength++; } @@ -1014,7 +1014,7 @@ static INLINE int x_get_ic_rate_ts(const uint32_t abs_level, { length = rice_par; symbol = symbol - (threshold << rice_par); - while (symbol >= (1 << length)) + while ((int32_t)symbol >= (1 << length)) { symbol -= (1 << (length++)); } @@ -1202,7 +1202,7 @@ int uvg_ts_rdoq(encoder_state_t* const state, coeff_t* src_coeff, coeff_t* dest_ int rem_reg_bins = (width * height * 7) >> 2; - for (int sbId = 0; sbId < cg_num; sbId++) + for (uint32_t sbId = 0; sbId < cg_num; sbId++) { uint32_t cg_blkpos = scan_cg[sbId]; @@ -1223,7 +1223,7 @@ int uvg_ts_rdoq(encoder_state_t* const state, coeff_t* src_coeff, coeff_t* dest_ // set coeff const int64_t tmp_level = (int64_t)(abs(src_coeff[blkpos])) * quant_coeff; - const int level_double = MIN(tmp_level, MAX_INT64 - (1ll << ((long long)q_bits - 1ll))); + const int level_double = (const int)MIN(tmp_level, MAX_INT64 - (1ll << ((long long)q_bits - 1ll))); uint32_t roundAbsLevel = MIN((uint32_t)(entropy_coding_maximum), (uint32_t)((level_double + ((1) << (q_bits - 1))) >> q_bits)); uint32_t min_abs_level = (roundAbsLevel > 1 ? roundAbsLevel - 1 : 1); diff --git a/src/reshape.c b/src/reshape.c index 2c85e36f..1375df32 100644 --- a/src/reshape.c +++ b/src/reshape.c @@ -124,9 +124,9 @@ void uvg_calc_seq_stats(struct encoder_state_t* const state, const videoframe_t* int32_t m_binNum = PIC_CODE_CW_BINS; uvg_pixel* picY = &frame->source->y[0]; - const int width = frame->source->width; - const int height = frame->source->height; - const int stride = frame->source->stride; + const uint32_t width = frame->source->width; + const uint32_t height = frame->source->height; + const uint32_t stride = frame->source->stride; uint32_t winLens = (aps->m_binNum == PIC_CODE_CW_BINS) ? (MIN(height, width) / 240) : 2; winLens = winLens > 0 ? winLens : 1; @@ -336,9 +336,9 @@ void uvg_calc_seq_stats(struct encoder_state_t* const state, const videoframe_t* picY = &frame->source->y[CU_TO_PIXEL(0, 0, 0, frame->source->stride)]; double avgY = 0.0; double varY = 0.0; - for (int y = 0; y < height; y++) + for (uint32_t y = 0; y < height; y++) { - for (int x = 0; x < width; x++) + for (uint32_t x = 0; x < width; x++) { avgY += picY[x]; varY += (double)picY[x] * (double)picY[x]; @@ -1083,9 +1083,9 @@ void uvg_lmcs_preanalyzer(struct encoder_state_t* const state, const videoframe_ { aps->m_binNum = PIC_CODE_CW_BINS; uvg_pixel* picY = &frame->source->y[0]; - const int width = frame->source->width; - const int height = frame->source->height; - const int stride = frame->source->stride; + const uint32_t width = frame->source->width; + const uint32_t height = frame->source->height; + const uint32_t stride = frame->source->stride; uint32_t binCnt[PIC_CODE_CW_BINS] = { 0 }; uvg_init_lmcs_seq_stats(&aps->m_srcSeqStats, aps->m_binNum); @@ -1109,9 +1109,9 @@ void uvg_lmcs_preanalyzer(struct encoder_state_t* const state, const videoframe_ double avgY = 0.0; double varY = 0.0; picY = &frame->source->y[0]; - for (int y = 0; y < height; y++) + for (uint32_t y = 0; y < height; y++) { - for (int x = 0; x < width; x++) + for (uint32_t x = 0; x < width; x++) { avgY += picY[x]; varY += (double)picY[x] * (double)picY[x]; @@ -1128,14 +1128,14 @@ void uvg_lmcs_preanalyzer(struct encoder_state_t* const state, const videoframe_ uvg_pixel* picU = &frame->source->u[0]; uvg_pixel* picV = &frame->source->v[0]; - const int widthC = frame->source->width>>1; - const int heightC = frame->source->height>>1; - const int strideC = frame->source->stride>>1; + const uint32_t widthC = frame->source->width>>1; + const uint32_t heightC = frame->source->height>>1; + const uint32_t strideC = frame->source->stride>>1; double avgU = 0.0, avgV = 0.0; double varU = 0.0, varV = 0.0; - for (int y = 0; y < heightC; y++) + for (uint32_t y = 0; y < heightC; y++) { - for (int x = 0; x < widthC; x++) + for (uint32_t x = 0; x < widthC; x++) { avgU += picU[x]; avgV += picV[x]; @@ -1188,7 +1188,7 @@ static void adjust_lmcs_pivot(lmcs_aps* aps) aps->m_reshapePivot[i + 1] = aps->m_reshapePivot[i] + aps->m_binCW[i]; } int segIdxMax = (aps->m_reshapePivot[aps->m_sliceReshapeInfo.reshaperModelMaxBinIdx + 1] >> log2SegSize); - for (int i = aps->m_sliceReshapeInfo.reshaperModelMinBinIdx; i <= aps->m_sliceReshapeInfo.reshaperModelMaxBinIdx; i++) + for (uint32_t i = aps->m_sliceReshapeInfo.reshaperModelMinBinIdx; i <= aps->m_sliceReshapeInfo.reshaperModelMaxBinIdx; i++) { aps->m_reshapePivot[i + 1] = aps->m_reshapePivot[i] + aps->m_binCW[i]; int segIdxCurr = (aps->m_reshapePivot[i] >> log2SegSize); @@ -1199,7 +1199,7 @@ static void adjust_lmcs_pivot(lmcs_aps* aps) if (segIdxCurr == segIdxMax) { aps->m_reshapePivot[i] = aps->m_reshapePivot[aps->m_sliceReshapeInfo.reshaperModelMaxBinIdx + 1]; - for (int j = i; j <= aps->m_sliceReshapeInfo.reshaperModelMaxBinIdx; j++) + for (uint32_t j = i; j <= aps->m_sliceReshapeInfo.reshaperModelMaxBinIdx; j++) { aps->m_reshapePivot[j + 1] = aps->m_reshapePivot[i]; aps->m_binCW[j] = 0; @@ -1213,7 +1213,7 @@ static void adjust_lmcs_pivot(lmcs_aps* aps) aps->m_reshapePivot[i + 1] += adjustVal; aps->m_binCW[i] += adjustVal; - for (int j = i + 1; j <= aps->m_sliceReshapeInfo.reshaperModelMaxBinIdx; j++) + for (uint32_t j = i + 1; j <= aps->m_sliceReshapeInfo.reshaperModelMaxBinIdx; j++) { if (aps->m_binCW[j] < (adjustVal + (orgCW >> 3))) { @@ -1246,7 +1246,7 @@ static void adjust_lmcs_pivot(lmcs_aps* aps) static int get_pwl_idx_inv(lmcs_aps* aps,int lumaVal) { - int idxS = 0; + uint32_t idxS = 0; for (idxS = aps->m_sliceReshapeInfo.reshaperModelMinBinIdx; (idxS <= aps->m_sliceReshapeInfo.reshaperModelMaxBinIdx); idxS++) { if (lumaVal < aps->m_reshapePivot[idxS + 1]) break; @@ -1304,7 +1304,7 @@ void uvg_construct_reshaper_lmcs(lmcs_aps* aps) adjust_lmcs_pivot(aps); int maxAbsDeltaCW = 0, absDeltaCW = 0, deltaCW = 0; - for (int i = aps->m_sliceReshapeInfo.reshaperModelMinBinIdx; i <= aps->m_sliceReshapeInfo.reshaperModelMaxBinIdx; i++) + for (uint32_t i = aps->m_sliceReshapeInfo.reshaperModelMinBinIdx; i <= aps->m_sliceReshapeInfo.reshaperModelMaxBinIdx; i++) { deltaCW = (int)aps->m_binCW[i] - (int)aps->m_initCW; aps->m_sliceReshapeInfo.reshaperModelBinCWDelta[i] = deltaCW; @@ -1365,7 +1365,7 @@ static void code_lmcs_aps(encoder_state_t* const state, lmcs_aps* aps) assert(aps->m_sliceReshapeInfo.maxNbitsNeededDeltaCW > 0); WRITE_UE(stream, aps->m_sliceReshapeInfo.maxNbitsNeededDeltaCW - 1, "lmcs_delta_cw_prec_minus1"); - for (int i = aps->m_sliceReshapeInfo.reshaperModelMinBinIdx; i <= aps->m_sliceReshapeInfo.reshaperModelMaxBinIdx; i++) + for (uint32_t i = aps->m_sliceReshapeInfo.reshaperModelMinBinIdx; i <= aps->m_sliceReshapeInfo.reshaperModelMaxBinIdx; i++) { int deltaCW = aps->m_sliceReshapeInfo.reshaperModelBinCWDelta[i]; int signCW = (deltaCW < 0) ? 1 : 0; @@ -1425,7 +1425,7 @@ void uvg_encode_lmcs_adaptive_parameter_set(encoder_state_t* const state) */ static int getPWLIdxInv(lmcs_aps* aps, int lumaVal) { - int idxS = 0; + uint32_t idxS = 0; for (idxS = aps->m_sliceReshapeInfo.reshaperModelMinBinIdx; (idxS <= aps->m_sliceReshapeInfo.reshaperModelMaxBinIdx); idxS++) { if (lumaVal < aps->m_reshapePivot[idxS + 1]) break; @@ -1491,7 +1491,7 @@ int uvg_calculate_lmcs_chroma_adj_vpdu_nei(encoder_state_t* const state, lmcs_ap { for (int i = 0; i < numNeighbor; i++) { - int k = (yPos + i) >= picH ? (picH - yPos - 1) : i; + int k = (yPos + i) >= (int32_t)picH ? (picH - yPos - 1) : i; recLuma += recSrc0[-1 + k * strideY]; pelnum++; } @@ -1500,7 +1500,7 @@ int uvg_calculate_lmcs_chroma_adj_vpdu_nei(encoder_state_t* const state, lmcs_ap { for (int i = 0; i < numNeighbor; i++) { - int k = (xPos + i) >= picW ? (picW - xPos - 1) : i; + int k = (xPos + i) >= (int32_t)picW ? (picW - xPos - 1) : i; recLuma += recSrc0[-strideY + k]; pelnum++; } diff --git a/src/sao.c b/src/sao.c index e83b8117..5f5e2fd0 100644 --- a/src/sao.c +++ b/src/sao.c @@ -423,8 +423,8 @@ static void sao_search_edge_sao(const encoder_state_t * const state, } { - float mode_bits = sao_mode_bits_edge(state, edge_class, edge_offset, sao_top, sao_left, buf_cnt); - sum_ddistortion += (int)((double)mode_bits*state->lambda +0.5); + double mode_bits = sao_mode_bits_edge(state, edge_class, edge_offset, sao_top, sao_left, buf_cnt); + sum_ddistortion += (int)(mode_bits*state->lambda +0.5); } // SAO is not applied for category 0. edge_offset[SAO_EO_CAT0] = 0; @@ -456,7 +456,7 @@ static void sao_search_band_sao(const encoder_state_t * const state, const uvg_p int sao_bands[2][32]; int temp_offsets[10]; int ddistortion = 0; - float temp_rate = 0.0; + double temp_rate = 0.0; for (i = 0; i < buf_cnt; ++i) { FILL(sao_bands, 0); @@ -468,7 +468,7 @@ static void sao_search_band_sao(const encoder_state_t * const state, const uvg_p } temp_rate = sao_mode_bits_band(state, sao_out->band_position, temp_offsets, sao_top, sao_left, buf_cnt); - ddistortion += (int)((double)temp_rate*state->lambda + 0.5); + ddistortion += (int)(temp_rate*state->lambda + 0.5); // Select band sao over edge sao when distortion is lower if (ddistortion < sao_out->ddistortion) { @@ -509,7 +509,7 @@ static void sao_search_best_mode(const encoder_state_t * const state, const uvg_ if (state->encoder_control->cfg.sao_type & 1){ sao_search_edge_sao(state, data, recdata, block_width, block_height, buf_cnt, &edge_sao, sao_top, sao_left); - float mode_bits = sao_mode_bits_edge(state, edge_sao.eo_class, edge_sao.offsets, sao_top, sao_left, buf_cnt); + double mode_bits = sao_mode_bits_edge(state, edge_sao.eo_class, edge_sao.offsets, sao_top, sao_left, buf_cnt); int ddistortion = (int)(mode_bits * state->lambda + 0.5); unsigned buf_i; @@ -527,7 +527,7 @@ static void sao_search_best_mode(const encoder_state_t * const state, const uvg_ if (state->encoder_control->cfg.sao_type & 2){ sao_search_band_sao(state, data, recdata, block_width, block_height, buf_cnt, &band_sao, sao_top, sao_left); - float mode_bits = sao_mode_bits_band(state, band_sao.band_position, band_sao.offsets, sao_top, sao_left, buf_cnt); + double mode_bits = sao_mode_bits_band(state, band_sao.band_position, band_sao.offsets, sao_top, sao_left, buf_cnt); int ddistortion = (int)(mode_bits * state->lambda + 0.5); unsigned buf_i; @@ -554,7 +554,7 @@ static void sao_search_best_mode(const encoder_state_t * const state, const uvg_ // Choose between SAO and doing nothing, taking into account the // rate-distortion cost of coding do nothing. { - float mode_bits_none = sao_mode_bits_none(state, sao_top, sao_left); + double mode_bits_none = sao_mode_bits_none(state, sao_top, sao_left); int cost_of_nothing = (int)(mode_bits_none * state->lambda + 0.5); if (sao_out->ddistortion >= cost_of_nothing) { sao_out->type = SAO_TYPE_NONE; @@ -571,7 +571,7 @@ static void sao_search_best_mode(const encoder_state_t * const state, const uvg_ if (merge_cand) { unsigned buf_i; - float mode_bits = sao_mode_bits_merge(state, i + 1); + double mode_bits = sao_mode_bits_merge(state, i + 1); int ddistortion = (int)(mode_bits * state->lambda + 0.5); switch (merge_cand->type) { diff --git a/src/search.c b/src/search.c index e3845569..f38593d3 100644 --- a/src/search.c +++ b/src/search.c @@ -129,7 +129,7 @@ void uvg_lcu_fill_trdepth(lcu_t *lcu, int x_px, int y_px, int depth, int tr_dept { const int x_local = SUB_SCU(x_px); const int y_local = SUB_SCU(y_px); - const int width = LCU_WIDTH >> depth; + const uint32_t width = LCU_WIDTH >> depth; for (unsigned y = 0; y < width; y += SCU_WIDTH) { for (unsigned x = 0; x < width; x += SCU_WIDTH) { @@ -183,7 +183,7 @@ static void lcu_fill_inter(lcu_t *lcu, int x_local, int y_local, int cu_width) } } -static void lcu_fill_cbf(lcu_t *lcu, int x_local, int y_local, int width, cu_info_t *cur_cu) +static void lcu_fill_cbf(lcu_t *lcu, uint32_t x_local, uint32_t y_local, uint32_t width, cu_info_t *cur_cu) { const uint32_t tr_split = cur_cu->tr_depth - cur_cu->depth; const uint32_t mask = ~((width >> tr_split)-1); diff --git a/src/search_inter.c b/src/search_inter.c index 7bd761ff..7117a1d0 100644 --- a/src/search_inter.c +++ b/src/search_inter.c @@ -313,11 +313,11 @@ static void select_starting_point(inter_search_info_t *info, } // Go through candidates - for (unsigned i = 0; i < info->num_merge_cand; ++i) { + for (int32_t i = 0; i < info->num_merge_cand; ++i) { if (info->merge_cand[i].dir == 3) continue; - int x = (info->merge_cand[i].mv[info->merge_cand[i].dir - 1][0] + (1 << (INTERNAL_MV_PREC - 1)) ) >> INTERNAL_MV_PREC; - int y = (info->merge_cand[i].mv[info->merge_cand[i].dir - 1][1] + (1 << (INTERNAL_MV_PREC - 1)) ) >> INTERNAL_MV_PREC; + int32_t x = (info->merge_cand[i].mv[info->merge_cand[i].dir - 1][0] + (1 << (INTERNAL_MV_PREC - 1)) ) >> INTERNAL_MV_PREC; + int32_t y = (info->merge_cand[i].mv[info->merge_cand[i].dir - 1][1] + (1 << (INTERNAL_MV_PREC - 1)) ) >> INTERNAL_MV_PREC; if (x == 0 && y == 0) continue; @@ -1063,7 +1063,7 @@ static void search_frac(inter_search_info_t *info, tmp_pic, tmp_stride, ext_origin + ext_s + 1, ext_s); - costs[0] += info->mvd_cost_func(state, + costs[0] += (uint32_t)info->mvd_cost_func(state, mv.x, mv.y, INTERNAL_MV_PREC, info->mv_cand, NULL, @@ -1120,7 +1120,7 @@ static void search_frac(inter_search_info_t *info, for (int j = 0; j < 4; j++) { if (within_tile[j]) { - costs[j] += info->mvd_cost_func( + costs[j] += (uint32_t)info->mvd_cost_func( state, mv.x + pattern[j]->x, mv.y + pattern[j]->y, @@ -1315,7 +1315,7 @@ static void search_pu_inter_ref(inter_search_info_t *info, // Kvazaar always sets collocated_from_l0_flag so the list is L1 when // there are future references. int col_list = ref_list; - for (int i = 0; i < info->state->frame->ref->used_size; i++) { + for (uint32_t i = 0; i < info->state->frame->ref->used_size; i++) { if (info->state->frame->ref->pocs[i] > info->state->frame->poc) { col_list = 1; break; @@ -1469,7 +1469,7 @@ static void search_pu_inter_bipred(inter_search_info_t *info, inter_merge_cand_t *merge_cand = info->merge_cand; - for (int32_t idx = 0; idx < num_cand_pairs; idx++) { + for (uint32_t idx = 0; idx < num_cand_pairs; idx++) { uint8_t i = priorityList0[idx]; uint8_t j = priorityList1[idx]; if (i >= info->num_merge_cand || j >= info->num_merge_cand) break; @@ -1810,12 +1810,12 @@ static void search_pu_inter(encoder_state_t * const state, amvp[2].size = 0; for (int mv_dir = 1; mv_dir < 4; ++mv_dir) { - for (int i = 0; i < state->frame->ref->used_size; ++i) { + for (uint32_t i = 0; i < state->frame->ref->used_size; ++i) { amvp[mv_dir - 1].cost[i] = MAX_DOUBLE; } } - for (int ref_idx = 0; ref_idx < state->frame->ref->used_size; ref_idx++) { + for (uint32_t ref_idx = 0; ref_idx < state->frame->ref->used_size; ref_idx++) { info->ref_idx = ref_idx; info->ref = state->frame->ref->images[ref_idx]; diff --git a/src/search_intra.c b/src/search_intra.c index 9dc24fba..3f4b1a05 100644 --- a/src/search_intra.c +++ b/src/search_intra.c @@ -260,7 +260,7 @@ static double search_intra_trdepth( int y_px, int depth, int max_depth, - int cost_treshold, + double cost_treshold, intra_search_data_t *const search_data, lcu_t *const lcu) { @@ -631,8 +631,8 @@ static int16_t search_intra_rough( if (mode + i * offset <= 66) { costs[modes_selected] = costs_out[i]; modes[modes_selected] = mode + i * offset; - min_cost = MIN(min_cost, costs[modes_selected]); - max_cost = MAX(max_cost, costs[modes_selected]); + min_cost = (int32_t)MIN(min_cost, costs[modes_selected]); + max_cost = (int32_t)MAX(max_cost, costs[modes_selected]); ++modes_selected; } } @@ -1219,7 +1219,7 @@ void uvg_search_cu_intra( number_of_modes_to_search = 0; } if(!skip_rough_search) { - sort_modes(search_data, number_of_modes); + sort_modes(search_data, (uint8_t)number_of_modes); } for(int pred_mode = 0; pred_mode < INTRA_MPM_COUNT; ++pred_mode) { diff --git a/src/strategies/avx2/intra-avx2.c b/src/strategies/avx2/intra-avx2.c index 3e8b06bc..5450f3d2 100644 --- a/src/strategies/avx2/intra-avx2.c +++ b/src/strategies/avx2/intra-avx2.c @@ -144,7 +144,7 @@ static void uvg_angular_pred_avx2( uvg_pixel temp_side[2 * 128 + 3 + 33 * MAX_REF_LINE_IDX] = { 0 }; const int_fast32_t width = 1 << log2_width; - uint32_t pred_mode = intra_mode; // ToDo: handle WAIP + int32_t pred_mode = intra_mode; // ToDo: handle WAIP // Whether to swap references to always project on the left reference row. const bool vertical_mode = intra_mode >= 34; diff --git a/src/strategies/avx2/ipol-avx2.c b/src/strategies/avx2/ipol-avx2.c index 45e675cc..99afb779 100644 --- a/src/strategies/avx2/ipol-avx2.c +++ b/src/strategies/avx2/ipol-avx2.c @@ -715,7 +715,7 @@ static void uvg_filter_hpel_blocks_hor_ver_luma_avx2(const encoder_control_t * e x = 0; int16_t sample = 64 * col_pos2[y + 1 + UVG_LUMA_FILTER_OFFSET] >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - out_l[y * dst_stride + x] = sample; + out_l[y * dst_stride + x] = (uvg_pixel)sample; } // Top @@ -782,7 +782,7 @@ static void uvg_filter_hpel_blocks_diag_luma_avx2(const encoder_control_t * enco x = 0; int16_t sample = uvg_eight_tap_filter_hor_16bit_avx2(fir2, &col_pos2[y]) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - out_tl[y * dst_stride + x] = sample; + out_tl[y * dst_stride + x] = (uvg_pixel)sample; for (x = 1; x < width; ++x) out_tl[y * dst_stride + x] = out_tr[y * dst_stride + x - 1]; } @@ -813,7 +813,7 @@ static void uvg_filter_hpel_blocks_diag_luma_avx2(const encoder_control_t * enco x = 0; int16_t sample = uvg_eight_tap_filter_hor_16bit_avx2(fir2, &col_pos2[(y + 1)]) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - out_bl[y * dst_stride + x] = sample; + out_bl[y * dst_stride + x] = (uvg_pixel)sample; } static void uvg_filter_qpel_blocks_hor_ver_luma_avx2(const encoder_control_t * encoder, diff --git a/src/strategies/avx2/picture-avx2.c b/src/strategies/avx2/picture-avx2.c index 9d91066f..98a9bf03 100644 --- a/src/strategies/avx2/picture-avx2.c +++ b/src/strategies/avx2/picture-avx2.c @@ -823,7 +823,7 @@ static INLINE void bipred_average_px_px_template_avx2(uvg_pixel *dst, assert(!(pu_w == 2 && pu_h == 8) && "Branch for 2x8 not yet implemented."); if (has_pow2_width && area_mod_32 == 0) { - for (int i = 0; i < pu_w * pu_h; i += 32) { + for (uint32_t i = 0; i < pu_w * pu_h; i += 32) { int y = i / pu_w; int x = i % pu_w; @@ -844,10 +844,10 @@ static INLINE void bipred_average_px_px_template_avx2(uvg_pixel *dst, } } } else if (area_mod_32 == 0) { - for (int i = 0; i < pu_w * pu_h; i += 24) { + for (uint32_t i = 0; i < pu_w * pu_h; i += 24) { - int y = i / pu_w; - int x = i % pu_w; + uint32_t y = i / pu_w; + uint32_t x = i % pu_w; // Last 64 bits of the 256 are not used to simplify the loop __m256i mask = _mm256_setr_epi64x(-1, -1, -1, 0); @@ -869,7 +869,7 @@ static INLINE void bipred_average_px_px_template_avx2(uvg_pixel *dst, switch (pu_w) { __m128i sample_L0, sample_L1, avg; case 8: // 8x2, 8x6 - for (int i = 0; i < pu_w * pu_h; i += 16) { + for (uint32_t i = 0; i < pu_w * pu_h; i += 16) { int y = i / pu_w; @@ -881,7 +881,7 @@ static INLINE void bipred_average_px_px_template_avx2(uvg_pixel *dst, } break; case 6: // 6x8 - for (int i = 0; i < pu_w * pu_h; i += 12) { + for (uint32_t i = 0; i < pu_w * pu_h; i += 12) { int y = i / pu_w; @@ -935,7 +935,7 @@ static INLINE void bipred_average_px_px_avx2(uvg_pixel *dst, int32_t shift = 15 - UVG_BIT_DEPTH; // TODO: defines int32_t offset = 1 << (shift - 1); - for (int i = 0; i < pu_w * pu_h; ++i) + for (uint32_t i = 0; i < pu_w * pu_h; ++i) { int y = i / pu_w; int x = i % pu_w; @@ -964,7 +964,7 @@ static INLINE void bipred_average_im_im_template_avx2(uvg_pixel *dst, assert(!(pu_w == 2 && pu_h == 8) && "Branch for 2x8 not yet implemented."); if (has_pow2_width && area_mod_32 == 0) { - for (int i = 0; i < pu_w * pu_h; i += 32) { + for (uint32_t i = 0; i < pu_w * pu_h; i += 32) { int y = i / pu_w; int x = i % pu_w; @@ -1011,7 +1011,7 @@ static INLINE void bipred_average_im_im_template_avx2(uvg_pixel *dst, } } } else if (area_mod_32 == 0) { - for (int i = 0; i < pu_w * pu_h; i += 24) { + for (uint32_t i = 0; i < pu_w * pu_h; i += 24) { int y = i / pu_w; int x = i % pu_w; @@ -1062,7 +1062,7 @@ static INLINE void bipred_average_im_im_template_avx2(uvg_pixel *dst, // 8x2, 8x6, 6x8 blocks (and maybe 2x8 in the future) switch (pu_w) { case 8: // 8x2, 8x6 - for (int i = 0; i < pu_w * pu_h; i += 16) { + for (uint32_t i = 0; i < pu_w * pu_h; i += 16) { int y = i / pu_w; @@ -1092,7 +1092,7 @@ static INLINE void bipred_average_im_im_template_avx2(uvg_pixel *dst, } break; case 6: // 6x8 - for (int i = 0; i < pu_w * pu_h; i += 12) { + for (uint32_t i = 0; i < pu_w * pu_h; i += 12) { int y = i / pu_w; @@ -1163,7 +1163,7 @@ static void bipred_average_im_im_avx2(uvg_pixel *dst, int32_t shift = 15 - UVG_BIT_DEPTH; // TODO: defines int32_t offset = 1 << (shift - 1); - for (int i = 0; i < pu_w * pu_h; ++i) + for (uint32_t i = 0; i < pu_w * pu_h; ++i) { int y = i / pu_w; int x = i % pu_w; @@ -1192,7 +1192,7 @@ static INLINE void bipred_average_px_im_template_avx2(uvg_pixel *dst, assert(!(pu_w == 2 && pu_h == 8) && "Branch for 2x8 not yet implemented."); if (has_pow2_width && area_mod_32 == 0) { - for (int i = 0; i < pu_w * pu_h; i += 32) { + for (uint32_t i = 0; i < pu_w * pu_h; i += 32) { int y = i / pu_w; int x = i % pu_w; @@ -1242,7 +1242,7 @@ static INLINE void bipred_average_px_im_template_avx2(uvg_pixel *dst, } } } else if (area_mod_32 == 0) { - for (int i = 0; i < pu_w * pu_h; i += 24) { + for (uint32_t i = 0; i < pu_w * pu_h; i += 24) { int y = i / pu_w; int x = i % pu_w; @@ -1297,7 +1297,7 @@ static INLINE void bipred_average_px_im_template_avx2(uvg_pixel *dst, // 8x2, 8x6, 6x8 blocks (and maybe 2x8 in the future) switch (pu_w) { case 8: // 8x2, 8x6 - for (int i = 0; i < pu_w * pu_h; i += 16) { + for (uint32_t i = 0; i < pu_w * pu_h; i += 16) { int y = i / pu_w; @@ -1329,7 +1329,7 @@ static INLINE void bipred_average_px_im_template_avx2(uvg_pixel *dst, } break; case 6: // 6x8 - for (int i = 0; i < pu_w * pu_h; i += 12) { + for (uint32_t i = 0; i < pu_w * pu_h; i += 12) { int y = i / pu_w; @@ -1404,7 +1404,7 @@ static void bipred_average_px_im_avx2(uvg_pixel *dst, int32_t shift = 15 - UVG_BIT_DEPTH; // TODO: defines int32_t offset = 1 << (shift - 1); - for (int i = 0; i < pu_w * pu_h; ++i) + for (uint32_t i = 0; i < pu_w * pu_h; ++i) { int y = i / pu_w; int x = i % pu_w; diff --git a/src/strategies/avx2/quant-avx2.c b/src/strategies/avx2/quant-avx2.c index 2d56b8c3..95ce550f 100644 --- a/src/strategies/avx2/quant-avx2.c +++ b/src/strategies/avx2/quant-avx2.c @@ -364,7 +364,7 @@ static INLINE unsigned uvg_math_floor_log2(unsigned value) for (int i = 4; i >= 0; --i) { unsigned bits = 1ull << i; - unsigned shift = value >= (1 << bits) ? bits : 0; + unsigned shift = value >= (unsigned)(1 << bits) ? bits : 0; result += shift; value >>= shift; } diff --git a/src/strategies/avx2/sao-avx2.c b/src/strategies/avx2/sao-avx2.c index f2c627fa..74e3e1a6 100644 --- a/src/strategies/avx2/sao-avx2.c +++ b/src/strategies/avx2/sao-avx2.c @@ -192,7 +192,7 @@ static INLINE void store_border_bytes( uint8_t *buf, const int32_t width_rest, uint32_t data) { - for (uint32_t i = 0; i < width_rest; i++) { + for (int32_t i = 0; i < width_rest; i++) { uint8_t currb = data & 0xff; buf[start_pos + i] = currb; data >>= 8; @@ -291,11 +291,11 @@ static int32_t sao_edge_ddistortion_avx2(const uint8_t *orig_data, int32_t eo_class, const int32_t offsets[NUM_SAO_EDGE_CATEGORIES]) { - int32_t y, x; + uint32_t y, x; vector2d_t a_ofs = g_sao_edge_offsets[eo_class][0]; vector2d_t b_ofs = g_sao_edge_offsets[eo_class][1]; - int32_t scan_width = block_width - 2; + uint32_t scan_width = block_width - 2; uint32_t width_db32 = scan_width & ~31; uint32_t width_db4 = scan_width & ~3; uint32_t width_rest = scan_width & 3; @@ -330,7 +330,7 @@ static int32_t sao_edge_ddistortion_avx2(const uint8_t *orig_data, __m256i offsets_256 = broadcast_xmm2ymm (offsets_8b); __m256i sum = _mm256_setzero_si256(); - for (y = 1; y < block_height - 1; y++) { + for (y = 1; y < (uint32_t)block_height - 1; y++) { for (x = 1; x < width_db32 + 1; x += 32) { uint32_t c_pos = y * block_width + x; uint32_t a_pos = (y + a_ofs.y) * block_width + x + a_ofs.x; @@ -630,7 +630,7 @@ static INLINE void reconstruct_color_band(const encoder_control_t *encoder, int32_t block_height, color_t color_i) { - const uint32_t width_db32 = block_width & ~31; + const int32_t width_db32 = block_width & ~31; const uint32_t width_db4 = block_width & ~3; const uint32_t width_rest = block_width & 3; @@ -644,8 +644,8 @@ static INLINE void reconstruct_color_band(const encoder_control_t *encoder, __m256i offsets[16]; calc_sao_offset_array_avx2(encoder, sao, offsets, color_i); - for (uint32_t y = 0; y < block_height; y++) { - uint32_t x = 0; + for (int32_t y = 0; y < block_height; y++) { + int32_t x = 0; for (; x < width_db32; x += 32) { const uint32_t curr_srcpos = y * stride + x; const uint32_t curr_dstpos = y * new_stride + x; @@ -721,7 +721,7 @@ static INLINE void reconstruct_color_other(const encoder_control_t *encoder, const vector2d_t a_ofs = g_sao_edge_offsets[sao->eo_class][0]; const vector2d_t b_ofs = g_sao_edge_offsets[sao->eo_class][1]; - const uint32_t width_db32 = block_width & ~31; + const int32_t width_db32 = block_width & ~31; const uint32_t width_db4 = block_width & ~3; const uint32_t width_rest = block_width & 3; @@ -738,8 +738,8 @@ static INLINE void reconstruct_color_other(const encoder_control_t *encoder, const __m256i sao_offs = broadcast_xmm2ymm(sao_offs_16); - for (uint32_t y = 0; y < block_height; y++) { - uint32_t x; + for (int32_t y = 0; y < block_height; y++) { + int32_t x; for (x = 0; x < width_db32; x += 32) { const uint32_t src_pos = y * stride + x; const uint32_t dst_pos = y * new_stride + x; @@ -857,8 +857,8 @@ static int32_t sao_band_ddistortion_avx2(const encoder_state_t *state, const __m256i threes = _mm256_set1_epi8 (3); __m256i sum = _mm256_setzero_si256(); - for (uint32_t y = 0; y < block_height; y++) { - for (uint32_t x = 0; x < block_width; x += 32) { + for (int32_t y = 0; y < block_height; y++) { + for (int32_t x = 0; x < block_width; x += 32) { const int32_t curr_pos = y * block_width + x; __m256i rd = _mm256_loadu_si256((const __m256i *)( rec_data + curr_pos)); diff --git a/src/strategies/generic/alf-generic.c b/src/strategies/generic/alf-generic.c index 1fcb0fb1..57e1705f 100644 --- a/src/strategies/generic/alf-generic.c +++ b/src/strategies/generic/alf-generic.c @@ -945,11 +945,11 @@ static void alf_get_blk_stats_generic(encoder_state_t* const state, { if (0/*m_alfWSSD*/) { - alf_covariance[class_idx].ee[k][l][b0][b1] += weight * (e_local[k][b0] * (double)e_local[l][b1]); + alf_covariance[class_idx].ee[k][l][b0][b1] += (int64_t)(weight * (e_local[k][b0] * (double)e_local[l][b1])); } else { - alf_covariance[class_idx].ee[k][l][b0][b1] += e_local[k][b0] * (double)e_local[l][b1]; + alf_covariance[class_idx].ee[k][l][b0][b1] += (int32_t)(e_local[k][b0] * (double)e_local[l][b1]); } } } @@ -958,11 +958,11 @@ static void alf_get_blk_stats_generic(encoder_state_t* const state, { if (0/*m_alfWSSD*/) { - alf_covariance[class_idx].y[k][b] += weight * (e_local[k][b] * (double)y_local); + alf_covariance[class_idx].y[k][b] += (int32_t)(weight * (e_local[k][b] * (double)y_local)); } else { - alf_covariance[class_idx].y[k][b] += e_local[k][b] * (double)y_local; + alf_covariance[class_idx].y[k][b] += (int32_t)(e_local[k][b] * (double)y_local); } } } diff --git a/src/strategies/generic/ipol-generic.c b/src/strategies/generic/ipol-generic.c index bff1a0aa..c8f4b893 100644 --- a/src/strategies/generic/ipol-generic.c +++ b/src/strategies/generic/ipol-generic.c @@ -305,7 +305,7 @@ void uvg_filter_hpel_blocks_hor_ver_luma_generic(const encoder_control_t * encod int xpos = x; int16_t sample = uvg_eight_tap_filter_ver_generic(fir2, &src[src_stride*ypos + xpos + 1], src_stride) >> shift1; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[2][y * dst_stride + x] = sample; + filtered[2][y * dst_stride + x] = (uvg_pixel)sample; } } @@ -321,7 +321,7 @@ void uvg_filter_hpel_blocks_hor_ver_luma_generic(const encoder_control_t * encod int xpos = x; int16_t sample = uvg_eight_tap_filter_ver_generic(fir2, &src[src_stride*(ypos + 1) + xpos + 1], src_stride) >> shift1; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[3][y * dst_stride + x] = sample; + filtered[3][y * dst_stride + x] = (uvg_pixel)sample; } } @@ -360,7 +360,7 @@ void uvg_filter_hpel_blocks_diag_luma_generic(const encoder_control_t * encoder, for (x = 0; x < width; ++x) { int16_t sample = uvg_eight_tap_filter_ver_16bit_generic(fir2, &hor_intermediate[1][y * hor_stride + x], hor_stride) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[1][y * dst_stride + x] = sample; + filtered[1][y * dst_stride + x] = (uvg_pixel)sample; } } @@ -376,7 +376,7 @@ void uvg_filter_hpel_blocks_diag_luma_generic(const encoder_control_t * encoder, x = 0; int16_t sample = uvg_eight_tap_filter_hor_16bit_generic(fir2, &col_pos2[y]) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[0][y * dst_stride + x] = sample; + filtered[0][y * dst_stride + x] = (uvg_pixel)sample; for (x = 1; x < width; ++x) filtered[0][y * dst_stride + x] = filtered[1][y * dst_stride + x - 1]; } @@ -389,7 +389,7 @@ void uvg_filter_hpel_blocks_diag_luma_generic(const encoder_control_t * encoder, for (x = 0; x < width; ++x) { int16_t sample = uvg_eight_tap_filter_ver_16bit_generic(fir2, &hor_intermediate[1][(y + 1) * hor_stride + x], hor_stride) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[3][y * dst_stride + x] = sample; + filtered[3][y * dst_stride + x] = (uvg_pixel)sample; } // Bottom-left @@ -403,7 +403,7 @@ void uvg_filter_hpel_blocks_diag_luma_generic(const encoder_control_t * encoder, x = 0; int16_t sample = uvg_eight_tap_filter_hor_16bit_generic(fir2, &col_pos2[(y + 1)]) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[2][y * dst_stride + x] = sample; + filtered[2][y * dst_stride + x] = (uvg_pixel)sample; } void uvg_filter_qpel_blocks_hor_ver_luma_generic(const encoder_control_t * encoder, @@ -502,14 +502,14 @@ void uvg_filter_qpel_blocks_hor_ver_luma_generic(const encoder_control_t * encod x = 0; int16_t sample = uvg_eight_tap_filter_hor_16bit_generic(ver_fir_l, &col_pos_l[y + sample_off_y]) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[0][y * dst_stride + x] = sample; + filtered[0][y * dst_stride + x] = (uvg_pixel)sample; } for (x = !off_x_fir_l; x < width; ++x) { int ypos = y + sample_off_y; int xpos = x - !off_x_fir_l; int16_t sample = uvg_eight_tap_filter_ver_16bit_generic(ver_fir_l, &hor_pos_l[ypos * hor_stride + xpos], hor_stride) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[0][y * dst_stride + x] = sample; + filtered[0][y * dst_stride + x] = (uvg_pixel)sample; } } @@ -519,14 +519,14 @@ void uvg_filter_qpel_blocks_hor_ver_luma_generic(const encoder_control_t * encod x = 0; int16_t sample = uvg_eight_tap_filter_hor_16bit_generic(ver_fir_r, &col_pos_r[y + sample_off_y]) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[1][y * dst_stride + x] = sample; + filtered[1][y * dst_stride + x] = (uvg_pixel)sample; } for (x = !off_x_fir_r; x < width; ++x) { int ypos = y + sample_off_y; int xpos = x - !off_x_fir_r; int16_t sample = uvg_eight_tap_filter_ver_16bit_generic(ver_fir_r, &hor_pos_r[ypos * hor_stride + xpos], hor_stride) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[1][y * dst_stride + x] = sample; + filtered[1][y * dst_stride + x] = (uvg_pixel)sample; } } @@ -537,14 +537,14 @@ void uvg_filter_qpel_blocks_hor_ver_luma_generic(const encoder_control_t * encod x = 0; int16_t sample = uvg_eight_tap_filter_hor_16bit_generic(ver_fir_t, &col_pos_hor[y + off_y_fir_t]) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[2][y * dst_stride + x] = sample; + filtered[2][y * dst_stride + x] = (uvg_pixel)sample; } for (x = !sample_off_x; x < width; ++x) { int ypos = y + off_y_fir_t; int xpos = x - !sample_off_x; int16_t sample = uvg_eight_tap_filter_ver_16bit_generic(ver_fir_t, &hor_hpel_pos[ypos * hor_stride + xpos], hor_stride) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[2][y * dst_stride + x] = sample; + filtered[2][y * dst_stride + x] = (uvg_pixel)sample; } } @@ -554,14 +554,14 @@ void uvg_filter_qpel_blocks_hor_ver_luma_generic(const encoder_control_t * encod x = 0; int16_t sample = uvg_eight_tap_filter_hor_16bit_generic(ver_fir_b, &col_pos_hor[y + off_y_fir_b]) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[3][y * dst_stride + x] = sample; + filtered[3][y * dst_stride + x] = (uvg_pixel)sample; } for (x = !sample_off_x; x < width; ++x) { int ypos = y + off_y_fir_b; int xpos = x - !sample_off_x; int16_t sample = uvg_eight_tap_filter_ver_16bit_generic(ver_fir_b, &hor_hpel_pos[ypos * hor_stride + xpos], hor_stride) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[3][y * dst_stride + x] = sample; + filtered[3][y * dst_stride + x] = (uvg_pixel)sample; } } } @@ -615,14 +615,14 @@ void uvg_filter_qpel_blocks_diag_luma_generic(const encoder_control_t * encoder, x = 0; int16_t sample = uvg_eight_tap_filter_hor_16bit_generic(ver_fir_t, &col_pos_l[y + off_y_fir_t]) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[0][y * dst_stride + x] = sample; + filtered[0][y * dst_stride + x] = (uvg_pixel)sample; } for (x = !off_x_fir_l; x < width; ++x) { int ypos = y + off_y_fir_t; int xpos = x - !off_x_fir_l; int16_t sample = uvg_eight_tap_filter_ver_16bit_generic(ver_fir_t, &hor_pos_l[ypos * hor_stride + xpos], hor_stride) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[0][y * dst_stride + x] = sample; + filtered[0][y * dst_stride + x] = (uvg_pixel)sample; } } @@ -632,14 +632,14 @@ void uvg_filter_qpel_blocks_diag_luma_generic(const encoder_control_t * encoder, x = 0; int16_t sample = uvg_eight_tap_filter_hor_16bit_generic(ver_fir_t, &col_pos_r[y + off_y_fir_t]) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[1][y * dst_stride + x] = sample; + filtered[1][y * dst_stride + x] = (uvg_pixel)sample; } for (x = !off_x_fir_r; x < width; ++x) { int ypos = y + off_y_fir_t; int xpos = x - !off_x_fir_r; int16_t sample = uvg_eight_tap_filter_ver_16bit_generic(ver_fir_t, &hor_pos_r[ypos * hor_stride + xpos], hor_stride) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[1][y * dst_stride + x] = sample; + filtered[1][y * dst_stride + x] = (uvg_pixel)sample; } } @@ -649,14 +649,14 @@ void uvg_filter_qpel_blocks_diag_luma_generic(const encoder_control_t * encoder, x = 0; int16_t sample = uvg_eight_tap_filter_hor_16bit_generic(ver_fir_b, &col_pos_l[y + off_y_fir_b]) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[2][y * dst_stride + x] = sample; + filtered[2][y * dst_stride + x] = (uvg_pixel)sample; } for (x = !off_x_fir_l; x < width; ++x) { int ypos = y + off_y_fir_b; int xpos = x - !off_x_fir_l; int16_t sample = uvg_eight_tap_filter_ver_16bit_generic(ver_fir_b, &hor_pos_l[ypos * hor_stride + xpos], hor_stride) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[2][y * dst_stride + x] = sample; + filtered[2][y * dst_stride + x] = (uvg_pixel)sample; } } @@ -666,14 +666,14 @@ void uvg_filter_qpel_blocks_diag_luma_generic(const encoder_control_t * encoder, x = 0; int16_t sample = uvg_eight_tap_filter_hor_16bit_generic(ver_fir_b, &col_pos_r[y + off_y_fir_b]) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[3][y * dst_stride + x] = sample; + filtered[3][y * dst_stride + x] = (uvg_pixel)sample; } for (x = !off_x_fir_r; x < width; ++x) { int ypos = y + off_y_fir_b; int xpos = x - !off_x_fir_r; int16_t sample = uvg_eight_tap_filter_ver_16bit_generic(ver_fir_b, &hor_pos_r[ypos * hor_stride + xpos], hor_stride) >> shift2; sample = uvg_fast_clip_16bit_to_pixel((sample + wp_offset1) >> wp_shift1); - filtered[3][y * dst_stride + x] = sample; + filtered[3][y * dst_stride + x] = (uvg_pixel)sample; } } } diff --git a/src/strategies/generic/nal-generic.c b/src/strategies/generic/nal-generic.c index 378f74f6..16aa23d8 100644 --- a/src/strategies/generic/nal-generic.c +++ b/src/strategies/generic/nal-generic.c @@ -52,7 +52,7 @@ static void array_md5_generic(const uvg_pixel* data, uint32_t width_modN = width % N; uint32_t width_less_modN = width - width_modN; - for (uint32_t y = 0; y < height; y++) + for (uint32_t y = 0; y < (uint32_t)height; y++) { for (uint32_t x = 0; x < width_less_modN; x += N) { diff --git a/src/strategies/generic/picture-generic.c b/src/strategies/generic/picture-generic.c index 420a4f79..d80e3706 100644 --- a/src/strategies/generic/picture-generic.c +++ b/src/strategies/generic/picture-generic.c @@ -49,10 +49,10 @@ uvg_pixel uvg_fast_clip_16bit_to_pixel(int16_t value) #if UVG_BIT_DEPTH == 10 temp &= PIXEL_MAX; #endif - return temp; + return (uvg_pixel)temp; } else { - return value; + return (uvg_pixel)value; } #else return CLIP(PIXEL_MIN, PIXEL_MAX, value); @@ -557,7 +557,7 @@ static void bipred_average_px_px(uvg_pixel *dst, int32_t shift = 15 - UVG_BIT_DEPTH; // TODO: defines int32_t offset = 1 << (shift - 1); - for (int i = 0; i < pu_w * pu_h; ++i) + for (uint32_t i = 0; i < pu_w * pu_h; ++i) { int y = i / pu_w; int x = i % pu_w; @@ -578,7 +578,7 @@ static void bipred_average_im_im(uvg_pixel *dst, int32_t shift = 15 - UVG_BIT_DEPTH; // TODO: defines int32_t offset = 1 << (shift - 1); - for (int i = 0; i < pu_w * pu_h; ++i) + for (uint32_t i = 0; i < pu_w * pu_h; ++i) { int y = i / pu_w; int x = i % pu_w; @@ -599,7 +599,7 @@ static void bipred_average_px_im(uvg_pixel *dst, int32_t shift = 15 - UVG_BIT_DEPTH; // TODO: defines int32_t offset = 1 << (shift - 1); - for (int i = 0; i < pu_w * pu_h; ++i) + for (uint32_t i = 0; i < pu_w * pu_h; ++i) { int y = i / pu_w; int x = i % pu_w; @@ -755,7 +755,7 @@ static double pixel_var_generic(const uvg_pixel *arr, const uint32_t len) double arr_mean = 0; // Calculate array mean - int i = 0; + uint32_t i = 0; double sum = 0; for (; i < len; ++i) { diff --git a/src/strategies/generic/quant-generic.c b/src/strategies/generic/quant-generic.c index a4ea1d58..8c1c21f0 100644 --- a/src/strategies/generic/quant-generic.c +++ b/src/strategies/generic/quant-generic.c @@ -77,7 +77,7 @@ void uvg_quant_generic(const encoder_state_t * const state, coeff_t *coef, coeff sign = (level < 0 ? -1 : 1); int32_t curr_quant_coeff = quant_coeff[n]; - level = (abs_level * curr_quant_coeff + add) >> q_bits; + level = (int32_t)((abs_level * curr_quant_coeff + add) >> q_bits); ac_sum += level; level *= sign; @@ -95,7 +95,7 @@ void uvg_quant_generic(const encoder_state_t * const state, coeff_t *coef, coeff int64_t abs_level = (int64_t)abs(level); int32_t curr_quant_coeff = quant_coeff[n]; - level = (abs_level * curr_quant_coeff + add) >> q_bits; + level = (int32_t)((abs_level * curr_quant_coeff + add) >> q_bits); delta_u[n] = (int32_t)((abs_level * curr_quant_coeff - (level << q_bits)) >> q_bits8); } diff --git a/src/strategies/sse2/picture-sse2.c b/src/strategies/sse2/picture-sse2.c index b87e0d5e..d215623e 100644 --- a/src/strategies/sse2/picture-sse2.c +++ b/src/strategies/sse2/picture-sse2.c @@ -61,7 +61,7 @@ static unsigned reg_sad_sse2(const uint8_t * const data1, const uint8_t * const } } _mm_storeu_si128((__m128i*) sse_inc_array, sse_inc); - sad += sse_inc_array[0] + sse_inc_array[1]; + sad += (uint32_t)(sse_inc_array[0] + sse_inc_array[1]); return sad; } diff --git a/src/strategies/sse41/reg_sad_pow2_widths-sse41.h b/src/strategies/sse41/reg_sad_pow2_widths-sse41.h index 4b35ea0b..720f7ca8 100644 --- a/src/strategies/sse41/reg_sad_pow2_widths-sse41.h +++ b/src/strategies/sse41/reg_sad_pow2_widths-sse41.h @@ -909,7 +909,7 @@ static INLINE uint32_t hor_sad_sse41_arbitrary(const uint8_t *pic_data, const ui __m128i borderpx_vec_f = _mm_set1_epi8(ref_data[(int32_t)((y + 2) * ref_stride + border_off)]); __m128i borderpx_vec_h = _mm_set1_epi8(ref_data[(int32_t)((y + 3) * ref_stride + border_off)]); - for (x = 0; x < outside_vecs; x++) { + for (x = 0; x < (int32_t)outside_vecs; x++) { __m128i a = _mm_loadu_si128((__m128i *)(pic_data + x * vec_width + (y + 0) * pic_stride + outvec_offset)); __m128i c = _mm_loadu_si128((__m128i *)(pic_data + x * vec_width + (y + 1) * pic_stride + outvec_offset)); __m128i e = _mm_loadu_si128((__m128i *)(pic_data + x * vec_width + (y + 2) * pic_stride + outvec_offset)); @@ -996,7 +996,7 @@ static INLINE uint32_t hor_sad_sse41_arbitrary(const uint8_t *pic_data, const ui if (height_residual_lines) { for (; y < height; y++) { __m128i borderpx_vec = _mm_set1_epi8(ref_data[(int32_t)((y + 0) * ref_stride + border_off)]); - for (x = 0; x < outside_vecs; x++) { + for (x = 0; x < (int32_t)outside_vecs; x++) { __m128i a = _mm_loadu_si128((__m128i *)(pic_data + x * vec_width + (y + 0) * pic_stride + outvec_offset)); __m128i startoffs = _mm_set1_epi8 ((x + inside_vecs) << vec_width_log2); diff --git a/src/strategyselector.c b/src/strategyselector.c index 4d31cd8d..477604a9 100644 --- a/src/strategyselector.c +++ b/src/strategyselector.c @@ -281,7 +281,7 @@ static void* strategyselector_choose_for(const strategy_list_t * const strategie int max_priority_i = -1; char buffer[256]; char *override = NULL; - int i = 0; + uint32_t i = 0; // Because VS doesn't support snprintf, let's assert that there is // enough room in the buffer. Max length for strategy type is @@ -369,7 +369,7 @@ static INLINE int get_cpuid(unsigned level, unsigned sublevel, cpuid_t *cpu_info __cpuidex(vendor_info, 0, 0); // Check highest supported function. - if (level > vendor_info[0]) return 0; + if ((int32_t)level > vendor_info[0]) return 0; int ms_cpu_info[4] = { cpu_info->eax, cpu_info->ebx, cpu_info->ecx, cpu_info->edx }; __cpuidex(ms_cpu_info, level, sublevel); diff --git a/src/uvg266.c b/src/uvg266.c index 07c96a94..4a576fc0 100644 --- a/src/uvg266.c +++ b/src/uvg266.c @@ -135,7 +135,7 @@ static uvg_encoder * uvg266_open(const uvg_config *cfg) encoder->states[i].frame->QP = (int8_t)cfg->qp; } - for (int i = 0; i < encoder->num_encoder_states; ++i) { + for (uint32_t i = 0; i < encoder->num_encoder_states; ++i) { if (i == 0) { encoder->states[i].previous_encoder_state = &encoder->states[encoder->num_encoder_states - 1]; } else { @@ -190,7 +190,7 @@ static int uvg266_headers(uvg_encoder *enc, uvg_encoder_state_write_parameter_sets(&stream, &enc->states[enc->cur_state_num]); // Get stream length before taking chunks since that clears the stream. - if (len_out) *len_out = uvg_bitstream_tell(&stream) / 8; + if (len_out) *len_out = (uint32_t)(uvg_bitstream_tell(&stream) / 8); if (data_out) *data_out = uvg_bitstream_take_chunks(&stream); uvg_bitstream_finalize(&stream); @@ -213,25 +213,25 @@ static int yuv_io_extract_field(const uvg_picture *frame_in, unsigned source_sca if ((source_scan_type != 1) && (source_scan_type != 2)) return 0; if ((field_parity != 0) && (field_parity != 1)) return 0; - unsigned offset = 0; + int32_t offset = 0; if (source_scan_type == 1) offset = field_parity ? 1 : 0; else if (source_scan_type == 2) offset = field_parity ? 0 : 1; //Luma - for (int i = 0; i < field_out->height; ++i){ + for (int32_t i = 0; i < field_out->height; ++i){ uvg_pixel *row_in = frame_in->y + MIN(frame_in->height - 1, 2 * i + offset) * frame_in->stride; uvg_pixel *row_out = field_out->y + i * field_out->stride; memcpy(row_out, row_in, sizeof(uvg_pixel) * frame_in->stride); } //Chroma - for (int i = 0; i < field_out->height / 2; ++i){ + for (int32_t i = 0; i < field_out->height / 2; ++i) { uvg_pixel *row_in = frame_in->u + MIN(frame_in->height / 2 - 1, 2 * i + offset) * frame_in->stride / 2; uvg_pixel *row_out = field_out->u + i * field_out->stride / 2; memcpy(row_out, row_in, sizeof(uvg_pixel) * frame_in->stride / 2); } - for (int i = 0; i < field_out->height / 2; ++i){ + for (int32_t i = 0; i < field_out->height / 2; ++i) { uvg_pixel *row_in = frame_in->v + MIN(frame_in->height / 2 - 1, 2 * i + offset) * frame_in->stride / 2; uvg_pixel *row_out = field_out->v + i * field_out->stride / 2; memcpy(row_out, row_in, sizeof(uvg_pixel) * frame_in->stride / 2); @@ -297,7 +297,7 @@ static int uvg266_encode(uvg_encoder *enc, uvg_threadqueue_free_job(&output_state->tqj_bitstream_written); // Get stream length before taking chunks since that clears the stream. - if (len_out) *len_out = uvg_bitstream_tell(&output_state->stream) / 8; + if (len_out) *len_out = (uint32_t)(uvg_bitstream_tell(&output_state->stream) / 8); if (data_out) *data_out = uvg_bitstream_take_chunks(&output_state->stream); if (pic_out) *pic_out = uvg_image_copy_ref(output_state->tile->frame->rec); if (src_out) *src_out = uvg_image_copy_ref(output_state->tile->frame->source); diff --git a/src/uvg_math.h b/src/uvg_math.h index 5fb81b97..ff0756e3 100644 --- a/src/uvg_math.h +++ b/src/uvg_math.h @@ -48,7 +48,7 @@ static INLINE unsigned uvg_math_floor_log2(unsigned value) for (int i = 4; i >= 0; --i) { unsigned bits = 1ull << i; - unsigned shift = value >= (1 << bits) ? bits : 0; + unsigned shift = (int32_t)value >= (1 << bits) ? bits : 0; result += shift; value >>= shift; } diff --git a/src/yuv_io.c b/src/yuv_io.c index abf31a25..1b72deb9 100644 --- a/src/yuv_io.c +++ b/src/yuv_io.c @@ -148,7 +148,7 @@ static bool machine_is_big_endian() static void mask_to_bitdepth(uvg_pixel *buf, unsigned length, unsigned bitdepth) { uvg_pixel bitdepth_mask = (1 << bitdepth) - 1; - for (int i = 0; i < length; ++i) { + for (uint32_t i = 0; i < length; ++i) { buf[i] = buf[i] & bitdepth_mask; } } @@ -340,16 +340,16 @@ int yuv_io_write(FILE* file, unsigned output_width, unsigned output_height) { const int stride = img->stride; - for (int y = 0; y < output_height; ++y) { + for (uint32_t y = 0; y < output_height; ++y) { fwrite(&img->y[y * stride], sizeof(*img->y), output_width, file); // TODO: Check that fwrite succeeded. } if (img->chroma_format != UVG_CSP_400) { - for (int y = 0; y < output_height / 2; ++y) { + for (uint32_t y = 0; y < output_height / 2; ++y) { fwrite(&img->u[y * stride / 2], sizeof(*img->u), output_width / 2, file); } - for (int y = 0; y < output_height / 2; ++y) { + for (uint32_t y = 0; y < output_height / 2; ++y) { fwrite(&img->v[y * stride / 2], sizeof(*img->v), output_width / 2, file); } }