android_view_ThreadedRenderer.cpp revision 84a4c887a07c1c2939443f4e0587d7f1ac109e4b 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "ThreadedRenderer"
18
19#include <algorithm>
20
21#include "jni.h"
22#include <nativehelper/JNIHelp.h>
23#include <android_runtime/AndroidRuntime.h>
24
25#include <EGL/egl.h>
26#include <EGL/eglext.h>
27#include <EGL/egl_cache.h>
28
29#include <utils/StrongPointer.h>
30#include <android_runtime/android_view_Surface.h>
31#include <system/window.h>
32
33#include "android_view_GraphicBuffer.h"
34
35#include <Animator.h>
36#include <RenderNode.h>
37#include <renderthread/CanvasContext.h>
38#include <renderthread/RenderProxy.h>
39#include <renderthread/RenderTask.h>
40#include <renderthread/RenderThread.h>
41#include <Vector.h>
42
43namespace android {
44
45#ifdef USE_OPENGL_RENDERER
46
47using namespace android::uirenderer;
48using namespace android::uirenderer::renderthread;
49
50static jmethodID gRunnableMethod;
51
52class JavaTask : public RenderTask {
53public:
54    JavaTask(JNIEnv* env, jobject jrunnable) {
55        env->GetJavaVM(&mVm);
56        mRunnable = env->NewGlobalRef(jrunnable);
57    }
58
59    virtual void run() {
60        env()->CallVoidMethod(mRunnable, gRunnableMethod);
61        env()->DeleteGlobalRef(mRunnable);
62        delete this;
63    };
64
65private:
66    JNIEnv* env() {
67        JNIEnv* env;
68        if (mVm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
69            return 0;
70        }
71        return env;
72    }
73
74    JavaVM* mVm;
75    jobject mRunnable;
76};
77
78class SetAtlasTask : public RenderTask {
79public:
80    SetAtlasTask(const sp<GraphicBuffer>& buffer, int64_t* map, size_t size)
81            : mBuffer(buffer)
82            , mMap(map)
83            , mMapSize(size) {
84    }
85
86    virtual void run() {
87        CanvasContext::setTextureAtlas(mBuffer, mMap, mMapSize);
88        mMap = 0;
89        delete this;
90    }
91
92private:
93    sp<GraphicBuffer> mBuffer;
94    int64_t* mMap;
95    size_t mMapSize;
96};
97
98class OnFinishedEvent {
99public:
100    OnFinishedEvent(BaseRenderNodeAnimator* animator, AnimationListener* listener)
101            : animator(animator), listener(listener) {}
102    sp<BaseRenderNodeAnimator> animator;
103    sp<AnimationListener> listener;
104};
105
106class InvokeAnimationListeners : public MessageHandler {
107public:
108    InvokeAnimationListeners(std::vector<OnFinishedEvent>& events) {
109        mOnFinishedEvents.swap(events);
110    }
111
112    static void callOnFinished(OnFinishedEvent& event) {
113        event.listener->onAnimationFinished(event.animator.get());
114    }
115
116    virtual void handleMessage(const Message& message) {
117        std::for_each(mOnFinishedEvents.begin(), mOnFinishedEvents.end(), callOnFinished);
118        mOnFinishedEvents.clear();
119    }
120
121private:
122    std::vector<OnFinishedEvent> mOnFinishedEvents;
123};
124
125class RootRenderNode : public RenderNode, public AnimationHook {
126public:
127    RootRenderNode() : RenderNode() {
128        mLooper = Looper::getForThread();
129        LOG_ALWAYS_FATAL_IF(!mLooper.get(),
130                "Must create RootRenderNode on a thread with a looper!");
131    }
132
133    virtual ~RootRenderNode() {}
134
135    virtual void callOnFinished(BaseRenderNodeAnimator* animator, AnimationListener* listener) {
136        OnFinishedEvent event(animator, listener);
137        mOnFinishedEvents.push_back(event);
138    }
139
140    virtual void prepareTree(TreeInfo& info) {
141        info.animationHook = this;
142        RenderNode::prepareTree(info);
143        info.animationHook = NULL;
144
145        // post all the finished stuff
146        if (mOnFinishedEvents.size()) {
147            sp<InvokeAnimationListeners> message
148                    = new InvokeAnimationListeners(mOnFinishedEvents);
149            mLooper->sendMessage(message, 0);
150        }
151    }
152
153private:
154    sp<Looper> mLooper;
155    std::vector<OnFinishedEvent> mOnFinishedEvents;
156};
157
158static void android_view_ThreadedRenderer_setAtlas(JNIEnv* env, jobject clazz,
159        jobject graphicBuffer, jlongArray atlasMapArray) {
160    sp<GraphicBuffer> buffer = graphicBufferForJavaObject(env, graphicBuffer);
161    jsize len = env->GetArrayLength(atlasMapArray);
162    if (len <= 0) {
163        ALOGW("Failed to initialize atlas, invalid map length: %d", len);
164        return;
165    }
166    int64_t* map = new int64_t[len];
167    env->GetLongArrayRegion(atlasMapArray, 0, len, map);
168
169    SetAtlasTask* task = new SetAtlasTask(buffer, map, len);
170    RenderThread::getInstance().queue(task);
171}
172
173static jlong android_view_ThreadedRenderer_createRootRenderNode(JNIEnv* env, jobject clazz) {
174    RootRenderNode* node = new RootRenderNode();
175    node->incStrong(0);
176    node->setName("RootRenderNode");
177    return reinterpret_cast<jlong>(node);
178}
179
180static jlong android_view_ThreadedRenderer_createProxy(JNIEnv* env, jobject clazz,
181        jboolean translucent, jlong rootRenderNodePtr) {
182    RenderNode* rootRenderNode = reinterpret_cast<RenderNode*>(rootRenderNodePtr);
183    return (jlong) new RenderProxy(translucent, rootRenderNode);
184}
185
186static void android_view_ThreadedRenderer_deleteProxy(JNIEnv* env, jobject clazz,
187        jlong proxyPtr) {
188    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
189    delete proxy;
190}
191
192static void android_view_ThreadedRenderer_setFrameInterval(JNIEnv* env, jobject clazz,
193        jlong proxyPtr, jlong frameIntervalNanos) {
194    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
195    proxy->setFrameInterval(frameIntervalNanos);
196}
197
198static jboolean android_view_ThreadedRenderer_loadSystemProperties(JNIEnv* env, jobject clazz,
199        jlong proxyPtr) {
200    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
201    return proxy->loadSystemProperties();
202}
203
204static jboolean android_view_ThreadedRenderer_initialize(JNIEnv* env, jobject clazz,
205        jlong proxyPtr, jobject jsurface) {
206    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
207    sp<ANativeWindow> window = android_view_Surface_getNativeWindow(env, jsurface);
208    return proxy->initialize(window);
209}
210
211static void android_view_ThreadedRenderer_updateSurface(JNIEnv* env, jobject clazz,
212        jlong proxyPtr, jobject jsurface) {
213    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
214    sp<ANativeWindow> window;
215    if (jsurface) {
216        window = android_view_Surface_getNativeWindow(env, jsurface);
217    }
218    proxy->updateSurface(window);
219}
220
221static void android_view_ThreadedRenderer_pauseSurface(JNIEnv* env, jobject clazz,
222        jlong proxyPtr, jobject jsurface) {
223    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
224    sp<ANativeWindow> window;
225    if (jsurface) {
226        window = android_view_Surface_getNativeWindow(env, jsurface);
227    }
228    proxy->pauseSurface(window);
229}
230
231static void android_view_ThreadedRenderer_setup(JNIEnv* env, jobject clazz, jlong proxyPtr,
232        jint width, jint height,
233        jfloat lightX, jfloat lightY, jfloat lightZ, jfloat lightRadius) {
234    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
235    proxy->setup(width, height, Vector3(lightX, lightY, lightZ), lightRadius);
236}
237
238static void android_view_ThreadedRenderer_setOpaque(JNIEnv* env, jobject clazz,
239        jlong proxyPtr, jboolean opaque) {
240    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
241    proxy->setOpaque(opaque);
242}
243
244static int android_view_ThreadedRenderer_syncAndDrawFrame(JNIEnv* env, jobject clazz,
245        jlong proxyPtr, jlong frameTimeNanos, jlong recordDuration, jfloat density,
246        jint dirtyLeft, jint dirtyTop, jint dirtyRight, jint dirtyBottom) {
247    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
248    return proxy->syncAndDrawFrame(frameTimeNanos, recordDuration, density,
249            dirtyLeft, dirtyTop, dirtyRight, dirtyBottom);
250}
251
252static void android_view_ThreadedRenderer_destroyCanvasAndSurface(JNIEnv* env, jobject clazz,
253        jlong proxyPtr) {
254    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
255    proxy->destroyCanvasAndSurface();
256}
257
258static void android_view_ThreadedRenderer_invokeFunctor(JNIEnv* env, jobject clazz,
259        jlong proxyPtr, jlong functorPtr, jboolean waitForCompletion) {
260    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
261    Functor* functor = reinterpret_cast<Functor*>(functorPtr);
262    proxy->invokeFunctor(functor, waitForCompletion);
263}
264
265static void android_view_ThreadedRenderer_runWithGlContext(JNIEnv* env, jobject clazz,
266        jlong proxyPtr, jobject jrunnable) {
267    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
268    RenderTask* task = new JavaTask(env, jrunnable);
269    proxy->runWithGlContext(task);
270}
271
272static jlong android_view_ThreadedRenderer_createDisplayListLayer(JNIEnv* env, jobject clazz,
273        jlong proxyPtr, jint width, jint height) {
274    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
275    DeferredLayerUpdater* layer = proxy->createDisplayListLayer(width, height);
276    return reinterpret_cast<jlong>(layer);
277}
278
279static jlong android_view_ThreadedRenderer_createTextureLayer(JNIEnv* env, jobject clazz,
280        jlong proxyPtr) {
281    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
282    DeferredLayerUpdater* layer = proxy->createTextureLayer();
283    return reinterpret_cast<jlong>(layer);
284}
285
286static jboolean android_view_ThreadedRenderer_copyLayerInto(JNIEnv* env, jobject clazz,
287        jlong proxyPtr, jlong layerPtr, jlong bitmapPtr) {
288    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
289    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
290    SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
291    return proxy->copyLayerInto(layer, bitmap);
292}
293
294static void android_view_ThreadedRenderer_pushLayerUpdate(JNIEnv* env, jobject clazz,
295        jlong proxyPtr, jlong layerPtr) {
296    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
297    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
298    proxy->pushLayerUpdate(layer);
299}
300
301static void android_view_ThreadedRenderer_cancelLayerUpdate(JNIEnv* env, jobject clazz,
302        jlong proxyPtr, jlong layerPtr) {
303    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
304    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
305    proxy->cancelLayerUpdate(layer);
306}
307
308static void android_view_ThreadedRenderer_flushCaches(JNIEnv* env, jobject clazz,
309        jlong proxyPtr, jint flushMode) {
310    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
311    proxy->flushCaches(static_cast<Caches::FlushMode>(flushMode));
312}
313
314static void android_view_ThreadedRenderer_fence(JNIEnv* env, jobject clazz,
315        jlong proxyPtr) {
316    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
317    proxy->fence();
318}
319
320static void android_view_ThreadedRenderer_notifyFramePending(JNIEnv* env, jobject clazz,
321        jlong proxyPtr) {
322    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
323    proxy->notifyFramePending();
324}
325
326static void android_view_ThreadedRenderer_dumpProfileInfo(JNIEnv* env, jobject clazz,
327        jlong proxyPtr, jobject javaFileDescriptor) {
328    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
329    int fd = jniGetFDFromFileDescriptor(env, javaFileDescriptor);
330    proxy->dumpProfileInfo(fd);
331}
332
333#endif
334
335// ----------------------------------------------------------------------------
336// Shaders
337// ----------------------------------------------------------------------------
338
339static void android_view_ThreadedRenderer_setupShadersDiskCache(JNIEnv* env, jobject clazz,
340        jstring diskCachePath) {
341
342    const char* cacheArray = env->GetStringUTFChars(diskCachePath, NULL);
343    egl_cache_t::get()->setCacheFilename(cacheArray);
344    env->ReleaseStringUTFChars(diskCachePath, cacheArray);
345}
346
347// ----------------------------------------------------------------------------
348// JNI Glue
349// ----------------------------------------------------------------------------
350
351const char* const kClassPathName = "android/view/ThreadedRenderer";
352
353static JNINativeMethod gMethods[] = {
354#ifdef USE_OPENGL_RENDERER
355    { "nSetAtlas", "(Landroid/view/GraphicBuffer;[J)V",   (void*) android_view_ThreadedRenderer_setAtlas },
356    { "nCreateRootRenderNode", "()J", (void*) android_view_ThreadedRenderer_createRootRenderNode },
357    { "nCreateProxy", "(ZJ)J", (void*) android_view_ThreadedRenderer_createProxy },
358    { "nDeleteProxy", "(J)V", (void*) android_view_ThreadedRenderer_deleteProxy },
359    { "nSetFrameInterval", "(JJ)V", (void*) android_view_ThreadedRenderer_setFrameInterval },
360    { "nLoadSystemProperties", "(J)Z", (void*) android_view_ThreadedRenderer_loadSystemProperties },
361    { "nInitialize", "(JLandroid/view/Surface;)Z", (void*) android_view_ThreadedRenderer_initialize },
362    { "nUpdateSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_updateSurface },
363    { "nPauseSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_pauseSurface },
364    { "nSetup", "(JIIFFFF)V", (void*) android_view_ThreadedRenderer_setup },
365    { "nSetOpaque", "(JZ)V", (void*) android_view_ThreadedRenderer_setOpaque },
366    { "nSyncAndDrawFrame", "(JJJFIIII)I", (void*) android_view_ThreadedRenderer_syncAndDrawFrame },
367    { "nDestroyCanvasAndSurface", "(J)V", (void*) android_view_ThreadedRenderer_destroyCanvasAndSurface },
368    { "nInvokeFunctor", "(JJZ)V", (void*) android_view_ThreadedRenderer_invokeFunctor },
369    { "nRunWithGlContext", "(JLjava/lang/Runnable;)V", (void*) android_view_ThreadedRenderer_runWithGlContext },
370    { "nCreateDisplayListLayer", "(JII)J", (void*) android_view_ThreadedRenderer_createDisplayListLayer },
371    { "nCreateTextureLayer", "(J)J", (void*) android_view_ThreadedRenderer_createTextureLayer },
372    { "nCopyLayerInto", "(JJJ)Z", (void*) android_view_ThreadedRenderer_copyLayerInto },
373    { "nPushLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_pushLayerUpdate },
374    { "nCancelLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_cancelLayerUpdate },
375    { "nFlushCaches", "(JI)V", (void*) android_view_ThreadedRenderer_flushCaches },
376    { "nFence", "(J)V", (void*) android_view_ThreadedRenderer_fence },
377    { "nNotifyFramePending", "(J)V", (void*) android_view_ThreadedRenderer_notifyFramePending },
378    { "nDumpProfileInfo", "(JLjava/io/FileDescriptor;)V", (void*) android_view_ThreadedRenderer_dumpProfileInfo },
379#endif
380    { "setupShadersDiskCache", "(Ljava/lang/String;)V",
381                (void*) android_view_ThreadedRenderer_setupShadersDiskCache },
382};
383
384int register_android_view_ThreadedRenderer(JNIEnv* env) {
385#ifdef USE_OPENGL_RENDERER
386    jclass cls = env->FindClass("java/lang/Runnable");
387    gRunnableMethod = env->GetMethodID(cls, "run", "()V");
388    env->DeleteLocalRef(cls);
389#endif
390    return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
391}
392
393}; // namespace android
394