1 /*
2 * Copyright 2013 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_NDEBUG 0
18 #define LOG_TAG "ImageReader_JNI"
19 #define ATRACE_TAG ATRACE_TAG_CAMERA
20 #include <android/hardware_buffer_jni.h>
21 #include <android_runtime/AndroidRuntime.h>
22 #include <android_runtime/android_graphics_GraphicBuffer.h>
23 #include <android_runtime/android_hardware_HardwareBuffer.h>
24 #include <android_runtime/android_view_Surface.h>
25 #include <com_android_graphics_libgui_flags.h>
26 #include <cutils/atomic.h>
27 #include <grallocusage/GrallocUsageConversion.h>
28 #include <gui/BufferItemConsumer.h>
29 #include <gui/Surface.h>
30 #include <inttypes.h>
31 #include <jni.h>
32 #include <nativehelper/JNIHelp.h>
33 #include <private/android/AHardwareBufferHelpers.h>
34 #include <stdint.h>
35 #include <ui/Rect.h>
36 #include <utils/List.h>
37 #include <utils/Log.h>
38 #include <utils/String8.h>
39 #include <utils/Trace.h>
40 #include <utils/misc.h>
41
42 #include <cstdio>
43
44 #include "android_media_Utils.h"
45
46 #define ANDROID_MEDIA_IMAGEREADER_CTX_JNI_ID "mNativeContext"
47 #define ANDROID_MEDIA_SURFACEIMAGE_BUFFER_JNI_ID "mNativeBuffer"
48 #define ANDROID_MEDIA_SURFACEIMAGE_TS_JNI_ID "mTimestamp"
49 #define ANDROID_MEDIA_SURFACEIMAGE_DS_JNI_ID "mDataSpace"
50 #define ANDROID_MEDIA_SURFACEIMAGE_TF_JNI_ID "mTransform"
51 #define ANDROID_MEDIA_SURFACEIMAGE_SM_JNI_ID "mScalingMode"
52
53 #define CONSUMER_BUFFER_USAGE_UNKNOWN 0;
54 // ----------------------------------------------------------------------------
55
56 using namespace android;
57
58
59 enum {
60 ACQUIRE_SUCCESS = 0,
61 ACQUIRE_NO_BUFFERS = 1,
62 ACQUIRE_MAX_IMAGES = 2,
63 };
64
65 static struct {
66 jfieldID mNativeContext;
67 jmethodID postEventFromNative;
68 } gImageReaderClassInfo;
69
70 static struct {
71 jfieldID mNativeBuffer;
72 jfieldID mTimestamp;
73 jfieldID mDataSpace;
74 jfieldID mTransform;
75 jfieldID mScalingMode;
76 jfieldID mPlanes;
77 } gSurfaceImageClassInfo;
78
79 static struct {
80 jclass clazz;
81 jmethodID ctor;
82 } gSurfacePlaneClassInfo;
83
84 static struct {
85 jclass clazz;
86 jmethodID ctor;
87 } gImagePlaneClassInfo;
88
89 // Get an ID that's unique within this process.
createProcessUniqueId()90 static int32_t createProcessUniqueId() {
91 static volatile int32_t globalCounter = 0;
92 return android_atomic_inc(&globalCounter);
93 }
94
95 // ----------------------------------------------------------------------------
96
97 class JNIImageReaderContext : public ConsumerBase::FrameAvailableListener
98 {
99 public:
100 JNIImageReaderContext(JNIEnv* env, jobject weakThiz, jclass clazz, int maxImages);
101
102 virtual ~JNIImageReaderContext();
103
104 virtual void onFrameAvailable(const BufferItem& item);
105
106 BufferItem* getBufferItem();
107 void returnBufferItem(BufferItem* buffer);
108
109
setBufferConsumer(const sp<BufferItemConsumer> & consumer)110 void setBufferConsumer(const sp<BufferItemConsumer>& consumer) { mConsumer = consumer; }
getBufferConsumer()111 BufferItemConsumer* getBufferConsumer() { return mConsumer.get(); }
112
setProducer(const sp<IGraphicBufferProducer> & producer)113 void setProducer(const sp<IGraphicBufferProducer>& producer) { mProducer = producer; }
getProducer()114 IGraphicBufferProducer* getProducer() { return mProducer.get(); }
115
setBufferFormat(int format)116 void setBufferFormat(int format) { mFormat = format; }
getBufferFormat()117 int getBufferFormat() { return mFormat; }
118
setBufferDataspace(android_dataspace dataSpace)119 void setBufferDataspace(android_dataspace dataSpace) { mDataSpace = dataSpace; }
getBufferDataspace()120 android_dataspace getBufferDataspace() { return mDataSpace; }
121
setBufferWidth(int width)122 void setBufferWidth(int width) { mWidth = width; }
getBufferWidth()123 int getBufferWidth() { return mWidth; }
124
setBufferHeight(int height)125 void setBufferHeight(int height) { mHeight = height; }
getBufferHeight()126 int getBufferHeight() { return mHeight; }
127
128 private:
129 static JNIEnv* getJNIEnv(bool* needsDetach);
130 static void detachJNI();
131
132 List<BufferItem*> mBuffers;
133 sp<BufferItemConsumer> mConsumer;
134 sp<IGraphicBufferProducer> mProducer;
135 jobject mWeakThiz;
136 jclass mClazz;
137 int mFormat;
138 android_dataspace mDataSpace;
139 int mWidth;
140 int mHeight;
141 };
142
JNIImageReaderContext(JNIEnv * env,jobject weakThiz,jclass clazz,int maxImages)143 JNIImageReaderContext::JNIImageReaderContext(JNIEnv* env,
144 jobject weakThiz, jclass clazz, int maxImages) :
145 mWeakThiz(env->NewGlobalRef(weakThiz)),
146 mClazz((jclass)env->NewGlobalRef(clazz)),
147 mFormat(0),
148 mDataSpace(HAL_DATASPACE_UNKNOWN),
149 mWidth(-1),
150 mHeight(-1) {
151 for (int i = 0; i < maxImages; i++) {
152 BufferItem* buffer = new BufferItem;
153 mBuffers.push_back(buffer);
154 }
155 }
156
getJNIEnv(bool * needsDetach)157 JNIEnv* JNIImageReaderContext::getJNIEnv(bool* needsDetach) {
158 LOG_ALWAYS_FATAL_IF(needsDetach == NULL, "needsDetach is null!!!");
159 *needsDetach = false;
160 JNIEnv* env = AndroidRuntime::getJNIEnv();
161 if (env == NULL) {
162 JavaVMAttachArgs args = {JNI_VERSION_1_4, NULL, NULL};
163 JavaVM* vm = AndroidRuntime::getJavaVM();
164 int result = vm->AttachCurrentThread(&env, (void*) &args);
165 if (result != JNI_OK) {
166 ALOGE("thread attach failed: %#x", result);
167 return NULL;
168 }
169 *needsDetach = true;
170 }
171 return env;
172 }
173
detachJNI()174 void JNIImageReaderContext::detachJNI() {
175 JavaVM* vm = AndroidRuntime::getJavaVM();
176 int result = vm->DetachCurrentThread();
177 if (result != JNI_OK) {
178 ALOGE("thread detach failed: %#x", result);
179 }
180 }
181
getBufferItem()182 BufferItem* JNIImageReaderContext::getBufferItem() {
183 if (mBuffers.empty()) {
184 return NULL;
185 }
186 // Return a BufferItem pointer and remove it from the list
187 List<BufferItem*>::iterator it = mBuffers.begin();
188 BufferItem* buffer = *it;
189 mBuffers.erase(it);
190 return buffer;
191 }
192
returnBufferItem(BufferItem * buffer)193 void JNIImageReaderContext::returnBufferItem(BufferItem* buffer) {
194 buffer->mGraphicBuffer = nullptr;
195 mBuffers.push_back(buffer);
196 }
197
~JNIImageReaderContext()198 JNIImageReaderContext::~JNIImageReaderContext() {
199 bool needsDetach = false;
200 JNIEnv* env = getJNIEnv(&needsDetach);
201 if (env != NULL) {
202 env->DeleteGlobalRef(mWeakThiz);
203 env->DeleteGlobalRef(mClazz);
204 } else {
205 ALOGW("leaking JNI object references");
206 }
207 if (needsDetach) {
208 detachJNI();
209 }
210
211 // Delete buffer items.
212 for (List<BufferItem *>::iterator it = mBuffers.begin();
213 it != mBuffers.end(); it++) {
214 delete *it;
215 }
216
217 if (mConsumer != 0) {
218 mConsumer.clear();
219 }
220 }
221
onFrameAvailable(const BufferItem &)222 void JNIImageReaderContext::onFrameAvailable(const BufferItem& /*item*/)
223 {
224 ATRACE_CALL();
225 ALOGV("%s: frame available", __FUNCTION__);
226 bool needsDetach = false;
227 JNIEnv* env = getJNIEnv(&needsDetach);
228 if (env != NULL) {
229 env->CallStaticVoidMethod(mClazz, gImageReaderClassInfo.postEventFromNative, mWeakThiz);
230 } else {
231 ALOGW("onFrameAvailable event will not posted");
232 }
233 if (needsDetach) {
234 detachJNI();
235 }
236 }
237
238 // ----------------------------------------------------------------------------
239
240 extern "C" {
241
ImageReader_getContext(JNIEnv * env,jobject thiz)242 static JNIImageReaderContext* ImageReader_getContext(JNIEnv* env, jobject thiz)
243 {
244 JNIImageReaderContext *ctx;
245 ctx = reinterpret_cast<JNIImageReaderContext *>
246 (env->GetLongField(thiz, gImageReaderClassInfo.mNativeContext));
247 return ctx;
248 }
249
ImageReader_getProducer(JNIEnv * env,jobject thiz)250 static IGraphicBufferProducer* ImageReader_getProducer(JNIEnv* env, jobject thiz)
251 {
252 ALOGV("%s:", __FUNCTION__);
253 JNIImageReaderContext* const ctx = ImageReader_getContext(env, thiz);
254 if (ctx == NULL) {
255 jniThrowRuntimeException(env, "ImageReaderContext is not initialized");
256 return NULL;
257 }
258
259 return ctx->getProducer();
260 }
261
ImageReader_setNativeContext(JNIEnv * env,jobject thiz,sp<JNIImageReaderContext> ctx)262 static void ImageReader_setNativeContext(JNIEnv* env,
263 jobject thiz, sp<JNIImageReaderContext> ctx)
264 {
265 ALOGV("%s:", __FUNCTION__);
266 JNIImageReaderContext* const p = ImageReader_getContext(env, thiz);
267 if (ctx != 0) {
268 ctx->incStrong((void*)ImageReader_setNativeContext);
269 }
270 if (p) {
271 p->decStrong((void*)ImageReader_setNativeContext);
272 }
273 env->SetLongField(thiz, gImageReaderClassInfo.mNativeContext,
274 reinterpret_cast<jlong>(ctx.get()));
275 }
276
ImageReader_getBufferConsumer(JNIEnv * env,jobject thiz)277 static BufferItemConsumer* ImageReader_getBufferConsumer(JNIEnv* env, jobject thiz)
278 {
279 ALOGV("%s:", __FUNCTION__);
280 JNIImageReaderContext* const ctx = ImageReader_getContext(env, thiz);
281 if (ctx == NULL) {
282 jniThrowRuntimeException(env, "ImageReaderContext is not initialized");
283 return NULL;
284 }
285
286 return ctx->getBufferConsumer();
287 }
288
Image_setBufferItem(JNIEnv * env,jobject thiz,const BufferItem * buffer)289 static void Image_setBufferItem(JNIEnv* env, jobject thiz,
290 const BufferItem* buffer)
291 {
292 env->SetLongField(thiz, gSurfaceImageClassInfo.mNativeBuffer, reinterpret_cast<jlong>(buffer));
293 }
294
Image_getBufferItem(JNIEnv * env,jobject image)295 static BufferItem* Image_getBufferItem(JNIEnv* env, jobject image)
296 {
297 return reinterpret_cast<BufferItem*>(
298 env->GetLongField(image, gSurfaceImageClassInfo.mNativeBuffer));
299 }
300
301
302 // ----------------------------------------------------------------------------
303
ImageReader_classInit(JNIEnv * env,jclass clazz)304 static void ImageReader_classInit(JNIEnv* env, jclass clazz)
305 {
306 ALOGV("%s:", __FUNCTION__);
307
308 jclass imageClazz = env->FindClass("android/media/ImageReader$SurfaceImage");
309 LOG_ALWAYS_FATAL_IF(imageClazz == NULL,
310 "can't find android/graphics/ImageReader$SurfaceImage");
311 gSurfaceImageClassInfo.mNativeBuffer = env->GetFieldID(
312 imageClazz, ANDROID_MEDIA_SURFACEIMAGE_BUFFER_JNI_ID, "J");
313 LOG_ALWAYS_FATAL_IF(gSurfaceImageClassInfo.mNativeBuffer == NULL,
314 "can't find android/graphics/ImageReader.%s",
315 ANDROID_MEDIA_SURFACEIMAGE_BUFFER_JNI_ID);
316
317 gSurfaceImageClassInfo.mTimestamp = env->GetFieldID(
318 imageClazz, ANDROID_MEDIA_SURFACEIMAGE_TS_JNI_ID, "J");
319 LOG_ALWAYS_FATAL_IF(gSurfaceImageClassInfo.mTimestamp == NULL,
320 "can't find android/graphics/ImageReader.%s",
321 ANDROID_MEDIA_SURFACEIMAGE_TS_JNI_ID);
322
323 gSurfaceImageClassInfo.mDataSpace = env->GetFieldID(
324 imageClazz, ANDROID_MEDIA_SURFACEIMAGE_DS_JNI_ID, "I");
325 LOG_ALWAYS_FATAL_IF(gSurfaceImageClassInfo.mDataSpace == NULL,
326 "can't find android/graphics/ImageReader.%s",
327 ANDROID_MEDIA_SURFACEIMAGE_DS_JNI_ID);
328
329 gSurfaceImageClassInfo.mTransform = env->GetFieldID(
330 imageClazz, ANDROID_MEDIA_SURFACEIMAGE_TF_JNI_ID, "I");
331 LOG_ALWAYS_FATAL_IF(gSurfaceImageClassInfo.mTransform == NULL,
332 "can't find android/graphics/ImageReader.%s",
333 ANDROID_MEDIA_SURFACEIMAGE_TF_JNI_ID);
334
335 gSurfaceImageClassInfo.mScalingMode = env->GetFieldID(
336 imageClazz, ANDROID_MEDIA_SURFACEIMAGE_SM_JNI_ID, "I");
337 LOG_ALWAYS_FATAL_IF(gSurfaceImageClassInfo.mScalingMode == NULL,
338 "can't find android/graphics/ImageReader.%s",
339 ANDROID_MEDIA_SURFACEIMAGE_SM_JNI_ID);
340
341 gSurfaceImageClassInfo.mPlanes = env->GetFieldID(
342 imageClazz, "mPlanes", "[Landroid/media/ImageReader$SurfaceImage$SurfacePlane;");
343 LOG_ALWAYS_FATAL_IF(gSurfaceImageClassInfo.mPlanes == NULL,
344 "can't find android/media/ImageReader$ReaderSurfaceImage.mPlanes");
345
346 gImageReaderClassInfo.mNativeContext = env->GetFieldID(
347 clazz, ANDROID_MEDIA_IMAGEREADER_CTX_JNI_ID, "J");
348 LOG_ALWAYS_FATAL_IF(gImageReaderClassInfo.mNativeContext == NULL,
349 "can't find android/graphics/ImageReader.%s",
350 ANDROID_MEDIA_IMAGEREADER_CTX_JNI_ID);
351
352 gImageReaderClassInfo.postEventFromNative = env->GetStaticMethodID(
353 clazz, "postEventFromNative", "(Ljava/lang/Object;)V");
354 LOG_ALWAYS_FATAL_IF(gImageReaderClassInfo.postEventFromNative == NULL,
355 "can't find android/graphics/ImageReader.postEventFromNative");
356
357 jclass planeClazz = env->FindClass("android/media/ImageReader$SurfaceImage$SurfacePlane");
358 LOG_ALWAYS_FATAL_IF(planeClazz == NULL, "Can not find SurfacePlane class");
359 // FindClass only gives a local reference of jclass object.
360 gSurfacePlaneClassInfo.clazz = (jclass) env->NewGlobalRef(planeClazz);
361 gSurfacePlaneClassInfo.ctor = env->GetMethodID(gSurfacePlaneClassInfo.clazz, "<init>",
362 "(Landroid/media/ImageReader$SurfaceImage;IILjava/nio/ByteBuffer;)V");
363 LOG_ALWAYS_FATAL_IF(gSurfacePlaneClassInfo.ctor == NULL,
364 "Can not find SurfacePlane constructor");
365
366 planeClazz = env->FindClass("android/media/ImageReader$ImagePlane");
367 LOG_ALWAYS_FATAL_IF(planeClazz == NULL, "Can not find ImagePlane class");
368 // FindClass only gives a local reference of jclass object.
369 gImagePlaneClassInfo.clazz = (jclass) env->NewGlobalRef(planeClazz);
370 gImagePlaneClassInfo.ctor = env->GetMethodID(gImagePlaneClassInfo.clazz, "<init>",
371 "(IILjava/nio/ByteBuffer;)V");
372 LOG_ALWAYS_FATAL_IF(gImagePlaneClassInfo.ctor == NULL,
373 "Can not find ImagePlane constructor");
374 }
375
ImageReader_init(JNIEnv * env,jobject thiz,jobject weakThiz,jint width,jint height,jint maxImages,jlong ndkUsage,jint nativeHalFormat,jint dataSpace)376 static void ImageReader_init(JNIEnv* env, jobject thiz, jobject weakThiz, jint width, jint height,
377 jint maxImages, jlong ndkUsage, jint nativeHalFormat, jint dataSpace) {
378 status_t res;
379
380 ALOGV("%s: width:%d, height: %d, nativeHalFormat: %d, maxImages:%d",
381 __FUNCTION__, width, height, nativeHalFormat, maxImages);
382
383 android_dataspace nativeDataspace = static_cast<android_dataspace>(dataSpace);
384
385 jclass clazz = env->GetObjectClass(thiz);
386 if (clazz == NULL) {
387 jniThrowRuntimeException(env, "Can't find android/graphics/ImageReader");
388 return;
389 }
390 sp<JNIImageReaderContext> ctx(new JNIImageReaderContext(env, weakThiz, clazz, maxImages));
391
392 String8 consumerName = String8::format("ImageReader-%dx%df%xm%d-%d-%d",
393 width, height, nativeHalFormat, maxImages, getpid(),
394 createProcessUniqueId());
395 uint64_t consumerUsage =
396 android_hardware_HardwareBuffer_convertToGrallocUsageBits(ndkUsage);
397
398 #if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
399 sp<BufferItemConsumer> bufferConsumer = new BufferItemConsumer(consumerUsage, maxImages,
400 /*controlledByApp*/ true);
401 sp<IGraphicBufferProducer> gbProducer =
402 bufferConsumer->getSurface()->getIGraphicBufferProducer();
403 #else
404 sp<IGraphicBufferProducer> gbProducer;
405 sp<IGraphicBufferConsumer> gbConsumer;
406 BufferQueue::createBufferQueue(&gbProducer, &gbConsumer);
407 sp<BufferItemConsumer> bufferConsumer;
408 bufferConsumer = new BufferItemConsumer(gbConsumer, consumerUsage, maxImages,
409 /*controlledByApp*/true);
410 #endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
411 if (bufferConsumer == nullptr) {
412 jniThrowExceptionFmt(env, "java/lang/RuntimeException",
413 "Failed to allocate native buffer consumer for hal format 0x%x and usage 0x%x",
414 nativeHalFormat, consumerUsage);
415 return;
416 }
417
418 if (consumerUsage & GRALLOC_USAGE_PROTECTED) {
419 #if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
420 bufferConsumer->setConsumerIsProtected(true);
421 #else
422 gbConsumer->setConsumerIsProtected(true);
423 #endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
424 }
425
426 ctx->setBufferConsumer(bufferConsumer);
427 bufferConsumer->setName(consumerName);
428
429 ctx->setProducer(gbProducer);
430 bufferConsumer->setFrameAvailableListener(ctx);
431 ImageReader_setNativeContext(env, thiz, ctx);
432 ctx->setBufferFormat(nativeHalFormat);
433 ctx->setBufferDataspace(nativeDataspace);
434 ctx->setBufferWidth(width);
435 ctx->setBufferHeight(height);
436
437 // Set the width/height/format/dataspace to the bufferConsumer.
438 res = bufferConsumer->setDefaultBufferSize(width, height);
439 if (res != OK) {
440 jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
441 "Failed to set buffer consumer default size (%dx%d) for Hal format 0x%x",
442 width, height, nativeHalFormat);
443 return;
444 }
445 res = bufferConsumer->setDefaultBufferFormat(nativeHalFormat);
446 if (res != OK) {
447 jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
448 "Failed to set buffer consumer default Halformat 0x%x", nativeHalFormat);
449 return;
450 }
451 res = bufferConsumer->setDefaultBufferDataSpace(nativeDataspace);
452 if (res != OK) {
453 jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
454 "Failed to set buffer consumer default dataSpace 0x%x", nativeDataspace);
455 return;
456 }
457 }
458
ImageReader_close(JNIEnv * env,jobject thiz)459 static void ImageReader_close(JNIEnv* env, jobject thiz)
460 {
461 ALOGV("%s:", __FUNCTION__);
462
463 JNIImageReaderContext* const ctx = ImageReader_getContext(env, thiz);
464 if (ctx == NULL) {
465 // ImageReader is already closed.
466 return;
467 }
468
469 BufferItemConsumer* consumer = NULL;
470 consumer = ImageReader_getBufferConsumer(env, thiz);
471
472 if (consumer != NULL) {
473 consumer->abandon();
474 consumer->setFrameAvailableListener(NULL);
475 }
476 ImageReader_setNativeContext(env, thiz, NULL);
477 }
478
Image_unlockIfLocked(JNIEnv * env,jobject image)479 static sp<Fence> Image_unlockIfLocked(JNIEnv* env, jobject image) {
480 ALOGV("%s", __FUNCTION__);
481 BufferItem* buffer = Image_getBufferItem(env, image);
482 if (buffer == NULL) {
483 jniThrowException(env, "java/lang/IllegalStateException",
484 "Image is not initialized");
485 return Fence::NO_FENCE;
486 }
487
488 // Is locked?
489 bool wasBufferLocked = false;
490 jobject planes = NULL;
491 if (!isFormatOpaque(buffer->mGraphicBuffer->getPixelFormat())) {
492 planes = env->GetObjectField(image, gSurfaceImageClassInfo.mPlanes);
493 }
494 wasBufferLocked = (planes != NULL);
495 if (wasBufferLocked) {
496 status_t res = OK;
497 int fenceFd = -1;
498 if (wasBufferLocked) {
499 res = buffer->mGraphicBuffer->unlockAsync(&fenceFd);
500 if (res != OK) {
501 jniThrowRuntimeException(env, "unlock buffer failed");
502 return Fence::NO_FENCE;
503 }
504 }
505 sp<Fence> releaseFence = new Fence(fenceFd);
506 return releaseFence;
507 ALOGV("Successfully unlocked the image");
508 }
509 return Fence::NO_FENCE;
510 }
511
ImageReader_imageRelease(JNIEnv * env,jobject thiz,jobject image)512 static void ImageReader_imageRelease(JNIEnv* env, jobject thiz, jobject image)
513 {
514 ALOGV("%s:", __FUNCTION__);
515 JNIImageReaderContext* ctx = ImageReader_getContext(env, thiz);
516 if (ctx == NULL) {
517 ALOGW("ImageReader#close called before Image#close, consider calling Image#close first");
518 return;
519 }
520
521 BufferItemConsumer* bufferConsumer = ctx->getBufferConsumer();
522 BufferItem* buffer = Image_getBufferItem(env, image);
523 if (buffer == nullptr) {
524 // Release an already closed image is harmless.
525 return;
526 }
527
528 sp<Fence> releaseFence = Image_unlockIfLocked(env, image);
529 bufferConsumer->releaseBuffer(*buffer, releaseFence);
530 Image_setBufferItem(env, image, NULL);
531 ctx->returnBufferItem(buffer);
532 ALOGV("%s: Image (format: 0x%x) has been released", __FUNCTION__, ctx->getBufferFormat());
533 }
534
ImageReader_imageSetup(JNIEnv * env,jobject thiz,jobject image)535 static jint ImageReader_imageSetup(JNIEnv* env, jobject thiz, jobject image) {
536 ALOGV("%s:", __FUNCTION__);
537 JNIImageReaderContext* ctx = ImageReader_getContext(env, thiz);
538 if (ctx == NULL) {
539 jniThrowException(env, "java/lang/IllegalStateException",
540 "ImageReader is not initialized or was already closed");
541 return -1;
542 }
543
544 BufferItemConsumer* bufferConsumer = ctx->getBufferConsumer();
545 BufferItem* buffer = ctx->getBufferItem();
546 if (buffer == NULL) {
547 ALOGW("Unable to acquire a buffer item, very likely client tried to acquire more than"
548 " maxImages buffers");
549 return ACQUIRE_MAX_IMAGES;
550 }
551
552 status_t res = bufferConsumer->acquireBuffer(buffer, 0);
553 if (res != OK) {
554 ctx->returnBufferItem(buffer);
555 if (res != BufferQueue::NO_BUFFER_AVAILABLE) {
556 if (res == INVALID_OPERATION) {
557 // Max number of images were already acquired.
558 ALOGE("%s: Max number of buffers allowed are already acquired : %s (%d)",
559 __FUNCTION__, strerror(-res), res);
560 return ACQUIRE_MAX_IMAGES;
561 } else {
562 ALOGE("%s: Acquire image failed with some unknown error: %s (%d)",
563 __FUNCTION__, strerror(-res), res);
564 jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
565 "Unknown error (%d) when we tried to acquire an image.",
566 res);
567 return ACQUIRE_NO_BUFFERS;
568 }
569 }
570 // This isn't really an error case, as the application may acquire buffer at any time.
571 return ACQUIRE_NO_BUFFERS;
572 }
573
574 // Add some extra checks for non-opaque formats.
575 if (!isFormatOpaque(ctx->getBufferFormat())) {
576 // Check if the left-top corner of the crop rect is origin, we currently assume this point is
577 // zero, will revisit this once this assumption turns out problematic.
578 Point lt = buffer->mCrop.leftTop();
579 if (lt.x != 0 || lt.y != 0) {
580 jniThrowExceptionFmt(env, "java/lang/UnsupportedOperationException",
581 "crop left top corner [%d, %d] need to be at origin", lt.x, lt.y);
582 return -1;
583 }
584
585 // Check if the producer buffer configurations match what ImageReader configured.
586 int outputWidth = getBufferWidth(buffer);
587 int outputHeight = getBufferHeight(buffer);
588
589 int imgReaderHalFmt = ctx->getBufferFormat();
590 int imageReaderWidth = ctx->getBufferWidth();
591 int imageReaderHeight = ctx->getBufferHeight();
592 int bufferFormat = buffer->mGraphicBuffer->getPixelFormat();
593 if ((bufferFormat != HAL_PIXEL_FORMAT_BLOB) && (imgReaderHalFmt != HAL_PIXEL_FORMAT_BLOB) &&
594 (imageReaderWidth != outputWidth || imageReaderHeight != outputHeight)) {
595 ALOGV("%s: Producer buffer size: %dx%d, doesn't match ImageReader configured size: %dx%d",
596 __FUNCTION__, outputWidth, outputHeight, imageReaderWidth, imageReaderHeight);
597 }
598 if (imgReaderHalFmt != bufferFormat) {
599 if (imgReaderHalFmt == HAL_PIXEL_FORMAT_YCbCr_420_888 &&
600 isPossiblyYUV(bufferFormat)) {
601 // Treat formats that are compatible with flexible YUV
602 // (HAL_PIXEL_FORMAT_YCbCr_420_888) as HAL_PIXEL_FORMAT_YCbCr_420_888.
603 ALOGV("%s: Treat buffer format to 0x%x as HAL_PIXEL_FORMAT_YCbCr_420_888",
604 __FUNCTION__, bufferFormat);
605 } else if (imgReaderHalFmt == HAL_PIXEL_FORMAT_YCBCR_P010 &&
606 isPossibly10BitYUV(bufferFormat)) {
607 // Treat formats that are compatible with flexible 10-bit YUV
608 // (HAL_PIXEL_FORMAT_YCBCR_P010) as HAL_PIXEL_FORMAT_YCBCR_P010.
609 ALOGV("%s: Treat buffer format to 0x%x as HAL_PIXEL_FORMAT_YCBCR_P010",
610 __FUNCTION__, bufferFormat);
611 } else if (imgReaderHalFmt == HAL_PIXEL_FORMAT_BLOB &&
612 bufferFormat == HAL_PIXEL_FORMAT_RGBA_8888) {
613 // Using HAL_PIXEL_FORMAT_RGBA_8888 Gralloc buffers containing JPEGs to get around
614 // SW write limitations for (b/17379185).
615 ALOGV("%s: Receiving JPEG in HAL_PIXEL_FORMAT_RGBA_8888 buffer.", __FUNCTION__);
616 } else {
617 // Return the buffer to the queue. No need to provide fence, as this buffer wasn't
618 // used anywhere yet.
619 bufferConsumer->releaseBuffer(*buffer);
620 ctx->returnBufferItem(buffer);
621
622 // Throw exception
623 ALOGE("Producer output buffer format: 0x%x, ImageReader configured format: 0x%x",
624 bufferFormat, ctx->getBufferFormat());
625 String8 msg;
626 msg.appendFormat("The producer output buffer format 0x%x doesn't "
627 "match the ImageReader's configured buffer format 0x%x.",
628 bufferFormat, ctx->getBufferFormat());
629 jniThrowException(env, "java/lang/UnsupportedOperationException",
630 msg.c_str());
631 return -1;
632 }
633 }
634
635 }
636
637 // Set SurfaceImage instance member variables
638 Image_setBufferItem(env, image, buffer);
639 env->SetLongField(image, gSurfaceImageClassInfo.mTimestamp,
640 static_cast<jlong>(buffer->mTimestamp));
641 env->SetIntField(image, gSurfaceImageClassInfo.mDataSpace,
642 static_cast<jint>(buffer->mDataSpace));
643 auto transform = buffer->mTransform;
644 if (buffer->mTransformToDisplayInverse) {
645 transform |= NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY;
646 }
647 env->SetIntField(image, gSurfaceImageClassInfo.mTransform,
648 static_cast<jint>(transform));
649 env->SetIntField(image, gSurfaceImageClassInfo.mScalingMode,
650 static_cast<jint>(buffer->mScalingMode));
651
652 return ACQUIRE_SUCCESS;
653 }
654
ImageReader_detachImage(JNIEnv * env,jobject thiz,jobject image,jboolean throwISEOnly)655 static jint ImageReader_detachImage(JNIEnv* env, jobject thiz, jobject image,
656 jboolean throwISEOnly) {
657 ALOGV("%s:", __FUNCTION__);
658 JNIImageReaderContext* ctx = ImageReader_getContext(env, thiz);
659 if (ctx == NULL) {
660 jniThrowException(env, "java/lang/IllegalStateException", "ImageReader was already closed");
661 return -1;
662 }
663
664 BufferItemConsumer* bufferConsumer = ctx->getBufferConsumer();
665 BufferItem* buffer = Image_getBufferItem(env, image);
666 if (!buffer) {
667 ALOGE(
668 "Image already released and can not be detached from ImageReader!!!");
669 jniThrowException(env, "java/lang/IllegalStateException",
670 "Image detach from ImageReader failed: buffer was already released");
671 return -1;
672 }
673
674 status_t res = OK;
675 Image_unlockIfLocked(env, image);
676 res = bufferConsumer->detachBuffer(buffer->mSlot);
677 if (res != OK) {
678 ALOGE("Image detach failed: %s (%d)!!!", strerror(-res), res);
679 if ((bool) throwISEOnly) {
680 jniThrowException(env, "java/lang/IllegalStateException",
681 "nativeDetachImage failed for image!!!");
682 } else {
683 jniThrowRuntimeException(env, "nativeDetachImage failed for image!!!");
684 }
685 return res;
686 }
687 return OK;
688 }
689
ImageReader_discardFreeBuffers(JNIEnv * env,jobject thiz)690 static void ImageReader_discardFreeBuffers(JNIEnv* env, jobject thiz) {
691 ALOGV("%s:", __FUNCTION__);
692 JNIImageReaderContext* ctx = ImageReader_getContext(env, thiz);
693 if (ctx == NULL) {
694 jniThrowException(env, "java/lang/IllegalStateException", "ImageReader was already closed");
695 return;
696 }
697
698 BufferItemConsumer* bufferConsumer = ctx->getBufferConsumer();
699 status_t res = bufferConsumer->discardFreeBuffers();
700 if (res != OK) {
701 ALOGE("Buffer discard failed: %s (%d)", strerror(-res), res);
702 jniThrowRuntimeException(env,
703 "nativeDicardFreebuffers failed");
704 }
705 }
706
ImageReader_getSurface(JNIEnv * env,jobject thiz)707 static jobject ImageReader_getSurface(JNIEnv* env, jobject thiz)
708 {
709 ALOGV("%s: ", __FUNCTION__);
710
711 IGraphicBufferProducer* gbp = ImageReader_getProducer(env, thiz);
712 if (gbp == NULL) {
713 jniThrowRuntimeException(env, "Buffer consumer is uninitialized");
714 return NULL;
715 }
716
717 // Wrap the IGBP in a Java-language Surface.
718 return android_view_Surface_createFromIGraphicBufferProducer(env, gbp);
719 }
720
Image_getLockedImage(JNIEnv * env,jobject thiz,LockedImage * image,uint64_t ndkReaderUsage)721 static void Image_getLockedImage(JNIEnv* env, jobject thiz, LockedImage *image,
722 uint64_t ndkReaderUsage) {
723 ALOGV("%s", __FUNCTION__);
724 BufferItem* buffer = Image_getBufferItem(env, thiz);
725 if (buffer == NULL) {
726 jniThrowException(env, "java/lang/IllegalStateException",
727 "Image is not initialized");
728 return;
729 }
730
731 uint32_t lockUsage;
732 if ((ndkReaderUsage & (AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY
733 | AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN)) != 0) {
734 lockUsage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN;
735 } else {
736 lockUsage = GRALLOC_USAGE_SW_READ_OFTEN;
737 }
738
739 status_t res = lockImageFromBuffer(buffer, lockUsage, buffer->mFence->dup(), image);
740
741 if (res != OK) {
742 jniThrowExceptionFmt(env, "java/lang/RuntimeException",
743 "lock buffer failed for format 0x%x",
744 buffer->mGraphicBuffer->getPixelFormat());
745 return;
746 }
747
748 // Carry over some fields from BufferItem.
749 image->crop = buffer->mCrop;
750 image->transform = buffer->mTransform;
751 image->scalingMode = buffer->mScalingMode;
752 image->timestamp = buffer->mTimestamp;
753 image->dataSpace = buffer->mDataSpace;
754 image->frameNumber = buffer->mFrameNumber;
755
756 ALOGV("%s: Successfully locked the image", __FUNCTION__);
757 // crop, transform, scalingMode, timestamp, and frameNumber should be set by producer,
758 // and we don't set them here.
759 }
760
Image_getLockedImageInfo(JNIEnv * env,LockedImage * buffer,int idx,int32_t writerFormat,uint8_t ** base,uint32_t * size,int * pixelStride,int * rowStride)761 static bool Image_getLockedImageInfo(JNIEnv* env, LockedImage* buffer, int idx,
762 int32_t writerFormat, uint8_t **base, uint32_t *size, int *pixelStride, int *rowStride) {
763 ALOGV("%s", __FUNCTION__);
764
765 status_t res = getLockedImageInfo(buffer, idx, writerFormat, base, size,
766 pixelStride, rowStride);
767 if (res != OK) {
768 jniThrowExceptionFmt(env, "java/lang/UnsupportedOperationException",
769 "Pixel format: 0x%x is unsupported", buffer->flexFormat);
770 return false;
771 }
772 return true;
773 }
774
ImageReader_unlockGraphicBuffer(JNIEnv * env,jobject,jobject buffer)775 static void ImageReader_unlockGraphicBuffer(JNIEnv* env, jobject /*thiz*/,
776 jobject buffer) {
777 sp<GraphicBuffer> graphicBuffer =
778 android_graphics_GraphicBuffer_getNativeGraphicsBuffer(env, buffer);
779 if (graphicBuffer.get() == NULL) {
780 jniThrowRuntimeException(env, "Invalid graphic buffer!");
781 return;
782 }
783
784 status_t res = graphicBuffer->unlock();
785 if (res != OK) {
786 jniThrowRuntimeException(env, "unlock buffer failed");
787 }
788 }
789
ImageReader_createImagePlanes(JNIEnv * env,jobject,int numPlanes,jobject buffer,int fenceFd,int format,int cropLeft,int cropTop,int cropRight,int cropBottom)790 static jobjectArray ImageReader_createImagePlanes(JNIEnv* env, jobject /*thiz*/,
791 int numPlanes, jobject buffer, int fenceFd, int format, int cropLeft, int cropTop,
792 int cropRight, int cropBottom)
793 {
794 ALOGV("%s: create ImagePlane array with size %d", __FUNCTION__, numPlanes);
795 int rowStride = 0;
796 int pixelStride = 0;
797 uint8_t *pData = NULL;
798 uint32_t dataSize = 0;
799 jobject byteBuffer = NULL;
800
801 PublicFormat publicReaderFormat = static_cast<PublicFormat>(format);
802 int halReaderFormat = mapPublicFormatToHalFormat(publicReaderFormat);
803
804 if (isFormatOpaque(halReaderFormat) && numPlanes > 0) {
805 String8 msg;
806 msg.appendFormat("Format 0x%x is opaque, thus not writable, the number of planes (%d)"
807 " must be 0", halReaderFormat, numPlanes);
808 jniThrowException(env, "java/lang/IllegalArgumentException", msg.c_str());
809 return NULL;
810 }
811
812 jobjectArray imagePlanes = env->NewObjectArray(numPlanes, gImagePlaneClassInfo.clazz,
813 /*initial_element*/NULL);
814 if (imagePlanes == NULL) {
815 jniThrowRuntimeException(env, "Failed to create ImagePlane arrays,"
816 " probably out of memory");
817 return NULL;
818 }
819 if (isFormatOpaque(halReaderFormat)) {
820 // Return 0 element surface array.
821 return imagePlanes;
822 }
823
824 LockedImage lockedImg = LockedImage();
825 uint32_t lockUsage = GRALLOC_USAGE_SW_READ_OFTEN;
826
827 Rect cropRect(cropLeft, cropTop, cropRight, cropBottom);
828 status_t res = lockImageFromBuffer(
829 android_graphics_GraphicBuffer_getNativeGraphicsBuffer(env, buffer), lockUsage,
830 cropRect, fenceFd, &lockedImg);
831 if (res != OK) {
832 jniThrowExceptionFmt(env, "java/lang/RuntimeException",
833 "lock buffer failed for format 0x%x", format);
834 return nullptr;
835 }
836
837 // Create all ImagePlanes
838 for (int i = 0; i < numPlanes; i++) {
839 if (!Image_getLockedImageInfo(env, &lockedImg, i, halReaderFormat,
840 &pData, &dataSize, &pixelStride, &rowStride)) {
841 return NULL;
842 }
843 byteBuffer = env->NewDirectByteBuffer(pData, dataSize);
844 if ((byteBuffer == NULL) && (env->ExceptionCheck() == false)) {
845 jniThrowException(env, "java/lang/IllegalStateException",
846 "Failed to allocate ByteBuffer");
847 return NULL;
848 }
849
850 // Finally, create this ImagePlane.
851 jobject imagePlane = env->NewObject(gImagePlaneClassInfo.clazz,
852 gImagePlaneClassInfo.ctor, rowStride, pixelStride, byteBuffer);
853 env->SetObjectArrayElement(imagePlanes, i, imagePlane);
854 }
855
856 return imagePlanes;
857 }
858
Image_createSurfacePlanes(JNIEnv * env,jobject thiz,int numPlanes,int halReaderFormat,uint64_t ndkReaderUsage)859 static jobjectArray Image_createSurfacePlanes(JNIEnv* env, jobject thiz,
860 int numPlanes, int halReaderFormat, uint64_t ndkReaderUsage)
861 {
862 ALOGV("%s: create SurfacePlane array with size %d", __FUNCTION__, numPlanes);
863 int rowStride = 0;
864 int pixelStride = 0;
865 uint8_t *pData = NULL;
866 uint32_t dataSize = 0;
867 jobject byteBuffer = NULL;
868
869 if (isFormatOpaque(halReaderFormat) && numPlanes > 0) {
870 String8 msg;
871 msg.appendFormat("Format 0x%x is opaque, thus not writable, the number of planes (%d)"
872 " must be 0", halReaderFormat, numPlanes);
873 jniThrowException(env, "java/lang/IllegalArgumentException", msg.c_str());
874 return NULL;
875 }
876
877 jobjectArray surfacePlanes = env->NewObjectArray(numPlanes, gSurfacePlaneClassInfo.clazz,
878 /*initial_element*/NULL);
879 if (surfacePlanes == NULL) {
880 jniThrowRuntimeException(env, "Failed to create SurfacePlane arrays,"
881 " probably out of memory");
882 return NULL;
883 }
884 if (isFormatOpaque(halReaderFormat)) {
885 // Return 0 element surface array.
886 return surfacePlanes;
887 }
888
889 LockedImage lockedImg = LockedImage();
890 Image_getLockedImage(env, thiz, &lockedImg, ndkReaderUsage);
891 if (env->ExceptionCheck()) {
892 return NULL;
893 }
894 // Create all SurfacePlanes
895 for (int i = 0; i < numPlanes; i++) {
896 if (!Image_getLockedImageInfo(env, &lockedImg, i, halReaderFormat,
897 &pData, &dataSize, &pixelStride, &rowStride)) {
898 return NULL;
899 }
900 byteBuffer = env->NewDirectByteBuffer(pData, dataSize);
901 if ((byteBuffer == NULL) && (env->ExceptionCheck() == false)) {
902 jniThrowException(env, "java/lang/IllegalStateException",
903 "Failed to allocate ByteBuffer");
904 return NULL;
905 }
906
907 // Finally, create this SurfacePlane.
908 jobject surfacePlane = env->NewObject(gSurfacePlaneClassInfo.clazz,
909 gSurfacePlaneClassInfo.ctor, thiz, rowStride, pixelStride, byteBuffer);
910 env->SetObjectArrayElement(surfacePlanes, i, surfacePlane);
911 }
912
913 return surfacePlanes;
914 }
915
Image_getWidth(JNIEnv * env,jobject thiz)916 static jint Image_getWidth(JNIEnv* env, jobject thiz)
917 {
918 BufferItem* buffer = Image_getBufferItem(env, thiz);
919 return getBufferWidth(buffer);
920 }
921
Image_getHeight(JNIEnv * env,jobject thiz)922 static jint Image_getHeight(JNIEnv* env, jobject thiz)
923 {
924 BufferItem* buffer = Image_getBufferItem(env, thiz);
925 return getBufferHeight(buffer);
926 }
927
Image_getFenceFd(JNIEnv * env,jobject thiz)928 static jint Image_getFenceFd(JNIEnv* env, jobject thiz)
929 {
930 BufferItem* buffer = Image_getBufferItem(env, thiz);
931 if ((buffer != NULL) && (buffer->mFence.get() != NULL)){
932 return buffer->mFence->get();
933 }
934
935 return -1;
936 }
937
Image_getFormat(JNIEnv * env,jobject thiz,jint readerFormat)938 static jint Image_getFormat(JNIEnv* env, jobject thiz, jint readerFormat)
939 {
940 if (isFormatOpaque(readerFormat)) {
941 // Assuming opaque reader produce opaque images.
942 return static_cast<jint>(PublicFormat::PRIVATE);
943 } else {
944 BufferItem* buffer = Image_getBufferItem(env, thiz);
945 if (buffer == nullptr) {
946 jniThrowException(env, "java/lang/IllegalStateException",
947 "Image is not initialized");
948 return -1;
949 }
950 int readerHalFormat = mapPublicFormatToHalFormat(static_cast<PublicFormat>(readerFormat));
951 int32_t fmt = applyFormatOverrides(
952 buffer->mGraphicBuffer->getPixelFormat(), readerHalFormat);
953 // Override the image format to HAL_PIXEL_FORMAT_YCbCr_420_888 if the actual format is
954 // NV21 or YV12. This could only happen when the Gralloc HAL version is v0.1 thus doesn't
955 // support lockycbcr(), the CpuConsumer need to use the lock() method in the
956 // lockNextBuffer() call. For Gralloc HAL v0.2 or newer, this format should already be
957 // overridden to HAL_PIXEL_FORMAT_YCbCr_420_888 for the flexible YUV compatible formats.
958 if (isPossiblyYUV(fmt)) {
959 fmt = HAL_PIXEL_FORMAT_YCbCr_420_888;
960 }
961 PublicFormat publicFmt = mapHalFormatDataspaceToPublicFormat(fmt, buffer->mDataSpace);
962 return static_cast<jint>(publicFmt);
963 }
964 }
965
Image_getHardwareBuffer(JNIEnv * env,jobject thiz)966 static jobject Image_getHardwareBuffer(JNIEnv* env, jobject thiz) {
967 BufferItem* buffer = Image_getBufferItem(env, thiz);
968 if (buffer == nullptr) {
969 jniThrowException(env, "java/lang/IllegalStateException",
970 "Image is not initialized");
971 return NULL;
972 }
973 AHardwareBuffer* b = AHardwareBuffer_from_GraphicBuffer(buffer->mGraphicBuffer.get());
974 // don't user the public AHardwareBuffer_toHardwareBuffer() because this would force us
975 // to link against libandroid.so
976 return android_hardware_HardwareBuffer_createFromAHardwareBuffer(env, b);
977 }
978
979 } // extern "C"
980
981 // ----------------------------------------------------------------------------
982
983 static const JNINativeMethod gImageReaderMethods[] = {
984 {"nativeClassInit", "()V", (void*)ImageReader_classInit },
985 {"nativeInit", "(Ljava/lang/Object;IIIJII)V", (void*)ImageReader_init },
986 {"nativeClose", "()V", (void*)ImageReader_close },
987 {"nativeReleaseImage", "(Landroid/media/Image;)V", (void*)ImageReader_imageRelease },
988 {"nativeImageSetup", "(Landroid/media/Image;)I", (void*)ImageReader_imageSetup },
989 {"nativeGetSurface", "()Landroid/view/Surface;", (void*)ImageReader_getSurface },
990 {"nativeDetachImage", "(Landroid/media/Image;Z)I", (void*)ImageReader_detachImage },
991 {"nativeCreateImagePlanes",
992 "(ILandroid/graphics/GraphicBuffer;IIIIII)[Landroid/media/ImageReader$ImagePlane;",
993 (void*)ImageReader_createImagePlanes },
994 {"nativeUnlockGraphicBuffer",
995 "(Landroid/graphics/GraphicBuffer;)V", (void*)ImageReader_unlockGraphicBuffer },
996 {"nativeDiscardFreeBuffers", "()V", (void*)ImageReader_discardFreeBuffers }
997 };
998
999 static const JNINativeMethod gImageMethods[] = {
1000 {"nativeCreatePlanes", "(IIJ)[Landroid/media/ImageReader$SurfaceImage$SurfacePlane;",
1001 (void*)Image_createSurfacePlanes },
1002 {"nativeGetWidth", "()I", (void*)Image_getWidth },
1003 {"nativeGetHeight", "()I", (void*)Image_getHeight },
1004 {"nativeGetFormat", "(I)I", (void*)Image_getFormat },
1005 {"nativeGetFenceFd", "()I", (void*)Image_getFenceFd },
1006 {"nativeGetHardwareBuffer", "()Landroid/hardware/HardwareBuffer;",
1007 (void*)Image_getHardwareBuffer },
1008 };
1009
register_android_media_ImageReader(JNIEnv * env)1010 int register_android_media_ImageReader(JNIEnv *env) {
1011
1012 int ret1 = AndroidRuntime::registerNativeMethods(env,
1013 "android/media/ImageReader", gImageReaderMethods, NELEM(gImageReaderMethods));
1014
1015 int ret2 = AndroidRuntime::registerNativeMethods(env,
1016 "android/media/ImageReader$SurfaceImage", gImageMethods, NELEM(gImageMethods));
1017
1018 return (ret1 || ret2);
1019 }
1020