Loading...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 | // SPDX-License-Identifier: GPL-2.0
/*
* Support for Intel Camera Imaging ISP subsystem.
* Copyright (c) 2015, Intel Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*/
#include <linux/slab.h>
#include <math_support.h>
#include "sh_css_param_shading.h"
#include "ia_css_shading.h"
#include "assert_support.h"
#include "sh_css_defs.h"
#include "sh_css_internal.h"
#include "ia_css_debug.h"
#include "ia_css_pipe_binarydesc.h"
#include "sh_css_hrt.h"
#include "platform_support.h"
/* Bilinear interpolation on shading tables:
* For each target point T, we calculate the 4 surrounding source points:
* ul (upper left), ur (upper right), ll (lower left) and lr (lower right).
* We then calculate the distances from the T to the source points: x0, x1,
* y0 and y1.
* We then calculate the value of T:
* dx0*dy0*Slr + dx0*dy1*Sur + dx1*dy0*Sll + dx1*dy1*Sul.
* We choose a grid size of 1x1 which means:
* dx1 = 1-dx0
* dy1 = 1-dy0
*
* Sul dx0 dx1 Sur
* .<----->|<------------->.
* ^
* dy0|
* v T
* - .
* ^
* |
* dy1|
* v
* . .
* Sll Slr
*
* Padding:
* The area that the ISP operates on can include padding both on the left
* and the right. We need to padd the shading table such that the shading
* values end up on the correct pixel values. This means we must padd the
* shading table to match the ISP padding.
* We can have 5 cases:
* 1. All 4 points fall in the left padding.
* 2. The left 2 points fall in the left padding.
* 3. All 4 points fall in the cropped (target) region.
* 4. The right 2 points fall in the right padding.
* 5. All 4 points fall in the right padding.
* Cases 1 and 5 are easy to handle: we simply use the
* value 1 in the shading table.
* Cases 2 and 4 require interpolation that takes into
* account how far into the padding area the pixels
* fall. We extrapolate the shading table into the
* padded area and then interpolate.
*/
static void
crop_and_interpolate(unsigned int cropped_width,
unsigned int cropped_height,
unsigned int left_padding,
int right_padding,
int top_padding,
const struct ia_css_shading_table *in_table,
struct ia_css_shading_table *out_table,
enum ia_css_sc_color color)
{
unsigned int i, j,
sensor_width,
sensor_height,
table_width,
table_height,
table_cell_h,
out_cell_size,
in_cell_size,
out_start_row,
padded_width;
int out_start_col, /* can be negative to indicate padded space */
table_cell_w;
unsigned short *in_ptr,
*out_ptr;
assert(in_table);
assert(out_table);
sensor_width = in_table->sensor_width;
sensor_height = in_table->sensor_height;
table_width = in_table->width;
table_height = in_table->height;
in_ptr = in_table->data[color];
out_ptr = out_table->data[color];
padded_width = cropped_width + left_padding + right_padding;
out_cell_size = CEIL_DIV(padded_width, out_table->width - 1);
in_cell_size = CEIL_DIV(sensor_width, table_width - 1);
out_start_col = ((int)sensor_width - (int)cropped_width) / 2 - left_padding;
out_start_row = ((int)sensor_height - (int)cropped_height) / 2 - top_padding;
table_cell_w = (int)((table_width - 1) * in_cell_size);
table_cell_h = (table_height - 1) * in_cell_size;
for (i = 0; i < out_table->height; i++) {
int ty, src_y0, src_y1;
unsigned int sy0, sy1, dy0, dy1, divy;
/* calculate target point and make sure it falls within
the table */
ty = out_start_row + i * out_cell_size;
/* calculate closest source points in shading table and
make sure they fall within the table */
src_y0 = ty / (int)in_cell_size;
if (in_cell_size < out_cell_size)
src_y1 = (ty + out_cell_size) / in_cell_size;
else
src_y1 = src_y0 + 1;
src_y0 = clamp(src_y0, 0, (int)table_height - 1);
src_y1 = clamp(src_y1, 0, (int)table_height - 1);
ty = min(clamp(ty, 0, (int)sensor_height - 1),
(int)table_cell_h);
/* calculate closest source points for distance computation */
sy0 = min(src_y0 * in_cell_size, sensor_height - 1);
sy1 = min(src_y1 * in_cell_size, sensor_height - 1);
/* calculate distance between source and target pixels */
dy0 = ty - sy0;
dy1 = sy1 - ty;
divy = sy1 - sy0;
if (divy == 0) {
dy0 = 1;
divy = 1;
}
for (j = 0; j < out_table->width; j++, out_ptr++) {
int tx, src_x0, src_x1;
unsigned int sx0, sx1, dx0, dx1, divx;
unsigned short s_ul, s_ur, s_ll, s_lr;
/* calculate target point */
tx = out_start_col + j * out_cell_size;
/* calculate closest source points. */
src_x0 = tx / (int)in_cell_size;
if (in_cell_size < out_cell_size) {
src_x1 = (tx + out_cell_size) /
(int)in_cell_size;
} else {
src_x1 = src_x0 + 1;
}
/* if src points fall in padding, select closest ones.*/
src_x0 = clamp(src_x0, 0, (int)table_width - 1);
src_x1 = clamp(src_x1, 0, (int)table_width - 1);
tx = min(clamp(tx, 0, (int)sensor_width - 1),
(int)table_cell_w);
/* calculate closest source points for distance
computation */
sx0 = min(src_x0 * in_cell_size, sensor_width - 1);
sx1 = min(src_x1 * in_cell_size, sensor_width - 1);
/* calculate distances between source and target
pixels */
dx0 = tx - sx0;
dx1 = sx1 - tx;
divx = sx1 - sx0;
/* if we're at the edge, we just use the closest
point still in the grid. We make up for the divider
in this case by setting the distance to
out_cell_size, since it's actually 0. */
if (divx == 0) {
dx0 = 1;
divx = 1;
}
/* get source pixel values */
s_ul = in_ptr[(table_width * src_y0) + src_x0];
s_ur = in_ptr[(table_width * src_y0) + src_x1];
s_ll = in_ptr[(table_width * src_y1) + src_x0];
s_lr = in_ptr[(table_width * src_y1) + src_x1];
*out_ptr = (unsigned short)((dx0 * dy0 * s_lr + dx0 * dy1 * s_ur + dx1 * dy0 *
s_ll + dx1 * dy1 * s_ul) /
(divx * divy));
}
}
}
void
sh_css_params_shading_id_table_generate(
struct ia_css_shading_table **target_table,
unsigned int table_width,
unsigned int table_height)
{
/* initialize table with ones, shift becomes zero */
unsigned int i, j;
struct ia_css_shading_table *result;
assert(target_table);
result = ia_css_shading_table_alloc(table_width, table_height);
if (!result) {
*target_table = NULL;
return;
}
for (i = 0; i < IA_CSS_SC_NUM_COLORS; i++) {
for (j = 0; j < table_height * table_width; j++)
result->data[i][j] = 1;
}
result->fraction_bits = 0;
*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, i;
unsigned int left_padding, top_padding, left_cropping;
unsigned int bds_numerator, bds_denominator;
int right_padding;
struct ia_css_shading_table *result;
assert(target_table);
assert(binary);
if (!in_table) {
sh_css_params_shading_id_table_generate(target_table,
binary->sctbl_legacy_width_per_color,
binary->sctbl_legacy_height);
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;
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;
#if !defined(USE_WINDOWS_BINNING_FACTOR)
/* @deprecated{This part of the code will be replaced by the code
* in the #else section below to make the calculation same across
* all platforms.
* Android and Windows platforms interpret the binning_factor parameter
* differently. In Android, the binning factor is expressed in the form
* 2^N * 2^N, whereas in Windows platform, the binning factor is N*N}
*/
/* 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;
#else
input_width *= sensor_binning;
input_height *= sensor_binning;
left_padding *= sensor_binning;
right_padding *= sensor_binning;
top_padding *= sensor_binning;
#endif /*USE_WINDOWS_BINNING_FACTOR*/
/* 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);
/* This prepare_shading_table() function is called only in legacy API (not in new API).
Then, the legacy shading table width and height should be used. */
table_width = binary->sctbl_legacy_width_per_color;
table_height = binary->sctbl_legacy_height;
result = ia_css_shading_table_alloc(table_width, table_height);
if (!result) {
*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;
}
struct ia_css_shading_table *
ia_css_shading_table_alloc(
unsigned int width,
unsigned int height)
{
unsigned int i;
struct ia_css_shading_table *me;
IA_CSS_ENTER("");
me = kmalloc(sizeof(*me), GFP_KERNEL);
if (!me)
return me;
me->width = width;
me->height = height;
me->sensor_width = 0;
me->sensor_height = 0;
me->fraction_bits = 0;
for (i = 0; i < IA_CSS_SC_NUM_COLORS; i++) {
me->data[i] =
kvmalloc(width * height * sizeof(*me->data[0]),
GFP_KERNEL);
if (!me->data[i]) {
unsigned int j;
for (j = 0; j < i; j++) {
kvfree(me->data[j]);
me->data[j] = NULL;
}
kfree(me);
return NULL;
}
}
IA_CSS_LEAVE("");
return me;
}
void
ia_css_shading_table_free(struct ia_css_shading_table *table)
{
unsigned int i;
if (!table)
return;
/* We only output logging when the table is not NULL, otherwise
* logs will give the impression that a table was freed.
* */
IA_CSS_ENTER("");
for (i = 0; i < IA_CSS_SC_NUM_COLORS; i++) {
if (table->data[i]) {
kvfree(table->data[i]);
table->data[i] = NULL;
}
}
kfree(table);
IA_CSS_LEAVE("");
}
|