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

Commit a1e84d08 authored by Hawkwood Glazier's avatar Hawkwood Glazier
Browse files

Limit interpolated axis values to set of valid values 

Rouding the axis values to the nearest valid step value should keep the
var cache from missing repeatedly due to functionally identical axis
values. Formerly this was not a problem because the progress float was
rounded to the nearest animation frame. However that is no longer
occuring as it caused issues w/ non-linear interpolation.

Since different axes have different min and max values, we manually
adjust the step size to roughly target the same number of valid values
within that range. This gives us a good target, but also allows us to
make specific adjustments to keep hit-rate high depending on which
axes are more important visually.

Bug: 394840414
Test: Ran animation on device
Flag: NONE TextAnimator Memory Fix
Change-Id: I1800b71601ef10e1c2b9fd083134f312c8dd6711
parent c26379f2

packages/SystemUI/animation/src/com/android/systemui/animation/FontInterpolator.kt

+28 −65
Original line number Diff line number Diff line
@@ -22,19 +22,8 @@ import android.util.Log 
import android.util.LruCache

import android.util.MathUtils

import androidx.annotation.VisibleForTesting

import java.lang.Float.max

import java.lang.Float.min

import kotlin.math.roundToInt



private const val TAG_WGHT = "wght"

private const val TAG_ITAL = "ital"



private const val FONT_WEIGHT_DEFAULT_VALUE = 400f

private const val FONT_ITALIC_MAX = 1f

private const val FONT_ITALIC_MIN = 0f

private const val FONT_ITALIC_ANIMATION_STEP = 0.1f

private const val FONT_ITALIC_DEFAULT_VALUE = 0f



/** Caches for font interpolation */

interface FontCache {

