blob: f7d4825844ccf7e932b60e1a24ac7c8ac0d94628 [file] [log] [blame]
Zhijun He212e78d2013-06-07 11:36:23 -07001/*
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"
Zhijun He0ab41622016-02-25 16:00:38 -080019#include "android_media_Utils.h"
Mathias Agopiandf7707c2017-02-28 17:43:39 -080020#include <cutils/atomic.h>
Zhijun He212e78d2013-06-07 11:36:23 -070021#include <utils/Log.h>
22#include <utils/misc.h>
23#include <utils/List.h>
Jeff Brownef961212013-08-05 20:39:29 -070024#include <utils/String8.h>
Zhijun He212e78d2013-06-07 11:36:23 -070025
26#include <cstdio>
27
Zhijun Hece9d6f92015-03-29 16:33:59 -070028#include <gui/BufferItemConsumer.h>
Zhijun He212e78d2013-06-07 11:36:23 -070029#include <gui/Surface.h>
30
31#include <android_runtime/AndroidRuntime.h>
32#include <android_runtime/android_view_Surface.h>
Emilian Peev9c778e12020-10-29 17:36:22 -070033#include <android_runtime/android_graphics_GraphicBuffer.h>
Zhijun He916d8ac2017-03-22 17:33:47 -070034#include <android_runtime/android_hardware_HardwareBuffer.h>
35#include <grallocusage/GrallocUsageConversion.h>
Zhijun He212e78d2013-06-07 11:36:23 -070036
Mathias Agopian3e88ed82018-02-20 18:32:22 -080037#include <private/android/AHardwareBufferHelpers.h>
38
Zhijun He212e78d2013-06-07 11:36:23 -070039#include <jni.h>
Steven Moreland2279b252017-07-19 09:50:45 -070040#include <nativehelper/JNIHelp.h>
Zhijun He212e78d2013-06-07 11:36:23 -070041
Igor Murashkin5096def2014-06-24 10:49:11 -070042#include <stdint.h>
43#include <inttypes.h>
Mathias Agopian3e88ed82018-02-20 18:32:22 -080044#include <android/hardware_buffer_jni.h>
Igor Murashkin5096def2014-06-24 10:49:11 -070045
Emilian Peev9c778e12020-10-29 17:36:22 -070046#include <ui/Rect.h>
47
Zhijun He212e78d2013-06-07 11:36:23 -070048#define ANDROID_MEDIA_IMAGEREADER_CTX_JNI_ID "mNativeContext"
Zhijun Hece9d6f92015-03-29 16:33:59 -070049#define ANDROID_MEDIA_SURFACEIMAGE_BUFFER_JNI_ID "mNativeBuffer"
Zhijun He212e78d2013-06-07 11:36:23 -070050#define ANDROID_MEDIA_SURFACEIMAGE_TS_JNI_ID "mTimestamp"
Sally Qiac97f992021-10-11 17:39:54 -070051#define ANDROID_MEDIA_SURFACEIMAGE_DS_JNI_ID "mDataSpace"
Emilian Peev450a5ff2018-03-19 16:05:10 +000052#define ANDROID_MEDIA_SURFACEIMAGE_TF_JNI_ID "mTransform"
Emilian Peev750aec62018-04-06 12:55:00 +010053#define ANDROID_MEDIA_SURFACEIMAGE_SM_JNI_ID "mScalingMode"
Zhijun He212e78d2013-06-07 11:36:23 -070054
Zhijun He916d8ac2017-03-22 17:33:47 -070055#define CONSUMER_BUFFER_USAGE_UNKNOWN 0;
Zhijun He212e78d2013-06-07 11:36:23 -070056// ----------------------------------------------------------------------------
57
58using namespace android;
59
Zhijun He212e78d2013-06-07 11:36:23 -070060
Igor Murashkine3351f12013-09-13 13:08:04 -070061enum {
62 ACQUIRE_SUCCESS = 0,
63 ACQUIRE_NO_BUFFERS = 1,
64 ACQUIRE_MAX_IMAGES = 2,
65};
66
Jeff Brownef961212013-08-05 20:39:29 -070067static struct {
68 jfieldID mNativeContext;
69 jmethodID postEventFromNative;
70} gImageReaderClassInfo;
Zhijun He212e78d2013-06-07 11:36:23 -070071
Jeff Brownef961212013-08-05 20:39:29 -070072static struct {
Zhijun Hece9d6f92015-03-29 16:33:59 -070073 jfieldID mNativeBuffer;
Jeff Brownef961212013-08-05 20:39:29 -070074 jfieldID mTimestamp;
Sally Qiac97f992021-10-11 17:39:54 -070075 jfieldID mDataSpace;
Emilian Peev450a5ff2018-03-19 16:05:10 +000076 jfieldID mTransform;
Emilian Peev750aec62018-04-06 12:55:00 +010077 jfieldID mScalingMode;
Zhijun He0ab41622016-02-25 16:00:38 -080078 jfieldID mPlanes;
Jeff Brownef961212013-08-05 20:39:29 -070079} gSurfaceImageClassInfo;
80
81static struct {
Zhijun He212e78d2013-06-07 11:36:23 -070082 jclass clazz;
83 jmethodID ctor;
Jeff Brownef961212013-08-05 20:39:29 -070084} gSurfacePlaneClassInfo;
Zhijun He212e78d2013-06-07 11:36:23 -070085
Emilian Peev9c778e12020-10-29 17:36:22 -070086static struct {
87 jclass clazz;
88 jmethodID ctor;
89} gImagePlaneClassInfo;
90
Eino-Ville Talvalaef9db7d2015-06-09 14:15:15 -070091// Get an ID that's unique within this process.
92static int32_t createProcessUniqueId() {
93 static volatile int32_t globalCounter = 0;
94 return android_atomic_inc(&globalCounter);
95}
96
Zhijun He212e78d2013-06-07 11:36:23 -070097// ----------------------------------------------------------------------------
98
Zhijun Hece9d6f92015-03-29 16:33:59 -070099class JNIImageReaderContext : public ConsumerBase::FrameAvailableListener
Zhijun He212e78d2013-06-07 11:36:23 -0700100{
101public:
102 JNIImageReaderContext(JNIEnv* env, jobject weakThiz, jclass clazz, int maxImages);
103
104 virtual ~JNIImageReaderContext();
105
Dan Stoza2c34b5e2014-11-04 11:36:33 -0800106 virtual void onFrameAvailable(const BufferItem& item);
Zhijun He212e78d2013-06-07 11:36:23 -0700107
Zhijun He0ab41622016-02-25 16:00:38 -0800108 BufferItem* getBufferItem();
109 void returnBufferItem(BufferItem* buffer);
Zhijun He212e78d2013-06-07 11:36:23 -0700110
Zhijun Hece9d6f92015-03-29 16:33:59 -0700111
Zhijun He0ab41622016-02-25 16:00:38 -0800112 void setBufferConsumer(const sp<BufferItemConsumer>& consumer) { mConsumer = consumer; }
113 BufferItemConsumer* getBufferConsumer() { return mConsumer.get(); }
Zhijun Hece9d6f92015-03-29 16:33:59 -0700114
Dan Stoza5b3c7c12014-03-12 16:44:45 -0700115 void setProducer(const sp<IGraphicBufferProducer>& producer) { mProducer = producer; }
116 IGraphicBufferProducer* getProducer() { return mProducer.get(); }
Zhijun He212e78d2013-06-07 11:36:23 -0700117
118 void setBufferFormat(int format) { mFormat = format; }
119 int getBufferFormat() { return mFormat; }
120
Eino-Ville Talvala805f3c92015-02-26 10:57:55 -0800121 void setBufferDataspace(android_dataspace dataSpace) { mDataSpace = dataSpace; }
122 android_dataspace getBufferDataspace() { return mDataSpace; }
123
Zhijun He212e78d2013-06-07 11:36:23 -0700124 void setBufferWidth(int width) { mWidth = width; }
125 int getBufferWidth() { return mWidth; }
126
127 void setBufferHeight(int height) { mHeight = height; }
128 int getBufferHeight() { return mHeight; }
129
130private:
131 static JNIEnv* getJNIEnv(bool* needsDetach);
132 static void detachJNI();
133
Zhijun He0ab41622016-02-25 16:00:38 -0800134 List<BufferItem*> mBuffers;
135 sp<BufferItemConsumer> mConsumer;
Dan Stoza5b3c7c12014-03-12 16:44:45 -0700136 sp<IGraphicBufferProducer> mProducer;
Zhijun He212e78d2013-06-07 11:36:23 -0700137 jobject mWeakThiz;
138 jclass mClazz;
139 int mFormat;
Eino-Ville Talvala805f3c92015-02-26 10:57:55 -0800140 android_dataspace mDataSpace;
Zhijun He212e78d2013-06-07 11:36:23 -0700141 int mWidth;
142 int mHeight;
143};
144
145JNIImageReaderContext::JNIImageReaderContext(JNIEnv* env,
146 jobject weakThiz, jclass clazz, int maxImages) :
147 mWeakThiz(env->NewGlobalRef(weakThiz)),
Zhijun He0ab41622016-02-25 16:00:38 -0800148 mClazz((jclass)env->NewGlobalRef(clazz)),
149 mFormat(0),
150 mDataSpace(HAL_DATASPACE_UNKNOWN),
151 mWidth(-1),
152 mHeight(-1) {
Zhijun He212e78d2013-06-07 11:36:23 -0700153 for (int i = 0; i < maxImages; i++) {
Zhijun He0ab41622016-02-25 16:00:38 -0800154 BufferItem* buffer = new BufferItem;
Zhijun He212e78d2013-06-07 11:36:23 -0700155 mBuffers.push_back(buffer);
156 }
157}
158
159JNIEnv* JNIImageReaderContext::getJNIEnv(bool* needsDetach) {
160 LOG_ALWAYS_FATAL_IF(needsDetach == NULL, "needsDetach is null!!!");
161 *needsDetach = false;
162 JNIEnv* env = AndroidRuntime::getJNIEnv();
163 if (env == NULL) {
164 JavaVMAttachArgs args = {JNI_VERSION_1_4, NULL, NULL};
165 JavaVM* vm = AndroidRuntime::getJavaVM();
166 int result = vm->AttachCurrentThread(&env, (void*) &args);
167 if (result != JNI_OK) {
168 ALOGE("thread attach failed: %#x", result);
169 return NULL;
170 }
171 *needsDetach = true;
172 }
173 return env;
174}
175
176void JNIImageReaderContext::detachJNI() {
177 JavaVM* vm = AndroidRuntime::getJavaVM();
178 int result = vm->DetachCurrentThread();
179 if (result != JNI_OK) {
180 ALOGE("thread detach failed: %#x", result);
181 }
182}
183
Zhijun He0ab41622016-02-25 16:00:38 -0800184BufferItem* JNIImageReaderContext::getBufferItem() {
Zhijun He212e78d2013-06-07 11:36:23 -0700185 if (mBuffers.empty()) {
186 return NULL;
187 }
Zhijun He0ab41622016-02-25 16:00:38 -0800188 // Return a BufferItem pointer and remove it from the list
189 List<BufferItem*>::iterator it = mBuffers.begin();
190 BufferItem* buffer = *it;
Zhijun He212e78d2013-06-07 11:36:23 -0700191 mBuffers.erase(it);
192 return buffer;
193}
194
Zhijun He0ab41622016-02-25 16:00:38 -0800195void JNIImageReaderContext::returnBufferItem(BufferItem* buffer) {
Eino-Ville Talvala0af943552017-06-13 12:43:19 -0700196 buffer->mGraphicBuffer = nullptr;
Zhijun He212e78d2013-06-07 11:36:23 -0700197 mBuffers.push_back(buffer);
198}
199
200JNIImageReaderContext::~JNIImageReaderContext() {
201 bool needsDetach = false;
202 JNIEnv* env = getJNIEnv(&needsDetach);
203 if (env != NULL) {
204 env->DeleteGlobalRef(mWeakThiz);
205 env->DeleteGlobalRef(mClazz);
206 } else {
207 ALOGW("leaking JNI object references");
208 }
209 if (needsDetach) {
210 detachJNI();
211 }
212
Zhijun He0ab41622016-02-25 16:00:38 -0800213 // Delete buffer items.
214 for (List<BufferItem *>::iterator it = mBuffers.begin();
Zhijun He212e78d2013-06-07 11:36:23 -0700215 it != mBuffers.end(); it++) {
216 delete *it;
217 }
Zhijun Hece9d6f92015-03-29 16:33:59 -0700218
Zhijun Hece9d6f92015-03-29 16:33:59 -0700219 if (mConsumer != 0) {
220 mConsumer.clear();
221 }
Zhijun He212e78d2013-06-07 11:36:23 -0700222}
223
Dan Stoza2c34b5e2014-11-04 11:36:33 -0800224void JNIImageReaderContext::onFrameAvailable(const BufferItem& /*item*/)
Zhijun He212e78d2013-06-07 11:36:23 -0700225{
226 ALOGV("%s: frame available", __FUNCTION__);
227 bool needsDetach = false;
228 JNIEnv* env = getJNIEnv(&needsDetach);
229 if (env != NULL) {
Jeff Brownef961212013-08-05 20:39:29 -0700230 env->CallStaticVoidMethod(mClazz, gImageReaderClassInfo.postEventFromNative, mWeakThiz);
Zhijun He212e78d2013-06-07 11:36:23 -0700231 } else {
232 ALOGW("onFrameAvailable event will not posted");
233 }
234 if (needsDetach) {
235 detachJNI();
236 }
237}
238
239// ----------------------------------------------------------------------------
240
241extern "C" {
242
243static JNIImageReaderContext* ImageReader_getContext(JNIEnv* env, jobject thiz)
244{
245 JNIImageReaderContext *ctx;
246 ctx = reinterpret_cast<JNIImageReaderContext *>
Jeff Brownef961212013-08-05 20:39:29 -0700247 (env->GetLongField(thiz, gImageReaderClassInfo.mNativeContext));
Zhijun He212e78d2013-06-07 11:36:23 -0700248 return ctx;
249}
250
Dan Stoza5b3c7c12014-03-12 16:44:45 -0700251static IGraphicBufferProducer* ImageReader_getProducer(JNIEnv* env, jobject thiz)
Mathias Agopian52a9a102013-08-02 01:38:38 -0700252{
253 ALOGV("%s:", __FUNCTION__);
254 JNIImageReaderContext* const ctx = ImageReader_getContext(env, thiz);
255 if (ctx == NULL) {
256 jniThrowRuntimeException(env, "ImageReaderContext is not initialized");
257 return NULL;
258 }
Zhijun Hece9d6f92015-03-29 16:33:59 -0700259
Dan Stoza5b3c7c12014-03-12 16:44:45 -0700260 return ctx->getProducer();
Mathias Agopian52a9a102013-08-02 01:38:38 -0700261}
262
Zhijun He212e78d2013-06-07 11:36:23 -0700263static void ImageReader_setNativeContext(JNIEnv* env,
264 jobject thiz, sp<JNIImageReaderContext> ctx)
265{
266 ALOGV("%s:", __FUNCTION__);
267 JNIImageReaderContext* const p = ImageReader_getContext(env, thiz);
268 if (ctx != 0) {
269 ctx->incStrong((void*)ImageReader_setNativeContext);
270 }
271 if (p) {
272 p->decStrong((void*)ImageReader_setNativeContext);
273 }
Jeff Brownef961212013-08-05 20:39:29 -0700274 env->SetLongField(thiz, gImageReaderClassInfo.mNativeContext,
275 reinterpret_cast<jlong>(ctx.get()));
Zhijun He212e78d2013-06-07 11:36:23 -0700276}
277
Zhijun He0ab41622016-02-25 16:00:38 -0800278static BufferItemConsumer* ImageReader_getBufferConsumer(JNIEnv* env, jobject thiz)
Zhijun Hece9d6f92015-03-29 16:33:59 -0700279{
280 ALOGV("%s:", __FUNCTION__);
281 JNIImageReaderContext* const ctx = ImageReader_getContext(env, thiz);
282 if (ctx == NULL) {
283 jniThrowRuntimeException(env, "ImageReaderContext is not initialized");
284 return NULL;
285 }
286
Zhijun He0ab41622016-02-25 16:00:38 -0800287 return ctx->getBufferConsumer();
Zhijun Hece9d6f92015-03-29 16:33:59 -0700288}
289
Zhijun He0ab41622016-02-25 16:00:38 -0800290static void Image_setBufferItem(JNIEnv* env, jobject thiz,
291 const BufferItem* buffer)
292{
293 env->SetLongField(thiz, gSurfaceImageClassInfo.mNativeBuffer, reinterpret_cast<jlong>(buffer));
294}
295
296static BufferItem* Image_getBufferItem(JNIEnv* env, jobject image)
Zhijun Hece9d6f92015-03-29 16:33:59 -0700297{
298 return reinterpret_cast<BufferItem*>(
299 env->GetLongField(image, gSurfaceImageClassInfo.mNativeBuffer));
300}
301
Zhijun Hece9d6f92015-03-29 16:33:59 -0700302
Zhijun He212e78d2013-06-07 11:36:23 -0700303// ----------------------------------------------------------------------------
304
305static void ImageReader_classInit(JNIEnv* env, jclass clazz)
306{
307 ALOGV("%s:", __FUNCTION__);
308
309 jclass imageClazz = env->FindClass("android/media/ImageReader$SurfaceImage");
310 LOG_ALWAYS_FATAL_IF(imageClazz == NULL,
311 "can't find android/graphics/ImageReader$SurfaceImage");
Zhijun Hece9d6f92015-03-29 16:33:59 -0700312 gSurfaceImageClassInfo.mNativeBuffer = env->GetFieldID(
Jeff Brownef961212013-08-05 20:39:29 -0700313 imageClazz, ANDROID_MEDIA_SURFACEIMAGE_BUFFER_JNI_ID, "J");
Zhijun Hece9d6f92015-03-29 16:33:59 -0700314 LOG_ALWAYS_FATAL_IF(gSurfaceImageClassInfo.mNativeBuffer == NULL,
Zhijun He212e78d2013-06-07 11:36:23 -0700315 "can't find android/graphics/ImageReader.%s",
316 ANDROID_MEDIA_SURFACEIMAGE_BUFFER_JNI_ID);
317
Jeff Brownef961212013-08-05 20:39:29 -0700318 gSurfaceImageClassInfo.mTimestamp = env->GetFieldID(
319 imageClazz, ANDROID_MEDIA_SURFACEIMAGE_TS_JNI_ID, "J");
320 LOG_ALWAYS_FATAL_IF(gSurfaceImageClassInfo.mTimestamp == NULL,
Zhijun He212e78d2013-06-07 11:36:23 -0700321 "can't find android/graphics/ImageReader.%s",
322 ANDROID_MEDIA_SURFACEIMAGE_TS_JNI_ID);
323
Sally Qiac97f992021-10-11 17:39:54 -0700324 gSurfaceImageClassInfo.mDataSpace = env->GetFieldID(
John Reckffa81f82022-02-04 17:05:30 -0500325 imageClazz, ANDROID_MEDIA_SURFACEIMAGE_DS_JNI_ID, "I");
Sally Qiac97f992021-10-11 17:39:54 -0700326 LOG_ALWAYS_FATAL_IF(gSurfaceImageClassInfo.mDataSpace == NULL,
327 "can't find android/graphics/ImageReader.%s",
328 ANDROID_MEDIA_SURFACEIMAGE_DS_JNI_ID);
329
Emilian Peev450a5ff2018-03-19 16:05:10 +0000330 gSurfaceImageClassInfo.mTransform = env->GetFieldID(
331 imageClazz, ANDROID_MEDIA_SURFACEIMAGE_TF_JNI_ID, "I");
332 LOG_ALWAYS_FATAL_IF(gSurfaceImageClassInfo.mTransform == NULL,
333 "can't find android/graphics/ImageReader.%s",
334 ANDROID_MEDIA_SURFACEIMAGE_TF_JNI_ID);
335
Emilian Peev750aec62018-04-06 12:55:00 +0100336 gSurfaceImageClassInfo.mScalingMode = env->GetFieldID(
337 imageClazz, ANDROID_MEDIA_SURFACEIMAGE_SM_JNI_ID, "I");
338 LOG_ALWAYS_FATAL_IF(gSurfaceImageClassInfo.mScalingMode == NULL,
339 "can't find android/graphics/ImageReader.%s",
340 ANDROID_MEDIA_SURFACEIMAGE_SM_JNI_ID);
341
Zhijun He0ab41622016-02-25 16:00:38 -0800342 gSurfaceImageClassInfo.mPlanes = env->GetFieldID(
343 imageClazz, "mPlanes", "[Landroid/media/ImageReader$SurfaceImage$SurfacePlane;");
344 LOG_ALWAYS_FATAL_IF(gSurfaceImageClassInfo.mPlanes == NULL,
345 "can't find android/media/ImageReader$ReaderSurfaceImage.mPlanes");
346
Jeff Brownef961212013-08-05 20:39:29 -0700347 gImageReaderClassInfo.mNativeContext = env->GetFieldID(
348 clazz, ANDROID_MEDIA_IMAGEREADER_CTX_JNI_ID, "J");
349 LOG_ALWAYS_FATAL_IF(gImageReaderClassInfo.mNativeContext == NULL,
Zhijun He212e78d2013-06-07 11:36:23 -0700350 "can't find android/graphics/ImageReader.%s",
351 ANDROID_MEDIA_IMAGEREADER_CTX_JNI_ID);
352
Jeff Brownef961212013-08-05 20:39:29 -0700353 gImageReaderClassInfo.postEventFromNative = env->GetStaticMethodID(
354 clazz, "postEventFromNative", "(Ljava/lang/Object;)V");
355 LOG_ALWAYS_FATAL_IF(gImageReaderClassInfo.postEventFromNative == NULL,
Zhijun He212e78d2013-06-07 11:36:23 -0700356 "can't find android/graphics/ImageReader.postEventFromNative");
357
358 jclass planeClazz = env->FindClass("android/media/ImageReader$SurfaceImage$SurfacePlane");
359 LOG_ALWAYS_FATAL_IF(planeClazz == NULL, "Can not find SurfacePlane class");
360 // FindClass only gives a local reference of jclass object.
Jeff Brownef961212013-08-05 20:39:29 -0700361 gSurfacePlaneClassInfo.clazz = (jclass) env->NewGlobalRef(planeClazz);
362 gSurfacePlaneClassInfo.ctor = env->GetMethodID(gSurfacePlaneClassInfo.clazz, "<init>",
Zhijun He0ab41622016-02-25 16:00:38 -0800363 "(Landroid/media/ImageReader$SurfaceImage;IILjava/nio/ByteBuffer;)V");
Jeff Brownef961212013-08-05 20:39:29 -0700364 LOG_ALWAYS_FATAL_IF(gSurfacePlaneClassInfo.ctor == NULL,
365 "Can not find SurfacePlane constructor");
Emilian Peev9c778e12020-10-29 17:36:22 -0700366
367 planeClazz = env->FindClass("android/media/ImageReader$ImagePlane");
368 LOG_ALWAYS_FATAL_IF(planeClazz == NULL, "Can not find ImagePlane class");
369 // FindClass only gives a local reference of jclass object.
370 gImagePlaneClassInfo.clazz = (jclass) env->NewGlobalRef(planeClazz);
371 gImagePlaneClassInfo.ctor = env->GetMethodID(gImagePlaneClassInfo.clazz, "<init>",
372 "(IILjava/nio/ByteBuffer;)V");
373 LOG_ALWAYS_FATAL_IF(gImagePlaneClassInfo.ctor == NULL,
374 "Can not find ImagePlane constructor");
Zhijun He212e78d2013-06-07 11:36:23 -0700375}
376
Zhijun He916d8ac2017-03-22 17:33:47 -0700377static void ImageReader_init(JNIEnv* env, jobject thiz, jobject weakThiz, jint width, jint height,
Sally Qi90393002022-06-02 12:55:49 -0700378 jint maxImages, jlong ndkUsage, jint nativeHalFormat, jint dataSpace) {
Zhijun He212e78d2013-06-07 11:36:23 -0700379 status_t res;
Zhijun He212e78d2013-06-07 11:36:23 -0700380
Sally Qi90393002022-06-02 12:55:49 -0700381 ALOGV("%s: width:%d, height: %d, nativeHalFormat: %d, maxImages:%d",
382 __FUNCTION__, width, height, nativeHalFormat, maxImages);
Zhijun He212e78d2013-06-07 11:36:23 -0700383
Sally Qiaba398d2021-12-06 16:37:50 -0800384 android_dataspace nativeDataspace = static_cast<android_dataspace>(dataSpace);
Zhijun He212e78d2013-06-07 11:36:23 -0700385
Zhijun He212e78d2013-06-07 11:36:23 -0700386 jclass clazz = env->GetObjectClass(thiz);
387 if (clazz == NULL) {
388 jniThrowRuntimeException(env, "Can't find android/graphics/ImageReader");
389 return;
390 }
391 sp<JNIImageReaderContext> ctx(new JNIImageReaderContext(env, weakThiz, clazz, maxImages));
Zhijun Hece9d6f92015-03-29 16:33:59 -0700392
393 sp<IGraphicBufferProducer> gbProducer;
394 sp<IGraphicBufferConsumer> gbConsumer;
395 BufferQueue::createBufferQueue(&gbProducer, &gbConsumer);
Zhijun He0ab41622016-02-25 16:00:38 -0800396 sp<BufferItemConsumer> bufferConsumer;
Eino-Ville Talvalaef9db7d2015-06-09 14:15:15 -0700397 String8 consumerName = String8::format("ImageReader-%dx%df%xm%d-%d-%d",
Sally Qi90393002022-06-02 12:55:49 -0700398 width, height, nativeHalFormat, maxImages, getpid(),
Eino-Ville Talvalaef9db7d2015-06-09 14:15:15 -0700399 createProcessUniqueId());
John Reck4d312b22019-01-25 15:20:24 -0800400 uint64_t consumerUsage =
401 android_hardware_HardwareBuffer_convertToGrallocUsageBits(ndkUsage);
Zhijun He0ab41622016-02-25 16:00:38 -0800402
Zhijun He0ab41622016-02-25 16:00:38 -0800403 bufferConsumer = new BufferItemConsumer(gbConsumer, consumerUsage, maxImages,
404 /*controlledByApp*/true);
405 if (bufferConsumer == nullptr) {
406 jniThrowExceptionFmt(env, "java/lang/RuntimeException",
Sally Qi90393002022-06-02 12:55:49 -0700407 "Failed to allocate native buffer consumer for hal format 0x%x and usage 0x%x",
408 nativeHalFormat, consumerUsage);
Zhijun He0ab41622016-02-25 16:00:38 -0800409 return;
410 }
Khushal65d19412019-01-25 14:12:14 -0800411
412 if (consumerUsage & GRALLOC_USAGE_PROTECTED) {
413 gbConsumer->setConsumerIsProtected(true);
414 }
415
Zhijun He0ab41622016-02-25 16:00:38 -0800416 ctx->setBufferConsumer(bufferConsumer);
417 bufferConsumer->setName(consumerName);
Zhijun Hece9d6f92015-03-29 16:33:59 -0700418
Dan Stoza5b3c7c12014-03-12 16:44:45 -0700419 ctx->setProducer(gbProducer);
Zhijun He0ab41622016-02-25 16:00:38 -0800420 bufferConsumer->setFrameAvailableListener(ctx);
Zhijun He212e78d2013-06-07 11:36:23 -0700421 ImageReader_setNativeContext(env, thiz, ctx);
Sally Qi90393002022-06-02 12:55:49 -0700422 ctx->setBufferFormat(nativeHalFormat);
Eino-Ville Talvala805f3c92015-02-26 10:57:55 -0800423 ctx->setBufferDataspace(nativeDataspace);
Zhijun He212e78d2013-06-07 11:36:23 -0700424 ctx->setBufferWidth(width);
425 ctx->setBufferHeight(height);
426
Zhijun He0ab41622016-02-25 16:00:38 -0800427 // Set the width/height/format/dataspace to the bufferConsumer.
428 res = bufferConsumer->setDefaultBufferSize(width, height);
429 if (res != OK) {
430 jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
Sally Qi90393002022-06-02 12:55:49 -0700431 "Failed to set buffer consumer default size (%dx%d) for Hal format 0x%x",
432 width, height, nativeHalFormat);
Zhijun He0ab41622016-02-25 16:00:38 -0800433 return;
434 }
Sally Qi90393002022-06-02 12:55:49 -0700435 res = bufferConsumer->setDefaultBufferFormat(nativeHalFormat);
Zhijun He0ab41622016-02-25 16:00:38 -0800436 if (res != OK) {
437 jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
Sally Qi90393002022-06-02 12:55:49 -0700438 "Failed to set buffer consumer default Halformat 0x%x", nativeHalFormat);
John Reckdcd4c582019-07-12 13:13:05 -0700439 return;
Zhijun He0ab41622016-02-25 16:00:38 -0800440 }
441 res = bufferConsumer->setDefaultBufferDataSpace(nativeDataspace);
442 if (res != OK) {
443 jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
444 "Failed to set buffer consumer default dataSpace 0x%x", nativeDataspace);
John Reckdcd4c582019-07-12 13:13:05 -0700445 return;
Zhijun He212e78d2013-06-07 11:36:23 -0700446 }
Zhijun He212e78d2013-06-07 11:36:23 -0700447}
448
449static void ImageReader_close(JNIEnv* env, jobject thiz)
450{
451 ALOGV("%s:", __FUNCTION__);
452
453 JNIImageReaderContext* const ctx = ImageReader_getContext(env, thiz);
454 if (ctx == NULL) {
455 // ImageReader is already closed.
456 return;
457 }
458
Zhijun He0ab41622016-02-25 16:00:38 -0800459 BufferItemConsumer* consumer = NULL;
460 consumer = ImageReader_getBufferConsumer(env, thiz);
Zhijun Hece9d6f92015-03-29 16:33:59 -0700461
Zhijun He212e78d2013-06-07 11:36:23 -0700462 if (consumer != NULL) {
463 consumer->abandon();
464 consumer->setFrameAvailableListener(NULL);
465 }
466 ImageReader_setNativeContext(env, thiz, NULL);
467}
468
Zhijun He0ab41622016-02-25 16:00:38 -0800469static sp<Fence> Image_unlockIfLocked(JNIEnv* env, jobject image) {
470 ALOGV("%s", __FUNCTION__);
471 BufferItem* buffer = Image_getBufferItem(env, image);
472 if (buffer == NULL) {
473 jniThrowException(env, "java/lang/IllegalStateException",
474 "Image is not initialized");
475 return Fence::NO_FENCE;
476 }
477
478 // Is locked?
479 bool wasBufferLocked = false;
480 jobject planes = NULL;
481 if (!isFormatOpaque(buffer->mGraphicBuffer->getPixelFormat())) {
482 planes = env->GetObjectField(image, gSurfaceImageClassInfo.mPlanes);
483 }
484 wasBufferLocked = (planes != NULL);
485 if (wasBufferLocked) {
486 status_t res = OK;
487 int fenceFd = -1;
488 if (wasBufferLocked) {
489 res = buffer->mGraphicBuffer->unlockAsync(&fenceFd);
490 if (res != OK) {
491 jniThrowRuntimeException(env, "unlock buffer failed");
492 return Fence::NO_FENCE;
493 }
494 }
495 sp<Fence> releaseFence = new Fence(fenceFd);
496 return releaseFence;
497 ALOGV("Successfully unlocked the image");
498 }
499 return Fence::NO_FENCE;
500}
501
Zhijun He212e78d2013-06-07 11:36:23 -0700502static void ImageReader_imageRelease(JNIEnv* env, jobject thiz, jobject image)
503{
504 ALOGV("%s:", __FUNCTION__);
505 JNIImageReaderContext* ctx = ImageReader_getContext(env, thiz);
506 if (ctx == NULL) {
507 ALOGW("ImageReader#close called before Image#close, consider calling Image#close first");
508 return;
509 }
510
Zhijun He0ab41622016-02-25 16:00:38 -0800511 BufferItemConsumer* bufferConsumer = ctx->getBufferConsumer();
512 BufferItem* buffer = Image_getBufferItem(env, image);
513 if (buffer == nullptr) {
514 // Release an already closed image is harmless.
515 return;
Zhijun He212e78d2013-06-07 11:36:23 -0700516 }
517
Zhijun He0ab41622016-02-25 16:00:38 -0800518 sp<Fence> releaseFence = Image_unlockIfLocked(env, image);
519 bufferConsumer->releaseBuffer(*buffer, releaseFence);
520 Image_setBufferItem(env, image, NULL);
521 ctx->returnBufferItem(buffer);
522 ALOGV("%s: Image (format: 0x%x) has been released", __FUNCTION__, ctx->getBufferFormat());
Zhijun He212e78d2013-06-07 11:36:23 -0700523}
524
Sally Qi90393002022-06-02 12:55:49 -0700525static jint ImageReader_imageSetup(JNIEnv* env, jobject thiz, jobject image) {
Zhijun Hece9d6f92015-03-29 16:33:59 -0700526 ALOGV("%s:", __FUNCTION__);
527 JNIImageReaderContext* ctx = ImageReader_getContext(env, thiz);
528 if (ctx == NULL) {
Zhijun Hedc6bb242015-12-03 15:34:34 -0800529 jniThrowException(env, "java/lang/IllegalStateException",
530 "ImageReader is not initialized or was already closed");
Zhijun Hece9d6f92015-03-29 16:33:59 -0700531 return -1;
532 }
533
Zhijun He0ab41622016-02-25 16:00:38 -0800534 BufferItemConsumer* bufferConsumer = ctx->getBufferConsumer();
535 BufferItem* buffer = ctx->getBufferItem();
536 if (buffer == NULL) {
537 ALOGW("Unable to acquire a buffer item, very likely client tried to acquire more than"
538 " maxImages buffers");
539 return ACQUIRE_MAX_IMAGES;
Zhijun Hece9d6f92015-03-29 16:33:59 -0700540 }
Zhijun He0ab41622016-02-25 16:00:38 -0800541
542 status_t res = bufferConsumer->acquireBuffer(buffer, 0);
543 if (res != OK) {
544 ctx->returnBufferItem(buffer);
545 if (res != BufferQueue::NO_BUFFER_AVAILABLE) {
546 if (res == INVALID_OPERATION) {
547 // Max number of images were already acquired.
548 ALOGE("%s: Max number of buffers allowed are already acquired : %s (%d)",
549 __FUNCTION__, strerror(-res), res);
550 return ACQUIRE_MAX_IMAGES;
551 } else {
552 ALOGE("%s: Acquire image failed with some unknown error: %s (%d)",
553 __FUNCTION__, strerror(-res), res);
554 jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
555 "Unknown error (%d) when we tried to acquire an image.",
556 res);
557 return ACQUIRE_NO_BUFFERS;
558 }
559 }
560 // This isn't really an error case, as the application may acquire buffer at any time.
561 return ACQUIRE_NO_BUFFERS;
562 }
563
564 // Add some extra checks for non-opaque formats.
565 if (!isFormatOpaque(ctx->getBufferFormat())) {
566 // Check if the left-top corner of the crop rect is origin, we currently assume this point is
567 // zero, will revisit this once this assumption turns out problematic.
568 Point lt = buffer->mCrop.leftTop();
569 if (lt.x != 0 || lt.y != 0) {
570 jniThrowExceptionFmt(env, "java/lang/UnsupportedOperationException",
571 "crop left top corner [%d, %d] need to be at origin", lt.x, lt.y);
572 return -1;
573 }
574
575 // Check if the producer buffer configurations match what ImageReader configured.
576 int outputWidth = getBufferWidth(buffer);
577 int outputHeight = getBufferHeight(buffer);
578
Sally Qi90393002022-06-02 12:55:49 -0700579 int imgReaderHalFmt = ctx->getBufferFormat();
Zhijun He0ab41622016-02-25 16:00:38 -0800580 int imageReaderWidth = ctx->getBufferWidth();
581 int imageReaderHeight = ctx->getBufferHeight();
582 int bufferFormat = buffer->mGraphicBuffer->getPixelFormat();
Sally Qi90393002022-06-02 12:55:49 -0700583 if ((bufferFormat != HAL_PIXEL_FORMAT_BLOB) && (imgReaderHalFmt != HAL_PIXEL_FORMAT_BLOB) &&
Zhijun He0ab41622016-02-25 16:00:38 -0800584 (imageReaderWidth != outputWidth || imageReaderHeight != outputHeight)) {
585 ALOGV("%s: Producer buffer size: %dx%d, doesn't match ImageReader configured size: %dx%d",
586 __FUNCTION__, outputWidth, outputHeight, imageReaderWidth, imageReaderHeight);
587 }
Sally Qi90393002022-06-02 12:55:49 -0700588 if (imgReaderHalFmt != bufferFormat) {
589 if (imgReaderHalFmt == HAL_PIXEL_FORMAT_YCbCr_420_888 &&
Zhijun He0ab41622016-02-25 16:00:38 -0800590 isPossiblyYUV(bufferFormat)) {
591 // Treat formats that are compatible with flexible YUV
592 // (HAL_PIXEL_FORMAT_YCbCr_420_888) as HAL_PIXEL_FORMAT_YCbCr_420_888.
593 ALOGV("%s: Treat buffer format to 0x%x as HAL_PIXEL_FORMAT_YCbCr_420_888",
594 __FUNCTION__, bufferFormat);
Sally Qi90393002022-06-02 12:55:49 -0700595 } else if (imgReaderHalFmt == HAL_PIXEL_FORMAT_YCBCR_P010 &&
Wonsik Kim584cde22022-04-07 16:51:46 -0700596 isPossibly10BitYUV(bufferFormat)) {
597 // Treat formats that are compatible with flexible 10-bit YUV
598 // (HAL_PIXEL_FORMAT_YCBCR_P010) as HAL_PIXEL_FORMAT_YCBCR_P010.
599 ALOGV("%s: Treat buffer format to 0x%x as HAL_PIXEL_FORMAT_YCBCR_P010",
600 __FUNCTION__, bufferFormat);
Sally Qi90393002022-06-02 12:55:49 -0700601 } else if (imgReaderHalFmt == HAL_PIXEL_FORMAT_BLOB &&
Zhijun He0ab41622016-02-25 16:00:38 -0800602 bufferFormat == HAL_PIXEL_FORMAT_RGBA_8888) {
603 // Using HAL_PIXEL_FORMAT_RGBA_8888 Gralloc buffers containing JPEGs to get around
604 // SW write limitations for (b/17379185).
605 ALOGV("%s: Receiving JPEG in HAL_PIXEL_FORMAT_RGBA_8888 buffer.", __FUNCTION__);
606 } else {
607 // Return the buffer to the queue. No need to provide fence, as this buffer wasn't
608 // used anywhere yet.
609 bufferConsumer->releaseBuffer(*buffer);
610 ctx->returnBufferItem(buffer);
611
612 // Throw exception
613 ALOGE("Producer output buffer format: 0x%x, ImageReader configured format: 0x%x",
614 bufferFormat, ctx->getBufferFormat());
615 String8 msg;
616 msg.appendFormat("The producer output buffer format 0x%x doesn't "
617 "match the ImageReader's configured buffer format 0x%x.",
618 bufferFormat, ctx->getBufferFormat());
619 jniThrowException(env, "java/lang/UnsupportedOperationException",
Tomasz Wasilczyk3815d342023-08-10 23:54:44 +0000620 msg.c_str());
Zhijun He0ab41622016-02-25 16:00:38 -0800621 return -1;
622 }
623 }
624
625 }
626
627 // Set SurfaceImage instance member variables
628 Image_setBufferItem(env, image, buffer);
629 env->SetLongField(image, gSurfaceImageClassInfo.mTimestamp,
630 static_cast<jlong>(buffer->mTimestamp));
John Recke20a7542022-02-09 08:56:56 -0500631 env->SetIntField(image, gSurfaceImageClassInfo.mDataSpace,
John Reckffa81f82022-02-04 17:05:30 -0500632 static_cast<jint>(buffer->mDataSpace));
Emilian Peevda49a5e2018-06-26 10:13:39 +0100633 auto transform = buffer->mTransform;
634 if (buffer->mTransformToDisplayInverse) {
635 transform |= NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY;
636 }
Emilian Peev450a5ff2018-03-19 16:05:10 +0000637 env->SetIntField(image, gSurfaceImageClassInfo.mTransform,
Emilian Peevda49a5e2018-06-26 10:13:39 +0100638 static_cast<jint>(transform));
Emilian Peev750aec62018-04-06 12:55:00 +0100639 env->SetIntField(image, gSurfaceImageClassInfo.mScalingMode,
640 static_cast<jint>(buffer->mScalingMode));
Zhijun He0ab41622016-02-25 16:00:38 -0800641
642 return ACQUIRE_SUCCESS;
Zhijun Hece9d6f92015-03-29 16:33:59 -0700643}
644
645static jint ImageReader_detachImage(JNIEnv* env, jobject thiz, jobject image) {
Zhijun Hef6a09e52015-02-24 18:12:23 -0800646 ALOGV("%s:", __FUNCTION__);
647 JNIImageReaderContext* ctx = ImageReader_getContext(env, thiz);
648 if (ctx == NULL) {
649 jniThrowException(env, "java/lang/IllegalStateException", "ImageReader was already closed");
Zhijun Hece9d6f92015-03-29 16:33:59 -0700650 return -1;
Zhijun Hef6a09e52015-02-24 18:12:23 -0800651 }
652
Zhijun He0ab41622016-02-25 16:00:38 -0800653 BufferItemConsumer* bufferConsumer = ctx->getBufferConsumer();
654 BufferItem* buffer = Image_getBufferItem(env, image);
655 if (!buffer) {
Zhijun Hece9d6f92015-03-29 16:33:59 -0700656 ALOGE(
Zhijun He0ab41622016-02-25 16:00:38 -0800657 "Image already released and can not be detached from ImageReader!!!");
Zhijun Hece9d6f92015-03-29 16:33:59 -0700658 jniThrowException(env, "java/lang/IllegalStateException",
Zhijun He0ab41622016-02-25 16:00:38 -0800659 "Image detach from ImageReader failed: buffer was already released");
Zhijun Hece9d6f92015-03-29 16:33:59 -0700660 return -1;
661 }
662
Zhijun He0ab41622016-02-25 16:00:38 -0800663 status_t res = OK;
664 Image_unlockIfLocked(env, image);
665 res = bufferConsumer->detachBuffer(buffer->mSlot);
Zhijun Hece9d6f92015-03-29 16:33:59 -0700666 if (res != OK) {
Zhijun He0ab41622016-02-25 16:00:38 -0800667 ALOGE("Image detach failed: %s (%d)!!!", strerror(-res), res);
Zhijun Hece9d6f92015-03-29 16:33:59 -0700668 jniThrowRuntimeException(env,
Zhijun He0ab41622016-02-25 16:00:38 -0800669 "nativeDetachImage failed for image!!!");
Zhijun Hece9d6f92015-03-29 16:33:59 -0700670 return res;
671 }
672 return OK;
Zhijun Hef6a09e52015-02-24 18:12:23 -0800673}
674
Eino-Ville Talvala2e2aaf62016-07-21 17:04:19 -0700675static void ImageReader_discardFreeBuffers(JNIEnv* env, jobject thiz) {
676 ALOGV("%s:", __FUNCTION__);
677 JNIImageReaderContext* ctx = ImageReader_getContext(env, thiz);
678 if (ctx == NULL) {
679 jniThrowException(env, "java/lang/IllegalStateException", "ImageReader was already closed");
680 return;
681 }
682
683 BufferItemConsumer* bufferConsumer = ctx->getBufferConsumer();
684 status_t res = bufferConsumer->discardFreeBuffers();
685 if (res != OK) {
686 ALOGE("Buffer discard failed: %s (%d)", strerror(-res), res);
687 jniThrowRuntimeException(env,
688 "nativeDicardFreebuffers failed");
689 }
690}
691
Zhijun He212e78d2013-06-07 11:36:23 -0700692static jobject ImageReader_getSurface(JNIEnv* env, jobject thiz)
693{
694 ALOGV("%s: ", __FUNCTION__);
695
Dan Stoza5b3c7c12014-03-12 16:44:45 -0700696 IGraphicBufferProducer* gbp = ImageReader_getProducer(env, thiz);
697 if (gbp == NULL) {
Zhijun He0ab41622016-02-25 16:00:38 -0800698 jniThrowRuntimeException(env, "Buffer consumer is uninitialized");
Zhijun He212e78d2013-06-07 11:36:23 -0700699 return NULL;
700 }
701
702 // Wrap the IGBP in a Java-language Surface.
Dan Stoza5b3c7c12014-03-12 16:44:45 -0700703 return android_view_Surface_createFromIGraphicBufferProducer(env, gbp);
Zhijun He212e78d2013-06-07 11:36:23 -0700704}
705
Clément Julliardcc217e32020-07-31 03:20:13 +0000706static void Image_getLockedImage(JNIEnv* env, jobject thiz, LockedImage *image,
707 uint64_t ndkReaderUsage) {
Zhijun He0ab41622016-02-25 16:00:38 -0800708 ALOGV("%s", __FUNCTION__);
709 BufferItem* buffer = Image_getBufferItem(env, thiz);
710 if (buffer == NULL) {
711 jniThrowException(env, "java/lang/IllegalStateException",
712 "Image is not initialized");
713 return;
714 }
715
Clément Julliardcc217e32020-07-31 03:20:13 +0000716 uint32_t lockUsage;
717 if ((ndkReaderUsage & (AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY
718 | AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN)) != 0) {
719 lockUsage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN;
720 } else {
721 lockUsage = GRALLOC_USAGE_SW_READ_OFTEN;
722 }
723
724 status_t res = lockImageFromBuffer(buffer, lockUsage, buffer->mFence->dup(), image);
725
Zhijun He0ab41622016-02-25 16:00:38 -0800726 if (res != OK) {
727 jniThrowExceptionFmt(env, "java/lang/RuntimeException",
728 "lock buffer failed for format 0x%x",
729 buffer->mGraphicBuffer->getPixelFormat());
730 return;
731 }
732
733 // Carry over some fields from BufferItem.
734 image->crop = buffer->mCrop;
735 image->transform = buffer->mTransform;
736 image->scalingMode = buffer->mScalingMode;
737 image->timestamp = buffer->mTimestamp;
738 image->dataSpace = buffer->mDataSpace;
739 image->frameNumber = buffer->mFrameNumber;
740
741 ALOGV("%s: Successfully locked the image", __FUNCTION__);
742 // crop, transform, scalingMode, timestamp, and frameNumber should be set by producer,
743 // and we don't set them here.
744}
745
John Reckdcd4c582019-07-12 13:13:05 -0700746static bool Image_getLockedImageInfo(JNIEnv* env, LockedImage* buffer, int idx,
Zhijun He0ab41622016-02-25 16:00:38 -0800747 int32_t writerFormat, uint8_t **base, uint32_t *size, int *pixelStride, int *rowStride) {
748 ALOGV("%s", __FUNCTION__);
749
750 status_t res = getLockedImageInfo(buffer, idx, writerFormat, base, size,
751 pixelStride, rowStride);
752 if (res != OK) {
753 jniThrowExceptionFmt(env, "java/lang/UnsupportedOperationException",
754 "Pixel format: 0x%x is unsupported", buffer->flexFormat);
John Reckdcd4c582019-07-12 13:13:05 -0700755 return false;
Zhijun He0ab41622016-02-25 16:00:38 -0800756 }
John Reckdcd4c582019-07-12 13:13:05 -0700757 return true;
Zhijun He0ab41622016-02-25 16:00:38 -0800758}
759
Emilian Peev9c778e12020-10-29 17:36:22 -0700760static void ImageReader_unlockGraphicBuffer(JNIEnv* env, jobject /*thiz*/,
761 jobject buffer) {
762 sp<GraphicBuffer> graphicBuffer =
763 android_graphics_GraphicBuffer_getNativeGraphicsBuffer(env, buffer);
764 if (graphicBuffer.get() == NULL) {
765 jniThrowRuntimeException(env, "Invalid graphic buffer!");
766 }
767
768 status_t res = graphicBuffer->unlock();
769 if (res != OK) {
770 jniThrowRuntimeException(env, "unlock buffer failed");
771 }
772}
773
774static jobjectArray ImageReader_createImagePlanes(JNIEnv* env, jobject /*thiz*/,
775 int numPlanes, jobject buffer, int fenceFd, int format, int cropLeft, int cropTop,
776 int cropRight, int cropBottom)
777{
778 ALOGV("%s: create ImagePlane array with size %d", __FUNCTION__, numPlanes);
779 int rowStride = 0;
780 int pixelStride = 0;
781 uint8_t *pData = NULL;
782 uint32_t dataSize = 0;
783 jobject byteBuffer = NULL;
784
785 PublicFormat publicReaderFormat = static_cast<PublicFormat>(format);
786 int halReaderFormat = mapPublicFormatToHalFormat(publicReaderFormat);
787
788 if (isFormatOpaque(halReaderFormat) && numPlanes > 0) {
789 String8 msg;
790 msg.appendFormat("Format 0x%x is opaque, thus not writable, the number of planes (%d)"
791 " must be 0", halReaderFormat, numPlanes);
Tomasz Wasilczyk3815d342023-08-10 23:54:44 +0000792 jniThrowException(env, "java/lang/IllegalArgumentException", msg.c_str());
Emilian Peev9c778e12020-10-29 17:36:22 -0700793 return NULL;
794 }
795
796 jobjectArray imagePlanes = env->NewObjectArray(numPlanes, gImagePlaneClassInfo.clazz,
797 /*initial_element*/NULL);
798 if (imagePlanes == NULL) {
799 jniThrowRuntimeException(env, "Failed to create ImagePlane arrays,"
800 " probably out of memory");
801 return NULL;
802 }
803 if (isFormatOpaque(halReaderFormat)) {
804 // Return 0 element surface array.
805 return imagePlanes;
806 }
807
808 LockedImage lockedImg = LockedImage();
809 uint32_t lockUsage = GRALLOC_USAGE_SW_READ_OFTEN;
810
811 Rect cropRect(cropLeft, cropTop, cropRight, cropBottom);
812 status_t res = lockImageFromBuffer(
813 android_graphics_GraphicBuffer_getNativeGraphicsBuffer(env, buffer), lockUsage,
814 cropRect, fenceFd, &lockedImg);
815 if (res != OK) {
816 jniThrowExceptionFmt(env, "java/lang/RuntimeException",
817 "lock buffer failed for format 0x%x", format);
818 return nullptr;
819 }
820
821 // Create all ImagePlanes
822 for (int i = 0; i < numPlanes; i++) {
823 if (!Image_getLockedImageInfo(env, &lockedImg, i, halReaderFormat,
824 &pData, &dataSize, &pixelStride, &rowStride)) {
825 return NULL;
826 }
827 byteBuffer = env->NewDirectByteBuffer(pData, dataSize);
828 if ((byteBuffer == NULL) && (env->ExceptionCheck() == false)) {
829 jniThrowException(env, "java/lang/IllegalStateException",
830 "Failed to allocate ByteBuffer");
831 return NULL;
832 }
833
834 // Finally, create this ImagePlane.
835 jobject imagePlane = env->NewObject(gImagePlaneClassInfo.clazz,
836 gImagePlaneClassInfo.ctor, rowStride, pixelStride, byteBuffer);
837 env->SetObjectArrayElement(imagePlanes, i, imagePlane);
838 }
839
840 return imagePlanes;
841}
842
Zhijun He0ab41622016-02-25 16:00:38 -0800843static jobjectArray Image_createSurfacePlanes(JNIEnv* env, jobject thiz,
Sally Qi90393002022-06-02 12:55:49 -0700844 int numPlanes, int halReaderFormat, uint64_t ndkReaderUsage)
Zhijun He212e78d2013-06-07 11:36:23 -0700845{
Zhijun He0ab41622016-02-25 16:00:38 -0800846 ALOGV("%s: create SurfacePlane array with size %d", __FUNCTION__, numPlanes);
847 int rowStride = 0;
848 int pixelStride = 0;
849 uint8_t *pData = NULL;
850 uint32_t dataSize = 0;
851 jobject byteBuffer = NULL;
852
Zhijun He0ab41622016-02-25 16:00:38 -0800853 if (isFormatOpaque(halReaderFormat) && numPlanes > 0) {
854 String8 msg;
855 msg.appendFormat("Format 0x%x is opaque, thus not writable, the number of planes (%d)"
856 " must be 0", halReaderFormat, numPlanes);
Tomasz Wasilczyk3815d342023-08-10 23:54:44 +0000857 jniThrowException(env, "java/lang/IllegalArgumentException", msg.c_str());
Zhijun He0ab41622016-02-25 16:00:38 -0800858 return NULL;
859 }
860
861 jobjectArray surfacePlanes = env->NewObjectArray(numPlanes, gSurfacePlaneClassInfo.clazz,
862 /*initial_element*/NULL);
863 if (surfacePlanes == NULL) {
864 jniThrowRuntimeException(env, "Failed to create SurfacePlane arrays,"
865 " probably out of memory");
866 return NULL;
867 }
Zhijun Hece9d6f92015-03-29 16:33:59 -0700868 if (isFormatOpaque(halReaderFormat)) {
Zhijun He0ab41622016-02-25 16:00:38 -0800869 // Return 0 element surface array.
870 return surfacePlanes;
Zhijun Hece9d6f92015-03-29 16:33:59 -0700871 }
Zhijun He212e78d2013-06-07 11:36:23 -0700872
Zhijun He0ab41622016-02-25 16:00:38 -0800873 LockedImage lockedImg = LockedImage();
Clément Julliardcc217e32020-07-31 03:20:13 +0000874 Image_getLockedImage(env, thiz, &lockedImg, ndkReaderUsage);
Robert Shih252f3b22017-03-09 12:40:09 -0800875 if (env->ExceptionCheck()) {
876 return NULL;
877 }
Zhijun He0ab41622016-02-25 16:00:38 -0800878 // Create all SurfacePlanes
879 for (int i = 0; i < numPlanes; i++) {
John Reckdcd4c582019-07-12 13:13:05 -0700880 if (!Image_getLockedImageInfo(env, &lockedImg, i, halReaderFormat,
881 &pData, &dataSize, &pixelStride, &rowStride)) {
882 return NULL;
883 }
Zhijun He0ab41622016-02-25 16:00:38 -0800884 byteBuffer = env->NewDirectByteBuffer(pData, dataSize);
885 if ((byteBuffer == NULL) && (env->ExceptionCheck() == false)) {
886 jniThrowException(env, "java/lang/IllegalStateException",
887 "Failed to allocate ByteBuffer");
888 return NULL;
889 }
Zhijun He212e78d2013-06-07 11:36:23 -0700890
Zhijun He0ab41622016-02-25 16:00:38 -0800891 // Finally, create this SurfacePlane.
892 jobject surfacePlane = env->NewObject(gSurfacePlaneClassInfo.clazz,
893 gSurfacePlaneClassInfo.ctor, thiz, rowStride, pixelStride, byteBuffer);
894 env->SetObjectArrayElement(surfacePlanes, i, surfacePlane);
Zhijun He212e78d2013-06-07 11:36:23 -0700895 }
Ruben Brunk0fd198a2014-09-23 23:35:43 -0700896
Zhijun He0ab41622016-02-25 16:00:38 -0800897 return surfacePlanes;
Zhijun He212e78d2013-06-07 11:36:23 -0700898}
899
Zhijun He0ab41622016-02-25 16:00:38 -0800900static jint Image_getWidth(JNIEnv* env, jobject thiz)
Zhijun He212e78d2013-06-07 11:36:23 -0700901{
Zhijun He0ab41622016-02-25 16:00:38 -0800902 BufferItem* buffer = Image_getBufferItem(env, thiz);
903 return getBufferWidth(buffer);
Zhijun He212e78d2013-06-07 11:36:23 -0700904}
905
Zhijun He0ab41622016-02-25 16:00:38 -0800906static jint Image_getHeight(JNIEnv* env, jobject thiz)
Ruben Brunkf4a637d2014-11-20 18:01:36 -0800907{
Zhijun He0ab41622016-02-25 16:00:38 -0800908 BufferItem* buffer = Image_getBufferItem(env, thiz);
909 return getBufferHeight(buffer);
Ruben Brunkf4a637d2014-11-20 18:01:36 -0800910}
911
Emilian Peev9c778e12020-10-29 17:36:22 -0700912static jint Image_getFenceFd(JNIEnv* env, jobject thiz)
913{
914 BufferItem* buffer = Image_getBufferItem(env, thiz);
915 if ((buffer != NULL) && (buffer->mFence.get() != NULL)){
916 return buffer->mFence->get();
917 }
918
919 return -1;
920}
921
Zhijun He7c3997d2015-05-06 10:08:37 -0700922static jint Image_getFormat(JNIEnv* env, jobject thiz, jint readerFormat)
923{
924 if (isFormatOpaque(readerFormat)) {
925 // Assuming opaque reader produce opaque images.
926 return static_cast<jint>(PublicFormat::PRIVATE);
927 } else {
Zhijun He0ab41622016-02-25 16:00:38 -0800928 BufferItem* buffer = Image_getBufferItem(env, thiz);
Fedor Kudasov4d027e92019-06-24 17:21:57 +0100929 int readerHalFormat = mapPublicFormatToHalFormat(static_cast<PublicFormat>(readerFormat));
Zhijun He0ab41622016-02-25 16:00:38 -0800930 int32_t fmt = applyFormatOverrides(
931 buffer->mGraphicBuffer->getPixelFormat(), readerHalFormat);
Zhijun He9cc3f882016-02-17 17:24:04 -0800932 // Override the image format to HAL_PIXEL_FORMAT_YCbCr_420_888 if the actual format is
933 // NV21 or YV12. This could only happen when the Gralloc HAL version is v0.1 thus doesn't
934 // support lockycbcr(), the CpuConsumer need to use the lock() method in the
935 // lockNextBuffer() call. For Gralloc HAL v0.2 or newer, this format should already be
936 // overridden to HAL_PIXEL_FORMAT_YCbCr_420_888 for the flexible YUV compatible formats.
Zhijun He0ab41622016-02-25 16:00:38 -0800937 if (isPossiblyYUV(fmt)) {
Zhijun He9cc3f882016-02-17 17:24:04 -0800938 fmt = HAL_PIXEL_FORMAT_YCbCr_420_888;
939 }
Fedor Kudasov4d027e92019-06-24 17:21:57 +0100940 PublicFormat publicFmt = mapHalFormatDataspaceToPublicFormat(fmt, buffer->mDataSpace);
Zhijun He7c3997d2015-05-06 10:08:37 -0700941 return static_cast<jint>(publicFmt);
942 }
943}
944
Mathias Agopian3e88ed82018-02-20 18:32:22 -0800945static jobject Image_getHardwareBuffer(JNIEnv* env, jobject thiz) {
946 BufferItem* buffer = Image_getBufferItem(env, thiz);
947 AHardwareBuffer* b = AHardwareBuffer_from_GraphicBuffer(buffer->mGraphicBuffer.get());
948 // don't user the public AHardwareBuffer_toHardwareBuffer() because this would force us
949 // to link against libandroid.so
950 return android_hardware_HardwareBuffer_createFromAHardwareBuffer(env, b);
951}
952
Zhijun He212e78d2013-06-07 11:36:23 -0700953} // extern "C"
954
955// ----------------------------------------------------------------------------
956
Daniel Micay76f6a862015-09-19 17:31:01 -0400957static const JNINativeMethod gImageReaderMethods[] = {
Zhijun He212e78d2013-06-07 11:36:23 -0700958 {"nativeClassInit", "()V", (void*)ImageReader_classInit },
John Reckffa81f82022-02-04 17:05:30 -0500959 {"nativeInit", "(Ljava/lang/Object;IIIJII)V", (void*)ImageReader_init },
Zhijun He212e78d2013-06-07 11:36:23 -0700960 {"nativeClose", "()V", (void*)ImageReader_close },
961 {"nativeReleaseImage", "(Landroid/media/Image;)V", (void*)ImageReader_imageRelease },
Sally Qi90393002022-06-02 12:55:49 -0700962 {"nativeImageSetup", "(Landroid/media/Image;)I", (void*)ImageReader_imageSetup },
Zhijun He212e78d2013-06-07 11:36:23 -0700963 {"nativeGetSurface", "()Landroid/view/Surface;", (void*)ImageReader_getSurface },
Zhijun Hece9d6f92015-03-29 16:33:59 -0700964 {"nativeDetachImage", "(Landroid/media/Image;)I", (void*)ImageReader_detachImage },
Emilian Peev9c778e12020-10-29 17:36:22 -0700965 {"nativeCreateImagePlanes",
966 "(ILandroid/graphics/GraphicBuffer;IIIIII)[Landroid/media/ImageReader$ImagePlane;",
967 (void*)ImageReader_createImagePlanes },
968 {"nativeUnlockGraphicBuffer",
969 "(Landroid/graphics/GraphicBuffer;)V", (void*)ImageReader_unlockGraphicBuffer },
Eino-Ville Talvala2e2aaf62016-07-21 17:04:19 -0700970 {"nativeDiscardFreeBuffers", "()V", (void*)ImageReader_discardFreeBuffers }
Zhijun He212e78d2013-06-07 11:36:23 -0700971};
972
Daniel Micay76f6a862015-09-19 17:31:01 -0400973static const JNINativeMethod gImageMethods[] = {
Clément Julliardcc217e32020-07-31 03:20:13 +0000974 {"nativeCreatePlanes", "(IIJ)[Landroid/media/ImageReader$SurfaceImage$SurfacePlane;",
Mathias Agopian3e88ed82018-02-20 18:32:22 -0800975 (void*)Image_createSurfacePlanes },
976 {"nativeGetWidth", "()I", (void*)Image_getWidth },
977 {"nativeGetHeight", "()I", (void*)Image_getHeight },
978 {"nativeGetFormat", "(I)I", (void*)Image_getFormat },
Emilian Peev9c778e12020-10-29 17:36:22 -0700979 {"nativeGetFenceFd", "()I", (void*)Image_getFenceFd },
Mathias Agopian3e88ed82018-02-20 18:32:22 -0800980 {"nativeGetHardwareBuffer", "()Landroid/hardware/HardwareBuffer;",
981 (void*)Image_getHardwareBuffer },
Zhijun He212e78d2013-06-07 11:36:23 -0700982};
983
984int register_android_media_ImageReader(JNIEnv *env) {
985
986 int ret1 = AndroidRuntime::registerNativeMethods(env,
987 "android/media/ImageReader", gImageReaderMethods, NELEM(gImageReaderMethods));
988
989 int ret2 = AndroidRuntime::registerNativeMethods(env,
990 "android/media/ImageReader$SurfaceImage", gImageMethods, NELEM(gImageMethods));
991
992 return (ret1 || ret2);
993}