runRemainingAnimations is used to animate the available animation handle
which were not yet run, it actually animate those animation handle and
removes from the list by notifyAnimationsRan(). In case if these animation
handles are not removed, it leads to the Fatal Assert of runRemainingAnimations.
Some usecases causes the addition of animation handle when there is
no animators, in these cases this check prevents execution of
notifyAnimationsRan() leads to Fatal Assert crash of runRemainingAnimations.
Allowing the animation to happen irrespective of animators solves the problem.
Change-Id: Ifa72286cdc6ff785fcc999f3b951dd787e7003e9
OpenGL ES 3.0+ lets us specify the row length for unpack operations
such as glTexSubImage2D(). This allows us to upload a sub-rectangle
of a texture. Also, the GL_EXT_unpack_subimage extension can also
support this feature in OpenGL ES 2.0
Change-Id: Id43c2c55c5eaefbace67087c955f0b4324fb2c35
Signed-off-by: xiaozhengdong <xiaozhengdong@xiaomi.com>
Due to precision loss of float math, we sometimes get 1.000001f for
dotProduct. This causes NaN result from acosf() and floor() funcs.
At the moment, this does not cause any problems on ARM, as casting
NaN to int results in 0. On mips however (possibly on x86), such cast
gives INT_MAX, so crash occurs when trying to use the resulting value.
Change-Id: I8e0285a0306a65b8469d9f4885c19665066fc4c8
glFinish() dequeues a native buffer, and it fails when
the bufeer has been abandoned, this is ok and will not
casue the app crash
GL_OUT_OF_MEMORY is generated in this case, and it is
not reset until glGetError called. This is happened in
build layer function, glGetError is called after glTexImg2d,
and get GL_OUT_OF_MEMORY, then this function return as OOM,
and app crash
Fix it by adding a glGetError after glFinish
Change-Id: I8803a726b6f609c4a2f8a6aa6bb7ff7064808932
To obtain the gfxinfo for each process, the static method of RenderProxy is used, which is named outputLogBuffer().
In there,
1. RenderTask is created for getting DisplayList Commands in RenderNode.
2. staticPostAndWait() is called
3. RenderThread's instance is created by 'RenderThread::getInstance()' in staticPostAndWait()
In case of the service, they don't use HW Acceleration, so don't need RenderThread.
But, by the process of No.3, RenderThread is created for all process.
As we know, RenderThread never be destroyed while the process is alive.
This patch checks RenderThread instance before the creation of RenderTask.
And, there is no one, just return to prevent the unnecessay creation of it.
Change-Id: I4fe29d83c9ced3e8b67177c0874c5d8ee62e1870
New ShadowTask with the ShadowDescription key that already
exists in the shadow LruCache will leak as it is not being
added.
Fix adds check for the existing key that is common in the hwui
code but missing for the TessellationCache::precacheShadow
function.
Change-Id: I37fd5ec82f8b8da5d1ec0f2ab9fd04c5f8534367
Most matrices used by the UI toolkit are translation matrices, whose
inverses can be quickly computed by using the negated translation
vector.
Change-Id: I54a28a634a586085779bfc26f3a4160cd5ab2b22
If hwuiTask thread is exited while HWUI renders something,
some tasks can remain unfinished forever.
This can make ANR problem if RenderThread waits this kind of tasks.
According to the current implementation, hwuiTask threads are
exited when HWUI receives trimMemory() callback with level >= 20
and some applications such as SystemUI can receive trimMemory()
with level >= 20 even though they renders something yet.
(For instance, when RecentsActivity in SystemUI is finished,
HWUI receives trimMemory() callback with level >= 20
but SystemUI should still render the status bar and navigation bar.)
This patch prevents the tasks from remaining unfinished and
make the tasks executed immediately if they cannot be added
to their TaskProcessors.
Change-Id: I5bd26439aa5f183b1a7c1ce466362e27554b4d16
Bug: 18226391
The issue occurs as a result of a dispatchFrame itself
taking longer than 12ms, the alloted budget. The result
is that a vsync request (which occured at the end) would
miss the vsync that occured 1ms prior to the end of the frame.
As a result it would end up waiting for the following vsync,
essentially dropping to 30fps even though 60 could have been
sustained.
Fix this with a few tweaks.
First, adjust the UI thread's delay bias from (now + 4ms) to
(vsync + 4ms), this prevents RT animators from slowly drifting
if the vsync occurs mid-task.
Second, request a vsync preemptively prior to running callbacks.
This way if any callbacks needs the next vsync and it takes
"too long", we will catch that vsync.
Finally, fix an issue where the display event queue was always
drained & rejected at the end of a task loop. Instead, drain
and reject all stale vsyncs. This still prevents the issue of
both UI thread & RT thread trying to drive 2 frames in a single
pulse, but also allows RT to notice that it missed a vsync
pulse it needed and that it should speed-up a bit in response
Change-Id: I9d6be037737e9283297898cac2e3563453e797cd
Bug: 18718646
Caused because the Texture object thought the GLES texture
was in a different state than it was as it persists across
EGL/GL contexts. Fix this by force-flushing the default
values when the texid has changed.
Change-Id: I264bac9a2beb08df8e2ba8a85ad15f0dd1fce22a
Bug: 18317479
RenderNode::prepareSubTree calls prefetchAndMarkInUse
on every bitmapResoruce in the DisplayList. However,
this resulted in textures being uploaded for bitmaps
that would be drawn from the AssetAtlas instead.
To fix this we teach TextureCache about the AssetAtlas
so that calls to TextureCache return the Texture from
AssetAtlas if it exists. Thus usage of AssetAtlas
is now purely to allow for further optimizations via
draw merging instead of a requirement to get
any benefit at all.
Change-Id: I65282fa05bac46f4e93822b3467ffa0261ccf200
bug:18667472
Previously, we were allocating per-frame temporary paths within the
PlaybackStateStruct, but these are not safe as layers allocate these
transiently. Instead, move these to the OpenGLRenderer, which has
better define lifecycle.
Additionally, don't store SkPath objects directly in vector, since
they are then subject to relocation.
Change-Id: I8187ef542fcd5b030502bb75eb123ee26c0daa96
The SkBitmap* used by HWUI holds a reference to the PixelRef (which
in turn holds the colorTable) so keeping an additional ref is not
only unnecessary, but also potentially problematic.
If a bitmap changes its pixelRef after it has been added to a displayList,
then we end up with unbalanced ref/unref calls that cause the newly added
PixelRef to be unref'd and prematurely deleted, while the original PixelRef
is leaked.
bug: 18659976
Change-Id: I34a06152e7bb2d733249a207dafd36b9b5dc0712
Bug: 18203577
The issue occurs as a result of performTraversals() both doing
a window relayout call *and* early-returning because it's not dirty.
To fix this pauseSurface() returns whether or not the RT-side is
"dirty" to force ViewRootImpl to do a draw even if mDirty is
otherwise empty.
Change-Id: I534f367e75d18d273ebf14df3927f5c464ef6bef