    val animationFrameCount: Int
@@ -91,11 +80,8 @@ class FontCacheImpl(override val animationFrameCount: Int = DEFAULT_FONT_CACHE_M 
class FontInterpolator(val fontCache: FontCache = FontCacheImpl()) {

    /** Linear interpolate the font variation settings. */

    fun lerp(start: Font, end: Font, progress: Float, linearProgress: Float): Font {

        if (progress == 0f) {

            return start

        } else if (progress == 1f) {

            return end

        }

        if (progress <= 0f) return start

        if (progress >= 1f) return end



        val startAxes = start.axes ?: EMPTY_AXES

        val endAxes = end.axes ?: EMPTY_AXES
@@ -110,7 +96,7 @@ class FontInterpolator(val fontCache: FontCache = FontCacheImpl()) { 
            InterpKey(start, end, (linearProgress * fontCache.animationFrameCount).roundToInt())

        fontCache.get(iKey)?.let {

            if (DEBUG) {

                Log.d(LOG_TAG, "[$progress] Interp. cache hit for $iKey")

                Log.d(LOG_TAG, "[$progress, $linearProgress] Interp. cache hit for $iKey")

            }

            return it

        }
@@ -121,37 +107,16 @@ class FontInterpolator(val fontCache: FontCache = FontCacheImpl()) { 
        // and also pre-fill the missing axes value with default value from 'fvar' table.

        val newAxes =

            lerp(startAxes, endAxes) { tag, startValue, endValue ->

                when (tag) {

                    TAG_WGHT ->

                        MathUtils.lerp(

                            startValue ?: FONT_WEIGHT_DEFAULT_VALUE,

                            endValue ?: FONT_WEIGHT_DEFAULT_VALUE,

                            progress,

                        )

                    TAG_ITAL ->

                        adjustItalic(

                            MathUtils.lerp(

                                startValue ?: FONT_ITALIC_DEFAULT_VALUE,

                                endValue ?: FONT_ITALIC_DEFAULT_VALUE,

                                progress,

                            )

                        )

                    else -> {

                        require(startValue != null && endValue != null) {

                            "Unable to interpolate due to unknown default axes value : $tag"

                        }

                MathUtils.lerp(startValue, endValue, progress)

            }

                }

            }



        // Check if we already make font for this axes. This is typically happens if the animation

        // happens backward.

        // happens backward and is being linearly interpolated.

        val vKey = VarFontKey(start, newAxes)

        fontCache.get(vKey)?.let {

            fontCache.put(iKey, it)

            if (DEBUG) {

                Log.d(LOG_TAG, "[$progress] Axis cache hit for $vKey")

                Log.d(LOG_TAG, "[$progress, $linearProgress] Axis cache hit for $vKey")

            }

            return it

        }
@@ -164,14 +129,14 @@ class FontInterpolator(val fontCache: FontCache = FontCacheImpl()) { 
        fontCache.put(vKey, newFont)



        // Cache misses are likely to create memory leaks, so this is logged at error level.

        Log.e(LOG_TAG, "[$progress] Cache MISS for $iKey / $vKey")

        Log.e(LOG_TAG, "[$progress, $linearProgress] Cache MISS for $iKey / $vKey")

        return newFont

    }



    private fun lerp(

        start: Array<FontVariationAxis>,

        end: Array<FontVariationAxis>,

        filter: (tag: String, left: Float?, right: Float?) -> Float,

        filter: (tag: String, left: Float, right: Float) -> Float,

    ): List<FontVariationAxis> {

        // Safe to modify result of Font#getAxes since it returns cloned object.

        start.sortBy { axis -> axis.tag }
@@ -191,39 +156,37 @@ class FontInterpolator(val fontCache: FontCache = FontCacheImpl()) { 
                    else -> tagA.compareTo(tagB)

                }



            val axis =

            val tag =

                when {

                    comp == 0 -> {

                        val v = filter(tagA!!, start[i++].styleValue, end[j++].styleValue)

                        FontVariationAxis(tagA, v)

                    comp == 0 -> tagA!!

                    comp < 0 -> tagA!!

                    else -> tagB!!

                }

                    comp < 0 -> {

                        val v = filter(tagA!!, start[i++].styleValue, null)

                        FontVariationAxis(tagA, v)

                    }

                    else -> { // comp > 0

                        val v = filter(tagB!!, null, end[j++].styleValue)

                        FontVariationAxis(tagB, v)



            val axisDefinition = GSFAxes.getAxis(tag)

            require(comp == 0 || axisDefinition != null) {

                "Unable to interpolate due to unknown default axes value: $tag"

            }



            val axisValue =

                when {

                    comp == 0 -> filter(tag, start[i++].styleValue, end[j++].styleValue)

                    comp < 0 -> filter(tag, start[i++].styleValue, axisDefinition!!.defaultValue)

                    else -> filter(tag, axisDefinition!!.defaultValue, end[j++].styleValue)

                }



            result.add(axis)

            // Round axis value to valid intermediate steps. This improves the cache hit rate.

            val step = axisDefinition?.animationStep ?: DEFAULT_ANIMATION_STEP

            result.add(FontVariationAxis(tag, (axisValue / step).roundToInt() * step))

        }

        return result

    }



    // For the performance reasons, we animate italic with FONT_ITALIC_ANIMATION_STEP. This helps

    // Cache hit ratio in the Skia glyph cache.

    private fun adjustItalic(value: Float) =

        coerceInWithStep(value, FONT_ITALIC_MIN, FONT_ITALIC_MAX, FONT_ITALIC_ANIMATION_STEP)



    private fun coerceInWithStep(v: Float, min: Float, max: Float, step: Float) =

        (v.coerceIn(min, max) / step).toInt() * step



    companion object {

        private const val LOG_TAG = "FontInterpolator"

        private val DEBUG = Log.isLoggable(LOG_TAG, Log.DEBUG)

        private val EMPTY_AXES = arrayOf<FontVariationAxis>()

        private const val DEFAULT_ANIMATION_STEP = 1f



        // Returns true if given two font instance can be interpolated.

        fun canInterpolate(start: Font, end: Font) =

packages/SystemUI/animation/src/com/android/systemui/animation/FontVariationUtils.kt

+20 −12
Original line number Diff line number Diff line 
package com.android.systemui.animation

/*

 * Copyright (C) 2024 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



object GSFAxes {

    const val WEIGHT = "wght"

    const val WIDTH = "wdth"

    const val SLANT = "slnt"

    const val ROUND = "ROND"

    const val OPTICAL_SIZE = "opsz"

}

package com.android.systemui.animation



class FontVariationUtils {

    private var mWeight = -1
@@ -46,20 +54,20 @@ class FontVariationUtils { 
        }

        var resultString = ""

        if (mWeight >= 0) {

            resultString += "'${GSFAxes.WEIGHT}' $mWeight"

            resultString += "'${GSFAxes.WEIGHT.tag}' $mWeight"

        }

        if (mWidth >= 0) {

            resultString +=

                (if (resultString.isBlank()) "" else ", ") + "'${GSFAxes.WIDTH}' $mWidth"

                (if (resultString.isBlank()) "" else ", ") + "'${GSFAxes.WIDTH.tag}' $mWidth"

        }

        if (mOpticalSize >= 0) {

            resultString +=

                (if (resultString.isBlank()) "" else ", ") +

                    "'${GSFAxes.OPTICAL_SIZE}' $mOpticalSize"

                    "'${GSFAxes.OPTICAL_SIZE.tag}' $mOpticalSize"

        }

        if (mRoundness >= 0) {

            resultString +=

                (if (resultString.isBlank()) "" else ", ") + "'${GSFAxes.ROUND}' $mRoundness"

                (if (resultString.isBlank()) "" else ", ") + "'${GSFAxes.ROUND.tag}' $mRoundness"

        }

        return if (isUpdated) resultString else ""

    }

packages/SystemUI/animation/src/com/android/systemui/animation/GSFAxes.kt

0 → 100644
+98 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2025 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.systemui.animation



data class AxisDefinition(

    val tag: String,

    val minValue: Float,

    val defaultValue: Float,

    val maxValue: Float,

    val animationStep: Float,

)



object GSFAxes {

    val WEIGHT =

        AxisDefinition(

            tag = "wght",

            minValue = 1f,

            defaultValue = 400f,

            maxValue = 1000f,

            animationStep = 10f,

        )



    val WIDTH =

        AxisDefinition(

            tag = "wdth",

            minValue = 25f,

            defaultValue = 100f,

            maxValue = 151f,

            animationStep = 1f,

        )



    val SLANT =

        AxisDefinition(

            tag = "slnt",

            minValue = 0f,

            defaultValue = 0f,

            maxValue = -10f,

            animationStep = 0.1f,

        )



    val ROUND =

        AxisDefinition(

            tag = "ROND",

            minValue = 0f,

            defaultValue = 0f,

            maxValue = 100f,

            animationStep = 1f,

        )



    val GRADE =

        AxisDefinition(

            tag = "GRAD",

            minValue = 0f,

            defaultValue = 0f,

            maxValue = 100f,

            animationStep = 1f,

        )



    val OPTICAL_SIZE =

        AxisDefinition(

            tag = "opsz",

            minValue = 6f,

            defaultValue = 18f,

            maxValue = 144f,

            animationStep = 1f,

        )



    // Not a GSF Axis, but present for FontInterpolator compatibility

    val ITALIC =

        AxisDefinition(

            tag = "ITAL",

            minValue = 0f,

            defaultValue = 0f,

            maxValue = 1f,

            animationStep = 0.1f,

        )



    private val AXIS_MAP =

        listOf(WEIGHT, WIDTH, SLANT, ROUND, GRADE, OPTICAL_SIZE, ITALIC)

            .map { def -> def.tag.toLowerCase() to def }

            .toMap()



    fun getAxis(axis: String): AxisDefinition? = AXIS_MAP[axis.toLowerCase()]

}

packages/SystemUI/customization/src/com/android/systemui/shared/clocks/FlexClockController.kt

+8 −22
Original line number Diff line number Diff line
@@ -130,39 +130,25 @@ class FlexClockController(private val clockCtx: ClockContext) : ClockController 


        private val FONT_AXES =

            listOf(

                ClockFontAxis(

                    key = GSFAxes.WEIGHT,

                GSFAxes.WEIGHT.toClockAxis(

                    type = AxisType.Float,

                    minValue = 25f,

                    currentValue = 400f,

                    maxValue = 1000f,

                    name = "Weight",

                    description = "Glyph Weight",

                ),

                ClockFontAxis(

                    key = GSFAxes.WIDTH,

                GSFAxes.WIDTH.toClockAxis(

                    type = AxisType.Float,

                    minValue = 25f,

                    currentValue = 85f,

                    maxValue = 151f,

                    name = "Width",

                    description = "Glyph Width",

                ),

                ClockFontAxis(

                    key = GSFAxes.ROUND,

                GSFAxes.ROUND.toClockAxis(

                    type = AxisType.Boolean,

                    minValue = 0f,

                    currentValue = 0f,

                    maxValue = 100f,

                    name = "Round",

                    description = "Glyph Roundness",

                ),

                ClockFontAxis(

                    key = GSFAxes.SLANT,

                GSFAxes.SLANT.toClockAxis(

                    type = AxisType.Boolean,

                    minValue = 0f,

                    currentValue = 0f,

                    maxValue = -10f,

                    name = "Slant",

                    description = "Glyph Slant",

                ),
@@ -170,10 +156,10 @@ class FlexClockController(private val clockCtx: ClockContext) : ClockController 


        private val LEGACY_FLEX_SETTINGS =

            listOf(

                ClockFontAxisSetting(GSFAxes.WEIGHT, 600f),

                ClockFontAxisSetting(GSFAxes.WIDTH, 100f),

                ClockFontAxisSetting(GSFAxes.ROUND, 100f),

                ClockFontAxisSetting(GSFAxes.SLANT, 0f),

                GSFAxes.WEIGHT.toClockAxisSetting(600f),

                GSFAxes.WIDTH.toClockAxisSetting(100f),

                GSFAxes.ROUND.toClockAxisSetting(100f),

                GSFAxes.SLANT.toClockAxisSetting(0f),

            )

    }

}

packages/SystemUI/customization/src/com/android/systemui/shared/clocks/FlexClockFaceController.kt

+1 −1
Original line number Diff line number Diff line
@@ -132,7 +132,7 @@ class FlexClockFaceController(clockCtx: ClockContext, private val isLargeClock: 
            if (!isLargeClock) {

                axes =

                    axes.map { axis ->

                        if (axis.key == GSFAxes.WIDTH && axis.value > SMALL_CLOCK_MAX_WDTH) {

                        if (axis.key == GSFAxes.WIDTH.tag && axis.value > SMALL_CLOCK_MAX_WDTH) {

                            axis.copy(value = SMALL_CLOCK_MAX_WDTH)

                        } else {

                            axis