xiaomi-sm8450/android_kernel_xiaomi_sm8450
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

drm/amd/display: get rid of 32.32 unsigned fixed point

Browse Source 
32.32 is redundant, 31.32 does everything we use 32.32 for

Signed-off-by: Dmytro Laktyushkin <Dmytro.Laktyushkin@amd.com>
Reviewed-by: Tony Cheng <Tony.Cheng@amd.com>
Acked-by: Harry Wentland <harry.wentland@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
This commit is contained in:
Dmytro Laktyushkin
2018-04-18 11:37:53 -04:00
committed by Alex Deucher
parent b79655c37b
commit eb0e515464
32 changed files with 661 additions and 947 deletions
Download Patch File Download Diff File Expand all files Collapse all files

446
drivers/gpu/drm/amd/display/modules/color/color_gamma.c
View File

@@ -43,7 +43,7 @@ static bool de_pq_initialized; /* = false; */
/* one-time setup of X points */
void setup_x_points_distribution(void)
{
struct fixed31_32 region_size = dal_fixed31_32_from_int(128);
struct fixed31_32 region_size = dc_fixpt_from_int(128);
int32_t segment;
uint32_t seg_offset;
uint32_t index;
@@ -53,8 +53,8 @@ void setup_x_points_distribution(void)
coordinates_x[MAX_HW_POINTS + 1].x = region_size;
for (segment = 6; segment > (6 - NUM_REGIONS); segment--) {
region_size = dal_fixed31_32_div_int(region_size, 2);
increment = dal_fixed31_32_div_int(region_size,
region_size = dc_fixpt_div_int(region_size, 2);
increment = dc_fixpt_div_int(region_size,
NUM_PTS_IN_REGION);
seg_offset = (segment + (NUM_REGIONS - 7)) * NUM_PTS_IN_REGION;
coordinates_x[seg_offset].x = region_size;
@@ -62,7 +62,7 @@ void setup_x_points_distribution(void)
for (index = seg_offset + 1;
index < seg_offset + NUM_PTS_IN_REGION;
index++) {
coordinates_x[index].x = dal_fixed31_32_add
coordinates_x[index].x = dc_fixpt_add
(coordinates_x[index-1].x, increment);
}
}
@@ -72,63 +72,63 @@ static void compute_pq(struct fixed31_32 in_x, struct fixed31_32 *out_y)
{
/* consts for PQ gamma formula. */
const struct fixed31_32 m1 =
dal_fixed31_32_from_fraction(159301758, 1000000000);
dc_fixpt_from_fraction(159301758, 1000000000);
const struct fixed31_32 m2 =
dal_fixed31_32_from_fraction(7884375, 100000);
dc_fixpt_from_fraction(7884375, 100000);
const struct fixed31_32 c1 =
dal_fixed31_32_from_fraction(8359375, 10000000);
dc_fixpt_from_fraction(8359375, 10000000);
const struct fixed31_32 c2 =
dal_fixed31_32_from_fraction(188515625, 10000000);
dc_fixpt_from_fraction(188515625, 10000000);
const struct fixed31_32 c3 =
dal_fixed31_32_from_fraction(186875, 10000);
dc_fixpt_from_fraction(186875, 10000);
struct fixed31_32 l_pow_m1;
struct fixed31_32 base;
if (dal_fixed31_32_lt(in_x, dal_fixed31_32_zero))
in_x = dal_fixed31_32_zero;
if (dc_fixpt_lt(in_x, dc_fixpt_zero))
in_x = dc_fixpt_zero;
l_pow_m1 = dal_fixed31_32_pow(in_x, m1);
base = dal_fixed31_32_div(
dal_fixed31_32_add(c1,
(dal_fixed31_32_mul(c2, l_pow_m1))),
dal_fixed31_32_add(dal_fixed31_32_one,
(dal_fixed31_32_mul(c3, l_pow_m1))));
*out_y = dal_fixed31_32_pow(base, m2);
l_pow_m1 = dc_fixpt_pow(in_x, m1);
base = dc_fixpt_div(
dc_fixpt_add(c1,
(dc_fixpt_mul(c2, l_pow_m1))),
dc_fixpt_add(dc_fixpt_one,
(dc_fixpt_mul(c3, l_pow_m1))));
*out_y = dc_fixpt_pow(base, m2);
}
static void compute_de_pq(struct fixed31_32 in_x, struct fixed31_32 *out_y)
{
/* consts for dePQ gamma formula. */
const struct fixed31_32 m1 =
dal_fixed31_32_from_fraction(159301758, 1000000000);
dc_fixpt_from_fraction(159301758, 1000000000);
const struct fixed31_32 m2 =
dal_fixed31_32_from_fraction(7884375, 100000);
dc_fixpt_from_fraction(7884375, 100000);
const struct fixed31_32 c1 =
dal_fixed31_32_from_fraction(8359375, 10000000);
dc_fixpt_from_fraction(8359375, 10000000);
const struct fixed31_32 c2 =
dal_fixed31_32_from_fraction(188515625, 10000000);
dc_fixpt_from_fraction(188515625, 10000000);
const struct fixed31_32 c3 =
dal_fixed31_32_from_fraction(186875, 10000);
dc_fixpt_from_fraction(186875, 10000);
struct fixed31_32 l_pow_m1;
struct fixed31_32 base, div;
if (dal_fixed31_32_lt(in_x, dal_fixed31_32_zero))
in_x = dal_fixed31_32_zero;
if (dc_fixpt_lt(in_x, dc_fixpt_zero))
in_x = dc_fixpt_zero;
l_pow_m1 = dal_fixed31_32_pow(in_x,
dal_fixed31_32_div(dal_fixed31_32_one, m2));
base = dal_fixed31_32_sub(l_pow_m1, c1);
l_pow_m1 = dc_fixpt_pow(in_x,
dc_fixpt_div(dc_fixpt_one, m2));
base = dc_fixpt_sub(l_pow_m1, c1);
if (dal_fixed31_32_lt(base, dal_fixed31_32_zero))
base = dal_fixed31_32_zero;
if (dc_fixpt_lt(base, dc_fixpt_zero))
base = dc_fixpt_zero;
div = dal_fixed31_32_sub(c2, dal_fixed31_32_mul(c3, l_pow_m1));
div = dc_fixpt_sub(c2, dc_fixpt_mul(c3, l_pow_m1));
*out_y = dal_fixed31_32_pow(dal_fixed31_32_div(base, div),
dal_fixed31_32_div(dal_fixed31_32_one, m1));
*out_y = dc_fixpt_pow(dc_fixpt_div(base, div),
dc_fixpt_div(dc_fixpt_one, m1));
}
/* one-time pre-compute PQ values - only for sdr_white_level 80 */
@@ -138,14 +138,14 @@ void precompute_pq(void)
struct fixed31_32 x;
const struct hw_x_point *coord_x = coordinates_x + 32;
struct fixed31_32 scaling_factor =
dal_fixed31_32_from_fraction(80, 10000);
dc_fixpt_from_fraction(80, 10000);
/* pow function has problems with arguments too small */
for (i = 0; i < 32; i++)
pq_table[i] = dal_fixed31_32_zero;
pq_table[i] = dc_fixpt_zero;
for (i = 32; i <= MAX_HW_POINTS; i++) {
x = dal_fixed31_32_mul(coord_x->x, scaling_factor);
x = dc_fixpt_mul(coord_x->x, scaling_factor);
compute_pq(x, &pq_table[i]);
++coord_x;
}
@@ -158,7 +158,7 @@ void precompute_de_pq(void)
struct fixed31_32 y;
uint32_t begin_index, end_index;
struct fixed31_32 scaling_factor = dal_fixed31_32_from_int(125);
struct fixed31_32 scaling_factor = dc_fixpt_from_int(125);
/* X points is 2^-25 to 2^7
* De-gamma X is 2^-12 to 2^0 – we are skipping first -12-(-25) = 13 regions
@@ -167,11 +167,11 @@ void precompute_de_pq(void)
end_index = begin_index + 12 * NUM_PTS_IN_REGION;
for (i = 0; i <= begin_index; i++)
de_pq_table[i] = dal_fixed31_32_zero;
de_pq_table[i] = dc_fixpt_zero;
for (; i <= end_index; i++) {
compute_de_pq(coordinates_x[i].x, &y);
de_pq_table[i] = dal_fixed31_32_mul(y, scaling_factor);
de_pq_table[i] = dc_fixpt_mul(y, scaling_factor);
}
for (; i <= MAX_HW_POINTS; i++)
@@ -195,15 +195,15 @@ static void build_coefficients(struct gamma_coefficients *coefficients, bool is_
uint32_t index = is_2_4 == true ? 0:1;
do {
coefficients->a0[i] = dal_fixed31_32_from_fraction(
coefficients->a0[i] = dc_fixpt_from_fraction(
numerator01[index], 10000000);
coefficients->a1[i] = dal_fixed31_32_from_fraction(
coefficients->a1[i] = dc_fixpt_from_fraction(
numerator02[index], 1000);
coefficients->a2[i] = dal_fixed31_32_from_fraction(
coefficients->a2[i] = dc_fixpt_from_fraction(
numerator03[index], 1000);
coefficients->a3[i] = dal_fixed31_32_from_fraction(
coefficients->a3[i] = dc_fixpt_from_fraction(
numerator04[index], 1000);
coefficients->user_gamma[i] = dal_fixed31_32_from_fraction(
coefficients->user_gamma[i] = dc_fixpt_from_fraction(
numerator05[index], 1000);
++i;
@@ -218,33 +218,33 @@ static struct fixed31_32 translate_from_linear_space(
struct fixed31_32 a3,
struct fixed31_32 gamma)
{
const struct fixed31_32 one = dal_fixed31_32_from_int(1);
const struct fixed31_32 one = dc_fixpt_from_int(1);
if (dal_fixed31_32_lt(one, arg))
if (dc_fixpt_lt(one, arg))
return one;
if (dal_fixed31_32_le(arg, dal_fixed31_32_neg(a0)))
return dal_fixed31_32_sub(
if (dc_fixpt_le(arg, dc_fixpt_neg(a0)))
return dc_fixpt_sub(
a2,
dal_fixed31_32_mul(
dal_fixed31_32_add(
dc_fixpt_mul(
dc_fixpt_add(
one,
a3),
dal_fixed31_32_pow(
dal_fixed31_32_neg(arg),
dal_fixed31_32_recip(gamma))));
else if (dal_fixed31_32_le(a0, arg))
return dal_fixed31_32_sub(
dal_fixed31_32_mul(
dal_fixed31_32_add(
dc_fixpt_pow(
dc_fixpt_neg(arg),
dc_fixpt_recip(gamma))));
else if (dc_fixpt_le(a0, arg))
return dc_fixpt_sub(
dc_fixpt_mul(
dc_fixpt_add(
one,
a3),
dal_fixed31_32_pow(
dc_fixpt_pow(
arg,
dal_fixed31_32_recip(gamma))),
dc_fixpt_recip(gamma))),
a2);
else
return dal_fixed31_32_mul(
return dc_fixpt_mul(
arg,
a1);
}
@@ -259,25 +259,25 @@ static struct fixed31_32 translate_to_linear_space(
{
struct fixed31_32 linear;
a0 = dal_fixed31_32_mul(a0, a1);
if (dal_fixed31_32_le(arg, dal_fixed31_32_neg(a0)))
a0 = dc_fixpt_mul(a0, a1);
if (dc_fixpt_le(arg, dc_fixpt_neg(a0)))
linear = dal_fixed31_32_neg(
dal_fixed31_32_pow(
dal_fixed31_32_div(
dal_fixed31_32_sub(a2, arg),
dal_fixed31_32_add(
dal_fixed31_32_one, a3)), gamma));
linear = dc_fixpt_neg(
dc_fixpt_pow(
dc_fixpt_div(
dc_fixpt_sub(a2, arg),
dc_fixpt_add(
dc_fixpt_one, a3)), gamma));
else if (dal_fixed31_32_le(dal_fixed31_32_neg(a0), arg) &&
dal_fixed31_32_le(arg, a0))
linear = dal_fixed31_32_div(arg, a1);
else if (dc_fixpt_le(dc_fixpt_neg(a0), arg) &&
dc_fixpt_le(arg, a0))
linear = dc_fixpt_div(arg, a1);
else
linear = dal_fixed31_32_pow(
dal_fixed31_32_div(
dal_fixed31_32_add(a2, arg),
dal_fixed31_32_add(
dal_fixed31_32_one, a3)), gamma);
linear = dc_fixpt_pow(
dc_fixpt_div(
dc_fixpt_add(a2, arg),
dc_fixpt_add(
dc_fixpt_one, a3)), gamma);
return linear;
}
@@ -352,8 +352,8 @@ static bool find_software_points(
right = axis_x[max_number - 1].b;
}
if (dal_fixed31_32_le(left, hw_point) &&
dal_fixed31_32_le(hw_point, right)) {
if (dc_fixpt_le(left, hw_point) &&
dc_fixpt_le(hw_point, right)) {
*index_to_start = i;
*index_left = i;
@@ -366,7 +366,7 @@ static bool find_software_points(
return true;
} else if ((i == *index_to_start) &&
dal_fixed31_32_le(hw_point, left)) {
dc_fixpt_le(hw_point, left)) {
*index_to_start = i;
*index_left = i;
*index_right = i;
@@ -375,7 +375,7 @@ static bool find_software_points(
return true;
} else if ((i == max_number - 1) &&
dal_fixed31_32_le(right, hw_point)) {
dc_fixpt_le(right, hw_point)) {
*index_to_start = i;
*index_left = i;
*index_right = i;
@@ -457,17 +457,17 @@ static bool build_custom_gamma_mapping_coefficients_worker(
}
if (hw_pos == HW_POINT_POSITION_MIDDLE)
point->coeff = dal_fixed31_32_div(
dal_fixed31_32_sub(
point->coeff = dc_fixpt_div(
dc_fixpt_sub(
coord_x,
left_pos),
dal_fixed31_32_sub(
dc_fixpt_sub(
right_pos,
left_pos));
else if (hw_pos == HW_POINT_POSITION_LEFT)
point->coeff = dal_fixed31_32_zero;
point->coeff = dc_fixpt_zero;
else if (hw_pos == HW_POINT_POSITION_RIGHT)
point->coeff = dal_fixed31_32_from_int(2);
point->coeff = dc_fixpt_from_int(2);
else {
BREAK_TO_DEBUGGER();
return false;
@@ -502,45 +502,45 @@ static struct fixed31_32 calculate_mapped_value(
if ((point->left_index < 0) || (point->left_index > max_index)) {
BREAK_TO_DEBUGGER();
return dal_fixed31_32_zero;
return dc_fixpt_zero;
}
if ((point->right_index < 0) || (point->right_index > max_index)) {
BREAK_TO_DEBUGGER();
return dal_fixed31_32_zero;
return dc_fixpt_zero;
}
if (point->pos == HW_POINT_POSITION_MIDDLE)
if (channel == CHANNEL_NAME_RED)
result = dal_fixed31_32_add(
dal_fixed31_32_mul(
result = dc_fixpt_add(
dc_fixpt_mul(
point->coeff,
dal_fixed31_32_sub(
dc_fixpt_sub(
rgb[point->right_index].r,
rgb[point->left_index].r)),
rgb[point->left_index].r);
else if (channel == CHANNEL_NAME_GREEN)
result = dal_fixed31_32_add(
dal_fixed31_32_mul(
result = dc_fixpt_add(
dc_fixpt_mul(
point->coeff,
dal_fixed31_32_sub(
dc_fixpt_sub(
rgb[point->right_index].g,
rgb[point->left_index].g)),
rgb[point->left_index].g);
else
result = dal_fixed31_32_add(
dal_fixed31_32_mul(
result = dc_fixpt_add(
dc_fixpt_mul(
point->coeff,
dal_fixed31_32_sub(
dc_fixpt_sub(
rgb[point->right_index].b,
rgb[point->left_index].b)),
rgb[point->left_index].b);
else if (point->pos == HW_POINT_POSITION_LEFT) {
BREAK_TO_DEBUGGER();
result = dal_fixed31_32_zero;
result = dc_fixpt_zero;
} else {
BREAK_TO_DEBUGGER();
result = dal_fixed31_32_one;
result = dc_fixpt_one;
}
return result;
@@ -558,7 +558,7 @@ static void build_pq(struct pwl_float_data_ex *rgb_regamma,
struct fixed31_32 x;
struct fixed31_32 output;
struct fixed31_32 scaling_factor =
dal_fixed31_32_from_fraction(sdr_white_level, 10000);
dc_fixpt_from_fraction(sdr_white_level, 10000);
if (!pq_initialized && sdr_white_level == 80) {
precompute_pq();
@@ -579,15 +579,15 @@ static void build_pq(struct pwl_float_data_ex *rgb_regamma,
if (sdr_white_level == 80) {
output = pq_table[i];
} else {
x = dal_fixed31_32_mul(coord_x->x, scaling_factor);
x = dc_fixpt_mul(coord_x->x, scaling_factor);
compute_pq(x, &output);
}
/* should really not happen? */
if (dal_fixed31_32_lt(output, dal_fixed31_32_zero))
output = dal_fixed31_32_zero;
else if (dal_fixed31_32_lt(dal_fixed31_32_one, output))
output = dal_fixed31_32_one;
if (dc_fixpt_lt(output, dc_fixpt_zero))
output = dc_fixpt_zero;
else if (dc_fixpt_lt(dc_fixpt_one, output))
output = dc_fixpt_one;
rgb->r = output;
rgb->g = output;
@@ -605,7 +605,7 @@ static void build_de_pq(struct pwl_float_data_ex *de_pq,
uint32_t i;
struct fixed31_32 output;
struct fixed31_32 scaling_factor = dal_fixed31_32_from_int(125);
struct fixed31_32 scaling_factor = dc_fixpt_from_int(125);
if (!de_pq_initialized) {
precompute_de_pq();
@@ -616,9 +616,9 @@ static void build_de_pq(struct pwl_float_data_ex *de_pq,
for (i = 0; i <= hw_points_num; i++) {
output = de_pq_table[i];
/* should really not happen? */
if (dal_fixed31_32_lt(output, dal_fixed31_32_zero))
output = dal_fixed31_32_zero;
else if (dal_fixed31_32_lt(scaling_factor, output))
if (dc_fixpt_lt(output, dc_fixpt_zero))
output = dc_fixpt_zero;
else if (dc_fixpt_lt(scaling_factor, output))
output = scaling_factor;
de_pq[i].r = output;
de_pq[i].g = output;
@@ -670,9 +670,9 @@ static void build_degamma(struct pwl_float_data_ex *curve,
end_index = begin_index + 12 * NUM_PTS_IN_REGION;
while (i != begin_index) {
curve[i].r = dal_fixed31_32_zero;
curve[i].g = dal_fixed31_32_zero;
curve[i].b = dal_fixed31_32_zero;
curve[i].r = dc_fixpt_zero;
curve[i].g = dc_fixpt_zero;
curve[i].b = dc_fixpt_zero;
i++;
}
@@ -684,9 +684,9 @@ static void build_degamma(struct pwl_float_data_ex *curve,
i++;
}
while (i != hw_points_num + 1) {
curve[i].r = dal_fixed31_32_one;
curve[i].g = dal_fixed31_32_one;
curve[i].b = dal_fixed31_32_one;
curve[i].r = dc_fixpt_one;
curve[i].g = dc_fixpt_one;
curve[i].b = dc_fixpt_one;
i++;
}
}
@@ -695,8 +695,8 @@ static void scale_gamma(struct pwl_float_data *pwl_rgb,
const struct dc_gamma *ramp,
struct dividers dividers)
{
const struct fixed31_32 max_driver = dal_fixed31_32_from_int(0xFFFF);
const struct fixed31_32 max_os = dal_fixed31_32_from_int(0xFF00);
const struct fixed31_32 max_driver = dc_fixpt_from_int(0xFFFF);
const struct fixed31_32 max_os = dc_fixpt_from_int(0xFF00);
struct fixed31_32 scaler = max_os;
uint32_t i;
struct pwl_float_data *rgb = pwl_rgb;
@@ -705,9 +705,9 @@ static void scale_gamma(struct pwl_float_data *pwl_rgb,
i = 0;
do {
if (dal_fixed31_32_lt(max_os, ramp->entries.red[i]) ||
dal_fixed31_32_lt(max_os, ramp->entries.green[i]) ||
dal_fixed31_32_lt(max_os, ramp->entries.blue[i])) {
if (dc_fixpt_lt(max_os, ramp->entries.red[i]) ||
dc_fixpt_lt(max_os, ramp->entries.green[i]) ||
dc_fixpt_lt(max_os, ramp->entries.blue[i])) {
scaler = max_driver;
break;
}
@@ -717,40 +717,40 @@ static void scale_gamma(struct pwl_float_data *pwl_rgb,
i = 0;
do {
rgb->r = dal_fixed31_32_div(
rgb->r = dc_fixpt_div(
ramp->entries.red[i], scaler);
rgb->g = dal_fixed31_32_div(
rgb->g = dc_fixpt_div(
ramp->entries.green[i], scaler);
rgb->b = dal_fixed31_32_div(
rgb->b = dc_fixpt_div(
ramp->entries.blue[i], scaler);
++rgb;
++i;
} while (i != ramp->num_entries);
rgb->r = dal_fixed31_32_mul(rgb_last->r,
rgb->r = dc_fixpt_mul(rgb_last->r,
dividers.divider1);
rgb->g = dal_fixed31_32_mul(rgb_last->g,
rgb->g = dc_fixpt_mul(rgb_last->g,
dividers.divider1);
rgb->b = dal_fixed31_32_mul(rgb_last->b,
rgb->b = dc_fixpt_mul(rgb_last->b,
dividers.divider1);
++rgb;
rgb->r = dal_fixed31_32_mul(rgb_last->r,
rgb->r = dc_fixpt_mul(rgb_last->r,
dividers.divider2);
rgb->g = dal_fixed31_32_mul(rgb_last->g,
rgb->g = dc_fixpt_mul(rgb_last->g,
dividers.divider2);
rgb->b = dal_fixed31_32_mul(rgb_last->b,
rgb->b = dc_fixpt_mul(rgb_last->b,
dividers.divider2);
++rgb;
rgb->r = dal_fixed31_32_mul(rgb_last->r,
rgb->r = dc_fixpt_mul(rgb_last->r,
dividers.divider3);
rgb->g = dal_fixed31_32_mul(rgb_last->g,
rgb->g = dc_fixpt_mul(rgb_last->g,
dividers.divider3);
rgb->b = dal_fixed31_32_mul(rgb_last->b,
rgb->b = dc_fixpt_mul(rgb_last->b,
dividers.divider3);
}
@@ -759,62 +759,62 @@ static void scale_gamma_dx(struct pwl_float_data *pwl_rgb,
struct dividers dividers)
{
uint32_t i;
struct fixed31_32 min = dal_fixed31_32_zero;
struct fixed31_32 max = dal_fixed31_32_one;
struct fixed31_32 min = dc_fixpt_zero;
struct fixed31_32 max = dc_fixpt_one;
struct fixed31_32 delta = dal_fixed31_32_zero;
struct fixed31_32 offset = dal_fixed31_32_zero;
struct fixed31_32 delta = dc_fixpt_zero;
struct fixed31_32 offset = dc_fixpt_zero;
for (i = 0 ; i < ramp->num_entries; i++) {
if (dal_fixed31_32_lt(ramp->entries.red[i], min))
if (dc_fixpt_lt(ramp->entries.red[i], min))
min = ramp->entries.red[i];
if (dal_fixed31_32_lt(ramp->entries.green[i], min))
if (dc_fixpt_lt(ramp->entries.green[i], min))
min = ramp->entries.green[i];
if (dal_fixed31_32_lt(ramp->entries.blue[i], min))
if (dc_fixpt_lt(ramp->entries.blue[i], min))
min = ramp->entries.blue[i];
if (dal_fixed31_32_lt(max, ramp->entries.red[i]))
if (dc_fixpt_lt(max, ramp->entries.red[i]))
max = ramp->entries.red[i];
if (dal_fixed31_32_lt(max, ramp->entries.green[i]))
if (dc_fixpt_lt(max, ramp->entries.green[i]))
max = ramp->entries.green[i];
if (dal_fixed31_32_lt(max, ramp->entries.blue[i]))
if (dc_fixpt_lt(max, ramp->entries.blue[i]))
max = ramp->entries.blue[i];
}
if (dal_fixed31_32_lt(min, dal_fixed31_32_zero))
delta = dal_fixed31_32_neg(min);
if (dc_fixpt_lt(min, dc_fixpt_zero))
delta = dc_fixpt_neg(min);
offset = dal_fixed31_32_add(min, max);
offset = dc_fixpt_add(min, max);
for (i = 0 ; i < ramp->num_entries; i++) {
pwl_rgb[i].r = dal_fixed31_32_div(
dal_fixed31_32_add(
pwl_rgb[i].r = dc_fixpt_div(
dc_fixpt_add(
ramp->entries.red[i], delta), offset);
pwl_rgb[i].g = dal_fixed31_32_div(
dal_fixed31_32_add(
pwl_rgb[i].g = dc_fixpt_div(
dc_fixpt_add(
ramp->entries.green[i], delta), offset);
pwl_rgb[i].b = dal_fixed31_32_div(
dal_fixed31_32_add(
pwl_rgb[i].b = dc_fixpt_div(
dc_fixpt_add(
ramp->entries.blue[i], delta), offset);
}
pwl_rgb[i].r = dal_fixed31_32_sub(dal_fixed31_32_mul_int(
pwl_rgb[i].r = dc_fixpt_sub(dc_fixpt_mul_int(
pwl_rgb[i-1].r, 2), pwl_rgb[i-2].r);
pwl_rgb[i].g = dal_fixed31_32_sub(dal_fixed31_32_mul_int(
pwl_rgb[i].g = dc_fixpt_sub(dc_fixpt_mul_int(
pwl_rgb[i-1].g, 2), pwl_rgb[i-2].g);
pwl_rgb[i].b = dal_fixed31_32_sub(dal_fixed31_32_mul_int(
pwl_rgb[i].b = dc_fixpt_sub(dc_fixpt_mul_int(
pwl_rgb[i-1].b, 2), pwl_rgb[i-2].b);
++i;
pwl_rgb[i].r = dal_fixed31_32_sub(dal_fixed31_32_mul_int(
pwl_rgb[i].r = dc_fixpt_sub(dc_fixpt_mul_int(
pwl_rgb[i-1].r, 2), pwl_rgb[i-2].r);
pwl_rgb[i].g = dal_fixed31_32_sub(dal_fixed31_32_mul_int(
pwl_rgb[i].g = dc_fixpt_sub(dc_fixpt_mul_int(
pwl_rgb[i-1].g, 2), pwl_rgb[i-2].g);
pwl_rgb[i].b = dal_fixed31_32_sub(dal_fixed31_32_mul_int(
pwl_rgb[i].b = dc_fixpt_sub(dc_fixpt_mul_int(
pwl_rgb[i-1].b, 2), pwl_rgb[i-2].b);
}
@@ -846,40 +846,40 @@ static void scale_user_regamma_ramp(struct pwl_float_data *pwl_rgb,
i = 0;
do {
rgb->r = dal_fixed31_32_from_fraction(
rgb->r = dc_fixpt_from_fraction(
ramp->gamma[i], scaler);
rgb->g = dal_fixed31_32_from_fraction(
rgb->g = dc_fixpt_from_fraction(
ramp->gamma[i + 256], scaler);
rgb->b = dal_fixed31_32_from_fraction(
rgb->b = dc_fixpt_from_fraction(
ramp->gamma[i + 512], scaler);
++rgb;
++i;
} while (i != GAMMA_RGB_256_ENTRIES);
rgb->r = dal_fixed31_32_mul(rgb_last->r,
rgb->r = dc_fixpt_mul(rgb_last->r,
dividers.divider1);
rgb->g = dal_fixed31_32_mul(rgb_last->g,
rgb->g = dc_fixpt_mul(rgb_last->g,
dividers.divider1);
rgb->b = dal_fixed31_32_mul(rgb_last->b,
rgb->b = dc_fixpt_mul(rgb_last->b,
dividers.divider1);
++rgb;
rgb->r = dal_fixed31_32_mul(rgb_last->r,
rgb->r = dc_fixpt_mul(rgb_last->r,
dividers.divider2);
rgb->g = dal_fixed31_32_mul(rgb_last->g,
rgb->g = dc_fixpt_mul(rgb_last->g,
dividers.divider2);
rgb->b = dal_fixed31_32_mul(rgb_last->b,
rgb->b = dc_fixpt_mul(rgb_last->b,
dividers.divider2);
++rgb;
rgb->r = dal_fixed31_32_mul(rgb_last->r,
rgb->r = dc_fixpt_mul(rgb_last->r,
dividers.divider3);
rgb->g = dal_fixed31_32_mul(rgb_last->g,
rgb->g = dc_fixpt_mul(rgb_last->g,
dividers.divider3);
rgb->b = dal_fixed31_32_mul(rgb_last->b,
rgb->b = dc_fixpt_mul(rgb_last->b,
dividers.divider3);
}
@@ -913,7 +913,7 @@ static void apply_lut_1d(
struct fixed31_32 lut2;
const int max_lut_index = 4095;
const struct fixed31_32 max_lut_index_f =
dal_fixed31_32_from_int_nonconst(max_lut_index);
dc_fixpt_from_int_nonconst(max_lut_index);
int32_t index = 0, index_next = 0;
struct fixed31_32 index_f;
struct fixed31_32 delta_lut;
@@ -931,10 +931,10 @@ static void apply_lut_1d(
else
regamma_y = &tf_pts->blue[i];
norm_y = dal_fixed31_32_mul(max_lut_index_f,
norm_y = dc_fixpt_mul(max_lut_index_f,
*regamma_y);
index = dal_fixed31_32_floor(norm_y);
index_f = dal_fixed31_32_from_int_nonconst(index);
index = dc_fixpt_floor(norm_y);
index_f = dc_fixpt_from_int_nonconst(index);
if (index < 0 || index > max_lut_index)
continue;
@@ -953,11 +953,11 @@ static void apply_lut_1d(
}
// we have everything now, so interpolate
delta_lut = dal_fixed31_32_sub(lut2, lut1);
delta_index = dal_fixed31_32_sub(norm_y, index_f);
delta_lut = dc_fixpt_sub(lut2, lut1);
delta_index = dc_fixpt_sub(norm_y, index_f);
*regamma_y = dal_fixed31_32_add(lut1,
dal_fixed31_32_mul(delta_index, delta_lut));
*regamma_y = dc_fixpt_add(lut1,
dc_fixpt_mul(delta_index, delta_lut));
}
}
}
@@ -973,7 +973,7 @@ static void build_evenly_distributed_points(
uint32_t i = 0;
do {
struct fixed31_32 value = dal_fixed31_32_from_fraction(i,
struct fixed31_32 value = dc_fixpt_from_fraction(i,
numberof_points - 1);
p->r = value;
@@ -984,21 +984,21 @@ static void build_evenly_distributed_points(
++i;
} while (i != numberof_points);
p->r = dal_fixed31_32_div(p_last->r, dividers.divider1);
p->g = dal_fixed31_32_div(p_last->g, dividers.divider1);
p->b = dal_fixed31_32_div(p_last->b, dividers.divider1);
p->r = dc_fixpt_div(p_last->r, dividers.divider1);
p->g = dc_fixpt_div(p_last->g, dividers.divider1);
p->b = dc_fixpt_div(p_last->b, dividers.divider1);
++p;
p->r = dal_fixed31_32_div(p_last->r, dividers.divider2);
p->g = dal_fixed31_32_div(p_last->g, dividers.divider2);
p->b = dal_fixed31_32_div(p_last->b, dividers.divider2);
p->r = dc_fixpt_div(p_last->r, dividers.divider2);
p->g = dc_fixpt_div(p_last->g, dividers.divider2);
p->b = dc_fixpt_div(p_last->b, dividers.divider2);
++p;
p->r = dal_fixed31_32_div(p_last->r, dividers.divider3);
p->g = dal_fixed31_32_div(p_last->g, dividers.divider3);
p->b = dal_fixed31_32_div(p_last->b, dividers.divider3);
p->r = dc_fixpt_div(p_last->r, dividers.divider3);
p->g = dc_fixpt_div(p_last->g, dividers.divider3);
p->b = dc_fixpt_div(p_last->b, dividers.divider3);
}
static inline void copy_rgb_regamma_to_coordinates_x(
@@ -1094,7 +1094,7 @@ static void interpolate_user_regamma(uint32_t hw_points_num,
struct fixed31_32 *tf_point;
struct fixed31_32 hw_x;
struct fixed31_32 norm_factor =
dal_fixed31_32_from_int_nonconst(255);
dc_fixpt_from_int_nonconst(255);
struct fixed31_32 norm_x;
struct fixed31_32 index_f;
struct fixed31_32 lut1;
@@ -1105,9 +1105,9 @@ static void interpolate_user_regamma(uint32_t hw_points_num,
i = 0;
/* fixed_pt library has problems handling too small values */
while (i != 32) {
tf_pts->red[i] = dal_fixed31_32_zero;
tf_pts->green[i] = dal_fixed31_32_zero;
tf_pts->blue[i] = dal_fixed31_32_zero;
tf_pts->red[i] = dc_fixpt_zero;
tf_pts->green[i] = dc_fixpt_zero;
tf_pts->blue[i] = dc_fixpt_zero;
++i;
}
while (i <= hw_points_num + 1) {
@@ -1129,12 +1129,12 @@ static void interpolate_user_regamma(uint32_t hw_points_num,
} else
hw_x = coordinates_x[i].x;
norm_x = dal_fixed31_32_mul(norm_factor, hw_x);
index = dal_fixed31_32_floor(norm_x);
norm_x = dc_fixpt_mul(norm_factor, hw_x);
index = dc_fixpt_floor(norm_x);
if (index < 0 || index > 255)
continue;
index_f = dal_fixed31_32_from_int_nonconst(index);
index_f = dc_fixpt_from_int_nonconst(index);
index_next = (index == 255) ? index : index + 1;
if (color == 0) {
@@ -1149,11 +1149,11 @@ static void interpolate_user_regamma(uint32_t hw_points_num,
}
// we have everything now, so interpolate
delta_lut = dal_fixed31_32_sub(lut2, lut1);
delta_index = dal_fixed31_32_sub(norm_x, index_f);
delta_lut = dc_fixpt_sub(lut2, lut1);
delta_index = dc_fixpt_sub(norm_x, index_f);
*tf_point = dal_fixed31_32_add(lut1,
dal_fixed31_32_mul(delta_index, delta_lut));
*tf_point = dc_fixpt_add(lut1,
dc_fixpt_mul(delta_index, delta_lut));
}
++i;
}
@@ -1168,15 +1168,15 @@ static void build_new_custom_resulted_curve(
i = 0;
while (i != hw_points_num + 1) {
tf_pts->red[i] = dal_fixed31_32_clamp(
tf_pts->red[i], dal_fixed31_32_zero,
dal_fixed31_32_one);
tf_pts->green[i] = dal_fixed31_32_clamp(
tf_pts->green[i], dal_fixed31_32_zero,
dal_fixed31_32_one);
tf_pts->blue[i] = dal_fixed31_32_clamp(
tf_pts->blue[i], dal_fixed31_32_zero,
dal_fixed31_32_one);
tf_pts->red[i] = dc_fixpt_clamp(
tf_pts->red[i], dc_fixpt_zero,
dc_fixpt_one);
tf_pts->green[i] = dc_fixpt_clamp(
tf_pts->green[i], dc_fixpt_zero,
dc_fixpt_one);
tf_pts->blue[i] = dc_fixpt_clamp(
tf_pts->blue[i], dc_fixpt_zero,
dc_fixpt_one);
++i;
}
@@ -1290,9 +1290,9 @@ bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf,
if (!coeff)
goto coeff_alloc_fail;
dividers.divider1 = dal_fixed31_32_from_fraction(3, 2);
dividers.divider2 = dal_fixed31_32_from_int(2);
dividers.divider3 = dal_fixed31_32_from_fraction(5, 2);
dividers.divider1 = dc_fixpt_from_fraction(3, 2);
dividers.divider2 = dc_fixpt_from_int(2);
dividers.divider3 = dc_fixpt_from_fraction(5, 2);
tf = output_tf->tf;
@@ -1357,15 +1357,15 @@ bool calculate_user_regamma_coeff(struct dc_transfer_func *output_tf,
uint32_t i = 0;
do {
coeff.a0[i] = dal_fixed31_32_from_fraction(
coeff.a0[i] = dc_fixpt_from_fraction(
regamma->coeff.A0[i], 10000000);
coeff.a1[i] = dal_fixed31_32_from_fraction(
coeff.a1[i] = dc_fixpt_from_fraction(
regamma->coeff.A1[i], 1000);
coeff.a2[i] = dal_fixed31_32_from_fraction(
coeff.a2[i] = dc_fixpt_from_fraction(
regamma->coeff.A2[i], 1000);
coeff.a3[i] = dal_fixed31_32_from_fraction(
coeff.a3[i] = dc_fixpt_from_fraction(
regamma->coeff.A3[i], 1000);
coeff.user_gamma[i] = dal_fixed31_32_from_fraction(
coeff.user_gamma[i] = dc_fixpt_from_fraction(
regamma->coeff.gamma[i], 1000);
++i;
@@ -1374,9 +1374,9 @@ bool calculate_user_regamma_coeff(struct dc_transfer_func *output_tf,
i = 0;
/* fixed_pt library has problems handling too small values */
while (i != 32) {
output_tf->tf_pts.red[i] = dal_fixed31_32_zero;
output_tf->tf_pts.green[i] = dal_fixed31_32_zero;
output_tf->tf_pts.blue[i] = dal_fixed31_32_zero;
output_tf->tf_pts.red[i] = dc_fixpt_zero;
output_tf->tf_pts.green[i] = dc_fixpt_zero;
output_tf->tf_pts.blue[i] = dc_fixpt_zero;
++coord_x;
++i;
}
@@ -1423,9 +1423,9 @@ bool calculate_user_regamma_ramp(struct dc_transfer_func *output_tf,
if (!rgb_regamma)
goto rgb_regamma_alloc_fail;
dividers.divider1 = dal_fixed31_32_from_fraction(3, 2);
dividers.divider2 = dal_fixed31_32_from_int(2);
dividers.divider3 = dal_fixed31_32_from_fraction(5, 2);
dividers.divider1 = dc_fixpt_from_fraction(3, 2);
dividers.divider2 = dc_fixpt_from_int(2);
dividers.divider3 = dc_fixpt_from_fraction(5, 2);
scale_user_regamma_ramp(rgb_user, &regamma->ramp, dividers);
@@ -1496,9 +1496,9 @@ bool mod_color_calculate_degamma_params(struct dc_transfer_func *input_tf,
if (!coeff)
goto coeff_alloc_fail;
dividers.divider1 = dal_fixed31_32_from_fraction(3, 2);
dividers.divider2 = dal_fixed31_32_from_int(2);
dividers.divider3 = dal_fixed31_32_from_fraction(5, 2);
dividers.divider1 = dc_fixpt_from_fraction(3, 2);
dividers.divider2 = dc_fixpt_from_int(2);
dividers.divider3 = dc_fixpt_from_fraction(5, 2);
tf = input_tf->tf;