1 /*
2 * Copyright (C) 2007 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 "Surface"
18
19 #include <stdio.h>
20
21 #include "jni.h"
22 #include "JNIHelp.h"
23 #include "android_os_Parcel.h"
24 #include "android/graphics/GraphicsJNI.h"
25
26 #include <android_runtime/AndroidRuntime.h>
27 #include <android_runtime/android_view_Surface.h>
28 #include <android_runtime/android_graphics_SurfaceTexture.h>
29 #include <android_runtime/Log.h>
30
31 #include <binder/Parcel.h>
32
33 #include <gui/Surface.h>
34 #include <gui/SurfaceControl.h>
35 #include <gui/GLConsumer.h>
36
37 #include <ui/Rect.h>
38 #include <ui/Region.h>
39
40 #include <SkCanvas.h>
41 #include <SkBitmap.h>
42 #include <SkImage.h>
43 #include <SkRegion.h>
44
45 #include <utils/misc.h>
46 #include <utils/Log.h>
47
48 #include <ScopedUtfChars.h>
49
50 // ----------------------------------------------------------------------------
51
52 namespace android {
53
54 static const char* const OutOfResourcesException =
55 "android/view/Surface$OutOfResourcesException";
56
57 static struct {
58 jclass clazz;
59 jfieldID mNativeObject;
60 jfieldID mLock;
61 jmethodID ctor;
62 } gSurfaceClassInfo;
63
64 static struct {
65 jfieldID left;
66 jfieldID top;
67 jfieldID right;
68 jfieldID bottom;
69 } gRectClassInfo;
70
71 static struct {
72 jfieldID mSurfaceFormat;
73 jmethodID setNativeBitmap;
74 } gCanvasClassInfo;
75
76 // ----------------------------------------------------------------------------
77
78 // this is just a pointer we use to pass to inc/decStrong
79 static const void *sRefBaseOwner;
80
android_view_Surface_isInstanceOf(JNIEnv * env,jobject obj)81 bool android_view_Surface_isInstanceOf(JNIEnv* env, jobject obj) {
82 return env->IsInstanceOf(obj, gSurfaceClassInfo.clazz);
83 }
84
android_view_Surface_getNativeWindow(JNIEnv * env,jobject surfaceObj)85 sp<ANativeWindow> android_view_Surface_getNativeWindow(JNIEnv* env, jobject surfaceObj) {
86 return android_view_Surface_getSurface(env, surfaceObj);
87 }
88
android_view_Surface_getSurface(JNIEnv * env,jobject surfaceObj)89 sp<Surface> android_view_Surface_getSurface(JNIEnv* env, jobject surfaceObj) {
90 sp<Surface> sur;
91 jobject lock = env->GetObjectField(surfaceObj,
92 gSurfaceClassInfo.mLock);
93 if (env->MonitorEnter(lock) == JNI_OK) {
94 sur = reinterpret_cast<Surface *>(
95 env->GetLongField(surfaceObj, gSurfaceClassInfo.mNativeObject));
96 env->MonitorExit(lock);
97 }
98 env->DeleteLocalRef(lock);
99 return sur;
100 }
101
android_view_Surface_createFromIGraphicBufferProducer(JNIEnv * env,const sp<IGraphicBufferProducer> & bufferProducer)102 jobject android_view_Surface_createFromIGraphicBufferProducer(JNIEnv* env,
103 const sp<IGraphicBufferProducer>& bufferProducer) {
104 if (bufferProducer == NULL) {
105 return NULL;
106 }
107
108 sp<Surface> surface(new Surface(bufferProducer, true));
109 if (surface == NULL) {
110 return NULL;
111 }
112
113 jobject surfaceObj = env->NewObject(gSurfaceClassInfo.clazz,
114 gSurfaceClassInfo.ctor, (jlong)surface.get());
115 if (surfaceObj == NULL) {
116 if (env->ExceptionCheck()) {
117 ALOGE("Could not create instance of Surface from IGraphicBufferProducer.");
118 LOGE_EX(env);
119 env->ExceptionClear();
120 }
121 return NULL;
122 }
123 surface->incStrong(&sRefBaseOwner);
124 return surfaceObj;
125 }
126
127 // ----------------------------------------------------------------------------
128
isSurfaceValid(const sp<Surface> & sur)129 static inline bool isSurfaceValid(const sp<Surface>& sur) {
130 return Surface::isValid(sur);
131 }
132
133 // ----------------------------------------------------------------------------
134
nativeCreateFromSurfaceTexture(JNIEnv * env,jclass clazz,jobject surfaceTextureObj)135 static jlong nativeCreateFromSurfaceTexture(JNIEnv* env, jclass clazz,
136 jobject surfaceTextureObj) {
137 sp<IGraphicBufferProducer> producer(SurfaceTexture_getProducer(env, surfaceTextureObj));
138 if (producer == NULL) {
139 jniThrowException(env, "java/lang/IllegalArgumentException",
140 "SurfaceTexture has already been released");
141 return 0;
142 }
143
144 sp<Surface> surface(new Surface(producer, true));
145 if (surface == NULL) {
146 jniThrowException(env, OutOfResourcesException, NULL);
147 return 0;
148 }
149
150 surface->incStrong(&sRefBaseOwner);
151 return jlong(surface.get());
152 }
153
nativeRelease(JNIEnv * env,jclass clazz,jlong nativeObject)154 static void nativeRelease(JNIEnv* env, jclass clazz, jlong nativeObject) {
155 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
156 sur->decStrong(&sRefBaseOwner);
157 }
158
nativeIsValid(JNIEnv * env,jclass clazz,jlong nativeObject)159 static jboolean nativeIsValid(JNIEnv* env, jclass clazz, jlong nativeObject) {
160 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
161 return isSurfaceValid(sur) ? JNI_TRUE : JNI_FALSE;
162 }
163
nativeIsConsumerRunningBehind(JNIEnv * env,jclass clazz,jlong nativeObject)164 static jboolean nativeIsConsumerRunningBehind(JNIEnv* env, jclass clazz, jlong nativeObject) {
165 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
166 if (!isSurfaceValid(sur)) {
167 doThrowIAE(env);
168 return JNI_FALSE;
169 }
170 int value = 0;
171 ANativeWindow* anw = static_cast<ANativeWindow*>(sur.get());
172 anw->query(anw, NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &value);
173 return value;
174 }
175
convertPixelFormat(PixelFormat format)176 static inline SkColorType convertPixelFormat(PixelFormat format) {
177 /* note: if PIXEL_FORMAT_RGBX_8888 means that all alpha bytes are 0xFF, then
178 we can map to kN32_SkColorType, and optionally call
179 bitmap.setAlphaType(kOpaque_SkAlphaType) on the resulting SkBitmap
180 (as an accelerator)
181 */
182 switch (format) {
183 case PIXEL_FORMAT_RGBX_8888: return kN32_SkColorType;
184 case PIXEL_FORMAT_RGBA_8888: return kN32_SkColorType;
185 case PIXEL_FORMAT_RGB_565: return kRGB_565_SkColorType;
186 default: return kUnknown_SkColorType;
187 }
188 }
189
nativeLockCanvas(JNIEnv * env,jclass clazz,jlong nativeObject,jobject canvasObj,jobject dirtyRectObj)190 static jlong nativeLockCanvas(JNIEnv* env, jclass clazz,
191 jlong nativeObject, jobject canvasObj, jobject dirtyRectObj) {
192 sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
193
194 if (!isSurfaceValid(surface)) {
195 doThrowIAE(env);
196 return 0;
197 }
198
199 Rect dirtyRect;
200 Rect* dirtyRectPtr = NULL;
201
202 if (dirtyRectObj) {
203 dirtyRect.left = env->GetIntField(dirtyRectObj, gRectClassInfo.left);
204 dirtyRect.top = env->GetIntField(dirtyRectObj, gRectClassInfo.top);
205 dirtyRect.right = env->GetIntField(dirtyRectObj, gRectClassInfo.right);
206 dirtyRect.bottom = env->GetIntField(dirtyRectObj, gRectClassInfo.bottom);
207 dirtyRectPtr = &dirtyRect;
208 }
209
210 ANativeWindow_Buffer outBuffer;
211 status_t err = surface->lock(&outBuffer, dirtyRectPtr);
212 if (err < 0) {
213 const char* const exception = (err == NO_MEMORY) ?
214 OutOfResourcesException :
215 "java/lang/IllegalArgumentException";
216 jniThrowException(env, exception, NULL);
217 return 0;
218 }
219
220 // Associate a SkCanvas object to this surface
221 env->SetIntField(canvasObj, gCanvasClassInfo.mSurfaceFormat, outBuffer.format);
222
223 SkImageInfo info = SkImageInfo::Make(outBuffer.width, outBuffer.height,
224 convertPixelFormat(outBuffer.format),
225 kPremul_SkAlphaType);
226 if (outBuffer.format == PIXEL_FORMAT_RGBX_8888) {
227 info.fAlphaType = kOpaque_SkAlphaType;
228 }
229
230 SkBitmap bitmap;
231 ssize_t bpr = outBuffer.stride * bytesPerPixel(outBuffer.format);
232 bitmap.setInfo(info, bpr);
233 if (outBuffer.width > 0 && outBuffer.height > 0) {
234 bitmap.setPixels(outBuffer.bits);
235 } else {
236 // be safe with an empty bitmap.
237 bitmap.setPixels(NULL);
238 }
239
240 env->CallVoidMethod(canvasObj, gCanvasClassInfo.setNativeBitmap,
241 reinterpret_cast<jlong>(&bitmap));
242
243 if (dirtyRectPtr) {
244 SkCanvas* nativeCanvas = GraphicsJNI::getNativeCanvas(env, canvasObj);
245 nativeCanvas->clipRect( SkRect::Make(reinterpret_cast<const SkIRect&>(dirtyRect)) );
246 }
247
248 if (dirtyRectObj) {
249 env->SetIntField(dirtyRectObj, gRectClassInfo.left, dirtyRect.left);
250 env->SetIntField(dirtyRectObj, gRectClassInfo.top, dirtyRect.top);
251 env->SetIntField(dirtyRectObj, gRectClassInfo.right, dirtyRect.right);
252 env->SetIntField(dirtyRectObj, gRectClassInfo.bottom, dirtyRect.bottom);
253 }
254
255 // Create another reference to the surface and return it. This reference
256 // should be passed to nativeUnlockCanvasAndPost in place of mNativeObject,
257 // because the latter could be replaced while the surface is locked.
258 sp<Surface> lockedSurface(surface);
259 lockedSurface->incStrong(&sRefBaseOwner);
260 return (jlong) lockedSurface.get();
261 }
262
nativeUnlockCanvasAndPost(JNIEnv * env,jclass clazz,jlong nativeObject,jobject canvasObj)263 static void nativeUnlockCanvasAndPost(JNIEnv* env, jclass clazz,
264 jlong nativeObject, jobject canvasObj) {
265 sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
266 if (!isSurfaceValid(surface)) {
267 return;
268 }
269
270 // detach the canvas from the surface
271 env->CallVoidMethod(canvasObj, gCanvasClassInfo.setNativeBitmap, (jlong)0);
272
273 // unlock surface
274 status_t err = surface->unlockAndPost();
275 if (err < 0) {
276 doThrowIAE(env);
277 }
278 }
279
nativeAllocateBuffers(JNIEnv *,jclass,jlong nativeObject)280 static void nativeAllocateBuffers(JNIEnv* /* env */ , jclass /* clazz */,
281 jlong nativeObject) {
282 sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
283 if (!isSurfaceValid(surface)) {
284 return;
285 }
286
287 surface->allocateBuffers();
288 }
289
290 // ----------------------------------------------------------------------------
291
nativeCreateFromSurfaceControl(JNIEnv * env,jclass clazz,jlong surfaceControlNativeObj)292 static jlong nativeCreateFromSurfaceControl(JNIEnv* env, jclass clazz,
293 jlong surfaceControlNativeObj) {
294 /*
295 * This is used by the WindowManagerService just after constructing
296 * a Surface and is necessary for returning the Surface reference to
297 * the caller. At this point, we should only have a SurfaceControl.
298 */
299
300 sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(surfaceControlNativeObj));
301 sp<Surface> surface(ctrl->getSurface());
302 if (surface != NULL) {
303 surface->incStrong(&sRefBaseOwner);
304 }
305 return reinterpret_cast<jlong>(surface.get());
306 }
307
nativeReadFromParcel(JNIEnv * env,jclass clazz,jlong nativeObject,jobject parcelObj)308 static jlong nativeReadFromParcel(JNIEnv* env, jclass clazz,
309 jlong nativeObject, jobject parcelObj) {
310 Parcel* parcel = parcelForJavaObject(env, parcelObj);
311 if (parcel == NULL) {
312 doThrowNPE(env);
313 return 0;
314 }
315
316 sp<Surface> self(reinterpret_cast<Surface *>(nativeObject));
317 sp<IBinder> binder(parcel->readStrongBinder());
318
319 // update the Surface only if the underlying IGraphicBufferProducer
320 // has changed.
321 if (self != NULL
322 && (self->getIGraphicBufferProducer()->asBinder() == binder)) {
323 // same IGraphicBufferProducer, return ourselves
324 return jlong(self.get());
325 }
326
327 sp<Surface> sur;
328 sp<IGraphicBufferProducer> gbp(interface_cast<IGraphicBufferProducer>(binder));
329 if (gbp != NULL) {
330 // we have a new IGraphicBufferProducer, create a new Surface for it
331 sur = new Surface(gbp, true);
332 // and keep a reference before passing to java
333 sur->incStrong(&sRefBaseOwner);
334 }
335
336 if (self != NULL) {
337 // and loose the java reference to ourselves
338 self->decStrong(&sRefBaseOwner);
339 }
340
341 return jlong(sur.get());
342 }
343
nativeWriteToParcel(JNIEnv * env,jclass clazz,jlong nativeObject,jobject parcelObj)344 static void nativeWriteToParcel(JNIEnv* env, jclass clazz,
345 jlong nativeObject, jobject parcelObj) {
346 Parcel* parcel = parcelForJavaObject(env, parcelObj);
347 if (parcel == NULL) {
348 doThrowNPE(env);
349 return;
350 }
351 sp<Surface> self(reinterpret_cast<Surface *>(nativeObject));
352 parcel->writeStrongBinder( self != 0 ? self->getIGraphicBufferProducer()->asBinder() : NULL);
353 }
354
355 // ----------------------------------------------------------------------------
356
357 static JNINativeMethod gSurfaceMethods[] = {
358 {"nativeCreateFromSurfaceTexture", "(Landroid/graphics/SurfaceTexture;)J",
359 (void*)nativeCreateFromSurfaceTexture },
360 {"nativeRelease", "(J)V",
361 (void*)nativeRelease },
362 {"nativeIsValid", "(J)Z",
363 (void*)nativeIsValid },
364 {"nativeIsConsumerRunningBehind", "(J)Z",
365 (void*)nativeIsConsumerRunningBehind },
366 {"nativeLockCanvas", "(JLandroid/graphics/Canvas;Landroid/graphics/Rect;)J",
367 (void*)nativeLockCanvas },
368 {"nativeUnlockCanvasAndPost", "(JLandroid/graphics/Canvas;)V",
369 (void*)nativeUnlockCanvasAndPost },
370 {"nativeAllocateBuffers", "(J)V",
371 (void*)nativeAllocateBuffers },
372 {"nativeCreateFromSurfaceControl", "(J)J",
373 (void*)nativeCreateFromSurfaceControl },
374 {"nativeReadFromParcel", "(JLandroid/os/Parcel;)J",
375 (void*)nativeReadFromParcel },
376 {"nativeWriteToParcel", "(JLandroid/os/Parcel;)V",
377 (void*)nativeWriteToParcel },
378 };
379
register_android_view_Surface(JNIEnv * env)380 int register_android_view_Surface(JNIEnv* env)
381 {
382 int err = AndroidRuntime::registerNativeMethods(env, "android/view/Surface",
383 gSurfaceMethods, NELEM(gSurfaceMethods));
384
385 jclass clazz = env->FindClass("android/view/Surface");
386 gSurfaceClassInfo.clazz = jclass(env->NewGlobalRef(clazz));
387 gSurfaceClassInfo.mNativeObject =
388 env->GetFieldID(gSurfaceClassInfo.clazz, "mNativeObject", "J");
389 gSurfaceClassInfo.mLock =
390 env->GetFieldID(gSurfaceClassInfo.clazz, "mLock", "Ljava/lang/Object;");
391 gSurfaceClassInfo.ctor = env->GetMethodID(gSurfaceClassInfo.clazz, "<init>", "(J)V");
392
393 clazz = env->FindClass("android/graphics/Canvas");
394 gCanvasClassInfo.mSurfaceFormat = env->GetFieldID(clazz, "mSurfaceFormat", "I");
395 gCanvasClassInfo.setNativeBitmap = env->GetMethodID(clazz, "setNativeBitmap", "(J)V");
396
397 clazz = env->FindClass("android/graphics/Rect");
398 gRectClassInfo.left = env->GetFieldID(clazz, "left", "I");
399 gRectClassInfo.top = env->GetFieldID(clazz, "top", "I");
400 gRectClassInfo.right = env->GetFieldID(clazz, "right", "I");
401 gRectClassInfo.bottom = env->GetFieldID(clazz, "bottom", "I");
402
403 return err;
404 }
405
406 };
407