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

Commit 26715c82 authored by Fiona Campbell's avatar Fiona Campbell Committed by Android (Google) Code Review
Browse files

Merge "Change BrightnessMappingStrategy to use DDC values" into sc-dev

parents a32ef5bd 9764e3ab

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) {