drm/amd/display: De PQ implementation
Some refactoring and optimizations in color module. Added de gamma 2.2 & 2.4, also re gamma 2.2. Added interface for diagnostic for de gamma & de pq. Signed-off-by: Vitaly Prosyak <vitaly.prosyak@amd.com> Reviewed-by: Krunoslav Kovac <Krunoslav.Kovac@amd.com> Acked-by: Harry Wentland <harry.wentland@amd.com> Signed-off-by: Alex Deucher <alexander.deucher@amd.com>hifive-unleashed-5.1
Vitaly Prosyak
Alex Deucher
parent
627c9a0a50
commit
792474b736
|
|
@ -298,6 +298,32 @@ static void dpp1_cm_get_reg_field(
|
|||
reg->masks.exp_resion_start_segment = dpp->tf_mask->CM_RGAM_RAMB_EXP_REGION_START_SEGMENT_B;
|
||||
}
|
||||
|
||||
static void dpp1_cm_get_degamma_reg_field(
|
||||
struct dcn10_dpp *dpp,
|
||||
struct xfer_func_reg *reg)
|
||||
{
|
||||
reg->shifts.exp_region0_lut_offset = dpp->tf_shift->CM_DGAM_RAMA_EXP_REGION0_LUT_OFFSET;
|
||||
reg->masks.exp_region0_lut_offset = dpp->tf_mask->CM_DGAM_RAMA_EXP_REGION0_LUT_OFFSET;
|
||||
reg->shifts.exp_region0_num_segments = dpp->tf_shift->CM_DGAM_RAMA_EXP_REGION0_NUM_SEGMENTS;
|
||||
reg->masks.exp_region0_num_segments = dpp->tf_mask->CM_DGAM_RAMA_EXP_REGION0_NUM_SEGMENTS;
|
||||
reg->shifts.exp_region1_lut_offset = dpp->tf_shift->CM_DGAM_RAMA_EXP_REGION1_LUT_OFFSET;
|
||||
reg->masks.exp_region1_lut_offset = dpp->tf_mask->CM_DGAM_RAMA_EXP_REGION1_LUT_OFFSET;
|
||||
reg->shifts.exp_region1_num_segments = dpp->tf_shift->CM_DGAM_RAMA_EXP_REGION1_NUM_SEGMENTS;
|
||||
reg->masks.exp_region1_num_segments = dpp->tf_mask->CM_DGAM_RAMA_EXP_REGION1_NUM_SEGMENTS;
|
||||
|
||||
reg->shifts.field_region_end = dpp->tf_shift->CM_DGAM_RAMB_EXP_REGION_END_B;
|
||||
reg->masks.field_region_end = dpp->tf_mask->CM_DGAM_RAMB_EXP_REGION_END_B;
|
||||
reg->shifts.field_region_end_slope = dpp->tf_shift->CM_DGAM_RAMB_EXP_REGION_END_SLOPE_B;
|
||||
reg->masks.field_region_end_slope = dpp->tf_mask->CM_DGAM_RAMB_EXP_REGION_END_SLOPE_B;
|
||||
reg->shifts.field_region_end_base = dpp->tf_shift->CM_DGAM_RAMB_EXP_REGION_END_BASE_B;
|
||||
reg->masks.field_region_end_base = dpp->tf_mask->CM_DGAM_RAMB_EXP_REGION_END_BASE_B;
|
||||
reg->shifts.field_region_linear_slope = dpp->tf_shift->CM_DGAM_RAMB_EXP_REGION_LINEAR_SLOPE_B;
|
||||
reg->masks.field_region_linear_slope = dpp->tf_mask->CM_DGAM_RAMB_EXP_REGION_LINEAR_SLOPE_B;
|
||||
reg->shifts.exp_region_start = dpp->tf_shift->CM_DGAM_RAMB_EXP_REGION_START_B;
|
||||
reg->masks.exp_region_start = dpp->tf_mask->CM_DGAM_RAMB_EXP_REGION_START_B;
|
||||
reg->shifts.exp_resion_start_segment = dpp->tf_shift->CM_DGAM_RAMB_EXP_REGION_START_SEGMENT_B;
|
||||
reg->masks.exp_resion_start_segment = dpp->tf_mask->CM_DGAM_RAMB_EXP_REGION_START_SEGMENT_B;
|
||||
}
|
||||
void dpp1_cm_set_output_csc_adjustment(
|
||||
struct dpp *dpp_base,
|
||||
const uint16_t *regval)
|
||||
|
|
@ -502,7 +528,7 @@ void dpp1_program_degamma_lutb_settings(
|
|||
struct dcn10_dpp *dpp = TO_DCN10_DPP(dpp_base);
|
||||
struct xfer_func_reg gam_regs;
|
||||
|
||||
dpp1_cm_get_reg_field(dpp, &gam_regs);
|
||||
dpp1_cm_get_degamma_reg_field(dpp, &gam_regs);
|
||||
|
||||
gam_regs.start_cntl_b = REG(CM_DGAM_RAMB_START_CNTL_B);
|
||||
gam_regs.start_cntl_g = REG(CM_DGAM_RAMB_START_CNTL_G);
|
||||
|
|
@ -531,7 +557,7 @@ void dpp1_program_degamma_luta_settings(
|
|||
struct dcn10_dpp *dpp = TO_DCN10_DPP(dpp_base);
|
||||
struct xfer_func_reg gam_regs;
|
||||
|
||||
dpp1_cm_get_reg_field(dpp, &gam_regs);
|
||||
dpp1_cm_get_degamma_reg_field(dpp, &gam_regs);
|
||||
|
||||
gam_regs.start_cntl_b = REG(CM_DGAM_RAMA_START_CNTL_B);
|
||||
gam_regs.start_cntl_g = REG(CM_DGAM_RAMA_START_CNTL_G);
|
||||
|
|
|
|||
|
|
@ -27,14 +27,21 @@
|
|||
#include "opp.h"
|
||||
#include "color_gamma.h"
|
||||
|
||||
/* MAX_HW_POINTS = NUM_REGIONS * NUM_PTS_IN_REGION */
|
||||
|
||||
#define NUM_PTS_IN_REGION 16
|
||||
#define NUM_REGIONS 32
|
||||
#define MAX_HW_POINTS 512
|
||||
#define NUM_DEGAMMA_REGIONS 12
|
||||
#define MAX_HW_POINTS (NUM_PTS_IN_REGION*NUM_REGIONS)
|
||||
#define MAX_HW_DEGAMMA_POINTS (NUM_PTS_IN_REGION*NUM_DEGAMMA_REGIONS)
|
||||
|
||||
static struct hw_x_point coordinates_x[MAX_HW_POINTS + 2];
|
||||
static struct hw_x_point degamma_coordinates_x[MAX_HW_DEGAMMA_POINTS + 2];
|
||||
|
||||
static struct fixed31_32 pq_table[MAX_HW_POINTS + 2];
|
||||
static struct fixed31_32 de_pq_table[MAX_HW_DEGAMMA_POINTS + 2];
|
||||
|
||||
static bool pq_initialized; /* = false; */
|
||||
static bool de_pq_initialized; /* = false; */
|
||||
|
||||
/* one-time setup of X points */
|
||||
void setup_x_points_distribution(void)
|
||||
|
|
@ -45,8 +52,8 @@ void setup_x_points_distribution(void)
|
|||
uint32_t index;
|
||||
struct fixed31_32 increment;
|
||||
|
||||
coordinates_x[NUM_REGIONS * NUM_PTS_IN_REGION].x = region_size;
|
||||
coordinates_x[NUM_REGIONS * NUM_PTS_IN_REGION + 1].x = region_size;
|
||||
coordinates_x[MAX_HW_POINTS].x = region_size;
|
||||
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);
|
||||
|
|
@ -62,6 +69,26 @@ void setup_x_points_distribution(void)
|
|||
(coordinates_x[index-1].x, increment);
|
||||
}
|
||||
}
|
||||
|
||||
region_size = dal_fixed31_32_from_int(1);
|
||||
degamma_coordinates_x[MAX_HW_DEGAMMA_POINTS].x = region_size;
|
||||
degamma_coordinates_x[MAX_HW_DEGAMMA_POINTS + 1].x = region_size;
|
||||
|
||||
for (segment = -1; segment > -(NUM_DEGAMMA_REGIONS + 1); segment--) {
|
||||
region_size = dal_fixed31_32_div_int(region_size, 2);
|
||||
increment = dal_fixed31_32_div_int(region_size,
|
||||
NUM_PTS_IN_REGION);
|
||||
seg_offset = (segment + NUM_DEGAMMA_REGIONS) * NUM_PTS_IN_REGION;
|
||||
degamma_coordinates_x[seg_offset].x = region_size;
|
||||
|
||||
for (index = seg_offset + 1;
|
||||
index < seg_offset + NUM_PTS_IN_REGION;
|
||||
index++) {
|
||||
degamma_coordinates_x[index].x = dal_fixed31_32_add
|
||||
(degamma_coordinates_x[index-1].x, increment);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
static void compute_pq(struct fixed31_32 in_x, struct fixed31_32 *out_y)
|
||||
|
|
@ -93,6 +120,40 @@ static void compute_pq(struct fixed31_32 in_x, struct fixed31_32 *out_y)
|
|||
*out_y = dal_fixed31_32_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);
|
||||
const struct fixed31_32 m2 =
|
||||
dal_fixed31_32_from_fraction(7884375, 100000);
|
||||
const struct fixed31_32 c1 =
|
||||
dal_fixed31_32_from_fraction(8359375, 10000000);
|
||||
const struct fixed31_32 c2 =
|
||||
dal_fixed31_32_from_fraction(188515625, 10000000);
|
||||
const struct fixed31_32 c3 =
|
||||
dal_fixed31_32_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;
|
||||
|
||||
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);
|
||||
|
||||
if (dal_fixed31_32_lt(base, dal_fixed31_32_zero))
|
||||
base = dal_fixed31_32_zero;
|
||||
|
||||
div = dal_fixed31_32_sub(c2, dal_fixed31_32_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));
|
||||
|
||||
}
|
||||
/* one-time pre-compute PQ values - only for sdr_white_level 80 */
|
||||
void precompute_pq(void)
|
||||
{
|
||||
|
|
@ -113,46 +174,49 @@ void precompute_pq(void)
|
|||
}
|
||||
}
|
||||
|
||||
/* one-time pre-compute dePQ values - only for max pixel value 125 FP16 */
|
||||
void precompute_de_pq(void)
|
||||
{
|
||||
int i;
|
||||
struct fixed31_32 y;
|
||||
const struct hw_x_point *coord_x = degamma_coordinates_x;
|
||||
struct fixed31_32 scaling_factor = dal_fixed31_32_from_int(125);
|
||||
|
||||
|
||||
for (i = 0; i <= MAX_HW_DEGAMMA_POINTS; i++) {
|
||||
compute_de_pq(coord_x->x, &y);
|
||||
de_pq_table[i] = dal_fixed31_32_mul(y, scaling_factor);
|
||||
++coord_x;
|
||||
}
|
||||
}
|
||||
struct dividers {
|
||||
struct fixed31_32 divider1;
|
||||
struct fixed31_32 divider2;
|
||||
struct fixed31_32 divider3;
|
||||
};
|
||||
|
||||
static void build_regamma_coefficients(struct gamma_coefficients *coefficients)
|
||||
static void build_coefficients(struct gamma_coefficients *coefficients, bool is_2_4)
|
||||
{
|
||||
/* sRGB should apply 2.4 */
|
||||
static const int32_t numerator01[3] = { 31308, 31308, 31308 };
|
||||
static const int32_t numerator02[3] = { 12920, 12920, 12920 };
|
||||
static const int32_t numerator03[3] = { 55, 55, 55 };
|
||||
static const int32_t numerator04[3] = { 55, 55, 55 };
|
||||
static const int32_t numerator05[3] = { 2400, 2400, 2400 };
|
||||
static const int32_t numerator01[] = { 31308, 180000};
|
||||
static const int32_t numerator02[] = { 12920, 4500};
|
||||
static const int32_t numerator03[] = { 55, 99};
|
||||
static const int32_t numerator04[] = { 55, 99};
|
||||
static const int32_t numerator05[] = { 2400, 2200};
|
||||
|
||||
const int32_t *numerator1;
|
||||
const int32_t *numerator2;
|
||||
const int32_t *numerator3;
|
||||
const int32_t *numerator4;
|
||||
const int32_t *numerator5;
|
||||
|
||||
uint32_t i = 0;
|
||||
|
||||
numerator1 = numerator01;
|
||||
numerator2 = numerator02;
|
||||
numerator3 = numerator03;
|
||||
numerator4 = numerator04;
|
||||
numerator5 = numerator05;
|
||||
uint32_t i = 0;
|
||||
uint32_t index = is_2_4 == true ? 0:1;
|
||||
|
||||
do {
|
||||
coefficients->a0[i] = dal_fixed31_32_from_fraction(
|
||||
numerator1[i], 10000000);
|
||||
numerator01[index], 10000000);
|
||||
coefficients->a1[i] = dal_fixed31_32_from_fraction(
|
||||
numerator2[i], 1000);
|
||||
numerator02[index], 1000);
|
||||
coefficients->a2[i] = dal_fixed31_32_from_fraction(
|
||||
numerator3[i], 1000);
|
||||
numerator03[index], 1000);
|
||||
coefficients->a3[i] = dal_fixed31_32_from_fraction(
|
||||
numerator4[i], 1000);
|
||||
numerator04[index], 1000);
|
||||
coefficients->user_gamma[i] = dal_fixed31_32_from_fraction(
|
||||
numerator5[i], 1000);
|
||||
numerator05[index], 1000);
|
||||
|
||||
++i;
|
||||
} while (i != ARRAY_SIZE(coefficients->a0));
|
||||
|
|
@ -197,6 +261,39 @@ static struct fixed31_32 translate_from_linear_space(
|
|||
a1);
|
||||
}
|
||||
|
||||
static struct fixed31_32 translate_to_linear_space(
|
||||
struct fixed31_32 arg,
|
||||
struct fixed31_32 a0,
|
||||
struct fixed31_32 a1,
|
||||
struct fixed31_32 a2,
|
||||
struct fixed31_32 a3,
|
||||
struct fixed31_32 gamma)
|
||||
{
|
||||
struct fixed31_32 linear;
|
||||
|
||||
a0 = dal_fixed31_32_mul(a0, a1);
|
||||
if (dal_fixed31_32_le(arg, dal_fixed31_32_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));
|
||||
|
||||
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
|
||||
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);
|
||||
|
||||
return linear;
|
||||
}
|
||||
|
||||
static inline struct fixed31_32 translate_from_linear_space_ex(
|
||||
struct fixed31_32 arg,
|
||||
struct gamma_coefficients *coeff,
|
||||
|
|
@ -211,6 +308,22 @@ static inline struct fixed31_32 translate_from_linear_space_ex(
|
|||
coeff->user_gamma[color_index]);
|
||||
}
|
||||
|
||||
|
||||
static inline struct fixed31_32 translate_to_linear_space_ex(
|
||||
struct fixed31_32 arg,
|
||||
struct gamma_coefficients *coeff,
|
||||
uint32_t color_index)
|
||||
{
|
||||
return translate_to_linear_space(
|
||||
arg,
|
||||
coeff->a0[color_index],
|
||||
coeff->a1[color_index],
|
||||
coeff->a2[color_index],
|
||||
coeff->a3[color_index],
|
||||
coeff->user_gamma[color_index]);
|
||||
}
|
||||
|
||||
|
||||
static bool find_software_points(
|
||||
const struct dc_gamma *ramp,
|
||||
const struct gamma_pixel *axis_x,
|
||||
|
|
@ -314,12 +427,6 @@ static bool build_custom_gamma_mapping_coefficients_worker(
|
|||
struct fixed31_32 left_pos;
|
||||
struct fixed31_32 right_pos;
|
||||
|
||||
/*
|
||||
* TODO: confirm enum in surface_pixel_format
|
||||
* if (pixel_format == PIXEL_FORMAT_FP16)
|
||||
*coord_x = coordinates_x[i].adjusted_x;
|
||||
*else
|
||||
*/
|
||||
if (channel == CHANNEL_NAME_RED)
|
||||
coord_x = coordinates_x[i].regamma_y_red;
|
||||
else if (channel == CHANNEL_NAME_GREEN)
|
||||
|
|
@ -451,7 +558,7 @@ static struct fixed31_32 calculate_mapped_value(
|
|||
return result;
|
||||
}
|
||||
|
||||
static void build_regamma_curve_pq(struct pwl_float_data_ex *rgb_regamma,
|
||||
static void build_pq(struct pwl_float_data_ex *rgb_regamma,
|
||||
uint32_t hw_points_num,
|
||||
const struct hw_x_point *coordinate_x,
|
||||
uint32_t sdr_white_level)
|
||||
|
|
@ -477,11 +584,6 @@ static void build_regamma_curve_pq(struct pwl_float_data_ex *rgb_regamma,
|
|||
rgb += start_index;
|
||||
coord_x += start_index;
|
||||
|
||||
/* use coord_x to retrieve coordinates chosen base on given user curve
|
||||
* the x values are exponentially distributed and currently it is hard
|
||||
* coded, the user curve shape is ignored. Need to recalculate coord_x
|
||||
* based on input curve, translation from 256/1025 to 128 PWL points.
|
||||
*/
|
||||
for (i = start_index; i <= hw_points_num; i++) {
|
||||
/* Multiply 0.008 as regamma is 0-1 and FP16 input is 0-125.
|
||||
* FP 1.0 = 80nits
|
||||
|
|
@ -508,37 +610,86 @@ static void build_regamma_curve_pq(struct pwl_float_data_ex *rgb_regamma,
|
|||
}
|
||||
}
|
||||
|
||||
static void build_regamma_curve(struct pwl_float_data_ex *rgb_regamma,
|
||||
static void build_de_pq(struct pwl_float_data_ex *de_pq,
|
||||
uint32_t hw_points_num,
|
||||
const struct hw_x_point *coordinate_x)
|
||||
{
|
||||
uint32_t i;
|
||||
struct fixed31_32 output;
|
||||
|
||||
struct pwl_float_data_ex *rgb = de_pq;
|
||||
const struct hw_x_point *coord_x = degamma_coordinates_x;
|
||||
struct fixed31_32 scaling_factor = dal_fixed31_32_from_int(125);
|
||||
|
||||
if (!de_pq_initialized) {
|
||||
precompute_de_pq();
|
||||
de_pq_initialized = true;
|
||||
}
|
||||
|
||||
|
||||
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))
|
||||
output = scaling_factor;
|
||||
|
||||
rgb->r = output;
|
||||
rgb->g = output;
|
||||
rgb->b = output;
|
||||
|
||||
++coord_x;
|
||||
++rgb;
|
||||
}
|
||||
}
|
||||
|
||||
static void build_regamma(struct pwl_float_data_ex *rgb_regamma,
|
||||
uint32_t hw_points_num,
|
||||
const struct hw_x_point *coordinate_x, bool is_2_4)
|
||||
{
|
||||
uint32_t i;
|
||||
|
||||
struct gamma_coefficients coeff;
|
||||
struct pwl_float_data_ex *rgb = rgb_regamma;
|
||||
const struct hw_x_point *coord_x = coordinate_x;
|
||||
|
||||
build_regamma_coefficients(&coeff);
|
||||
|
||||
/* Use opp110->regamma.coordinates_x to retrieve
|
||||
* coordinates chosen base on given user curve (future task).
|
||||
* The x values are exponentially distributed and currently
|
||||
* it is hard-coded, the user curve shape is ignored.
|
||||
* The future task is to recalculate opp110-
|
||||
* regamma.coordinates_x based on input/user curve,
|
||||
* translation from 256/1025 to 128 pwl points.
|
||||
*/
|
||||
build_coefficients(&coeff, is_2_4);
|
||||
|
||||
i = 0;
|
||||
|
||||
while (i != hw_points_num + 1) {
|
||||
/*TODO use y vs r,g,b*/
|
||||
rgb->r = translate_from_linear_space_ex(
|
||||
coord_x->x, &coeff, 0);
|
||||
rgb->g = translate_from_linear_space_ex(
|
||||
coord_x->x, &coeff, 1);
|
||||
rgb->b = translate_from_linear_space_ex(
|
||||
coord_x->x, &coeff, 2);
|
||||
rgb->g = rgb->r;
|
||||
rgb->b = rgb->r;
|
||||
++coord_x;
|
||||
++rgb;
|
||||
++i;
|
||||
}
|
||||
}
|
||||
|
||||
static void build_degamma(struct pwl_float_data_ex *curve,
|
||||
uint32_t hw_points_num,
|
||||
const struct hw_x_point *coordinate_x, bool is_2_4)
|
||||
{
|
||||
uint32_t i;
|
||||
|
||||
struct gamma_coefficients coeff;
|
||||
struct pwl_float_data_ex *rgb = curve;
|
||||
const struct hw_x_point *coord_x = degamma_coordinates_x;
|
||||
|
||||
build_coefficients(&coeff, is_2_4);
|
||||
|
||||
i = 0;
|
||||
|
||||
while (i != hw_points_num + 1) {
|
||||
/*TODO use y vs r,g,b*/
|
||||
rgb->r = translate_to_linear_space_ex(
|
||||
coord_x->x, &coeff, 0);
|
||||
rgb->g = rgb->r;
|
||||
rgb->b = rgb->r;
|
||||
++coord_x;
|
||||
++rgb;
|
||||
++i;
|
||||
|
|
@ -921,6 +1072,8 @@ static bool map_regamma_hw_to_x_user(
|
|||
return true;
|
||||
}
|
||||
|
||||
#define _EXTRA_POINTS 3
|
||||
|
||||
bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf,
|
||||
const struct dc_gamma *ramp, bool mapUserRamp)
|
||||
{
|
||||
|
|
@ -930,7 +1083,7 @@ bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf,
|
|||
struct pwl_float_data *rgb_user = NULL;
|
||||
struct pwl_float_data_ex *rgb_regamma = NULL;
|
||||
struct gamma_pixel *axix_x = NULL;
|
||||
struct pixel_gamma_point *coeff128 = NULL;
|
||||
struct pixel_gamma_point *coeff = NULL;
|
||||
enum dc_transfer_func_predefined tf = TRANSFER_FUNCTION_SRGB;
|
||||
bool ret = false;
|
||||
|
||||
|
|
@ -945,11 +1098,11 @@ bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf,
|
|||
|
||||
output_tf->type = TF_TYPE_DISTRIBUTED_POINTS;
|
||||
|
||||
rgb_user = kzalloc(sizeof(*rgb_user) * (ramp->num_entries + 3),
|
||||
rgb_user = kzalloc(sizeof(*rgb_user) * (ramp->num_entries + _EXTRA_POINTS),
|
||||
GFP_KERNEL);
|
||||
if (!rgb_user)
|
||||
goto rgb_user_alloc_fail;
|
||||
rgb_regamma = kzalloc(sizeof(*rgb_regamma) * (MAX_HW_POINTS + 3),
|
||||
rgb_regamma = kzalloc(sizeof(*rgb_regamma) * (MAX_HW_POINTS + _EXTRA_POINTS),
|
||||
GFP_KERNEL);
|
||||
if (!rgb_regamma)
|
||||
goto rgb_regamma_alloc_fail;
|
||||
|
|
@ -957,9 +1110,9 @@ bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf,
|
|||
GFP_KERNEL);
|
||||
if (!axix_x)
|
||||
goto axix_x_alloc_fail;
|
||||
coeff128 = kzalloc(sizeof(*coeff128) * (MAX_HW_POINTS + 3), GFP_KERNEL);
|
||||
if (!coeff128)
|
||||
goto coeff128_alloc_fail;
|
||||
coeff = kzalloc(sizeof(*coeff) * (MAX_HW_POINTS + _EXTRA_POINTS), GFP_KERNEL);
|
||||
if (!coeff)
|
||||
goto coeff_alloc_fail;
|
||||
|
||||
dividers.divider1 = dal_fixed31_32_from_fraction(3, 2);
|
||||
dividers.divider2 = dal_fixed31_32_from_int(2);
|
||||
|
|
@ -983,7 +1136,7 @@ bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf,
|
|||
tf_pts->x_point_at_y1_green = 125;
|
||||
tf_pts->x_point_at_y1_blue = 125;
|
||||
|
||||
build_regamma_curve_pq(rgb_regamma,
|
||||
build_pq(rgb_regamma,
|
||||
MAX_HW_POINTS,
|
||||
coordinates_x,
|
||||
output_tf->sdr_ref_white_level);
|
||||
|
|
@ -993,12 +1146,12 @@ bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf,
|
|||
tf_pts->x_point_at_y1_green = 1;
|
||||
tf_pts->x_point_at_y1_blue = 1;
|
||||
|
||||
build_regamma_curve(rgb_regamma,
|
||||
build_regamma(rgb_regamma,
|
||||
MAX_HW_POINTS,
|
||||
coordinates_x);
|
||||
coordinates_x, tf == TRANSFER_FUNCTION_SRGB ? true:false);
|
||||
}
|
||||
|
||||
map_regamma_hw_to_x_user(ramp, coeff128, rgb_user,
|
||||
map_regamma_hw_to_x_user(ramp, coeff, rgb_user,
|
||||
coordinates_x, axix_x, rgb_regamma,
|
||||
MAX_HW_POINTS, tf_pts,
|
||||
(mapUserRamp || ramp->type != GAMMA_RGB_256) &&
|
||||
|
|
@ -1009,8 +1162,8 @@ bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf,
|
|||
|
||||
ret = true;
|
||||
|
||||
kfree(coeff128);
|
||||
coeff128_alloc_fail:
|
||||
kfree(coeff);
|
||||
coeff_alloc_fail:
|
||||
kfree(axix_x);
|
||||
axix_x_alloc_fail:
|
||||
kfree(rgb_regamma);
|
||||
|
|
@ -1024,6 +1177,98 @@ rgb_user_alloc_fail:
|
|||
/*TODO fix me should be 2*/
|
||||
#define _EXTRA_POINTS 3
|
||||
|
||||
bool mod_color_calculate_degamma_params(struct dc_transfer_func *input_tf,
|
||||
const struct dc_gamma *ramp, bool mapUserRamp)
|
||||
{
|
||||
struct dc_transfer_func_distributed_points *tf_pts = &input_tf->tf_pts;
|
||||
struct dividers dividers;
|
||||
|
||||
struct pwl_float_data *rgb_user = NULL;
|
||||
struct pwl_float_data_ex *curve = NULL;
|
||||
struct gamma_pixel *axix_x = NULL;
|
||||
struct pixel_gamma_point *coeff = NULL;
|
||||
enum dc_transfer_func_predefined tf = TRANSFER_FUNCTION_SRGB;
|
||||
bool ret = false;
|
||||
|
||||
if (input_tf->type == TF_TYPE_BYPASS)
|
||||
return false;
|
||||
|
||||
/* we can use hardcoded curve for plain SRGB TF */
|
||||
if (input_tf->type == TF_TYPE_PREDEFINED &&
|
||||
input_tf->tf == TRANSFER_FUNCTION_SRGB &&
|
||||
(!mapUserRamp && ramp->type == GAMMA_RGB_256))
|
||||
return true;
|
||||
|
||||
input_tf->type = TF_TYPE_DISTRIBUTED_POINTS;
|
||||
|
||||
rgb_user = kzalloc(sizeof(*rgb_user) * (ramp->num_entries + _EXTRA_POINTS),
|
||||
GFP_KERNEL);
|
||||
if (!rgb_user)
|
||||
goto rgb_user_alloc_fail;
|
||||
curve = kzalloc(sizeof(*curve) * (MAX_HW_DEGAMMA_POINTS + _EXTRA_POINTS),
|
||||
GFP_KERNEL);
|
||||
if (!curve)
|
||||
goto curve_alloc_fail;
|
||||
axix_x = kzalloc(sizeof(*axix_x) * (ramp->num_entries + _EXTRA_POINTS),
|
||||
GFP_KERNEL);
|
||||
if (!axix_x)
|
||||
goto axix_x_alloc_fail;
|
||||
coeff = kzalloc(sizeof(*coeff) * (MAX_HW_DEGAMMA_POINTS + _EXTRA_POINTS), GFP_KERNEL);
|
||||
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);
|
||||
|
||||
tf = input_tf->tf;
|
||||
|
||||
build_evenly_distributed_points(
|
||||
axix_x,
|
||||
ramp->num_entries,
|
||||
dividers);
|
||||
|
||||
if (ramp->type == GAMMA_RGB_256 && mapUserRamp)
|
||||
scale_gamma(rgb_user, ramp, dividers);
|
||||
else if (ramp->type == GAMMA_RGB_FLOAT_1024)
|
||||
scale_gamma_dx(rgb_user, ramp, dividers);
|
||||
|
||||
if (tf == TRANSFER_FUNCTION_PQ)
|
||||
build_de_pq(curve,
|
||||
MAX_HW_DEGAMMA_POINTS,
|
||||
degamma_coordinates_x);
|
||||
else
|
||||
build_degamma(curve,
|
||||
MAX_HW_DEGAMMA_POINTS,
|
||||
degamma_coordinates_x,
|
||||
tf == TRANSFER_FUNCTION_SRGB ? true:false);
|
||||
|
||||
tf_pts->end_exponent = 0;
|
||||
tf_pts->x_point_at_y1_red = 1;
|
||||
tf_pts->x_point_at_y1_green = 1;
|
||||
tf_pts->x_point_at_y1_blue = 1;
|
||||
|
||||
map_regamma_hw_to_x_user(ramp, coeff, rgb_user,
|
||||
degamma_coordinates_x, axix_x, curve,
|
||||
MAX_HW_DEGAMMA_POINTS, tf_pts,
|
||||
mapUserRamp);
|
||||
|
||||
ret = true;
|
||||
|
||||
kfree(coeff);
|
||||
coeff_alloc_fail:
|
||||
kfree(axix_x);
|
||||
axix_x_alloc_fail:
|
||||
kfree(curve);
|
||||
curve_alloc_fail:
|
||||
kfree(rgb_user);
|
||||
rgb_user_alloc_fail:
|
||||
|
||||
return ret;
|
||||
|
||||
}
|
||||
|
||||
|
||||
bool mod_color_calculate_curve(enum dc_transfer_func_predefined trans,
|
||||
struct dc_transfer_func_distributed_points *points)
|
||||
{
|
||||
|
|
@ -1032,7 +1277,11 @@ bool mod_color_calculate_curve(enum dc_transfer_func_predefined trans,
|
|||
struct pwl_float_data_ex *rgb_regamma = NULL;
|
||||
|
||||
if (trans == TRANSFER_FUNCTION_UNITY) {
|
||||
//setup_x_points_distribution(coordinates_x);
|
||||
points->end_exponent = 0;
|
||||
points->x_point_at_y1_red = 1;
|
||||
points->x_point_at_y1_green = 1;
|
||||
points->x_point_at_y1_blue = 1;
|
||||
|
||||
for (i = 0; i < MAX_HW_POINTS ; i++) {
|
||||
points->red[i] = coordinates_x[i].x;
|
||||
points->green[i] = coordinates_x[i].x;
|
||||
|
|
@ -1044,16 +1293,38 @@ bool mod_color_calculate_curve(enum dc_transfer_func_predefined trans,
|
|||
_EXTRA_POINTS), GFP_KERNEL);
|
||||
if (!rgb_regamma)
|
||||
goto rgb_regamma_alloc_fail;
|
||||
//setup_x_points_distribution(coordinates_x);
|
||||
points->end_exponent = 7;
|
||||
points->x_point_at_y1_red = 125;
|
||||
points->x_point_at_y1_green = 125;
|
||||
points->x_point_at_y1_blue = 125;
|
||||
|
||||
|
||||
build_pq(rgb_regamma,
|
||||
MAX_HW_POINTS,
|
||||
coordinates_x,
|
||||
80);
|
||||
for (i = 0; i < MAX_HW_POINTS ; i++) {
|
||||
points->red[i] = rgb_regamma[i].r;
|
||||
points->green[i] = rgb_regamma[i].g;
|
||||
points->blue[i] = rgb_regamma[i].b;
|
||||
}
|
||||
ret = true;
|
||||
|
||||
kfree(rgb_regamma);
|
||||
} else if (trans == TRANSFER_FUNCTION_SRGB ||
|
||||
trans == TRANSFER_FUNCTION_BT709) {
|
||||
rgb_regamma = kzalloc(sizeof(*rgb_regamma) * (MAX_HW_POINTS +
|
||||
_EXTRA_POINTS), GFP_KERNEL);
|
||||
if (!rgb_regamma)
|
||||
goto rgb_regamma_alloc_fail;
|
||||
points->end_exponent = 0;
|
||||
points->x_point_at_y1_red = 1;
|
||||
points->x_point_at_y1_green = 1;
|
||||
points->x_point_at_y1_blue = 1;
|
||||
|
||||
build_regamma_curve_pq(rgb_regamma,
|
||||
build_regamma(rgb_regamma,
|
||||
MAX_HW_POINTS,
|
||||
coordinates_x,
|
||||
80);
|
||||
coordinates_x, trans == TRANSFER_FUNCTION_SRGB ? true:false);
|
||||
for (i = 0; i < MAX_HW_POINTS ; i++) {
|
||||
points->red[i] = rgb_regamma[i].r;
|
||||
points->green[i] = rgb_regamma[i].g;
|
||||
|
|
@ -1068,3 +1339,65 @@ rgb_regamma_alloc_fail:
|
|||
}
|
||||
|
||||
|
||||
bool mod_color_calculate_degamma_curve(enum dc_transfer_func_predefined trans,
|
||||
struct dc_transfer_func_distributed_points *points)
|
||||
{
|
||||
uint32_t i;
|
||||
bool ret = false;
|
||||
struct pwl_float_data_ex *rgb_degamma = NULL;
|
||||
|
||||
if (trans == TRANSFER_FUNCTION_UNITY) {
|
||||
|
||||
for (i = 0; i < MAX_HW_DEGAMMA_POINTS ; i++) {
|
||||
points->red[i] = degamma_coordinates_x[i].x;
|
||||
points->green[i] = degamma_coordinates_x[i].x;
|
||||
points->blue[i] = degamma_coordinates_x[i].x;
|
||||
}
|
||||
ret = true;
|
||||
} else if (trans == TRANSFER_FUNCTION_PQ) {
|
||||
rgb_degamma = kzalloc(sizeof(*rgb_degamma) * (MAX_HW_DEGAMMA_POINTS +
|
||||
_EXTRA_POINTS), GFP_KERNEL);
|
||||
if (!rgb_degamma)
|
||||
goto rgb_degamma_alloc_fail;
|
||||
|
||||
|
||||
build_de_pq(rgb_degamma,
|
||||
MAX_HW_DEGAMMA_POINTS,
|
||||
degamma_coordinates_x);
|
||||
for (i = 0; i < MAX_HW_DEGAMMA_POINTS ; i++) {
|
||||
points->red[i] = rgb_degamma[i].r;
|
||||
points->green[i] = rgb_degamma[i].g;
|
||||
points->blue[i] = rgb_degamma[i].b;
|
||||
}
|
||||
ret = true;
|
||||
|
||||
kfree(rgb_degamma);
|
||||
} else if (trans == TRANSFER_FUNCTION_SRGB ||
|
||||
trans == TRANSFER_FUNCTION_BT709) {
|
||||
rgb_degamma = kzalloc(sizeof(*rgb_degamma) * (MAX_HW_DEGAMMA_POINTS +
|
||||
_EXTRA_POINTS), GFP_KERNEL);
|
||||
if (!rgb_degamma)
|
||||
goto rgb_degamma_alloc_fail;
|
||||
|
||||
build_degamma(rgb_degamma,
|
||||
MAX_HW_DEGAMMA_POINTS,
|
||||
degamma_coordinates_x, trans == TRANSFER_FUNCTION_SRGB ? true:false);
|
||||
for (i = 0; i < MAX_HW_DEGAMMA_POINTS ; i++) {
|
||||
points->red[i] = rgb_degamma[i].r;
|
||||
points->green[i] = rgb_degamma[i].g;
|
||||
points->blue[i] = rgb_degamma[i].b;
|
||||
}
|
||||
ret = true;
|
||||
|
||||
kfree(rgb_degamma);
|
||||
}
|
||||
points->end_exponent = 0;
|
||||
points->x_point_at_y1_red = 1;
|
||||
points->x_point_at_y1_green = 1;
|
||||
points->x_point_at_y1_blue = 1;
|
||||
|
||||
rgb_degamma_alloc_fail:
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -34,12 +34,20 @@ enum dc_transfer_func_predefined;
|
|||
|
||||
void setup_x_points_distribution(void);
|
||||
void precompute_pq(void);
|
||||
void precompute_de_pq(void);
|
||||
|
||||
bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf,
|
||||
const struct dc_gamma *ramp, bool mapUserRamp);
|
||||
|
||||
bool mod_color_calculate_degamma_params(struct dc_transfer_func *output_tf,
|
||||
const struct dc_gamma *ramp, bool mapUserRamp);
|
||||
|
||||
bool mod_color_calculate_curve(enum dc_transfer_func_predefined trans,
|
||||
struct dc_transfer_func_distributed_points *points);
|
||||
|
||||
bool mod_color_calculate_degamma_curve(enum dc_transfer_func_predefined trans,
|
||||
struct dc_transfer_func_distributed_points *points);
|
||||
|
||||
|
||||
|
||||
#endif /* COLOR_MOD_COLOR_GAMMA_H_ */
|
||||
|
|
|
|||
Loading…
Reference in New Issue