Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9764e3ab authored by Fiona Campbell's avatar Fiona Campbell
Browse files

Change BrightnessMappingStrategy to use DDC values 

Use brightness min and max values from display device config.
Use brightness nits and backlight ranges from display device config

Convert the nits to backlight splines to only use the valid range considering the min and max values given in the ddc.
Backlight refers to the values handled by the HAL.
Brightness refers to the values used and stored in the system.

Bug: 151620088
Bug: 174757872
Bug: 171380847
Test: LocalDisplayAdapterTest, AutomaticBrightessControllerTest, BrightnessMappingStrategyTest

Change-Id: I6907f11cdf4e62ec9e6ed4304d11fe7686f5c8b6
parent d549483e

packages/SystemUI/src/com/android/systemui/settings/brightness/BrightnessController.java

+4 −10
Original line number Diff line number Diff line
@@ -72,8 +72,6 @@ public class BrightnessController implements ToggleSlider.Listener { 
    private static final Uri BRIGHTNESS_FOR_VR_FLOAT_URI =

            Settings.System.getUriFor(Settings.System.SCREEN_BRIGHTNESS_FOR_VR_FLOAT);



    private final float mMinimumBacklight;

    private final float mMaximumBacklight;

    private final float mDefaultBacklight;

    private final float mMinimumBacklightForVr;

    private final float mMaximumBacklightForVr;
@@ -314,10 +312,6 @@ public class BrightnessController implements ToggleSlider.Listener { 


        mDisplayId = mContext.getDisplayId();

        PowerManager pm = context.getSystemService(PowerManager.class);

        mMinimumBacklight = pm.getBrightnessConstraint(

                PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_MINIMUM);

        mMaximumBacklight = pm.getBrightnessConstraint(

                PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_MAXIMUM);

        mDefaultBacklight = mContext.getDisplay().getBrightnessDefault();

        mMinimumBacklightForVr = pm.getBrightnessConstraint(

                PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_MINIMUM_VR);
@@ -375,8 +369,8 @@ public class BrightnessController implements ToggleSlider.Listener { 
            metric = mAutomatic

                    ? MetricsEvent.ACTION_BRIGHTNESS_AUTO

                    : MetricsEvent.ACTION_BRIGHTNESS;

            minBacklight = mMinimumBacklight;

            maxBacklight = mMaximumBacklight;

            minBacklight = PowerManager.BRIGHTNESS_MIN;

            maxBacklight = PowerManager.BRIGHTNESS_MAX;

            settingToChange = Settings.System.SCREEN_BRIGHTNESS_FLOAT;

        }

        final float valFloat = MathUtils.min(convertGammaToLinearFloat(value,
@@ -439,8 +433,8 @@ public class BrightnessController implements ToggleSlider.Listener { 
            min = mMinimumBacklightForVr;

            max = mMaximumBacklightForVr;

        } else {

            min = mMinimumBacklight;

            max = mMaximumBacklight;

            min = PowerManager.BRIGHTNESS_MIN;

            max = PowerManager.BRIGHTNESS_MAX;

        }

        // convertGammaToLinearFloat returns 0-1

        if (BrightnessSynchronizer.floatEquals(brightnessValue,

services/core/java/com/android/server/display/BrightnessMappingStrategy.java

+52 −62
Original line number Diff line number Diff line
@@ -61,7 +61,10 @@ public abstract class BrightnessMappingStrategy { 
    private static final Plog PLOG = Plog.createSystemPlog(TAG);



    @Nullable

    public static BrightnessMappingStrategy create(Resources resources) {

    public static BrightnessMappingStrategy create(Resources resources,

            DisplayDeviceConfig displayDeviceConfig) {



        // Display independent values

        float[] luxLevels = getLuxLevels(resources.getIntArray(

                com.android.internal.R.array.config_autoBrightnessLevels));

        int[] brightnessLevelsBacklight = resources.getIntArray(
@@ -71,32 +74,22 @@ public abstract class BrightnessMappingStrategy { 
        float autoBrightnessAdjustmentMaxGamma = resources.getFraction(

                com.android.internal.R.fraction.config_autoBrightnessAdjustmentMaxGamma,

                1, 1);



        float[] nitsRange = getFloatArray(resources.obtainTypedArray(

                com.android.internal.R.array.config_screenBrightnessNits));

        int[] backlightRange = resources.getIntArray(

                com.android.internal.R.array.config_screenBrightnessBacklight);



        long shortTermModelTimeout = resources.getInteger(

                com.android.internal.R.integer.config_autoBrightnessShortTermModelTimeout);



        if (isValidMapping(nitsRange, backlightRange)

        // Display dependent values - used for physical mapping strategy nits -> brightness

        final float[] nitsRange = displayDeviceConfig.getNits();

        final float[] brightnessRange = displayDeviceConfig.getBrightness();



        if (isValidMapping(nitsRange, brightnessRange)

                && isValidMapping(luxLevels, brightnessLevelsNits)) {

            int minimumBacklight = resources.getInteger(

                    com.android.internal.R.integer.config_screenBrightnessSettingMinimum);

            int maximumBacklight = resources.getInteger(

                    com.android.internal.R.integer.config_screenBrightnessSettingMaximum);

            if (backlightRange[0] > minimumBacklight

                    || backlightRange[backlightRange.length - 1] < maximumBacklight) {

                Slog.w(TAG, "Screen brightness mapping does not cover whole range of available " +

                        "backlight values, autobrightness functionality may be impaired.");

            }



            BrightnessConfiguration.Builder builder = new BrightnessConfiguration.Builder(

                    luxLevels, brightnessLevelsNits);

            builder.setShortTermModelTimeoutMillis(shortTermModelTimeout);

            builder.setShortTermModelLowerLuxMultiplier(SHORT_TERM_MODEL_THRESHOLD_RATIO);

            builder.setShortTermModelUpperLuxMultiplier(SHORT_TERM_MODEL_THRESHOLD_RATIO);

            return new PhysicalMappingStrategy(builder.build(), nitsRange, backlightRange,

            return new PhysicalMappingStrategy(builder.build(), nitsRange, brightnessRange,

                    autoBrightnessAdjustmentMaxGamma);

        } else if (isValidMapping(luxLevels, brightnessLevelsBacklight)) {

            return new SimpleMappingStrategy(luxLevels, brightnessLevelsBacklight,
@@ -264,11 +257,11 @@ public abstract class BrightnessMappingStrategy { 
    public abstract boolean setAutoBrightnessAdjustment(float adjustment);



    /**

     * Converts the provided backlight value to nits if possible.

     * Converts the provided brightness value to nits if possible.

     *

     * Returns -1.0f if there's no available mapping for the backlight to nits.

     * Returns -1.0f if there's no available mapping for the brightness to nits.

     */

    public abstract float convertToNits(int backlight);

    public abstract float convertToNits(float brightness);



    /**

     * Adds a user interaction data point to the brightness mapping.
@@ -603,7 +596,7 @@ public abstract class BrightnessMappingStrategy { 
        }



        @Override

        public float convertToNits(int backlight) {

        public float convertToNits(float brightness) {

            return -1.0f;

        }
@@ -701,37 +694,39 @@ public abstract class BrightnessMappingStrategy { 
        // in nits.

        private Spline mBrightnessSpline;



        // A spline mapping from nits to the corresponding backlight value, normalized to the range

        // A spline mapping from nits to the corresponding brightness value, normalized to the range

        // [0, 1.0].

        private Spline mNitsToBacklightSpline;

        private Spline mNitsToBrightnessSpline;



        // A spline mapping from the system brightness value, normalized to the range [0, 1.0], to

        // a brightness in nits.

        private Spline mBrightnessToNitsSpline;



        // The default brightness configuration.

        private final BrightnessConfiguration mDefaultConfig;



        // A spline mapping from the device's backlight value, normalized to the range [0, 1.0], to

        // a brightness in nits.

        private Spline mBacklightToNitsSpline;



        private float[] mNits;

        private int[] mBacklight;

        private final float[] mNits;

        private final float[] mBrightness;



        private boolean mBrightnessRangeAdjustmentApplied;



        private float mMaxGamma;

        private final float mMaxGamma;

        private float mAutoBrightnessAdjustment;

        private float mUserLux;

        private float mUserBrightness;



        public PhysicalMappingStrategy(BrightnessConfiguration config, float[] nits,

                                       int[] backlight, float maxGamma) {

            Preconditions.checkArgument(nits.length != 0 && backlight.length != 0,

                    "Nits and backlight arrays must not be empty!");

            Preconditions.checkArgument(nits.length == backlight.length,

                    "Nits and backlight arrays must be the same length!");

                float[] brightness, float maxGamma) {



            Preconditions.checkArgument(nits.length != 0 && brightness.length != 0,

                    "Nits and brightness arrays must not be empty!");



            Preconditions.checkArgument(nits.length == brightness.length,

                    "Nits and brightness arrays must be the same length!");

            Objects.requireNonNull(config);

            Preconditions.checkArrayElementsInRange(nits, 0, Float.MAX_VALUE, "nits");

            Preconditions.checkArrayElementsInRange(backlight,

                    PowerManager.BRIGHTNESS_OFF, PowerManager.BRIGHTNESS_ON, "backlight");

            Preconditions.checkArrayElementsInRange(brightness,

                    PowerManager.BRIGHTNESS_MIN, PowerManager.BRIGHTNESS_MAX, "brightness");



            mMaxGamma = maxGamma;

            mAutoBrightnessAdjustment = 0;
@@ -739,7 +734,7 @@ public abstract class BrightnessMappingStrategy { 
            mUserBrightness = -1;



            mNits = nits;

            mBacklight = backlight;

            mBrightness = brightness;

            computeNitsBrightnessSplines(mNits);



            mDefaultConfig = config;
@@ -784,15 +779,15 @@ public abstract class BrightnessMappingStrategy { 
        public float getBrightness(float lux, String packageName,

                @ApplicationInfo.Category int category) {

            float nits = mBrightnessSpline.interpolate(lux);

            float backlight = mNitsToBacklightSpline.interpolate(nits);

            float brightness = mNitsToBrightnessSpline.interpolate(nits);

            // Correct the brightness according to the current application and its category, but

            // only if no user data point is set (as this will oevrride the user setting).

            // only if no user data point is set (as this will override the user setting).

            if (mUserLux == -1) {

                backlight = correctBrightness(backlight, packageName, category);

                brightness = correctBrightness(brightness, packageName, category);

            } else if (mLoggingEnabled) {

                Slog.d(TAG, "user point set, correction not applied");

            }

            return backlight;

            return brightness;

        }



        @Override
@@ -817,8 +812,8 @@ public abstract class BrightnessMappingStrategy { 
        }



        @Override

        public float convertToNits(int backlight) {

            return mBacklightToNitsSpline.interpolate(normalizeAbsoluteBrightness(backlight));

        public float convertToNits(float brightness) {

            return mBrightnessToNitsSpline.interpolate(brightness);

        }



        @Override
@@ -884,7 +879,8 @@ public abstract class BrightnessMappingStrategy { 
            pw.println("PhysicalMappingStrategy");

            pw.println("  mConfig=" + mConfig);

            pw.println("  mBrightnessSpline=" + mBrightnessSpline);

            pw.println("  mNitsToBacklightSpline=" + mNitsToBacklightSpline);

            pw.println("  mNitsToBrightnessSpline=" + mNitsToBrightnessSpline);

            pw.println("  mBrightnessToNitsSpline=" + mBrightnessToNitsSpline);

            pw.println("  mMaxGamma=" + mMaxGamma);

            pw.println("  mAutoBrightnessAdjustment=" + mAutoBrightnessAdjustment);

            pw.println("  mUserLux=" + mUserLux);
@@ -894,31 +890,25 @@ public abstract class BrightnessMappingStrategy { 
        }



        private void computeNitsBrightnessSplines(float[] nits) {

            final int len = nits.length;

            float[] normalizedBacklight = new float[len];

            for (int i = 0; i < len; i++) {

                normalizedBacklight[i] = normalizeAbsoluteBrightness(mBacklight[i]);

            }



            mNitsToBacklightSpline = Spline.createSpline(nits, normalizedBacklight);

            mBacklightToNitsSpline = Spline.createSpline(normalizedBacklight, nits);

            mNitsToBrightnessSpline = Spline.createSpline(nits, mBrightness);

            mBrightnessToNitsSpline = Spline.createSpline(mBrightness, nits);

        }



        private void computeSpline() {

            Pair<float[], float[]> defaultCurve = mConfig.getCurve();

            float[] defaultLux = defaultCurve.first;

            float[] defaultNits = defaultCurve.second;

            float[] defaultBacklight = new float[defaultNits.length];

            for (int i = 0; i < defaultBacklight.length; i++) {

                defaultBacklight[i] = mNitsToBacklightSpline.interpolate(defaultNits[i]);

            float[] defaultBrightness = new float[defaultNits.length];

            for (int i = 0; i < defaultBrightness.length; i++) {

                defaultBrightness[i] = mNitsToBrightnessSpline.interpolate(defaultNits[i]);

            }

            Pair<float[], float[]> curve = getAdjustedCurve(defaultLux, defaultBacklight, mUserLux,

            Pair<float[], float[]> curve = getAdjustedCurve(defaultLux, defaultBrightness, mUserLux,

                    mUserBrightness, mAutoBrightnessAdjustment, mMaxGamma);

            float[] lux = curve.first;

            float[] backlight = curve.second;

            float[] nits = new float[backlight.length];

            float[] brightness = curve.second;

            float[] nits = new float[brightness.length];

            for (int i = 0; i < nits.length; i++) {

                nits[i] = mBacklightToNitsSpline.interpolate(backlight[i]);

                nits[i] = mBrightnessToNitsSpline.interpolate(brightness[i]);

            }

            mBrightnessSpline = Spline.createSpline(lux, nits);

        }
@@ -926,7 +916,7 @@ public abstract class BrightnessMappingStrategy { 
        private float getUnadjustedBrightness(float lux) {

            Pair<float[], float[]> curve = mConfig.getCurve();

            Spline spline = Spline.createSpline(curve.first, curve.second);

            return mNitsToBacklightSpline.interpolate(spline.interpolate(lux));

            return mNitsToBrightnessSpline.interpolate(spline.interpolate(lux));

        }



        private float correctBrightness(float brightness, String packageName, int category) {

services/core/java/com/android/server/display/DisplayDeviceConfig.java

+196 −32

File changed.

Preview size limit exceeded, changes collapsed.

services/core/java/com/android/server/display/DisplayPowerController.java

+20 −40
Original line number Diff line number Diff line
@@ -190,12 +190,6 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
    // The dim screen brightness.

    private final float mScreenBrightnessDimConfig;



    // The minimum allowed brightness.

    private final float mScreenBrightnessRangeMinimum;



    // The maximum allowed brightness.

    private final float mScreenBrightnessRangeMaximum;



    private final float mScreenBrightnessDefault;



    // The minimum allowed brightness while in VR.
@@ -443,8 +437,6 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 


        final Resources resources = context.getResources();



        final float screenBrightnessSettingMinimumFloat = clampAbsoluteBrightness(

                pm.getBrightnessConstraint(PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_MINIMUM));



        // DOZE AND DIM SETTINGS

        mScreenBrightnessDozeConfig = clampAbsoluteBrightness(
@@ -453,10 +445,6 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
                pm.getBrightnessConstraint(PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_DIM));



        // NORMAL SCREEN SETTINGS

        mScreenBrightnessRangeMinimum =

                Math.min(screenBrightnessSettingMinimumFloat, mScreenBrightnessDimConfig);

        mScreenBrightnessRangeMaximum = clampAbsoluteBrightness(

                pm.getBrightnessConstraint(PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_MAXIMUM));

        mScreenBrightnessDefault = clampAbsoluteBrightness(

                mLogicalDisplay.getDisplayInfoLocked().brightnessDefault);
@@ -545,12 +533,14 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
                    com.android.internal.R.string.config_displayLightSensorType);

            Sensor lightSensor = findDisplayLightSensor(lightSensorType);



            mBrightnessMapper = BrightnessMappingStrategy.create(resources);

            final DisplayDeviceConfig ddc =

                    logicalDisplay.getPrimaryDisplayDeviceLocked().getDisplayDeviceConfig();

            mBrightnessMapper = BrightnessMappingStrategy.create(resources, ddc);

            if (mBrightnessMapper != null) {

                mAutomaticBrightnessController = new AutomaticBrightnessController(this,

                        handler.getLooper(), sensorManager, lightSensor, mBrightnessMapper,

                        lightSensorWarmUpTimeConfig, mScreenBrightnessRangeMinimum,

                        mScreenBrightnessRangeMaximum, dozeScaleFactor, lightSensorRate,

                        lightSensorWarmUpTimeConfig, PowerManager.BRIGHTNESS_MIN,

                        PowerManager.BRIGHTNESS_MAX, dozeScaleFactor, lightSensorRate,

                        initialLightSensorRate, brighteningLightDebounce, darkeningLightDebounce,

                        autoBrightnessResetAmbientLuxAfterWarmUp, ambientBrightnessThresholds,

                        screenBrightnessThresholds, logicalDisplay, context);
@@ -838,9 +828,8 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        noteScreenBrightness(mPowerState.getScreenBrightness());



        // Initialize all of the brightness tracking state

        final float brightness = convertToNits(BrightnessSynchronizer.brightnessFloatToInt(

                mPowerState.getScreenBrightness()));

        if (brightness >= 0.0f) {

        final float brightness = convertToNits(mPowerState.getScreenBrightness());

        if (brightness >= PowerManager.BRIGHTNESS_MIN) {

            mBrightnessTracker.start(brightness);

        }
@@ -1151,10 +1140,10 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        // Apply dimming by at least some minimum amount when user activity

        // timeout is about to expire.

        if (mPowerRequest.policy == DisplayPowerRequest.POLICY_DIM) {

            if (brightnessState > mScreenBrightnessRangeMinimum) {

            if (brightnessState > PowerManager.BRIGHTNESS_MIN) {

                brightnessState = Math.max(Math.min(brightnessState

                                - SCREEN_DIM_MINIMUM_REDUCTION_FLOAT,

                        mScreenBrightnessDimConfig), mScreenBrightnessRangeMinimum);

                        mScreenBrightnessDimConfig), PowerManager.BRIGHTNESS_MIN);

                mBrightnessReasonTemp.addModifier(BrightnessReason.MODIFIER_DIMMED);

            }

            if (!mAppliedDimming) {
@@ -1168,12 +1157,11 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        // If low power mode is enabled, scale brightness by screenLowPowerBrightnessFactor

        // as long as it is above the minimum threshold.

        if (mPowerRequest.lowPowerMode) {

            if (brightnessState > mScreenBrightnessRangeMinimum) {

            if (brightnessState > PowerManager.BRIGHTNESS_MIN) {

                final float brightnessFactor =

                        Math.min(mPowerRequest.screenLowPowerBrightnessFactor, 1);

                final float lowPowerBrightnessFloat = (brightnessState * brightnessFactor);

                brightnessState = Math.max(lowPowerBrightnessFloat,

                        mScreenBrightnessRangeMinimum);

                brightnessState = Math.max(lowPowerBrightnessFloat, PowerManager.BRIGHTNESS_MIN);

                mBrightnessReasonTemp.addModifier(BrightnessReason.MODIFIER_LOW_POWER);

            }

            if (!mAppliedLowPower) {
@@ -1258,9 +1246,8 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
                    // slider event so notify as if the system changed the brightness.

                    userInitiatedChange = false;

                }

                notifyBrightnessChanged(

                        BrightnessSynchronizer.brightnessFloatToInt(brightnessState),

                        userInitiatedChange, hadUserBrightnessPoint);

                notifyBrightnessChanged(brightnessState, userInitiatedChange,

                        hadUserBrightnessPoint);

            }



        }
@@ -1487,17 +1474,17 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 


    private float clampScreenBrightness(float value) {

        if (Float.isNaN(value)) {

            return mScreenBrightnessRangeMinimum;

            return PowerManager.BRIGHTNESS_MIN;

        }

        return MathUtils.constrain(

                value, mScreenBrightnessRangeMinimum, mScreenBrightnessRangeMaximum);

                value, PowerManager.BRIGHTNESS_MIN, PowerManager.BRIGHTNESS_MAX);

    }



    // Checks whether the brightness is within the valid brightness range, not including the off or

    // invalid states.

    private boolean isValidBrightnessValue(float brightnessState) {

        return brightnessState >= mScreenBrightnessRangeMinimum

                && brightnessState <= mScreenBrightnessRangeMaximum;

        return brightnessState >= PowerManager.BRIGHTNESS_MIN

                && brightnessState <= PowerManager.BRIGHTNESS_MAX;

    }



    private void animateScreenBrightness(float target, float rate) {
@@ -1874,7 +1861,7 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        return true;

    }



    private void notifyBrightnessChanged(int brightness, boolean userInitiated,

    private void notifyBrightnessChanged(float brightness, boolean userInitiated,

            boolean hadUserDataPoint) {

        final float brightnessInNits = convertToNits(brightness);

        if (mPowerRequest.useAutoBrightness && brightnessInNits >= 0.0f
@@ -1891,9 +1878,9 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        }

    }



    private float convertToNits(int backlight) {

    private float convertToNits(float brightness) {

        if (mBrightnessMapper != null) {

            return mBrightnessMapper.convertToNits(backlight);

            return mBrightnessMapper.convertToNits(brightness);

        } else {

            return -1.0f;

        }
@@ -1972,12 +1959,9 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 


        pw.println();

        pw.println("Display Power Controller Configuration:");

        pw.println("  mScreenBrightnessRangeMinimum=" + mScreenBrightnessRangeMinimum);

        pw.println("  mScreenBrightnessRangeMaximum=" + mScreenBrightnessRangeMaximum);

        pw.println("  mScreenBrightnessRangeDefault=" + mScreenBrightnessDefault);

        pw.println("  mScreenBrightnessDozeConfig=" + mScreenBrightnessDozeConfig);

        pw.println("  mScreenBrightnessDimConfig=" + mScreenBrightnessDimConfig);

        pw.println("  mScreenBrightnessDefault=" + mScreenBrightnessDefault);

        pw.println("  mScreenBrightnessForVrRangeMinimum=" + mScreenBrightnessForVrRangeMinimum);

        pw.println("  mScreenBrightnessForVrRangeMaximum=" + mScreenBrightnessForVrRangeMaximum);

        pw.println("  mScreenBrightnessForVrDefault=" + mScreenBrightnessForVrDefault);
@@ -2109,10 +2093,6 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        }

    }



    private static int clampAbsoluteBrightness(int value) {

        return MathUtils.constrain(value, PowerManager.BRIGHTNESS_OFF, PowerManager.BRIGHTNESS_ON);

    }



    private static float clampAbsoluteBrightness(float value) {

        return MathUtils.constrain(value, PowerManager.BRIGHTNESS_MIN,

                PowerManager.BRIGHTNESS_MAX);

services/core/java/com/android/server/display/LocalDisplayAdapter.java

+15 −72

File changed.

Preview size limit exceeded, changes collapsed.