static void sh_css_param_shading_table_prepare(const struct sh_css_shading_table *in_table, unsigned int sensor_binning, bool raw_binning, struct sh_css_shading_table_isp **target_table, const struct sh_css_binary *binary) { unsigned int input_width, input_height, table_width, table_stride, table_height, left_padding, right_padding; struct sh_css_shading_table_isp *result; if (!in_table) { generate_id_shading_table(target_table, binary); return; } /* We use the ISP input resolution for the shading table because shading correction is performed in the bayer domain (before bayer down scaling). */ input_height = binary->in_frame_info.height; input_width = binary->in_frame_info.width; left_padding = binary->left_padding; right_padding = binary->in_frame_info.padded_width - (input_width + left_padding); if ((binary->info->mode == SH_CSS_BINARY_MODE_PREVIEW) && raw_binning && binary->info->enable.raw_binning) { input_width = input_width * 2 - binary->info->left_cropping; input_height = input_height * 2 - binary->info->top_cropping; } /* We take into account the binning done by the sensor. We do this by cropping the non-binned part of the shading table and then increasing the size of a grid cell with this same binning factor. */ input_width <<= sensor_binning; input_height <<= sensor_binning; /* We also scale the padding by the same binning factor. This will make it much easier later on to calculate the padding of the shading table. */ left_padding <<= sensor_binning; right_padding <<= sensor_binning; /* during simulation, the used resolution can exceed the sensor resolution, so we clip it. */ input_width = min(input_width, in_table->sensor_width); input_height = min(input_height, in_table->sensor_height); table_width = binary->sctbl_width_per_color; table_stride = binary->sctbl_aligned_width_per_color; table_height = binary->sctbl_height; result = sh_css_malloc(sizeof(*result)); if (result == NULL) { *target_table = NULL; return; } result->width = table_width; result->stride = table_stride; result->height = table_height; result->sensor_width = in_table->sensor_width; result->sensor_height = in_table->sensor_height; result->fraction_bits = in_table->fraction_bits; result->data = sh_css_malloc(SH_CSS_SC_NUM_COLORS * table_stride * table_height * sizeof(*result->data)); if (result->data == NULL) { sh_css_free(result); *target_table = NULL; return; } crop_and_interpolate(input_width, input_height, left_padding, right_padding, in_table, result); *target_table = result; }
void prepare_shading_table(const struct ia_css_shading_table *in_table, unsigned int sensor_binning, bool raw_binning, struct ia_css_shading_table **target_table, const struct sh_css_binary *binary) { unsigned int input_width, input_height, table_width, table_height, left_padding, right_padding, i; struct ia_css_shading_table *result; assert(target_table != NULL); assert(binary != NULL); if (!in_table) { generate_id_shading_table(target_table, binary); return; } /* We use the ISP input resolution for the shading table because shading correction is performed in the bayer domain (before bayer down scaling). */ input_height = binary->in_frame_info.res.height; input_width = binary->in_frame_info.res.width; left_padding = binary->left_padding; right_padding = binary->in_frame_info.padded_width - (input_width + left_padding); if ((binary->info->mode == SH_CSS_BINARY_MODE_PREVIEW) && raw_binning && binary->info->enable.raw_binning) { input_width = input_width * 2 - binary->info->left_cropping; input_height = input_height * 2 - binary->info->top_cropping; } /* We take into account the binning done by the sensor. We do this by cropping the non-binned part of the shading table and then increasing the size of a grid cell with this same binning factor. */ input_width <<= sensor_binning; input_height <<= sensor_binning; /* We also scale the padding by the same binning factor. This will make it much easier later on to calculate the padding of the shading table. */ left_padding <<= sensor_binning; right_padding <<= sensor_binning; /* during simulation, the used resolution can exceed the sensor resolution, so we clip it. */ input_width = min(input_width, in_table->sensor_width); input_height = min(input_height, in_table->sensor_height); table_width = binary->sctbl_width_per_color; table_height = binary->sctbl_height; result = ia_css_shading_table_alloc(table_width, table_height); if (result == NULL) { *target_table = NULL; return; } result->sensor_width = in_table->sensor_width; result->sensor_height = in_table->sensor_height; result->fraction_bits = in_table->fraction_bits; /* now we crop the original shading table and then interpolate to the requested resolution and decimation factor. */ for (i = 0; i < IA_CSS_SC_NUM_COLORS; i++) { crop_and_interpolate(input_width, input_height, left_padding, right_padding, in_table, result, i); } *target_table = result; }
void prepare_shading_table(const struct ia_css_shading_table *in_table, unsigned int sensor_binning, struct ia_css_shading_table **target_table, const struct ia_css_binary *binary, unsigned int bds_factor) { unsigned int input_width, input_height, table_width, table_height, left_padding, top_padding, padded_width, left_cropping, i; unsigned int bds_numerator, bds_denominator; int right_padding; struct ia_css_shading_table *result; assert(target_table != NULL); assert(binary != NULL); if (!in_table) { sh_css_params_shading_id_table_generate(target_table, binary); return; } padded_width = binary->in_frame_info.padded_width; /* We use the ISP input resolution for the shading table because shading correction is performed in the bayer domain (before bayer down scaling). */ #if defined(USE_INPUT_SYSTEM_VERSION_2401) padded_width = CEIL_MUL(binary->effective_in_frame_res.width + 2*ISP_VEC_NELEMS, 2*ISP_VEC_NELEMS); #endif input_height = binary->in_frame_info.res.height; input_width = binary->in_frame_info.res.width; left_padding = binary->left_padding; left_cropping = (binary->info->sp.pipeline.left_cropping == 0) ? binary->dvs_envelope.width : 2*ISP_VEC_NELEMS; sh_css_bds_factor_get_numerator_denominator (bds_factor, &bds_numerator, &bds_denominator); left_padding = (left_padding + binary->info->sp.pipeline.left_cropping) * bds_numerator / bds_denominator - binary->info->sp.pipeline.left_cropping; right_padding = (binary->internal_frame_info.res.width - binary->effective_in_frame_res.width * bds_denominator / bds_numerator - left_cropping) * bds_numerator / bds_denominator; top_padding = binary->info->sp.pipeline.top_cropping * bds_numerator / bds_denominator - binary->info->sp.pipeline.top_cropping; /* We take into account the binning done by the sensor. We do this by cropping the non-binned part of the shading table and then increasing the size of a grid cell with this same binning factor. */ input_width <<= sensor_binning; input_height <<= sensor_binning; /* We also scale the padding by the same binning factor. This will make it much easier later on to calculate the padding of the shading table. */ left_padding <<= sensor_binning; right_padding <<= sensor_binning; top_padding <<= sensor_binning; /* during simulation, the used resolution can exceed the sensor resolution, so we clip it. */ input_width = min(input_width, in_table->sensor_width); input_height = min(input_height, in_table->sensor_height); table_width = binary->sctbl_width_per_color; table_height = binary->sctbl_height; result = ia_css_shading_table_alloc(table_width, table_height); if (result == NULL) { *target_table = NULL; return; } result->sensor_width = in_table->sensor_width; result->sensor_height = in_table->sensor_height; result->fraction_bits = in_table->fraction_bits; /* now we crop the original shading table and then interpolate to the requested resolution and decimation factor. */ for (i = 0; i < IA_CSS_SC_NUM_COLORS; i++) { crop_and_interpolate(input_width, input_height, left_padding, right_padding, top_padding, in_table, result, i); } *target_table = result; }