自动背光算法-Android 8.1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

Brightness
 1 ^
   |
   |
   |             。
   |            。
   |           。
   +       。
min+   。
   |
   0---+---+-------------------> lux 
          min

1
2
3
4
5
6
7

/
出地库        光照稳定在0.8~1.1倍之间4S   /
  |         |                       |/
  +---------+-----------------------+--------------
10lux   5000lux         开始改变屏幕，假设屏幕亮度从55 -> 255, 
                        那么亮度调节完需要时间为((255-55)/rampRate)*16.6ms, 约3.3S
                     (16.6ms是一个vsync时间，rampRate默认为1，可以更改进行速率调节)

1
2
3
4
5
6

frameworks/base/core/res/res/values/config.xml
<bool name="config_automatic_brightness_available">false</bool> <!-- 自动背光功能是否可用开关 -->
<integer-array name="config_autoBrightnessLevels"> <!-- lux 数组 -->
</integer-array>
<integer-array name="config_autoBrightnessLcdBacklightValues"> <!-- 对应lcd brightness 数组 -->
</integer-array>

1
2
3
4
5
6
7

config_autoBrightnessLevels -> lux
config_autoBrightnessLcdBacklightValues -> brightness
       --> brightness[0]
lux[0] --> brightness[1]
lux[1] --> brightness[2]
lux[2] --> brightness[3]
.....

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

