android_view_Surface.cpp revision b1d90c8f60f71422196c337f1d078b68867f5710
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 30#include <gui/Surface.h> 31#include <gui/SurfaceControl.h> 32#include <gui/GLConsumer.h> 33 34#include <ui/Rect.h> 35#include <ui/Region.h> 36 37#include <SkCanvas.h> 38#include <SkBitmap.h> 39#include <SkRegion.h> 40 41#include <utils/misc.h> 42#include <utils/Log.h> 43 44#include <ScopedUtfChars.h> 45 46// ---------------------------------------------------------------------------- 47 48namespace android { 49 50static const char* const OutOfResourcesException = 51 "android/view/Surface$OutOfResourcesException"; 52 53static struct { 54 jclass clazz; 55 jfieldID mNativeObject; 56 jfieldID mCanvas; 57 jmethodID ctor; 58} gSurfaceClassInfo; 59 60static struct { 61 jfieldID left; 62 jfieldID top; 63 jfieldID right; 64 jfieldID bottom; 65} gRectClassInfo; 66 67static struct { 68 jfieldID mFinalizer; 69 jfieldID mNativeCanvas; 70 jfieldID mSurfaceFormat; 71} gCanvasClassInfo; 72 73static struct { 74 jfieldID mNativeCanvas; 75} gCanvasFinalizerClassInfo; 76 77// ---------------------------------------------------------------------------- 78 79// this is just a pointer we use to pass to inc/decStrong 80static const void *sRefBaseOwner; 81 82bool android_view_Surface_isInstanceOf(JNIEnv* env, jobject obj) { 83 return env->IsInstanceOf(obj, gSurfaceClassInfo.clazz); 84} 85 86sp<ANativeWindow> android_view_Surface_getNativeWindow(JNIEnv* env, jobject surfaceObj) { 87 return android_view_Surface_getSurface(env, surfaceObj); 88} 89 90sp<Surface> android_view_Surface_getSurface(JNIEnv* env, jobject surfaceObj) { 91 return reinterpret_cast<Surface *>( 92 env->GetIntField(surfaceObj, gSurfaceClassInfo.mNativeObject)); 93} 94 95jobject android_view_Surface_createFromIGraphicBufferProducer(JNIEnv* env, 96 const sp<IGraphicBufferProducer>& bufferProducer) { 97 if (bufferProducer == NULL) { 98 return NULL; 99 } 100 101 sp<Surface> surface(new Surface(bufferProducer)); 102 if (surface == NULL) { 103 return NULL; 104 } 105 106 jobject surfaceObj = env->NewObject(gSurfaceClassInfo.clazz, gSurfaceClassInfo.ctor, surface.get()); 107 if (surfaceObj == NULL) { 108 if (env->ExceptionCheck()) { 109 ALOGE("Could not create instance of Surface from IGraphicBufferProducer."); 110 LOGE_EX(env); 111 env->ExceptionClear(); 112 } 113 return NULL; 114 } 115 surface->incStrong(&sRefBaseOwner); 116 return surfaceObj; 117} 118 119// ---------------------------------------------------------------------------- 120 121static inline bool isSurfaceValid(const sp<Surface>& sur) { 122 return Surface::isValid(sur); 123} 124 125// ---------------------------------------------------------------------------- 126 127static jint nativeCreateFromSurfaceTexture(JNIEnv* env, jclass clazz, 128 jobject surfaceTextureObj) { 129 sp<GLConsumer> st(SurfaceTexture_getSurfaceTexture(env, surfaceTextureObj)); 130 if (st == NULL) { 131 jniThrowException(env, "java/lang/IllegalArgumentException", 132 "SurfaceTexture has already been released"); 133 return 0; 134 } 135 136 sp<IGraphicBufferProducer> bq = st->getBufferQueue(); 137 sp<Surface> surface(new Surface(bq)); 138 if (surface == NULL) { 139 jniThrowException(env, OutOfResourcesException, NULL); 140 return 0; 141 } 142 143 surface->incStrong(&sRefBaseOwner); 144 return int(surface.get()); 145} 146 147static void nativeRelease(JNIEnv* env, jclass clazz, jint nativeObject) { 148 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject)); 149 sur->decStrong(&sRefBaseOwner); 150} 151 152static void nativeDestroy(JNIEnv* env, jclass clazz, jint nativeObject) { 153 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject)); 154 sur->decStrong(&sRefBaseOwner); 155} 156 157static jboolean nativeIsValid(JNIEnv* env, jclass clazz, jint nativeObject) { 158 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject)); 159 return isSurfaceValid(sur) ? JNI_TRUE : JNI_FALSE; 160} 161 162static jboolean nativeIsConsumerRunningBehind(JNIEnv* env, jclass clazz, jint nativeObject) { 163 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject)); 164 if (!isSurfaceValid(sur)) { 165 doThrowIAE(env); 166 return JNI_FALSE; 167 } 168 int value = 0; 169 ANativeWindow* anw = static_cast<ANativeWindow*>(sur.get()); 170 anw->query(anw, NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &value); 171 return value; 172} 173 174static inline SkBitmap::Config convertPixelFormat(PixelFormat format) { 175 /* note: if PIXEL_FORMAT_RGBX_8888 means that all alpha bytes are 0xFF, then 176 we can map to SkBitmap::kARGB_8888_Config, and optionally call 177 bitmap.setIsOpaque(true) on the resulting SkBitmap (as an accelerator) 178 */ 179 switch (format) { 180 case PIXEL_FORMAT_RGBX_8888: return SkBitmap::kARGB_8888_Config; 181 case PIXEL_FORMAT_RGBA_8888: return SkBitmap::kARGB_8888_Config; 182 case PIXEL_FORMAT_RGBA_4444: return SkBitmap::kARGB_4444_Config; 183 case PIXEL_FORMAT_RGB_565: return SkBitmap::kRGB_565_Config; 184 case PIXEL_FORMAT_A_8: return SkBitmap::kA8_Config; 185 default: return SkBitmap::kNo_Config; 186 } 187} 188 189static inline void swapCanvasPtr(JNIEnv* env, jobject canvasObj, SkCanvas* newCanvas) { 190 jobject canvasFinalizerObj = env->GetObjectField(canvasObj, gCanvasClassInfo.mFinalizer); 191 SkCanvas* previousCanvas = reinterpret_cast<SkCanvas*>( 192 env->GetIntField(canvasObj, gCanvasClassInfo.mNativeCanvas)); 193 env->SetIntField(canvasObj, gCanvasClassInfo.mNativeCanvas, (int)newCanvas); 194 env->SetIntField(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (int)newCanvas); 195 SkSafeUnref(previousCanvas); 196} 197 198static jobject nativeLockCanvas(JNIEnv* env, jobject surfaceObj, jint nativeObject, jobject dirtyRectObj) { 199 sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject)); 200 201 if (!isSurfaceValid(surface)) { 202 doThrowIAE(env); 203 return NULL; 204 } 205 206 // get dirty region 207 Region dirtyRegion; 208 if (dirtyRectObj) { 209 Rect dirty; 210 dirty.left = env->GetIntField(dirtyRectObj, gRectClassInfo.left); 211 dirty.top = env->GetIntField(dirtyRectObj, gRectClassInfo.top); 212 dirty.right = env->GetIntField(dirtyRectObj, gRectClassInfo.right); 213 dirty.bottom = env->GetIntField(dirtyRectObj, gRectClassInfo.bottom); 214 if (!dirty.isEmpty()) { 215 dirtyRegion.set(dirty); 216 } 217 } else { 218 dirtyRegion.set(Rect(0x3FFF, 0x3FFF)); 219 } 220 221 ANativeWindow_Buffer outBuffer; 222 Rect dirtyBounds(dirtyRegion.getBounds()); 223 status_t err = surface->lock(&outBuffer, &dirtyBounds); 224 dirtyRegion.set(dirtyBounds); 225 if (err < 0) { 226 const char* const exception = (err == NO_MEMORY) ? 227 OutOfResourcesException : 228 "java/lang/IllegalArgumentException"; 229 jniThrowException(env, exception, NULL); 230 return NULL; 231 } 232 233 // Associate a SkCanvas object to this surface 234 jobject canvasObj = env->GetObjectField(surfaceObj, gSurfaceClassInfo.mCanvas); 235 env->SetIntField(canvasObj, gCanvasClassInfo.mSurfaceFormat, outBuffer.format); 236 237 SkBitmap bitmap; 238 ssize_t bpr = outBuffer.stride * bytesPerPixel(outBuffer.format); 239 bitmap.setConfig(convertPixelFormat(outBuffer.format), outBuffer.width, outBuffer.height, bpr); 240 if (outBuffer.format == PIXEL_FORMAT_RGBX_8888) { 241 bitmap.setIsOpaque(true); 242 } 243 if (outBuffer.width > 0 && outBuffer.height > 0) { 244 bitmap.setPixels(outBuffer.bits); 245 } else { 246 // be safe with an empty bitmap. 247 bitmap.setPixels(NULL); 248 } 249 250 SkCanvas* nativeCanvas = SkNEW_ARGS(SkCanvas, (bitmap)); 251 swapCanvasPtr(env, canvasObj, nativeCanvas); 252 253 SkRegion clipReg; 254 if (dirtyRegion.isRect()) { // very common case 255 const Rect b(dirtyRegion.getBounds()); 256 clipReg.setRect(b.left, b.top, b.right, b.bottom); 257 } else { 258 size_t count; 259 Rect const* r = dirtyRegion.getArray(&count); 260 while (count) { 261 clipReg.op(r->left, r->top, r->right, r->bottom, SkRegion::kUnion_Op); 262 r++, count--; 263 } 264 } 265 266 nativeCanvas->clipRegion(clipReg); 267 268 if (dirtyRectObj) { 269 const Rect& bounds(dirtyRegion.getBounds()); 270 env->SetIntField(dirtyRectObj, gRectClassInfo.left, bounds.left); 271 env->SetIntField(dirtyRectObj, gRectClassInfo.top, bounds.top); 272 env->SetIntField(dirtyRectObj, gRectClassInfo.right, bounds.right); 273 env->SetIntField(dirtyRectObj, gRectClassInfo.bottom, bounds.bottom); 274 } 275 276 return canvasObj; 277} 278 279static void nativeUnlockCanvasAndPost(JNIEnv* env, jobject surfaceObj, jint nativeObject, jobject canvasObj) { 280 jobject ownCanvasObj = env->GetObjectField(surfaceObj, gSurfaceClassInfo.mCanvas); 281 if (!env->IsSameObject(ownCanvasObj, canvasObj)) { 282 doThrowIAE(env); 283 return; 284 } 285 286 sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject)); 287 if (!isSurfaceValid(surface)) { 288 return; 289 } 290 291 // detach the canvas from the surface 292 SkCanvas* nativeCanvas = SkNEW(SkCanvas); 293 swapCanvasPtr(env, canvasObj, nativeCanvas); 294 295 // unlock surface 296 status_t err = surface->unlockAndPost(); 297 if (err < 0) { 298 doThrowIAE(env); 299 } 300} 301 302// ---------------------------------------------------------------------------- 303 304static jint nativeCopyFrom(JNIEnv* env, jclass clazz, 305 jint nativeObject, jint surfaceControlNativeObj) { 306 /* 307 * This is used by the WindowManagerService just after constructing 308 * a Surface and is necessary for returning the Surface reference to 309 * the caller. At this point, we should only have a SurfaceControl. 310 */ 311 312 sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(surfaceControlNativeObj)); 313 sp<Surface> other(ctrl->getSurface()); 314 if (other != NULL) { 315 other->incStrong(&sRefBaseOwner); 316 } 317 318 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject)); 319 if (sur != NULL) { 320 sur->decStrong(&sRefBaseOwner); 321 } 322 323 return int(other.get()); 324} 325 326static jint nativeReadFromParcel(JNIEnv* env, jclass clazz, 327 jint nativeObject, jobject parcelObj) { 328 Parcel* parcel = parcelForJavaObject(env, parcelObj); 329 if (parcel == NULL) { 330 doThrowNPE(env); 331 return 0; 332 } 333 sp<Surface> self(reinterpret_cast<Surface *>(nativeObject)); 334 if (self != NULL) { 335 self->decStrong(&sRefBaseOwner); 336 } 337 sp<Surface> sur(Surface::readFromParcel(*parcel)); 338 if (sur != NULL) { 339 sur->incStrong(&sRefBaseOwner); 340 } 341 return int(sur.get()); 342} 343 344static void nativeWriteToParcel(JNIEnv* env, jclass clazz, 345 jint 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 Surface::writeToParcel(self, parcel); 353} 354 355// ---------------------------------------------------------------------------- 356 357static JNINativeMethod gSurfaceMethods[] = { 358 {"nativeCreateFromSurfaceTexture", "(Landroid/graphics/SurfaceTexture;)I", 359 (void*)nativeCreateFromSurfaceTexture }, 360 {"nativeRelease", "(I)V", 361 (void*)nativeRelease }, 362 {"nativeDestroy", "(I)V", 363 (void*)nativeDestroy }, 364 {"nativeIsValid", "(I)Z", 365 (void*)nativeIsValid }, 366 {"nativeIsConsumerRunningBehind", "(I)Z", 367 (void*)nativeIsConsumerRunningBehind }, 368 {"nativeLockCanvas", "(ILandroid/graphics/Rect;)Landroid/graphics/Canvas;", 369 (void*)nativeLockCanvas }, 370 {"nativeUnlockCanvasAndPost", "(ILandroid/graphics/Canvas;)V", 371 (void*)nativeUnlockCanvasAndPost }, 372 {"nativeCopyFrom", "(II)I", 373 (void*)nativeCopyFrom }, 374 {"nativeReadFromParcel", "(ILandroid/os/Parcel;)I", 375 (void*)nativeReadFromParcel }, 376 {"nativeWriteToParcel", "(ILandroid/os/Parcel;)V", 377 (void*)nativeWriteToParcel }, 378}; 379 380int 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", "I"); 389 gSurfaceClassInfo.mCanvas = 390 env->GetFieldID(gSurfaceClassInfo.clazz, "mCanvas", "Landroid/graphics/Canvas;"); 391 gSurfaceClassInfo.ctor = env->GetMethodID(gSurfaceClassInfo.clazz, "<init>", "(I)V"); 392 393 clazz = env->FindClass("android/graphics/Canvas"); 394 gCanvasClassInfo.mFinalizer = env->GetFieldID(clazz, "mFinalizer", "Landroid/graphics/Canvas$CanvasFinalizer;"); 395 gCanvasClassInfo.mNativeCanvas = env->GetFieldID(clazz, "mNativeCanvas", "I"); 396 gCanvasClassInfo.mSurfaceFormat = env->GetFieldID(clazz, "mSurfaceFormat", "I"); 397 398 clazz = env->FindClass("android/graphics/Canvas$CanvasFinalizer"); 399 gCanvasFinalizerClassInfo.mNativeCanvas = env->GetFieldID(clazz, "mNativeCanvas", "I"); 400 401 clazz = env->FindClass("android/graphics/Rect"); 402 gRectClassInfo.left = env->GetFieldID(clazz, "left", "I"); 403 gRectClassInfo.top = env->GetFieldID(clazz, "top", "I"); 404 gRectClassInfo.right = env->GetFieldID(clazz, "right", "I"); 405 gRectClassInfo.bottom = env->GetFieldID(clazz, "bottom", "I"); 406 407 return err; 408} 409 410}; 411