frameworks/base/services/core/java/com/android/server/display/DisplayPowerController.java
public DisplayPowerController(......) {
......
    // 使能开关
    mUseSoftwareAutoBrightnessConfig = resources.getBoolean(
            com.android.internal.R.bool.config_automatic_brightness_available);
......
    if (mUseSoftwareAutoBrightnessConfig) {
        // 光感数组
        int[] lux = resources.getIntArray(
                com.android.internal.R.array.config_autoBrightnessLevels);
        // 背光亮度数组
        int[] screenBrightness = resources.getIntArray(
                com.android.internal.R.array.config_autoBrightnessLcdBacklightValues);
        // 其它一些配置
        int lightSensorWarmUpTimeConfig = resources.getInteger(
                com.android.internal.R.integer.config_lightSensorWarmupTime);
        final float dozeScaleFactor = resources.getFraction(
                com.android.internal.R.fraction.config_screenAutoBrightnessDozeScaleFactor,
                1, 1);
        // 创建自动背光样条
        Spline screenAutoBrightnessSpline = createAutoBrightnessSpline(lux, screenBrightness);
        if (screenAutoBrightnessSpline == null) {
            // 如果lux, brightness不合要求，禁用自动背光
            Slog.e(TAG, "Error in config.xml.  config_autoBrightnessLcdBacklightValues "
                    + "(size " + screenBrightness.length + ") "
                    + "must be monotic and have exactly one more entry than "
                    + "config_autoBrightnessLevels (size " + lux.length + ") "
                    + "which must be strictly increasing.  "
                    + "Auto-brightness will be disabled.");
            mUseSoftwareAutoBrightnessConfig = false;
        } else {
            ......
            mAutomaticBrightnessController = new AutomaticBrightnessController(this,
                   handler.getLooper(), sensorManager, screenAutoBrightnessSpline,
                   ...// gamma, 最大最小值等其他配置
        }
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

private static Spline createAutoBrightnessSpline(int[] lux, int[] brightness) {
......
        // 归一化brightness[0]作为y[0]
        y[0] = normalizeAbsoluteBrightness(brightness[0]);
        // 处理对应的lux和brightness
        for (int i = 1; i < n; i++) {
            x[i] = lux[i - 1];
            y[i] = normalizeAbsoluteBrightness(brightness[i]);
        }
        Spline spline = Spline.createSpline(x, y);
......
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

frameworks/base/core/java/android/util/Spline.java
public static Spline createSpline(float[] x, float[] y) {
    // 是否严格单调递增
    if (!isStrictlyIncreasing(x)) {
        throw new IllegalArgumentException("The control points must all have strictly "
                + "increasing X values.");
    }

    // 单调的还是线性的
    if (isMonotonic(y)) {
        // 创建单调三次样条插值
        return createMonotoneCubicSpline(x, y);
    } else {
        return createLinearSpline(x, y);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

public static Spline createMonotoneCubicSpline(float[] x, float[] y) {
    return new MonotoneCubicSpline(x, y);
}

public static class MonotoneCubicSpline extends Spline {
    // 主要的就是这三个数组，横坐标x,纵坐标y,以及相邻点的斜率
    private float[] mX;
    private float[] mY;
    private float[] mM;

    public MonotoneCubicSpline(float[] x, float[] y) {
        ....
        // d存放相邻点的斜率，m存放相邻两斜率的平均值
        float[] d = new float[n - 1]; // could optimize this out
        float[] m = new float[n];
        // Compute slopes of secant lines between successive points.
        for (int i = 0; i < n - 1; i++) {
            float h = x[i + 1] - x[i];
            ...
            // 相邻点斜率
            d[i] = (y[i + 1] - y[i]) / h;
        }
        // Initialize the tangents as the average of the secants.
        m[0] = d[0];
        for (int i = 1; i < n - 1; i++) {
            // 相邻两斜率的平均值
            m[i] = (d[i - 1] + d[i]) * 0.5f;
        }
        m[n - 1] = d[n - 2];
        // Update the tangents to preserve monotonicity.
        // 再次更新m以保持单调性
        for (int i = 0; i < n - 1; i++) {
            if (d[i] == 0f) { // successive Y values are equal
                m[i] = 0f;
                m[i + 1] = 0f;
            } else {
                float a = m[i] / d[i];
                float b = m[i + 1] / d[i];
                if (a < 0f || b < 0f) {
                    throw new IllegalArgumentException("The control points must have "
                            + "monotonic Y values.");
                }
                float h = (float) Math.hypot(a, b);
                if (h > 3f) {
                    float t = 3f / h;
                    m[i] *= t;
                    m[i + 1] *= t;
                }
            }
        }
        mX = x;
        mY = y;
        mM = m;
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

frameworks/base/services/core/java/com/android/server/display/DisplayPowerController.java
private void updatePowerState() {
    int brightness = PowerManager.BRIGHTNESS_DEFAULT;
    ......
        // 检查是否使能自动背光
        autoBrightnessEnabled = mPowerRequest.useAutoBrightness
                && (state == Display.STATE_ON || autoBrightnessEnabledInDoze)
                // 这个brightness与Doze模式是否允许使用自动背光配置有关，不是表示屏幕亮度<0,默认是BRIGHTNESS_DEFAULT为-1
                && brightness < 0;
        mAutomaticBrightnessController.configure(autoBrightnessEnabled,
                mPowerRequest.screenAutoBrightnessAdjustment, state != Display.STATE_ON,
                userInitiatedChange);

1
2
3
4
5
6
7

frameworks/base/services/core/java/com/android/server/display/AutomaticBrightnessController.java
public void configure(boolean enable, float adjustment, boolean dozing,
        boolean userInitiatedChange) {
......
    boolean changed = setLightSensorEnabled(enable && !dozing);
......
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

private final SensorEventListener mLightSensorListener = new SensorEventListener() {
    @Override
    public void onSensorChanged(SensorEvent event) {
        if (mLightSensorEnabled) {
            final long time = SystemClock.uptimeMillis();
            final float lux = event.values[0];
            handleLightSensorEvent(time, lux);
        }
    }
    ......
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

private void handleLightSensorEvent(long time, float lux) {
    // 如果有 MSG_UPDATE_AMBIENT_LUX 消息，则移除
    mHandler.removeMessages(MSG_UPDATE_AMBIENT_LUX);
......
    // 更新缓冲区
    applyLightSensorMeasurement(time, lux);
    // 更新数据
    updateAmbientLux(time);
}

private void applyLightSensorMeasurement(long time, float lux) {
......
    // 将多少周期(默认10s)前的数据删掉
    mAmbientLightRingBuffer.prune(time - mAmbientLightHorizon);
    // 将当前数据放到缓冲中
    mAmbientLightRingBuffer.push(time, lux);
.....
}

1

<integer name="config_autoBrightnessAmbientLightHorizon">10000</integer>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

private void updateAmbientLux(long time) {
    // If the light sensor was just turned on then immediately update our initial
    // estimate of the current ambient light level.
    if (!mAmbientLuxValid) {
        ......
        // 打开sensor后第一次更新数据情况，略过...
    }
    // 计算明暗变化的时间点
    long nextBrightenTransition = nextAmbientLightBrighteningTransition(time);
    long nextDarkenTransition = nextAmbientLightDarkeningTransition(time);
    // 计算10s和2s内的lux
    float slowAmbientLux = calculateAmbientLux(time, AMBIENT_LIGHT_LONG_HORIZON_MILLIS);
    float fastAmbientLux = calculateAmbientLux(time, AMBIENT_LIGHT_SHORT_HORIZON_MILLIS);
    // 如果满足去抖的要求，会进行lux和亮度的计算更新
    if (slowAmbientLux >= mBrighteningLuxThreshold &&
            fastAmbientLux >= mBrighteningLuxThreshold && nextBrightenTransition <= time
            || slowAmbientLux <= mDarkeningLuxThreshold
            && fastAmbientLux <= mDarkeningLuxThreshold && nextDarkenTransition <= time) {
        // 更新lux和明暗lux阀值
        setAmbientLux(fastAmbientLux);
        // 这个log应该放在setAmbientLux()前面，不然 fastAmbientLux > mAmbientLux永远为false
        if (DEBUG) {
            Slog.d(TAG, "updateAmbientLux: "
                    + ((fastAmbientLux > mAmbientLux) ? "Brightened" : "Darkened") + ": "
                    + "mBrighteningLuxThreshold=" + mBrighteningLuxThreshold
                    + ", mAmbientLightRingBuffer=" + mAmbientLightRingBuffer
                    + ", mAmbientLux=" + mAmbientLux);
        }
        // 更新亮度
        updateAutoBrightness(true);
    ......
    mHandler.sendEmptyMessageAtTime(MSG_UPDATE_AMBIENT_LUX, nextTransitionTime);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

private long nextAmbientLightBrighteningTransition(long time) {
    final int N = mAmbientLightRingBuffer.size();
    long earliestValidTime = time;
    // 从后往前找到离当前时间第一个大于阀值的点
    for (int i = N - 1; i >= 0; i--) {
        if (mAmbientLightRingBuffer.getLux(i) <= mBrighteningLuxThreshold) {
            break;
        }
        earliestValidTime = mAmbientLightRingBuffer.getTime(i);
    }
    // 找到的点时间加上去抖时间
    return earliestValidTime + mBrighteningLightDebounceConfig;
}

private long nextAmbientLightDarkeningTransition(long time) {
    final int N = mAmbientLightRingBuffer.size();
    long earliestValidTime = time;
    从后往前找到离当前时间第一个小于阀值的点
    for (int i = N - 1; i >= 0; i--) {
        if (mAmbientLightRingBuffer.getLux(i) >= mDarkeningLuxThreshold) {
            break;
        }
        earliestValidTime = mAmbientLightRingBuffer.getTime(i);
    }
    // 找到的点时间加上去抖时间
    return earliestValidTime + mDarkeningLightDebounceConfig;
}

1

<integer name="config_autoBrightnessBrighteningLightDebounce">4000</integer>

1

<integer name="config_autoBrightnessDarkeningLightDebounce">8000</integer>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

private float calculateAmbientLux(long now, long horizon) {
......
    // Find the first measurement that is just outside of the horizon.
    int endIndex = 0;
    // 计算出指定时间的开始下标
    final long horizonStartTime = now - horizon;
    for (int i = 0; i < N-1; i++) {
        if (mAmbientLightRingBuffer.getTime(i + 1) <= horizonStartTime) {
            endIndex++;
        } else {
            break;
        }
    }
    ......
    float sum = 0;
    float totalWeight = 0;
    long endTime = AMBIENT_LIGHT_PREDICTION_TIME_MILLIS;
    for (int i = N - 1; i >= endIndex; i--) {
        long eventTime = mAmbientLightRingBuffer.getTime(i);
        if (i == endIndex && eventTime < horizonStartTime) {
            // If we're at the final value, make sure we only consider the part of the sample
            // within our desired horizon.
            eventTime = horizonStartTime;
        }
        final long startTime = eventTime - now;
        // 权值计算
        float weight = calculateWeight(startTime, endTime);
        float lux = mAmbientLightRingBuffer.getLux(i);
        ......
        totalWeight += weight;
        sum += mAmbientLightRingBuffer.getLux(i) * weight;
        endTime = startTime;
    }
    ......
    // 加权平均
    return sum / totalWeight;
}

1
2
3
4

if (slowAmbientLux >= mBrighteningLuxThreshold &&
            fastAmbientLux >= mBrighteningLuxThreshold && nextBrightenTransition <= time
            || slowAmbientLux <= mDarkeningLuxThreshold
            && fastAmbientLux <= mDarkeningLuxThreshold && nextDarkenTransition <= time)

1
2
3
4
5
6
7
8
9

setAmbientLux(fastAmbientLux)
private void setAmbientLux(float lux) {
    ...
    // 更新lux
    mAmbientLux = lux;
    // 更新阀值
    mBrighteningLuxThreshold = mDynamicHysteresis.getBrighteningThreshold(lux);
    mDarkeningLuxThreshold = mDynamicHysteresis.getDarkeningThreshold(lux);
}

1
2

float brightThreshold = lux * (1.0f + brightConstant);
float darkThreshold = lux * (1.0f - darkConstant);

1
2
3
4
5
6
7
8

<integer-array name="config_dynamicHysteresisBrightLevels">
    <item>100</item>
</integer-array>
<integer-array name="config_dynamicHysteresisDarkLevels">
    <item>200</item>
</integer-array>
<integer-array name="config_dynamicHysteresisLuxLevels">
</integer-array>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

private void updateAutoBrightness(boolean sendUpdate) {
    // 如果自动光感没数据，直接返回了。
    if (!mAmbientLuxValid) {
        return;
    }

    // 从建模的曲线中算出对应的brightness，这只是初步的亮度值
    float value = mScreenAutoBrightnessSpline.interpolate(mAmbientLux);
    float gamma = 1.0f;

    // 如果用户有调整，处理用户的adjustment
    if (USE_SCREEN_AUTO_BRIGHTNESS_ADJUSTMENT
            && mScreenAutoBrightnessAdjustment != 0.0f) {
        // mScreenAutoBrightnessAdjustmentMaxGamma 配置里用的是300%
        // 即我们前面列的公式的 3^(-x) x为-1.0~1.0之间
        final float adjGamma = MathUtils.pow(mScreenAutoBrightnessAdjustmentMaxGamma,
                Math.min(1.0f, Math.max(-1.0f, -mScreenAutoBrightnessAdjustment)));
        gamma *= adjGamma;
        .....
    }

    // gamma不为1.0f表示用户有调整
    if (gamma != 1.0f) {
        final float in = value;
        // value^gamma
        value = MathUtils.pow(value, gamma);
        ....
    }
    
    // value*255向下取整并使值在mScreenBrightnessRangeMinimum～mScreenBrightnessRangeMaximum区间
    // 这样就得出了最终亮度
    int newScreenAutoBrightness =
            clampScreenBrightness(Math.round(value * PowerManager.BRIGHTNESS_ON));
    if (mScreenAutoBrightness != newScreenAutoBrightness) {
        ......
        if (sendUpdate) {
            // 通知更新
            mCallbacks.updateBrightness();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

frameworks/base/core/java/android/util/Spline.java
public static class MonotoneCubicSpline extends Spline {
    ......
    @Override
    public float interpolate(float x) {
        ......
        // 小于最小lux，直接反回brightness[0]
        if (x <= mX[0]) {
            return mY[0];
        }
        // 大于最大的lux, 直接返回最大的
        if (x >= mX[n - 1]) {
            return mY[n - 1];
        }
        // Find the index 'i' of the last point with smaller X.
        // We know this will be within the spline due to the boundary tests.
        int i = 0;
        // 刚好落在采样点上
        while (x >= mX[i + 1]) {
            i += 1;
            if (x == mX[i]) {
                return mY[i];
            }
        }
        // Perform cubic Hermite spline interpolation.
        float h = mX[i + 1] - mX[i];
        float t = (x - mX[i]) / h;
        // 三次插值计算
        return (mY[i] * (1 + 2 * t) + h * mM[i] * t) * (1 - t) * (1 - t)
                + (mY[i + 1] * (3 - 2 * t) + h * mM[i + 1] * (t - 1)) * t * t;
}

1
2
3
4
5

<!-- Fast brightness animation ramp rate in brightness units per second-->
<integer translatable="false" name="config_brightness_ramp_rate_fast">180</integer>

<!-- Slow brightness animation ramp rate in brightness units per second-->
<integer translatable="false" name="config_brightness_ramp_rate_slow">60</integer>

1
2

mAutomaticBrightnessController.configure(....
                    mPowerRequest.screenAutoBrightnessAdjustment....

1
2
3
4
5
6
7
8

AutomaticBrightnessController.java
public void configure(boolean enable, float adjustment, boolean dozing,
....
    changed |= setScreenAutoBrightnessAdjustment(adjustment);

private boolean setScreenAutoBrightnessAdjustment(float adjustment) {
    ....
        mScreenAutoBrightnessAdjustment = adjustment;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

frameworks/base/core/res/res/values/config.xml
// 自动背光功能是否可用开关, 默认关，需要打开
config_automatic_brightness_available
// lux 数组 
config_autoBrightnessLevels
// 对应lcd brightness 数组
config_autoBrightnessLcdBacklightValues
// 光感数据缓冲区周期，即采集多少时间内的数据
config_autoBrightnessAmbientLightHorizon
// 由暗到亮场景防抖时间，注意不要超过 config_autoBrightnessAmbientLightHorizon
config_autoBrightnessBrighteningLightDebounce
// 由亮到暗场景防抖时间，注意不要超过 config_autoBrightnessAmbientLightHorizon
config_autoBrightnessDarkeningLightDebounce
// 计算变亮变暗场景阀值时的Constant
config_dynamicHysteresisBrightLevels
config_dynamicHysteresisDarkLevels
config_dynamicHysteresisLuxLevels
// 屏幕亮度变化时的ramp rate
config_brightness_ramp_rate_slow

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

DisplayPowerController.java
public DisplayPowerController()
    + Spline screenAutoBrightnessSpline = createAutoBrightnessSpline(lux, screenBrightness);
    |                                        + normalize
    |                                        + createSpline()
    |                                            + createMonotoneCubicSpline()
    |                                                + new MonotoneCubicSpline(x, y)
    |                                                    + mX = x;
    |                                                    + mY = y;
    |                                                    + mM = m;
    + mAutomaticBrightnessController = new AutomaticBrightnessController(...screenAutoBrightnessSpline,...)

1
2
3
4
5

updatePowerState() DisplayPowerController.java
  + mAutomaticBrightnessController.configure(autoBrightnessEnabled,
      + configure() AutomaticBrightnessController.java
          + setLightSensorEnabled()
              + registerListener(mLightSensorListener

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

mLightSensorListener
onSensorChanged()
  + handleLightSensorEvent()
  |   + applyLightSensorMeasurement()
  |   |   + mAmbientLightRingBuffer.prune(time - mAmbientLightHorizon);
  |   |   + mAmbientLightRingBuffer.push(time, lux);
  |   + updateAmbientLux(time)
  |   |   + long nextBrightenTransition = nextAmbientLightBrighteningTransition(time);
  |   |   + long nextDarkenTransition = nextAmbientLightDarkeningTransition(time);
  |   |   + float slowAmbientLux = calculateAmbientLux(time, AMBIENT_LIGHT_LONG_HORIZON_MILLIS);
  |   |   + float fastAmbientLux = calculateAmbientLux(time, AMBIENT_LIGHT_SHORT_HORIZON_MILLIS);
  |   |   + if (slowAmbientLux >= mBrighteningLuxThreshold &&...
  |   |   |     + setAmbientLux(fastAmbientLux);
  |   |   |     |   + mAmbientLux = lux;
  |   |   |     |   + mBrighteningLuxThreshold = mDynamicHysteresis.getBrighteningThreshold(lux);
  |   |   |     |   |                              + lux * (1.0f + brightConstant); // 1.1lux
  |   |   |     |   + mDarkeningLuxThreshold = mDynamicHysteresis.getDarkeningThreshold(lux);
  |   |   |     |                                  + lux * (1.0f - brightConstant); // 0.8lux
  |   |   |     + updateAutoBrightness(true);
  |   |   |     |   + mScreenAutoBrightnessSpline.interpolate(mAmbientLux) // 计算出y
  |   |   |     |   + MathUtils.pow(mScreenAutoBrightnessAdjustmentMaxGamma... -mScreenAutoBrightnessAdjustment) // 3^(-x)
  |   |   |     |   + MathUtils.pow(value, gamma); // y^{3^{-x}}
  |   |   |     |   + clampScreenBrightness(Math.round(value * PowerManager.BRIGHTNESS_ON)); // y^{3^{-x}} * 255
  +   +   +     +   + mCallbacks.updateBrightness()

1

adb shell settings put system screen_brightness_mode 1

1

adb shell settings put system screen_auto_brightness_adj 0.0

1

adb shell dumpsys display