1 /*
2 * Copyright (C) 2011-2012 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 "RenderScript_jni"
18
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <fcntl.h>
22 #include <unistd.h>
23 #include <math.h>
24 #include <utils/misc.h>
25 #include <inttypes.h>
26
27 #include <androidfw/Asset.h>
28 #include <androidfw/AssetManager.h>
29 #include <androidfw/ResourceTypes.h>
30
31 #include "jni.h"
32 #include "JNIHelp.h"
33 #include "android_runtime/AndroidRuntime.h"
34 #include "android_runtime/android_view_Surface.h"
35 #include "android_runtime/android_util_AssetManager.h"
36 #include "android/graphics/GraphicsJNI.h"
37
38 #include <rs.h>
39 #include <rsEnv.h>
40 #include <gui/Surface.h>
41 #include <gui/GLConsumer.h>
42 #include <android_runtime/android_graphics_SurfaceTexture.h>
43
44 //#define LOG_API ALOGE
45 static constexpr bool kLogApi = false;
46
47 using namespace android;
48
49 template <typename... T>
UNUSED(T...t)50 void UNUSED(T... t) {}
51
52 #define PER_ARRAY_TYPE(flag, fnc, readonly, ...) { \
53 jint len = 0; \
54 void *ptr = nullptr; \
55 void *srcPtr = nullptr; \
56 size_t typeBytes = 0; \
57 jint relFlag = 0; \
58 if (readonly) { \
59 /* The on-release mode should only be JNI_ABORT for read-only accesses. */ \
60 /* readonly = true, also indicates we are copying to the allocation . */ \
61 relFlag = JNI_ABORT; \
62 } \
63 switch(dataType) { \
64 case RS_TYPE_FLOAT_32: \
65 len = _env->GetArrayLength((jfloatArray)data); \
66 ptr = _env->GetFloatArrayElements((jfloatArray)data, flag); \
67 if (ptr == nullptr) { \
68 ALOGE("Failed to get Java array elements."); \
69 return; \
70 } \
71 typeBytes = 4; \
72 if (usePadding) { \
73 srcPtr = ptr; \
74 len = len / 3 * 4; \
75 if (count == 0) { \
76 count = len / 4; \
77 } \
78 ptr = malloc (len * typeBytes); \
79 if (readonly) { \
80 copyWithPadding(ptr, srcPtr, mSize, count); \
81 fnc(__VA_ARGS__); \
82 } else { \
83 fnc(__VA_ARGS__); \
84 copyWithUnPadding(srcPtr, ptr, mSize, count); \
85 } \
86 free(ptr); \
87 ptr = srcPtr; \
88 } else { \
89 fnc(__VA_ARGS__); \
90 } \
91 _env->ReleaseFloatArrayElements((jfloatArray)data, (jfloat *)ptr, relFlag); \
92 return; \
93 case RS_TYPE_FLOAT_64: \
94 len = _env->GetArrayLength((jdoubleArray)data); \
95 ptr = _env->GetDoubleArrayElements((jdoubleArray)data, flag); \
96 if (ptr == nullptr) { \
97 ALOGE("Failed to get Java array elements."); \
98 return; \
99 } \
100 typeBytes = 8; \
101 if (usePadding) { \
102 srcPtr = ptr; \
103 len = len / 3 * 4; \
104 if (count == 0) { \
105 count = len / 4; \
106 } \
107 ptr = malloc (len * typeBytes); \
108 if (readonly) { \
109 copyWithPadding(ptr, srcPtr, mSize, count); \
110 fnc(__VA_ARGS__); \
111 } else { \
112 fnc(__VA_ARGS__); \
113 copyWithUnPadding(srcPtr, ptr, mSize, count); \
114 } \
115 free(ptr); \
116 ptr = srcPtr; \
117 } else { \
118 fnc(__VA_ARGS__); \
119 } \
120 _env->ReleaseDoubleArrayElements((jdoubleArray)data, (jdouble *)ptr, relFlag); \
121 return; \
122 case RS_TYPE_SIGNED_8: \
123 case RS_TYPE_UNSIGNED_8: \
124 len = _env->GetArrayLength((jbyteArray)data); \
125 ptr = _env->GetByteArrayElements((jbyteArray)data, flag); \
126 if (ptr == nullptr) { \
127 ALOGE("Failed to get Java array elements."); \
128 return; \
129 } \
130 typeBytes = 1; \
131 if (usePadding) { \
132 srcPtr = ptr; \
133 len = len / 3 * 4; \
134 if (count == 0) { \
135 count = len / 4; \
136 } \
137 ptr = malloc (len * typeBytes); \
138 if (readonly) { \
139 copyWithPadding(ptr, srcPtr, mSize, count); \
140 fnc(__VA_ARGS__); \
141 } else { \
142 fnc(__VA_ARGS__); \
143 copyWithUnPadding(srcPtr, ptr, mSize, count); \
144 } \
145 free(ptr); \
146 ptr = srcPtr; \
147 } else { \
148 fnc(__VA_ARGS__); \
149 } \
150 _env->ReleaseByteArrayElements((jbyteArray)data, (jbyte*)ptr, relFlag); \
151 return; \
152 case RS_TYPE_SIGNED_16: \
153 case RS_TYPE_UNSIGNED_16: \
154 case RS_TYPE_FLOAT_16: \
155 len = _env->GetArrayLength((jshortArray)data); \
156 ptr = _env->GetShortArrayElements((jshortArray)data, flag); \
157 if (ptr == nullptr) { \
158 ALOGE("Failed to get Java array elements."); \
159 return; \
160 } \
161 typeBytes = 2; \
162 if (usePadding) { \
163 srcPtr = ptr; \
164 len = len / 3 * 4; \
165 if (count == 0) { \
166 count = len / 4; \
167 } \
168 ptr = malloc (len * typeBytes); \
169 if (readonly) { \
170 copyWithPadding(ptr, srcPtr, mSize, count); \
171 fnc(__VA_ARGS__); \
172 } else { \
173 fnc(__VA_ARGS__); \
174 copyWithUnPadding(srcPtr, ptr, mSize, count); \
175 } \
176 free(ptr); \
177 ptr = srcPtr; \
178 } else { \
179 fnc(__VA_ARGS__); \
180 } \
181 _env->ReleaseShortArrayElements((jshortArray)data, (jshort *)ptr, relFlag); \
182 return; \
183 case RS_TYPE_SIGNED_32: \
184 case RS_TYPE_UNSIGNED_32: \
185 len = _env->GetArrayLength((jintArray)data); \
186 ptr = _env->GetIntArrayElements((jintArray)data, flag); \
187 if (ptr == nullptr) { \
188 ALOGE("Failed to get Java array elements."); \
189 return; \
190 } \
191 typeBytes = 4; \
192 if (usePadding) { \
193 srcPtr = ptr; \
194 len = len / 3 * 4; \
195 if (count == 0) { \
196 count = len / 4; \
197 } \
198 ptr = malloc (len * typeBytes); \
199 if (readonly) { \
200 copyWithPadding(ptr, srcPtr, mSize, count); \
201 fnc(__VA_ARGS__); \
202 } else { \
203 fnc(__VA_ARGS__); \
204 copyWithUnPadding(srcPtr, ptr, mSize, count); \
205 } \
206 free(ptr); \
207 ptr = srcPtr; \
208 } else { \
209 fnc(__VA_ARGS__); \
210 } \
211 _env->ReleaseIntArrayElements((jintArray)data, (jint *)ptr, relFlag); \
212 return; \
213 case RS_TYPE_SIGNED_64: \
214 case RS_TYPE_UNSIGNED_64: \
215 len = _env->GetArrayLength((jlongArray)data); \
216 ptr = _env->GetLongArrayElements((jlongArray)data, flag); \
217 if (ptr == nullptr) { \
218 ALOGE("Failed to get Java array elements."); \
219 return; \
220 } \
221 typeBytes = 8; \
222 if (usePadding) { \
223 srcPtr = ptr; \
224 len = len / 3 * 4; \
225 if (count == 0) { \
226 count = len / 4; \
227 } \
228 ptr = malloc (len * typeBytes); \
229 if (readonly) { \
230 copyWithPadding(ptr, srcPtr, mSize, count); \
231 fnc(__VA_ARGS__); \
232 } else { \
233 fnc(__VA_ARGS__); \
234 copyWithUnPadding(srcPtr, ptr, mSize, count); \
235 } \
236 free(ptr); \
237 ptr = srcPtr; \
238 } else { \
239 fnc(__VA_ARGS__); \
240 } \
241 _env->ReleaseLongArrayElements((jlongArray)data, (jlong *)ptr, relFlag); \
242 return; \
243 default: \
244 break; \
245 } \
246 UNUSED(len, ptr, srcPtr, typeBytes, relFlag); \
247 }
248
249
250 class AutoJavaStringToUTF8 {
251 public:
AutoJavaStringToUTF8(JNIEnv * env,jstring str)252 AutoJavaStringToUTF8(JNIEnv* env, jstring str) : fEnv(env), fJStr(str) {
253 fCStr = env->GetStringUTFChars(str, nullptr);
254 fLength = env->GetStringUTFLength(str);
255 }
~AutoJavaStringToUTF8()256 ~AutoJavaStringToUTF8() {
257 fEnv->ReleaseStringUTFChars(fJStr, fCStr);
258 }
c_str() const259 const char* c_str() const { return fCStr; }
length() const260 jsize length() const { return fLength; }
261
262 private:
263 JNIEnv* fEnv;
264 jstring fJStr;
265 const char* fCStr;
266 jsize fLength;
267 };
268
269 class AutoJavaStringArrayToUTF8 {
270 public:
AutoJavaStringArrayToUTF8(JNIEnv * env,jobjectArray strings,jsize stringsLength)271 AutoJavaStringArrayToUTF8(JNIEnv* env, jobjectArray strings, jsize stringsLength)
272 : mEnv(env), mStrings(strings), mStringsLength(stringsLength) {
273 mCStrings = nullptr;
274 mSizeArray = nullptr;
275 if (stringsLength > 0) {
276 mCStrings = (const char **)calloc(stringsLength, sizeof(char *));
277 mSizeArray = (size_t*)calloc(stringsLength, sizeof(size_t));
278 for (jsize ct = 0; ct < stringsLength; ct ++) {
279 jstring s = (jstring)mEnv->GetObjectArrayElement(mStrings, ct);
280 mCStrings[ct] = mEnv->GetStringUTFChars(s, nullptr);
281 mSizeArray[ct] = mEnv->GetStringUTFLength(s);
282 }
283 }
284 }
~AutoJavaStringArrayToUTF8()285 ~AutoJavaStringArrayToUTF8() {
286 for (jsize ct=0; ct < mStringsLength; ct++) {
287 jstring s = (jstring)mEnv->GetObjectArrayElement(mStrings, ct);
288 mEnv->ReleaseStringUTFChars(s, mCStrings[ct]);
289 }
290 free(mCStrings);
291 free(mSizeArray);
292 }
c_str() const293 const char **c_str() const { return mCStrings; }
c_str_len() const294 size_t *c_str_len() const { return mSizeArray; }
length() const295 jsize length() const { return mStringsLength; }
296
297 private:
298 JNIEnv *mEnv;
299 jobjectArray mStrings;
300 const char **mCStrings;
301 size_t *mSizeArray;
302 jsize mStringsLength;
303 };
304
305 // ---------------------------------------------------------------------------
306
307 static jfieldID gContextId = 0;
308
_nInit(JNIEnv * _env,jclass _this)309 static void _nInit(JNIEnv *_env, jclass _this)
310 {
311 gContextId = _env->GetFieldID(_this, "mContext", "J");
312 }
313
314 // ---------------------------------------------------------------------------
315
copyWithPadding(void * ptr,void * srcPtr,int mSize,int count)316 static void copyWithPadding(void* ptr, void* srcPtr, int mSize, int count) {
317 int sizeBytesPad = mSize * 4;
318 int sizeBytes = mSize * 3;
319 uint8_t *dst = static_cast<uint8_t *>(ptr);
320 uint8_t *src = static_cast<uint8_t *>(srcPtr);
321 for (int i = 0; i < count; i++) {
322 memcpy(dst, src, sizeBytes);
323 dst += sizeBytesPad;
324 src += sizeBytes;
325 }
326 }
327
copyWithUnPadding(void * ptr,void * srcPtr,int mSize,int count)328 static void copyWithUnPadding(void* ptr, void* srcPtr, int mSize, int count) {
329 int sizeBytesPad = mSize * 4;
330 int sizeBytes = mSize * 3;
331 uint8_t *dst = static_cast<uint8_t *>(ptr);
332 uint8_t *src = static_cast<uint8_t *>(srcPtr);
333 for (int i = 0; i < count; i++) {
334 memcpy(dst, src, sizeBytes);
335 dst += sizeBytes;
336 src += sizeBytesPad;
337 }
338 }
339
340
341 // ---------------------------------------------------------------------------
342 static void
nContextFinish(JNIEnv * _env,jobject _this,jlong con)343 nContextFinish(JNIEnv *_env, jobject _this, jlong con)
344 {
345 if (kLogApi) {
346 ALOGD("nContextFinish, con(%p)", (RsContext)con);
347 }
348 rsContextFinish((RsContext)con);
349 }
350
351 static jlong
nClosureCreate(JNIEnv * _env,jobject _this,jlong con,jlong kernelID,jlong returnValue,jlongArray fieldIDArray,jlongArray valueArray,jintArray sizeArray,jlongArray depClosureArray,jlongArray depFieldIDArray)352 nClosureCreate(JNIEnv *_env, jobject _this, jlong con, jlong kernelID,
353 jlong returnValue, jlongArray fieldIDArray,
354 jlongArray valueArray, jintArray sizeArray,
355 jlongArray depClosureArray, jlongArray depFieldIDArray) {
356 jlong ret = 0;
357
358 jlong* jFieldIDs = _env->GetLongArrayElements(fieldIDArray, nullptr);
359 jsize fieldIDs_length = _env->GetArrayLength(fieldIDArray);
360 if (jFieldIDs == nullptr) {
361 ALOGE("Failed to get Java array elements: fieldIDs.");
362 return ret;
363 }
364
365 jlong* jValues = _env->GetLongArrayElements(valueArray, nullptr);
366 jsize values_length = _env->GetArrayLength(valueArray);
367 if (jValues == nullptr) {
368 ALOGE("Failed to get Java array elements: values.");
369 return ret;
370 }
371
372 jint* jSizes = _env->GetIntArrayElements(sizeArray, nullptr);
373 jsize sizes_length = _env->GetArrayLength(sizeArray);
374 if (jSizes == nullptr) {
375 ALOGE("Failed to get Java array elements: sizes.");
376 return ret;
377 }
378
379 jlong* jDepClosures =
380 _env->GetLongArrayElements(depClosureArray, nullptr);
381 jsize depClosures_length = _env->GetArrayLength(depClosureArray);
382 if (jDepClosures == nullptr) {
383 ALOGE("Failed to get Java array elements: depClosures.");
384 return ret;
385 }
386
387 jlong* jDepFieldIDs =
388 _env->GetLongArrayElements(depFieldIDArray, nullptr);
389 jsize depFieldIDs_length = _env->GetArrayLength(depFieldIDArray);
390 if (jDepFieldIDs == nullptr) {
391 ALOGE("Failed to get Java array elements: depFieldIDs.");
392 return ret;
393 }
394
395 size_t numValues, numDependencies;
396 RsScriptFieldID* fieldIDs;
397 RsClosure* depClosures;
398 RsScriptFieldID* depFieldIDs;
399
400 if (fieldIDs_length != values_length || values_length != sizes_length) {
401 ALOGE("Unmatched field IDs, values, and sizes in closure creation.");
402 goto exit;
403 }
404
405 numValues = (size_t)fieldIDs_length;
406
407 if (depClosures_length != depFieldIDs_length) {
408 ALOGE("Unmatched closures and field IDs for dependencies in closure creation.");
409 goto exit;
410 }
411
412 numDependencies = (size_t)depClosures_length;
413
414 if (numDependencies > numValues) {
415 ALOGE("Unexpected number of dependencies in closure creation");
416 goto exit;
417 }
418
419 if (numValues > RS_CLOSURE_MAX_NUMBER_ARGS_AND_BINDINGS) {
420 ALOGE("Too many arguments or globals in closure creation");
421 goto exit;
422 }
423
424 fieldIDs = (RsScriptFieldID*)alloca(sizeof(RsScriptFieldID) * numValues);
425 if (fieldIDs == nullptr) {
426 goto exit;
427 }
428
429 for (size_t i = 0; i < numValues; i++) {
430 fieldIDs[i] = (RsScriptFieldID)jFieldIDs[i];
431 }
432
433 depClosures = (RsClosure*)alloca(sizeof(RsClosure) * numDependencies);
434 if (depClosures == nullptr) {
435 goto exit;
436 }
437
438 for (size_t i = 0; i < numDependencies; i++) {
439 depClosures[i] = (RsClosure)jDepClosures[i];
440 }
441
442 depFieldIDs = (RsScriptFieldID*)alloca(sizeof(RsScriptFieldID) * numDependencies);
443 if (depFieldIDs == nullptr) {
444 goto exit;
445 }
446
447 for (size_t i = 0; i < numDependencies; i++) {
448 depFieldIDs[i] = (RsClosure)jDepFieldIDs[i];
449 }
450
451 ret = (jlong)(uintptr_t)rsClosureCreate(
452 (RsContext)con, (RsScriptKernelID)kernelID, (RsAllocation)returnValue,
453 fieldIDs, numValues, jValues, numValues,
454 (int*)jSizes, numValues,
455 depClosures, numDependencies,
456 depFieldIDs, numDependencies);
457
458 exit:
459
460 _env->ReleaseLongArrayElements(depFieldIDArray, jDepFieldIDs, JNI_ABORT);
461 _env->ReleaseLongArrayElements(depClosureArray, jDepClosures, JNI_ABORT);
462 _env->ReleaseIntArrayElements (sizeArray, jSizes, JNI_ABORT);
463 _env->ReleaseLongArrayElements(valueArray, jValues, JNI_ABORT);
464 _env->ReleaseLongArrayElements(fieldIDArray, jFieldIDs, JNI_ABORT);
465
466 return ret;
467 }
468
469 static jlong
nInvokeClosureCreate(JNIEnv * _env,jobject _this,jlong con,jlong invokeID,jbyteArray paramArray,jlongArray fieldIDArray,jlongArray valueArray,jintArray sizeArray)470 nInvokeClosureCreate(JNIEnv *_env, jobject _this, jlong con, jlong invokeID,
471 jbyteArray paramArray, jlongArray fieldIDArray, jlongArray valueArray,
472 jintArray sizeArray) {
473 jlong ret = 0;
474
475 jbyte* jParams = _env->GetByteArrayElements(paramArray, nullptr);
476 jsize jParamLength = _env->GetArrayLength(paramArray);
477 if (jParams == nullptr) {
478 ALOGE("Failed to get Java array elements: params.");
479 return ret;
480 }
481
482 jlong* jFieldIDs = _env->GetLongArrayElements(fieldIDArray, nullptr);
483 jsize fieldIDs_length = _env->GetArrayLength(fieldIDArray);
484 if (jFieldIDs == nullptr) {
485 ALOGE("Failed to get Java array elements: fieldIDs.");
486 return ret;
487 }
488
489 jlong* jValues = _env->GetLongArrayElements(valueArray, nullptr);
490 jsize values_length = _env->GetArrayLength(valueArray);
491 if (jValues == nullptr) {
492 ALOGE("Failed to get Java array elements: values.");
493 return ret;
494 }
495
496 jint* jSizes = _env->GetIntArrayElements(sizeArray, nullptr);
497 jsize sizes_length = _env->GetArrayLength(sizeArray);
498 if (jSizes == nullptr) {
499 ALOGE("Failed to get Java array elements: sizes.");
500 return ret;
501 }
502
503 size_t numValues;
504 RsScriptFieldID* fieldIDs;
505
506 if (fieldIDs_length != values_length || values_length != sizes_length) {
507 ALOGE("Unmatched field IDs, values, and sizes in closure creation.");
508 goto exit;
509 }
510
511 numValues = (size_t) fieldIDs_length;
512
513 if (numValues > RS_CLOSURE_MAX_NUMBER_ARGS_AND_BINDINGS) {
514 ALOGE("Too many arguments or globals in closure creation");
515 goto exit;
516 }
517
518 fieldIDs = (RsScriptFieldID*)alloca(sizeof(RsScriptFieldID) * numValues);
519 if (fieldIDs == nullptr) {
520 goto exit;
521 }
522
523 for (size_t i = 0; i< numValues; i++) {
524 fieldIDs[i] = (RsScriptFieldID)jFieldIDs[i];
525 }
526
527 ret = (jlong)(uintptr_t)rsInvokeClosureCreate(
528 (RsContext)con, (RsScriptInvokeID)invokeID, jParams, jParamLength,
529 fieldIDs, numValues, jValues, numValues,
530 (int*)jSizes, numValues);
531
532 exit:
533
534 _env->ReleaseIntArrayElements (sizeArray, jSizes, JNI_ABORT);
535 _env->ReleaseLongArrayElements(valueArray, jValues, JNI_ABORT);
536 _env->ReleaseLongArrayElements(fieldIDArray, jFieldIDs, JNI_ABORT);
537 _env->ReleaseByteArrayElements(paramArray, jParams, JNI_ABORT);
538
539 return ret;
540 }
541
542 static void
nClosureSetArg(JNIEnv * _env,jobject _this,jlong con,jlong closureID,jint index,jlong value,jint size)543 nClosureSetArg(JNIEnv *_env, jobject _this, jlong con, jlong closureID,
544 jint index, jlong value, jint size) {
545 // Size is signed with -1 indicating the value is an Allocation
546 rsClosureSetArg((RsContext)con, (RsClosure)closureID, (uint32_t)index,
547 (uintptr_t)value, size);
548 }
549
550 static void
nClosureSetGlobal(JNIEnv * _env,jobject _this,jlong con,jlong closureID,jlong fieldID,jlong value,jint size)551 nClosureSetGlobal(JNIEnv *_env, jobject _this, jlong con, jlong closureID,
552 jlong fieldID, jlong value, jint size) {
553 // Size is signed with -1 indicating the value is an Allocation
554 rsClosureSetGlobal((RsContext)con, (RsClosure)closureID,
555 (RsScriptFieldID)fieldID, (int64_t)value, size);
556 }
557
558 static long
nScriptGroup2Create(JNIEnv * _env,jobject _this,jlong con,jstring name,jstring cacheDir,jlongArray closureArray)559 nScriptGroup2Create(JNIEnv *_env, jobject _this, jlong con, jstring name,
560 jstring cacheDir, jlongArray closureArray) {
561 jlong ret = 0;
562
563 AutoJavaStringToUTF8 nameUTF(_env, name);
564 AutoJavaStringToUTF8 cacheDirUTF(_env, cacheDir);
565
566 jlong* jClosures = _env->GetLongArrayElements(closureArray, nullptr);
567 jsize numClosures = _env->GetArrayLength(closureArray);
568 if (jClosures == nullptr) {
569 ALOGE("Failed to get Java array elements: closures.");
570 return ret;
571 }
572
573 RsClosure* closures;
574
575 if (numClosures > (jsize) RS_SCRIPT_GROUP_MAX_NUMBER_CLOSURES) {
576 ALOGE("Too many closures in script group");
577 goto exit;
578 }
579
580 closures = (RsClosure*)alloca(sizeof(RsClosure) * numClosures);
581 if (closures == nullptr) {
582 goto exit;
583 }
584
585 for (int i = 0; i < numClosures; i++) {
586 closures[i] = (RsClosure)jClosures[i];
587 }
588
589 ret = (jlong)(uintptr_t)rsScriptGroup2Create(
590 (RsContext)con, nameUTF.c_str(), nameUTF.length(),
591 cacheDirUTF.c_str(), cacheDirUTF.length(),
592 closures, numClosures);
593
594 exit:
595
596 _env->ReleaseLongArrayElements(closureArray, jClosures, JNI_ABORT);
597
598 return ret;
599 }
600
601 static void
nScriptGroup2Execute(JNIEnv * _env,jobject _this,jlong con,jlong groupID)602 nScriptGroup2Execute(JNIEnv *_env, jobject _this, jlong con, jlong groupID) {
603 rsScriptGroupExecute((RsContext)con, (RsScriptGroup2)groupID);
604 }
605
606 static void
nScriptIntrinsicBLAS_Single(JNIEnv * _env,jobject _this,jlong con,jlong id,jint func,jint TransA,jint TransB,jint Side,jint Uplo,jint Diag,jint M,jint N,jint K,jfloat alpha,jlong A,jlong B,jfloat beta,jlong C,jint incX,jint incY,jint KL,jint KU)607 nScriptIntrinsicBLAS_Single(JNIEnv *_env, jobject _this, jlong con, jlong id, jint func, jint TransA,
608 jint TransB, jint Side, jint Uplo, jint Diag, jint M, jint N, jint K,
609 jfloat alpha, jlong A, jlong B, jfloat beta, jlong C, jint incX, jint incY,
610 jint KL, jint KU) {
611 RsBlasCall call;
612 memset(&call, 0, sizeof(call));
613 call.func = (RsBlasFunction)func;
614 call.transA = (RsBlasTranspose)TransA;
615 call.transB = (RsBlasTranspose)TransB;
616 call.side = (RsBlasSide)Side;
617 call.uplo = (RsBlasUplo)Uplo;
618 call.diag = (RsBlasDiag)Diag;
619 call.M = M;
620 call.N = N;
621 call.K = K;
622 call.alpha.f = alpha;
623 call.beta.f = beta;
624 call.incX = incX;
625 call.incY = incY;
626 call.KL = KL;
627 call.KU = KU;
628
629 RsAllocation in_allocs[3];
630 in_allocs[0] = (RsAllocation)A;
631 in_allocs[1] = (RsAllocation)B;
632 in_allocs[2] = (RsAllocation)C;
633
634 rsScriptForEachMulti((RsContext)con, (RsScript)id, 0,
635 in_allocs, sizeof(in_allocs), nullptr,
636 &call, sizeof(call), nullptr, 0);
637 }
638
639 static void
nScriptIntrinsicBLAS_Double(JNIEnv * _env,jobject _this,jlong con,jlong id,jint func,jint TransA,jint TransB,jint Side,jint Uplo,jint Diag,jint M,jint N,jint K,jdouble alpha,jlong A,jlong B,jdouble beta,jlong C,jint incX,jint incY,jint KL,jint KU)640 nScriptIntrinsicBLAS_Double(JNIEnv *_env, jobject _this, jlong con, jlong id, jint func, jint TransA,
641 jint TransB, jint Side, jint Uplo, jint Diag, jint M, jint N, jint K,
642 jdouble alpha, jlong A, jlong B, jdouble beta, jlong C, jint incX, jint incY,
643 jint KL, jint KU) {
644 RsBlasCall call;
645 memset(&call, 0, sizeof(call));
646 call.func = (RsBlasFunction)func;
647 call.transA = (RsBlasTranspose)TransA;
648 call.transB = (RsBlasTranspose)TransB;
649 call.side = (RsBlasSide)Side;
650 call.uplo = (RsBlasUplo)Uplo;
651 call.diag = (RsBlasDiag)Diag;
652 call.M = M;
653 call.N = N;
654 call.K = K;
655 call.alpha.d = alpha;
656 call.beta.d = beta;
657 call.incX = incX;
658 call.incY = incY;
659 call.KL = KL;
660 call.KU = KU;
661
662 RsAllocation in_allocs[3];
663 in_allocs[0] = (RsAllocation)A;
664 in_allocs[1] = (RsAllocation)B;
665 in_allocs[2] = (RsAllocation)C;
666
667 rsScriptForEachMulti((RsContext)con, (RsScript)id, 0,
668 in_allocs, NELEM(in_allocs), nullptr,
669 &call, sizeof(call), nullptr, 0);
670 }
671
672 static void
nScriptIntrinsicBLAS_Complex(JNIEnv * _env,jobject _this,jlong con,jlong id,jint func,jint TransA,jint TransB,jint Side,jint Uplo,jint Diag,jint M,jint N,jint K,jfloat alphaX,jfloat alphaY,jlong A,jlong B,jfloat betaX,jfloat betaY,jlong C,jint incX,jint incY,jint KL,jint KU)673 nScriptIntrinsicBLAS_Complex(JNIEnv *_env, jobject _this, jlong con, jlong id, jint func, jint TransA,
674 jint TransB, jint Side, jint Uplo, jint Diag, jint M, jint N, jint K,
675 jfloat alphaX, jfloat alphaY, jlong A, jlong B, jfloat betaX,
676 jfloat betaY, jlong C, jint incX, jint incY, jint KL, jint KU) {
677 RsBlasCall call;
678 memset(&call, 0, sizeof(call));
679 call.func = (RsBlasFunction)func;
680 call.transA = (RsBlasTranspose)TransA;
681 call.transB = (RsBlasTranspose)TransB;
682 call.side = (RsBlasSide)Side;
683 call.uplo = (RsBlasUplo)Uplo;
684 call.diag = (RsBlasDiag)Diag;
685 call.M = M;
686 call.N = N;
687 call.K = K;
688 call.alpha.c.r = alphaX;
689 call.alpha.c.i = alphaY;
690 call.beta.c.r = betaX;
691 call.beta.c.i = betaY;
692 call.incX = incX;
693 call.incY = incY;
694 call.KL = KL;
695 call.KU = KU;
696
697 RsAllocation in_allocs[3];
698 in_allocs[0] = (RsAllocation)A;
699 in_allocs[1] = (RsAllocation)B;
700 in_allocs[2] = (RsAllocation)C;
701
702 rsScriptForEachMulti((RsContext)con, (RsScript)id, 0,
703 in_allocs, NELEM(in_allocs), nullptr,
704 &call, sizeof(call), nullptr, 0);
705 }
706
707 static void
nScriptIntrinsicBLAS_Z(JNIEnv * _env,jobject _this,jlong con,jlong id,jint func,jint TransA,jint TransB,jint Side,jint Uplo,jint Diag,jint M,jint N,jint K,jdouble alphaX,jdouble alphaY,jlong A,jlong B,jdouble betaX,jdouble betaY,jlong C,jint incX,jint incY,jint KL,jint KU)708 nScriptIntrinsicBLAS_Z(JNIEnv *_env, jobject _this, jlong con, jlong id, jint func, jint TransA,
709 jint TransB, jint Side, jint Uplo, jint Diag, jint M, jint N, jint K,
710 jdouble alphaX, jdouble alphaY, jlong A, jlong B, jdouble betaX,
711 jdouble betaY, jlong C, jint incX, jint incY, jint KL, jint KU) {
712 RsBlasCall call;
713 memset(&call, 0, sizeof(call));
714 call.func = (RsBlasFunction)func;
715 call.transA = (RsBlasTranspose)TransA;
716 call.transB = (RsBlasTranspose)TransB;
717 call.side = (RsBlasSide)Side;
718 call.uplo = (RsBlasUplo)Uplo;
719 call.diag = (RsBlasDiag)Diag;
720 call.M = M;
721 call.N = N;
722 call.K = K;
723 call.alpha.z.r = alphaX;
724 call.alpha.z.i = alphaY;
725 call.beta.z.r = betaX;
726 call.beta.z.i = betaY;
727 call.incX = incX;
728 call.incY = incY;
729 call.KL = KL;
730 call.KU = KU;
731
732 RsAllocation in_allocs[3];
733 in_allocs[0] = (RsAllocation)A;
734 in_allocs[1] = (RsAllocation)B;
735 in_allocs[2] = (RsAllocation)C;
736
737 rsScriptForEachMulti((RsContext)con, (RsScript)id, 0,
738 in_allocs, NELEM(in_allocs), nullptr,
739 &call, sizeof(call), nullptr, 0);
740 }
741
742
743 static void
nScriptIntrinsicBLAS_BNNM(JNIEnv * _env,jobject _this,jlong con,jlong id,jint M,jint N,jint K,jlong A,jint a_offset,jlong B,jint b_offset,jlong C,jint c_offset,jint c_mult_int)744 nScriptIntrinsicBLAS_BNNM(JNIEnv *_env, jobject _this, jlong con, jlong id, jint M, jint N, jint K,
745 jlong A, jint a_offset, jlong B, jint b_offset, jlong C, jint c_offset,
746 jint c_mult_int) {
747 RsBlasCall call;
748 memset(&call, 0, sizeof(call));
749 call.func = RsBlas_bnnm;
750 call.M = M;
751 call.N = N;
752 call.K = K;
753 call.a_offset = a_offset & 0xFF;
754 call.b_offset = b_offset & 0xFF;
755 call.c_offset = c_offset;
756 call.c_mult_int = c_mult_int;
757
758 RsAllocation in_allocs[3];
759 in_allocs[0] = (RsAllocation)A;
760 in_allocs[1] = (RsAllocation)B;
761 in_allocs[2] = (RsAllocation)C;
762
763 rsScriptForEachMulti((RsContext)con, (RsScript)id, 0,
764 in_allocs, NELEM(in_allocs), nullptr,
765 &call, sizeof(call), nullptr, 0);
766 }
767
768
769 static void
nAssignName(JNIEnv * _env,jobject _this,jlong con,jlong obj,jbyteArray str)770 nAssignName(JNIEnv *_env, jobject _this, jlong con, jlong obj, jbyteArray str)
771 {
772 if (kLogApi) {
773 ALOGD("nAssignName, con(%p), obj(%p)", (RsContext)con, (void *)obj);
774 }
775 jint len = _env->GetArrayLength(str);
776 jbyte * cptr = (jbyte *) _env->GetPrimitiveArrayCritical(str, 0);
777 if (cptr == nullptr) {
778 ALOGE("Failed to get Java array elements");
779 return;
780 }
781
782 rsAssignName((RsContext)con, (void *)obj, (const char *)cptr, len);
783 _env->ReleasePrimitiveArrayCritical(str, cptr, JNI_ABORT);
784 }
785
786 static jstring
nGetName(JNIEnv * _env,jobject _this,jlong con,jlong obj)787 nGetName(JNIEnv *_env, jobject _this, jlong con, jlong obj)
788 {
789 if (kLogApi) {
790 ALOGD("nGetName, con(%p), obj(%p)", (RsContext)con, (void *)obj);
791 }
792 const char *name = nullptr;
793 rsaGetName((RsContext)con, (void *)obj, &name);
794 if(name == nullptr || strlen(name) == 0) {
795 return nullptr;
796 }
797 return _env->NewStringUTF(name);
798 }
799
800 static void
nObjDestroy(JNIEnv * _env,jobject _this,jlong con,jlong obj)801 nObjDestroy(JNIEnv *_env, jobject _this, jlong con, jlong obj)
802 {
803 if (kLogApi) {
804 ALOGD("nObjDestroy, con(%p) obj(%p)", (RsContext)con, (void *)obj);
805 }
806 rsObjDestroy((RsContext)con, (void *)obj);
807 }
808
809 // ---------------------------------------------------------------------------
810
811 static jlong
nDeviceCreate(JNIEnv * _env,jobject _this)812 nDeviceCreate(JNIEnv *_env, jobject _this)
813 {
814 if (kLogApi) {
815 ALOGD("nDeviceCreate");
816 }
817 return (jlong)(uintptr_t)rsDeviceCreate();
818 }
819
820 static void
nDeviceDestroy(JNIEnv * _env,jobject _this,jlong dev)821 nDeviceDestroy(JNIEnv *_env, jobject _this, jlong dev)
822 {
823 if (kLogApi) {
824 ALOGD("nDeviceDestroy");
825 }
826 return rsDeviceDestroy((RsDevice)dev);
827 }
828
829 static void
nDeviceSetConfig(JNIEnv * _env,jobject _this,jlong dev,jint p,jint value)830 nDeviceSetConfig(JNIEnv *_env, jobject _this, jlong dev, jint p, jint value)
831 {
832 if (kLogApi) {
833 ALOGD("nDeviceSetConfig dev(%p), param(%i), value(%i)", (void *)dev, p, value);
834 }
835 return rsDeviceSetConfig((RsDevice)dev, (RsDeviceParam)p, value);
836 }
837
838 static jlong
nContextCreate(JNIEnv * _env,jobject _this,jlong dev,jint flags,jint sdkVer,jint contextType)839 nContextCreate(JNIEnv *_env, jobject _this, jlong dev, jint flags, jint sdkVer, jint contextType)
840 {
841 if (kLogApi) {
842 ALOGD("nContextCreate");
843 }
844 return (jlong)(uintptr_t)rsContextCreate((RsDevice)dev, 0, sdkVer, (RsContextType)contextType, flags);
845 }
846
847 static jlong
nContextCreateGL(JNIEnv * _env,jobject _this,jlong dev,jint ver,jint sdkVer,jint colorMin,jint colorPref,jint alphaMin,jint alphaPref,jint depthMin,jint depthPref,jint stencilMin,jint stencilPref,jint samplesMin,jint samplesPref,jfloat samplesQ,jint dpi)848 nContextCreateGL(JNIEnv *_env, jobject _this, jlong dev, jint ver, jint sdkVer,
849 jint colorMin, jint colorPref,
850 jint alphaMin, jint alphaPref,
851 jint depthMin, jint depthPref,
852 jint stencilMin, jint stencilPref,
853 jint samplesMin, jint samplesPref, jfloat samplesQ,
854 jint dpi)
855 {
856 RsSurfaceConfig sc;
857 sc.alphaMin = alphaMin;
858 sc.alphaPref = alphaPref;
859 sc.colorMin = colorMin;
860 sc.colorPref = colorPref;
861 sc.depthMin = depthMin;
862 sc.depthPref = depthPref;
863 sc.samplesMin = samplesMin;
864 sc.samplesPref = samplesPref;
865 sc.samplesQ = samplesQ;
866
867 if (kLogApi) {
868 ALOGD("nContextCreateGL");
869 }
870 return (jlong)(uintptr_t)rsContextCreateGL((RsDevice)dev, ver, sdkVer, sc, dpi);
871 }
872
873 static void
nContextSetPriority(JNIEnv * _env,jobject _this,jlong con,jint p)874 nContextSetPriority(JNIEnv *_env, jobject _this, jlong con, jint p)
875 {
876 if (kLogApi) {
877 ALOGD("ContextSetPriority, con(%p), priority(%i)", (RsContext)con, p);
878 }
879 rsContextSetPriority((RsContext)con, p);
880 }
881
882 static void
nContextSetCacheDir(JNIEnv * _env,jobject _this,jlong con,jstring cacheDir)883 nContextSetCacheDir(JNIEnv *_env, jobject _this, jlong con, jstring cacheDir)
884 {
885 AutoJavaStringToUTF8 cacheDirUTF(_env, cacheDir);
886
887 if (kLogApi) {
888 ALOGD("ContextSetCacheDir, con(%p), cacheDir(%s)", (RsContext)con, cacheDirUTF.c_str());
889 }
890 rsContextSetCacheDir((RsContext)con, cacheDirUTF.c_str(), cacheDirUTF.length());
891 }
892
893
894
895 static void
nContextSetSurface(JNIEnv * _env,jobject _this,jlong con,jint width,jint height,jobject wnd)896 nContextSetSurface(JNIEnv *_env, jobject _this, jlong con, jint width, jint height, jobject wnd)
897 {
898 if (kLogApi) {
899 ALOGD("nContextSetSurface, con(%p), width(%i), height(%i), surface(%p)", (RsContext)con,
900 width, height, (Surface *)wnd);
901 }
902
903 ANativeWindow * window = nullptr;
904 if (wnd == nullptr) {
905
906 } else {
907 window = android_view_Surface_getNativeWindow(_env, wnd).get();
908 }
909
910 rsContextSetSurface((RsContext)con, width, height, window);
911 }
912
913 static void
nContextDestroy(JNIEnv * _env,jobject _this,jlong con)914 nContextDestroy(JNIEnv *_env, jobject _this, jlong con)
915 {
916 if (kLogApi) {
917 ALOGD("nContextDestroy, con(%p)", (RsContext)con);
918 }
919 rsContextDestroy((RsContext)con);
920 }
921
922 static void
nContextDump(JNIEnv * _env,jobject _this,jlong con,jint bits)923 nContextDump(JNIEnv *_env, jobject _this, jlong con, jint bits)
924 {
925 if (kLogApi) {
926 ALOGD("nContextDump, con(%p) bits(%i)", (RsContext)con, bits);
927 }
928 rsContextDump((RsContext)con, bits);
929 }
930
931 static void
nContextPause(JNIEnv * _env,jobject _this,jlong con)932 nContextPause(JNIEnv *_env, jobject _this, jlong con)
933 {
934 if (kLogApi) {
935 ALOGD("nContextPause, con(%p)", (RsContext)con);
936 }
937 rsContextPause((RsContext)con);
938 }
939
940 static void
nContextResume(JNIEnv * _env,jobject _this,jlong con)941 nContextResume(JNIEnv *_env, jobject _this, jlong con)
942 {
943 if (kLogApi) {
944 ALOGD("nContextResume, con(%p)", (RsContext)con);
945 }
946 rsContextResume((RsContext)con);
947 }
948
949
950 static jstring
nContextGetErrorMessage(JNIEnv * _env,jobject _this,jlong con)951 nContextGetErrorMessage(JNIEnv *_env, jobject _this, jlong con)
952 {
953 if (kLogApi) {
954 ALOGD("nContextGetErrorMessage, con(%p)", (RsContext)con);
955 }
956 char buf[1024];
957
958 size_t receiveLen;
959 uint32_t subID;
960 int id = rsContextGetMessage((RsContext)con,
961 buf, sizeof(buf),
962 &receiveLen, sizeof(receiveLen),
963 &subID, sizeof(subID));
964 if (!id && receiveLen) {
965 ALOGV("message receive buffer too small. %zu", receiveLen);
966 }
967 return _env->NewStringUTF(buf);
968 }
969
970 static jint
nContextGetUserMessage(JNIEnv * _env,jobject _this,jlong con,jintArray data)971 nContextGetUserMessage(JNIEnv *_env, jobject _this, jlong con, jintArray data)
972 {
973 jint len = _env->GetArrayLength(data);
974 if (kLogApi) {
975 ALOGD("nContextGetMessage, con(%p), len(%i)", (RsContext)con, len);
976 }
977 jint *ptr = _env->GetIntArrayElements(data, nullptr);
978 if (ptr == nullptr) {
979 ALOGE("Failed to get Java array elements");
980 return 0;
981 }
982 size_t receiveLen;
983 uint32_t subID;
984 int id = rsContextGetMessage((RsContext)con,
985 ptr, len * 4,
986 &receiveLen, sizeof(receiveLen),
987 &subID, sizeof(subID));
988 if (!id && receiveLen) {
989 ALOGV("message receive buffer too small. %zu", receiveLen);
990 }
991 _env->ReleaseIntArrayElements(data, ptr, 0);
992 return (jint)id;
993 }
994
995 static jint
nContextPeekMessage(JNIEnv * _env,jobject _this,jlong con,jintArray auxData)996 nContextPeekMessage(JNIEnv *_env, jobject _this, jlong con, jintArray auxData)
997 {
998 if (kLogApi) {
999 ALOGD("nContextPeekMessage, con(%p)", (RsContext)con);
1000 }
1001 jint *auxDataPtr = _env->GetIntArrayElements(auxData, nullptr);
1002 if (auxDataPtr == nullptr) {
1003 ALOGE("Failed to get Java array elements");
1004 return 0;
1005 }
1006 size_t receiveLen;
1007 uint32_t subID;
1008 int id = rsContextPeekMessage((RsContext)con, &receiveLen, sizeof(receiveLen),
1009 &subID, sizeof(subID));
1010 auxDataPtr[0] = (jint)subID;
1011 auxDataPtr[1] = (jint)receiveLen;
1012 _env->ReleaseIntArrayElements(auxData, auxDataPtr, 0);
1013 return (jint)id;
1014 }
1015
nContextInitToClient(JNIEnv * _env,jobject _this,jlong con)1016 static void nContextInitToClient(JNIEnv *_env, jobject _this, jlong con)
1017 {
1018 if (kLogApi) {
1019 ALOGD("nContextInitToClient, con(%p)", (RsContext)con);
1020 }
1021 rsContextInitToClient((RsContext)con);
1022 }
1023
nContextDeinitToClient(JNIEnv * _env,jobject _this,jlong con)1024 static void nContextDeinitToClient(JNIEnv *_env, jobject _this, jlong con)
1025 {
1026 if (kLogApi) {
1027 ALOGD("nContextDeinitToClient, con(%p)", (RsContext)con);
1028 }
1029 rsContextDeinitToClient((RsContext)con);
1030 }
1031
1032 static void
nContextSendMessage(JNIEnv * _env,jobject _this,jlong con,jint id,jintArray data)1033 nContextSendMessage(JNIEnv *_env, jobject _this, jlong con, jint id, jintArray data)
1034 {
1035 jint *ptr = nullptr;
1036 jint len = 0;
1037 if (data) {
1038 len = _env->GetArrayLength(data);
1039 ptr = _env->GetIntArrayElements(data, nullptr);
1040 if (ptr == nullptr) {
1041 ALOGE("Failed to get Java array elements");
1042 return;
1043 }
1044 }
1045 if (kLogApi) {
1046 ALOGD("nContextSendMessage, con(%p), id(%i), len(%i)", (RsContext)con, id, len);
1047 }
1048 rsContextSendMessage((RsContext)con, id, (const uint8_t *)ptr, len * sizeof(int));
1049 if (data) {
1050 _env->ReleaseIntArrayElements(data, ptr, JNI_ABORT);
1051 }
1052 }
1053
1054
1055
1056 static jlong
nElementCreate(JNIEnv * _env,jobject _this,jlong con,jlong type,jint kind,jboolean norm,jint size)1057 nElementCreate(JNIEnv *_env, jobject _this, jlong con, jlong type, jint kind, jboolean norm,
1058 jint size)
1059 {
1060 if (kLogApi) {
1061 ALOGD("nElementCreate, con(%p), type(%" PRId64 "), kind(%i), norm(%i), size(%i)", (RsContext)con,
1062 type, kind, norm, size);
1063 }
1064 return (jlong)(uintptr_t)rsElementCreate((RsContext)con, (RsDataType)type, (RsDataKind)kind,
1065 norm, size);
1066 }
1067
1068 static jlong
nElementCreate2(JNIEnv * _env,jobject _this,jlong con,jlongArray _ids,jobjectArray _names,jintArray _arraySizes)1069 nElementCreate2(JNIEnv *_env, jobject _this, jlong con,
1070 jlongArray _ids, jobjectArray _names, jintArray _arraySizes)
1071 {
1072 int fieldCount = _env->GetArrayLength(_ids);
1073 if (kLogApi) {
1074 ALOGD("nElementCreate2, con(%p)", (RsContext)con);
1075 }
1076
1077 jlong *jIds = _env->GetLongArrayElements(_ids, nullptr);
1078 if (jIds == nullptr) {
1079 ALOGE("Failed to get Java array elements: ids");
1080 return 0;
1081 }
1082 jint *jArraySizes = _env->GetIntArrayElements(_arraySizes, nullptr);
1083 if (jArraySizes == nullptr) {
1084 ALOGE("Failed to get Java array elements: arraySizes");
1085 return 0;
1086 }
1087
1088 RsElement *ids = (RsElement*)malloc(fieldCount * sizeof(RsElement));
1089 uint32_t *arraySizes = (uint32_t *)malloc(fieldCount * sizeof(uint32_t));
1090
1091 for(int i = 0; i < fieldCount; i ++) {
1092 ids[i] = (RsElement)jIds[i];
1093 arraySizes[i] = (uint32_t)jArraySizes[i];
1094 }
1095
1096 AutoJavaStringArrayToUTF8 names(_env, _names, fieldCount);
1097
1098 const char **nameArray = names.c_str();
1099 size_t *sizeArray = names.c_str_len();
1100
1101 jlong id = (jlong)(uintptr_t)rsElementCreate2((RsContext)con,
1102 (const RsElement *)ids, fieldCount,
1103 nameArray, fieldCount * sizeof(size_t), sizeArray,
1104 (const uint32_t *)arraySizes, fieldCount);
1105
1106 free(ids);
1107 free(arraySizes);
1108 _env->ReleaseLongArrayElements(_ids, jIds, JNI_ABORT);
1109 _env->ReleaseIntArrayElements(_arraySizes, jArraySizes, JNI_ABORT);
1110
1111 return (jlong)(uintptr_t)id;
1112 }
1113
1114 static void
nElementGetNativeData(JNIEnv * _env,jobject _this,jlong con,jlong id,jintArray _elementData)1115 nElementGetNativeData(JNIEnv *_env, jobject _this, jlong con, jlong id, jintArray _elementData)
1116 {
1117 int dataSize = _env->GetArrayLength(_elementData);
1118 if (kLogApi) {
1119 ALOGD("nElementGetNativeData, con(%p)", (RsContext)con);
1120 }
1121
1122 // we will pack mType; mKind; mNormalized; mVectorSize; NumSubElements
1123 assert(dataSize == 5);
1124
1125 uintptr_t elementData[5];
1126 rsaElementGetNativeData((RsContext)con, (RsElement)id, elementData, dataSize);
1127
1128 for(jint i = 0; i < dataSize; i ++) {
1129 const jint data = (jint)elementData[i];
1130 _env->SetIntArrayRegion(_elementData, i, 1, &data);
1131 }
1132 }
1133
1134
1135 static void
nElementGetSubElements(JNIEnv * _env,jobject _this,jlong con,jlong id,jlongArray _IDs,jobjectArray _names,jintArray _arraySizes)1136 nElementGetSubElements(JNIEnv *_env, jobject _this, jlong con, jlong id,
1137 jlongArray _IDs,
1138 jobjectArray _names,
1139 jintArray _arraySizes)
1140 {
1141 uint32_t dataSize = _env->GetArrayLength(_IDs);
1142 if (kLogApi) {
1143 ALOGD("nElementGetSubElements, con(%p)", (RsContext)con);
1144 }
1145
1146 uintptr_t *ids = (uintptr_t*)malloc(dataSize * sizeof(uintptr_t));
1147 const char **names = (const char **)malloc(dataSize * sizeof(const char *));
1148 uint32_t *arraySizes = (uint32_t *)malloc(dataSize * sizeof(uint32_t));
1149
1150 rsaElementGetSubElements((RsContext)con, (RsElement)id, ids, names, arraySizes,
1151 (uint32_t)dataSize);
1152
1153 for(uint32_t i = 0; i < dataSize; i++) {
1154 const jlong id = (jlong)(uintptr_t)ids[i];
1155 const jint arraySize = (jint)arraySizes[i];
1156 _env->SetObjectArrayElement(_names, i, _env->NewStringUTF(names[i]));
1157 _env->SetLongArrayRegion(_IDs, i, 1, &id);
1158 _env->SetIntArrayRegion(_arraySizes, i, 1, &arraySize);
1159 }
1160
1161 free(ids);
1162 free(names);
1163 free(arraySizes);
1164 }
1165
1166 // -----------------------------------
1167
1168 static jlong
nTypeCreate(JNIEnv * _env,jobject _this,jlong con,jlong eid,jint dimx,jint dimy,jint dimz,jboolean mips,jboolean faces,jint yuv)1169 nTypeCreate(JNIEnv *_env, jobject _this, jlong con, jlong eid,
1170 jint dimx, jint dimy, jint dimz, jboolean mips, jboolean faces, jint yuv)
1171 {
1172 if (kLogApi) {
1173 ALOGD("nTypeCreate, con(%p) eid(%p), x(%i), y(%i), z(%i), mips(%i), faces(%i), yuv(%i)",
1174 (RsContext)con, (void*)eid, dimx, dimy, dimz, mips, faces, yuv);
1175 }
1176
1177 return (jlong)(uintptr_t)rsTypeCreate((RsContext)con, (RsElement)eid, dimx, dimy, dimz, mips,
1178 faces, yuv);
1179 }
1180
1181 static void
nTypeGetNativeData(JNIEnv * _env,jobject _this,jlong con,jlong id,jlongArray _typeData)1182 nTypeGetNativeData(JNIEnv *_env, jobject _this, jlong con, jlong id, jlongArray _typeData)
1183 {
1184 // We are packing 6 items: mDimX; mDimY; mDimZ;
1185 // mDimLOD; mDimFaces; mElement; into typeData
1186 int elementCount = _env->GetArrayLength(_typeData);
1187
1188 assert(elementCount == 6);
1189 if (kLogApi) {
1190 ALOGD("nTypeGetNativeData, con(%p)", (RsContext)con);
1191 }
1192
1193 uintptr_t typeData[6];
1194 rsaTypeGetNativeData((RsContext)con, (RsType)id, typeData, 6);
1195
1196 for(jint i = 0; i < elementCount; i ++) {
1197 const jlong data = (jlong)(uintptr_t)typeData[i];
1198 _env->SetLongArrayRegion(_typeData, i, 1, &data);
1199 }
1200 }
1201
1202 // -----------------------------------
1203
1204 static jlong
nAllocationCreateTyped(JNIEnv * _env,jobject _this,jlong con,jlong type,jint mips,jint usage,jlong pointer)1205 nAllocationCreateTyped(JNIEnv *_env, jobject _this, jlong con, jlong type, jint mips, jint usage,
1206 jlong pointer)
1207 {
1208 if (kLogApi) {
1209 ALOGD("nAllocationCreateTyped, con(%p), type(%p), mip(%i), usage(%i), ptr(%p)",
1210 (RsContext)con, (RsElement)type, mips, usage, (void *)pointer);
1211 }
1212 return (jlong)(uintptr_t) rsAllocationCreateTyped((RsContext)con, (RsType)type,
1213 (RsAllocationMipmapControl)mips,
1214 (uint32_t)usage, (uintptr_t)pointer);
1215 }
1216
1217 static void
nAllocationSyncAll(JNIEnv * _env,jobject _this,jlong con,jlong a,jint bits)1218 nAllocationSyncAll(JNIEnv *_env, jobject _this, jlong con, jlong a, jint bits)
1219 {
1220 if (kLogApi) {
1221 ALOGD("nAllocationSyncAll, con(%p), a(%p), bits(0x%08x)", (RsContext)con, (RsAllocation)a,
1222 bits);
1223 }
1224 rsAllocationSyncAll((RsContext)con, (RsAllocation)a, (RsAllocationUsageType)bits);
1225 }
1226
1227 static void
nAllocationSetupBufferQueue(JNIEnv * _env,jobject _this,jlong con,jlong alloc,jint numAlloc)1228 nAllocationSetupBufferQueue(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jint numAlloc)
1229 {
1230 if (kLogApi) {
1231 ALOGD("nAllocationSetupBufferQueue, con(%p), alloc(%p), numAlloc(%d)", (RsContext)con,
1232 (RsAllocation)alloc, numAlloc);
1233 }
1234 rsAllocationSetupBufferQueue((RsContext)con, (RsAllocation)alloc, (uint32_t)numAlloc);
1235 }
1236
1237 static void
nAllocationShareBufferQueue(JNIEnv * _env,jobject _this,jlong con,jlong alloc1,jlong alloc2)1238 nAllocationShareBufferQueue(JNIEnv *_env, jobject _this, jlong con, jlong alloc1, jlong alloc2)
1239 {
1240 if (kLogApi) {
1241 ALOGD("nAllocationShareBufferQueue, con(%p), alloc1(%p), alloc2(%p)", (RsContext)con,
1242 (RsAllocation)alloc1, (RsAllocation)alloc2);
1243 }
1244
1245 rsAllocationShareBufferQueue((RsContext)con, (RsAllocation)alloc1, (RsAllocation)alloc2);
1246 }
1247
1248 static jobject
nAllocationGetSurface(JNIEnv * _env,jobject _this,jlong con,jlong a)1249 nAllocationGetSurface(JNIEnv *_env, jobject _this, jlong con, jlong a)
1250 {
1251 if (kLogApi) {
1252 ALOGD("nAllocationGetSurface, con(%p), a(%p)", (RsContext)con, (RsAllocation)a);
1253 }
1254
1255 IGraphicBufferProducer *v = (IGraphicBufferProducer *)rsAllocationGetSurface((RsContext)con,
1256 (RsAllocation)a);
1257 sp<IGraphicBufferProducer> bp = v;
1258 v->decStrong(nullptr);
1259
1260 jobject o = android_view_Surface_createFromIGraphicBufferProducer(_env, bp);
1261 return o;
1262 }
1263
1264 static void
nAllocationSetSurface(JNIEnv * _env,jobject _this,jlong con,jlong alloc,jobject sur)1265 nAllocationSetSurface(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jobject sur)
1266 {
1267 if (kLogApi) {
1268 ALOGD("nAllocationSetSurface, con(%p), alloc(%p), surface(%p)", (RsContext)con,
1269 (RsAllocation)alloc, (Surface *)sur);
1270 }
1271
1272 sp<Surface> s;
1273 if (sur != 0) {
1274 s = android_view_Surface_getSurface(_env, sur);
1275 }
1276
1277 rsAllocationSetSurface((RsContext)con, (RsAllocation)alloc,
1278 static_cast<ANativeWindow *>(s.get()));
1279 }
1280
1281 static void
nAllocationIoSend(JNIEnv * _env,jobject _this,jlong con,jlong alloc)1282 nAllocationIoSend(JNIEnv *_env, jobject _this, jlong con, jlong alloc)
1283 {
1284 if (kLogApi) {
1285 ALOGD("nAllocationIoSend, con(%p), alloc(%p)", (RsContext)con, (RsAllocation)alloc);
1286 }
1287 rsAllocationIoSend((RsContext)con, (RsAllocation)alloc);
1288 }
1289
1290 static jlong
nAllocationIoReceive(JNIEnv * _env,jobject _this,jlong con,jlong alloc)1291 nAllocationIoReceive(JNIEnv *_env, jobject _this, jlong con, jlong alloc)
1292 {
1293 if (kLogApi) {
1294 ALOGD("nAllocationIoReceive, con(%p), alloc(%p)", (RsContext)con, (RsAllocation)alloc);
1295 }
1296 return (jlong) rsAllocationIoReceive((RsContext)con, (RsAllocation)alloc);
1297 }
1298
1299 static void
nAllocationGenerateMipmaps(JNIEnv * _env,jobject _this,jlong con,jlong alloc)1300 nAllocationGenerateMipmaps(JNIEnv *_env, jobject _this, jlong con, jlong alloc)
1301 {
1302 if (kLogApi) {
1303 ALOGD("nAllocationGenerateMipmaps, con(%p), a(%p)", (RsContext)con, (RsAllocation)alloc);
1304 }
1305 rsAllocationGenerateMipmaps((RsContext)con, (RsAllocation)alloc);
1306 }
1307
1308 static jlong
nAllocationCreateFromBitmap(JNIEnv * _env,jobject _this,jlong con,jlong type,jint mip,jobject jbitmap,jint usage)1309 nAllocationCreateFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong type, jint mip,
1310 jobject jbitmap, jint usage)
1311 {
1312 SkBitmap bitmap;
1313 GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap);
1314
1315 bitmap.lockPixels();
1316 const void* ptr = bitmap.getPixels();
1317 jlong id = (jlong)(uintptr_t)rsAllocationCreateFromBitmap((RsContext)con,
1318 (RsType)type, (RsAllocationMipmapControl)mip,
1319 ptr, bitmap.getSize(), usage);
1320 bitmap.unlockPixels();
1321 return id;
1322 }
1323
1324 static jlong
nAllocationCreateBitmapBackedAllocation(JNIEnv * _env,jobject _this,jlong con,jlong type,jint mip,jobject jbitmap,jint usage)1325 nAllocationCreateBitmapBackedAllocation(JNIEnv *_env, jobject _this, jlong con, jlong type,
1326 jint mip, jobject jbitmap, jint usage)
1327 {
1328 SkBitmap bitmap;
1329 GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap);
1330
1331 bitmap.lockPixels();
1332 const void* ptr = bitmap.getPixels();
1333 jlong id = (jlong)(uintptr_t)rsAllocationCreateTyped((RsContext)con,
1334 (RsType)type, (RsAllocationMipmapControl)mip,
1335 (uint32_t)usage, (uintptr_t)ptr);
1336 bitmap.unlockPixels();
1337 return id;
1338 }
1339
1340 static jlong
nAllocationCubeCreateFromBitmap(JNIEnv * _env,jobject _this,jlong con,jlong type,jint mip,jobject jbitmap,jint usage)1341 nAllocationCubeCreateFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong type, jint mip,
1342 jobject jbitmap, jint usage)
1343 {
1344 SkBitmap bitmap;
1345 GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap);
1346
1347 bitmap.lockPixels();
1348 const void* ptr = bitmap.getPixels();
1349 jlong id = (jlong)(uintptr_t)rsAllocationCubeCreateFromBitmap((RsContext)con,
1350 (RsType)type, (RsAllocationMipmapControl)mip,
1351 ptr, bitmap.getSize(), usage);
1352 bitmap.unlockPixels();
1353 return id;
1354 }
1355
1356 static void
nAllocationCopyFromBitmap(JNIEnv * _env,jobject _this,jlong con,jlong alloc,jobject jbitmap)1357 nAllocationCopyFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jobject jbitmap)
1358 {
1359 SkBitmap bitmap;
1360 GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap);
1361 int w = bitmap.width();
1362 int h = bitmap.height();
1363
1364 bitmap.lockPixels();
1365 const void* ptr = bitmap.getPixels();
1366 rsAllocation2DData((RsContext)con, (RsAllocation)alloc, 0, 0,
1367 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X,
1368 w, h, ptr, bitmap.getSize(), 0);
1369 bitmap.unlockPixels();
1370 }
1371
1372 static void
nAllocationCopyToBitmap(JNIEnv * _env,jobject _this,jlong con,jlong alloc,jobject jbitmap)1373 nAllocationCopyToBitmap(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jobject jbitmap)
1374 {
1375 SkBitmap bitmap;
1376 GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap);
1377
1378 bitmap.lockPixels();
1379 void* ptr = bitmap.getPixels();
1380 rsAllocationCopyToBitmap((RsContext)con, (RsAllocation)alloc, ptr, bitmap.getSize());
1381 bitmap.unlockPixels();
1382 bitmap.notifyPixelsChanged();
1383 }
1384
1385 // Copies from the Java object data into the Allocation pointed to by _alloc.
1386 static void
nAllocationData1D(JNIEnv * _env,jobject _this,jlong con,jlong _alloc,jint offset,jint lod,jint count,jobject data,jint sizeBytes,jint dataType,jint mSize,jboolean usePadding)1387 nAllocationData1D(JNIEnv *_env, jobject _this, jlong con, jlong _alloc, jint offset, jint lod,
1388 jint count, jobject data, jint sizeBytes, jint dataType, jint mSize,
1389 jboolean usePadding)
1390 {
1391 RsAllocation *alloc = (RsAllocation *)_alloc;
1392 if (kLogApi) {
1393 ALOGD("nAllocation1DData, con(%p), adapter(%p), offset(%i), count(%i), sizeBytes(%i), "
1394 "dataType(%i)", (RsContext)con, (RsAllocation)alloc, offset, count, sizeBytes,
1395 dataType);
1396 }
1397 PER_ARRAY_TYPE(nullptr, rsAllocation1DData, true,
1398 (RsContext)con, alloc, offset, lod, count, ptr, sizeBytes);
1399 }
1400
1401 static void
nAllocationElementData(JNIEnv * _env,jobject _this,jlong con,jlong alloc,jint xoff,jint yoff,jint zoff,jint lod,jint compIdx,jbyteArray data,jint sizeBytes)1402 nAllocationElementData(JNIEnv *_env, jobject _this, jlong con, jlong alloc,
1403 jint xoff, jint yoff, jint zoff,
1404 jint lod, jint compIdx, jbyteArray data, jint sizeBytes)
1405 {
1406 jint len = _env->GetArrayLength(data);
1407 if (kLogApi) {
1408 ALOGD("nAllocationElementData, con(%p), alloc(%p), xoff(%i), yoff(%i), zoff(%i), comp(%i), len(%i), "
1409 "sizeBytes(%i)", (RsContext)con, (RsAllocation)alloc, xoff, yoff, zoff, compIdx, len,
1410 sizeBytes);
1411 }
1412 jbyte *ptr = _env->GetByteArrayElements(data, nullptr);
1413 if (ptr == nullptr) {
1414 ALOGE("Failed to get Java array elements");
1415 return;
1416 }
1417 rsAllocationElementData((RsContext)con, (RsAllocation)alloc,
1418 xoff, yoff, zoff,
1419 lod, ptr, sizeBytes, compIdx);
1420 _env->ReleaseByteArrayElements(data, ptr, JNI_ABORT);
1421 }
1422
1423
1424 // Copies from the Java object data into the Allocation pointed to by _alloc.
1425 static void
nAllocationData2D(JNIEnv * _env,jobject _this,jlong con,jlong _alloc,jint xoff,jint yoff,jint lod,jint _face,jint w,jint h,jobject data,jint sizeBytes,jint dataType,jint mSize,jboolean usePadding)1426 nAllocationData2D(JNIEnv *_env, jobject _this, jlong con, jlong _alloc, jint xoff, jint yoff, jint lod, jint _face,
1427 jint w, jint h, jobject data, jint sizeBytes, jint dataType, jint mSize,
1428 jboolean usePadding)
1429 {
1430 RsAllocation *alloc = (RsAllocation *)_alloc;
1431 RsAllocationCubemapFace face = (RsAllocationCubemapFace)_face;
1432 if (kLogApi) {
1433 ALOGD("nAllocation2DData, con(%p), adapter(%p), xoff(%i), yoff(%i), w(%i), h(%i), len(%i) "
1434 "type(%i)", (RsContext)con, alloc, xoff, yoff, w, h, sizeBytes, dataType);
1435 }
1436 int count = w * h;
1437 PER_ARRAY_TYPE(nullptr, rsAllocation2DData, true,
1438 (RsContext)con, alloc, xoff, yoff, lod, face, w, h, ptr, sizeBytes, 0);
1439 }
1440
1441 // Copies from the Allocation pointed to by srcAlloc into the Allocation
1442 // pointed to by dstAlloc.
1443 static void
nAllocationData2D_alloc(JNIEnv * _env,jobject _this,jlong con,jlong dstAlloc,jint dstXoff,jint dstYoff,jint dstMip,jint dstFace,jint width,jint height,jlong srcAlloc,jint srcXoff,jint srcYoff,jint srcMip,jint srcFace)1444 nAllocationData2D_alloc(JNIEnv *_env, jobject _this, jlong con,
1445 jlong dstAlloc, jint dstXoff, jint dstYoff,
1446 jint dstMip, jint dstFace,
1447 jint width, jint height,
1448 jlong srcAlloc, jint srcXoff, jint srcYoff,
1449 jint srcMip, jint srcFace)
1450 {
1451 if (kLogApi) {
1452 ALOGD("nAllocation2DData_s, con(%p), dstAlloc(%p), dstXoff(%i), dstYoff(%i),"
1453 " dstMip(%i), dstFace(%i), width(%i), height(%i),"
1454 " srcAlloc(%p), srcXoff(%i), srcYoff(%i), srcMip(%i), srcFace(%i)",
1455 (RsContext)con, (RsAllocation)dstAlloc, dstXoff, dstYoff, dstMip, dstFace,
1456 width, height, (RsAllocation)srcAlloc, srcXoff, srcYoff, srcMip, srcFace);
1457 }
1458
1459 rsAllocationCopy2DRange((RsContext)con,
1460 (RsAllocation)dstAlloc,
1461 dstXoff, dstYoff,
1462 dstMip, dstFace,
1463 width, height,
1464 (RsAllocation)srcAlloc,
1465 srcXoff, srcYoff,
1466 srcMip, srcFace);
1467 }
1468
1469 // Copies from the Java object data into the Allocation pointed to by _alloc.
1470 static void
nAllocationData3D(JNIEnv * _env,jobject _this,jlong con,jlong _alloc,jint xoff,jint yoff,jint zoff,jint lod,jint w,jint h,jint d,jobject data,jint sizeBytes,jint dataType,jint mSize,jboolean usePadding)1471 nAllocationData3D(JNIEnv *_env, jobject _this, jlong con, jlong _alloc, jint xoff, jint yoff, jint zoff, jint lod,
1472 jint w, jint h, jint d, jobject data, jint sizeBytes, jint dataType,
1473 jint mSize, jboolean usePadding)
1474 {
1475 RsAllocation *alloc = (RsAllocation *)_alloc;
1476 if (kLogApi) {
1477 ALOGD("nAllocation3DData, con(%p), alloc(%p), xoff(%i), yoff(%i), zoff(%i), lod(%i), w(%i),"
1478 " h(%i), d(%i), sizeBytes(%i)", (RsContext)con, (RsAllocation)alloc, xoff, yoff, zoff,
1479 lod, w, h, d, sizeBytes);
1480 }
1481 int count = w * h * d;
1482 PER_ARRAY_TYPE(nullptr, rsAllocation3DData, true,
1483 (RsContext)con, alloc, xoff, yoff, zoff, lod, w, h, d, ptr, sizeBytes, 0);
1484 }
1485
1486 // Copies from the Allocation pointed to by srcAlloc into the Allocation
1487 // pointed to by dstAlloc.
1488 static void
nAllocationData3D_alloc(JNIEnv * _env,jobject _this,jlong con,jlong dstAlloc,jint dstXoff,jint dstYoff,jint dstZoff,jint dstMip,jint width,jint height,jint depth,jlong srcAlloc,jint srcXoff,jint srcYoff,jint srcZoff,jint srcMip)1489 nAllocationData3D_alloc(JNIEnv *_env, jobject _this, jlong con,
1490 jlong dstAlloc, jint dstXoff, jint dstYoff, jint dstZoff,
1491 jint dstMip,
1492 jint width, jint height, jint depth,
1493 jlong srcAlloc, jint srcXoff, jint srcYoff, jint srcZoff,
1494 jint srcMip)
1495 {
1496 if (kLogApi) {
1497 ALOGD("nAllocationData3D_alloc, con(%p), dstAlloc(%p), dstXoff(%i), dstYoff(%i),"
1498 " dstMip(%i), width(%i), height(%i),"
1499 " srcAlloc(%p), srcXoff(%i), srcYoff(%i), srcMip(%i)",
1500 (RsContext)con, (RsAllocation)dstAlloc, dstXoff, dstYoff, dstMip,
1501 width, height, (RsAllocation)srcAlloc, srcXoff, srcYoff, srcMip);
1502 }
1503
1504 rsAllocationCopy3DRange((RsContext)con,
1505 (RsAllocation)dstAlloc,
1506 dstXoff, dstYoff, dstZoff, dstMip,
1507 width, height, depth,
1508 (RsAllocation)srcAlloc,
1509 srcXoff, srcYoff, srcZoff, srcMip);
1510 }
1511
1512
1513 // Copies from the Allocation pointed to by _alloc into the Java object data.
1514 static void
nAllocationRead(JNIEnv * _env,jobject _this,jlong con,jlong _alloc,jobject data,jint dataType,jint mSize,jboolean usePadding)1515 nAllocationRead(JNIEnv *_env, jobject _this, jlong con, jlong _alloc, jobject data, jint dataType,
1516 jint mSize, jboolean usePadding)
1517 {
1518 RsAllocation *alloc = (RsAllocation *)_alloc;
1519 if (kLogApi) {
1520 ALOGD("nAllocationRead, con(%p), alloc(%p)", (RsContext)con, (RsAllocation)alloc);
1521 }
1522 int count = 0;
1523 PER_ARRAY_TYPE(0, rsAllocationRead, false,
1524 (RsContext)con, alloc, ptr, len * typeBytes);
1525 }
1526
1527 // Copies from the Allocation pointed to by _alloc into the Java object data.
1528 static void
nAllocationRead1D(JNIEnv * _env,jobject _this,jlong con,jlong _alloc,jint offset,jint lod,jint count,jobject data,jint sizeBytes,jint dataType,jint mSize,jboolean usePadding)1529 nAllocationRead1D(JNIEnv *_env, jobject _this, jlong con, jlong _alloc, jint offset, jint lod,
1530 jint count, jobject data, jint sizeBytes, jint dataType,
1531 jint mSize, jboolean usePadding)
1532 {
1533 RsAllocation *alloc = (RsAllocation *)_alloc;
1534 if (kLogApi) {
1535 ALOGD("nAllocation1DRead, con(%p), adapter(%p), offset(%i), count(%i), sizeBytes(%i), "
1536 "dataType(%i)", (RsContext)con, alloc, offset, count, sizeBytes, dataType);
1537 }
1538 PER_ARRAY_TYPE(0, rsAllocation1DRead, false,
1539 (RsContext)con, alloc, offset, lod, count, ptr, sizeBytes);
1540 }
1541
1542 // Copies from the Element in the Allocation pointed to by _alloc into the Java array data.
1543 static void
nAllocationElementRead(JNIEnv * _env,jobject _this,jlong con,jlong alloc,jint xoff,jint yoff,jint zoff,jint lod,jint compIdx,jbyteArray data,jint sizeBytes)1544 nAllocationElementRead(JNIEnv *_env, jobject _this, jlong con, jlong alloc,
1545 jint xoff, jint yoff, jint zoff,
1546 jint lod, jint compIdx, jbyteArray data, jint sizeBytes)
1547 {
1548 jint len = _env->GetArrayLength(data);
1549 if (kLogApi) {
1550 ALOGD("nAllocationElementRead, con(%p), alloc(%p), xoff(%i), yoff(%i), zoff(%i), comp(%i), len(%i), "
1551 "sizeBytes(%i)", (RsContext)con, (RsAllocation)alloc, xoff, yoff, zoff, compIdx, len,
1552 sizeBytes);
1553 }
1554 jbyte *ptr = _env->GetByteArrayElements(data, nullptr);
1555 if (ptr == nullptr) {
1556 ALOGE("Failed to get Java array elements");
1557 return;
1558 }
1559 rsAllocationElementRead((RsContext)con, (RsAllocation)alloc,
1560 xoff, yoff, zoff,
1561 lod, ptr, sizeBytes, compIdx);
1562 _env->ReleaseByteArrayElements(data, ptr, 0);
1563 }
1564
1565 // Copies from the Allocation pointed to by _alloc into the Java object data.
1566 static void
nAllocationRead2D(JNIEnv * _env,jobject _this,jlong con,jlong _alloc,jint xoff,jint yoff,jint lod,jint _face,jint w,jint h,jobject data,jint sizeBytes,jint dataType,jint mSize,jboolean usePadding)1567 nAllocationRead2D(JNIEnv *_env, jobject _this, jlong con, jlong _alloc, jint xoff, jint yoff, jint lod, jint _face,
1568 jint w, jint h, jobject data, jint sizeBytes, jint dataType,
1569 jint mSize, jboolean usePadding)
1570 {
1571 RsAllocation *alloc = (RsAllocation *)_alloc;
1572 RsAllocationCubemapFace face = (RsAllocationCubemapFace)_face;
1573 if (kLogApi) {
1574 ALOGD("nAllocation2DRead, con(%p), adapter(%p), xoff(%i), yoff(%i), w(%i), h(%i), len(%i) "
1575 "type(%i)", (RsContext)con, alloc, xoff, yoff, w, h, sizeBytes, dataType);
1576 }
1577 int count = w * h;
1578 PER_ARRAY_TYPE(0, rsAllocation2DRead, false,
1579 (RsContext)con, alloc, xoff, yoff, lod, face, w, h, ptr, sizeBytes, 0);
1580 }
1581
1582 // Copies from the Allocation pointed to by _alloc into the Java object data.
1583 static void
nAllocationRead3D(JNIEnv * _env,jobject _this,jlong con,jlong _alloc,jint xoff,jint yoff,jint zoff,jint lod,jint w,jint h,jint d,jobject data,int sizeBytes,int dataType,jint mSize,jboolean usePadding)1584 nAllocationRead3D(JNIEnv *_env, jobject _this, jlong con, jlong _alloc, jint xoff, jint yoff, jint zoff, jint lod,
1585 jint w, jint h, jint d, jobject data, int sizeBytes, int dataType,
1586 jint mSize, jboolean usePadding)
1587 {
1588 RsAllocation *alloc = (RsAllocation *)_alloc;
1589 if (kLogApi) {
1590 ALOGD("nAllocation3DRead, con(%p), alloc(%p), xoff(%i), yoff(%i), zoff(%i), lod(%i), w(%i),"
1591 " h(%i), d(%i), sizeBytes(%i)", (RsContext)con, (RsAllocation)alloc, xoff, yoff, zoff,
1592 lod, w, h, d, sizeBytes);
1593 }
1594 int count = w * h * d;
1595 PER_ARRAY_TYPE(nullptr, rsAllocation3DRead, false,
1596 (RsContext)con, alloc, xoff, yoff, zoff, lod, w, h, d, ptr, sizeBytes, 0);
1597 }
1598
1599 static jlong
nAllocationGetType(JNIEnv * _env,jobject _this,jlong con,jlong a)1600 nAllocationGetType(JNIEnv *_env, jobject _this, jlong con, jlong a)
1601 {
1602 if (kLogApi) {
1603 ALOGD("nAllocationGetType, con(%p), a(%p)", (RsContext)con, (RsAllocation)a);
1604 }
1605 return (jlong)(uintptr_t) rsaAllocationGetType((RsContext)con, (RsAllocation)a);
1606 }
1607
1608 static void
nAllocationResize1D(JNIEnv * _env,jobject _this,jlong con,jlong alloc,jint dimX)1609 nAllocationResize1D(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jint dimX)
1610 {
1611 if (kLogApi) {
1612 ALOGD("nAllocationResize1D, con(%p), alloc(%p), sizeX(%i)", (RsContext)con,
1613 (RsAllocation)alloc, dimX);
1614 }
1615 rsAllocationResize1D((RsContext)con, (RsAllocation)alloc, dimX);
1616 }
1617
1618
1619 static jlong
nAllocationAdapterCreate(JNIEnv * _env,jobject _this,jlong con,jlong basealloc,jlong type)1620 nAllocationAdapterCreate(JNIEnv *_env, jobject _this, jlong con, jlong basealloc, jlong type)
1621 {
1622 if (kLogApi) {
1623 ALOGD("nAllocationAdapterCreate, con(%p), base(%p), type(%p)",
1624 (RsContext)con, (RsAllocation)basealloc, (RsElement)type);
1625 }
1626 return (jlong)(uintptr_t) rsAllocationAdapterCreate((RsContext)con, (RsType)type,
1627 (RsAllocation)basealloc);
1628
1629 }
1630
1631 static void
nAllocationAdapterOffset(JNIEnv * _env,jobject _this,jlong con,jlong alloc,jint x,jint y,jint z,jint face,jint lod,jint a1,jint a2,jint a3,jint a4)1632 nAllocationAdapterOffset(JNIEnv *_env, jobject _this, jlong con, jlong alloc,
1633 jint x, jint y, jint z, jint face, jint lod,
1634 jint a1, jint a2, jint a3, jint a4)
1635 {
1636 uint32_t params[] = {
1637 (uint32_t)x, (uint32_t)y, (uint32_t)z, (uint32_t)face,
1638 (uint32_t)lod, (uint32_t)a1, (uint32_t)a2, (uint32_t)a3, (uint32_t)a4
1639 };
1640 if (kLogApi) {
1641 ALOGD("nAllocationAdapterOffset, con(%p), alloc(%p), x(%i), y(%i), z(%i), face(%i), lod(%i), arrays(%i %i %i %i)",
1642 (RsContext)con, (RsAllocation)alloc, x, y, z, face, lod, a1, a2, a3, a4);
1643 }
1644 rsAllocationAdapterOffset((RsContext)con, (RsAllocation)alloc,
1645 params, sizeof(params));
1646 }
1647
1648
1649 // -----------------------------------
1650
1651 static jlong
nFileA3DCreateFromAssetStream(JNIEnv * _env,jobject _this,jlong con,jlong native_asset)1652 nFileA3DCreateFromAssetStream(JNIEnv *_env, jobject _this, jlong con, jlong native_asset)
1653 {
1654 Asset* asset = reinterpret_cast<Asset*>(native_asset);
1655 ALOGV("______nFileA3D %p", asset);
1656
1657 jlong id = (jlong)(uintptr_t)rsaFileA3DCreateFromMemory((RsContext)con, asset->getBuffer(false), asset->getLength());
1658 return id;
1659 }
1660
1661 static jlong
nFileA3DCreateFromAsset(JNIEnv * _env,jobject _this,jlong con,jobject _assetMgr,jstring _path)1662 nFileA3DCreateFromAsset(JNIEnv *_env, jobject _this, jlong con, jobject _assetMgr, jstring _path)
1663 {
1664 AssetManager* mgr = assetManagerForJavaObject(_env, _assetMgr);
1665 if (mgr == nullptr) {
1666 return 0;
1667 }
1668
1669 AutoJavaStringToUTF8 str(_env, _path);
1670 Asset* asset = mgr->open(str.c_str(), Asset::ACCESS_BUFFER);
1671 if (asset == nullptr) {
1672 return 0;
1673 }
1674
1675 jlong id = (jlong)(uintptr_t)rsaFileA3DCreateFromAsset((RsContext)con, asset);
1676 return id;
1677 }
1678
1679 static jlong
nFileA3DCreateFromFile(JNIEnv * _env,jobject _this,jlong con,jstring fileName)1680 nFileA3DCreateFromFile(JNIEnv *_env, jobject _this, jlong con, jstring fileName)
1681 {
1682 AutoJavaStringToUTF8 fileNameUTF(_env, fileName);
1683 jlong id = (jlong)(uintptr_t)rsaFileA3DCreateFromFile((RsContext)con, fileNameUTF.c_str());
1684
1685 return id;
1686 }
1687
1688 static jint
nFileA3DGetNumIndexEntries(JNIEnv * _env,jobject _this,jlong con,jlong fileA3D)1689 nFileA3DGetNumIndexEntries(JNIEnv *_env, jobject _this, jlong con, jlong fileA3D)
1690 {
1691 int32_t numEntries = 0;
1692 rsaFileA3DGetNumIndexEntries((RsContext)con, &numEntries, (RsFile)fileA3D);
1693 return (jint)numEntries;
1694 }
1695
1696 static void
nFileA3DGetIndexEntries(JNIEnv * _env,jobject _this,jlong con,jlong fileA3D,jint numEntries,jintArray _ids,jobjectArray _entries)1697 nFileA3DGetIndexEntries(JNIEnv *_env, jobject _this, jlong con, jlong fileA3D, jint numEntries, jintArray _ids, jobjectArray _entries)
1698 {
1699 ALOGV("______nFileA3D %p", (RsFile) fileA3D);
1700 RsFileIndexEntry *fileEntries = (RsFileIndexEntry*)malloc((uint32_t)numEntries * sizeof(RsFileIndexEntry));
1701
1702 rsaFileA3DGetIndexEntries((RsContext)con, fileEntries, (uint32_t)numEntries, (RsFile)fileA3D);
1703
1704 for(jint i = 0; i < numEntries; i ++) {
1705 _env->SetObjectArrayElement(_entries, i, _env->NewStringUTF(fileEntries[i].objectName));
1706 _env->SetIntArrayRegion(_ids, i, 1, (const jint*)&fileEntries[i].classID);
1707 }
1708
1709 free(fileEntries);
1710 }
1711
1712 static jlong
nFileA3DGetEntryByIndex(JNIEnv * _env,jobject _this,jlong con,jlong fileA3D,jint index)1713 nFileA3DGetEntryByIndex(JNIEnv *_env, jobject _this, jlong con, jlong fileA3D, jint index)
1714 {
1715 ALOGV("______nFileA3D %p", (RsFile) fileA3D);
1716 jlong id = (jlong)(uintptr_t)rsaFileA3DGetEntryByIndex((RsContext)con, (uint32_t)index, (RsFile)fileA3D);
1717 return id;
1718 }
1719
1720 // -----------------------------------
1721
1722 static jlong
nFontCreateFromFile(JNIEnv * _env,jobject _this,jlong con,jstring fileName,jfloat fontSize,jint dpi)1723 nFontCreateFromFile(JNIEnv *_env, jobject _this, jlong con,
1724 jstring fileName, jfloat fontSize, jint dpi)
1725 {
1726 AutoJavaStringToUTF8 fileNameUTF(_env, fileName);
1727 jlong id = (jlong)(uintptr_t)rsFontCreateFromFile((RsContext)con,
1728 fileNameUTF.c_str(), fileNameUTF.length(),
1729 fontSize, dpi);
1730
1731 return id;
1732 }
1733
1734 static jlong
nFontCreateFromAssetStream(JNIEnv * _env,jobject _this,jlong con,jstring name,jfloat fontSize,jint dpi,jlong native_asset)1735 nFontCreateFromAssetStream(JNIEnv *_env, jobject _this, jlong con,
1736 jstring name, jfloat fontSize, jint dpi, jlong native_asset)
1737 {
1738 Asset* asset = reinterpret_cast<Asset*>(native_asset);
1739 AutoJavaStringToUTF8 nameUTF(_env, name);
1740
1741 jlong id = (jlong)(uintptr_t)rsFontCreateFromMemory((RsContext)con,
1742 nameUTF.c_str(), nameUTF.length(),
1743 fontSize, dpi,
1744 asset->getBuffer(false), asset->getLength());
1745 return id;
1746 }
1747
1748 static jlong
nFontCreateFromAsset(JNIEnv * _env,jobject _this,jlong con,jobject _assetMgr,jstring _path,jfloat fontSize,jint dpi)1749 nFontCreateFromAsset(JNIEnv *_env, jobject _this, jlong con, jobject _assetMgr, jstring _path,
1750 jfloat fontSize, jint dpi)
1751 {
1752 AssetManager* mgr = assetManagerForJavaObject(_env, _assetMgr);
1753 if (mgr == nullptr) {
1754 return 0;
1755 }
1756
1757 AutoJavaStringToUTF8 str(_env, _path);
1758 Asset* asset = mgr->open(str.c_str(), Asset::ACCESS_BUFFER);
1759 if (asset == nullptr) {
1760 return 0;
1761 }
1762
1763 jlong id = (jlong)(uintptr_t)rsFontCreateFromMemory((RsContext)con,
1764 str.c_str(), str.length(),
1765 fontSize, dpi,
1766 asset->getBuffer(false), asset->getLength());
1767 delete asset;
1768 return id;
1769 }
1770
1771 // -----------------------------------
1772
1773 static void
nScriptBindAllocation(JNIEnv * _env,jobject _this,jlong con,jlong script,jlong alloc,jint slot)1774 nScriptBindAllocation(JNIEnv *_env, jobject _this, jlong con, jlong script, jlong alloc, jint slot)
1775 {
1776 if (kLogApi) {
1777 ALOGD("nScriptBindAllocation, con(%p), script(%p), alloc(%p), slot(%i)", (RsContext)con,
1778 (RsScript)script, (RsAllocation)alloc, slot);
1779 }
1780 rsScriptBindAllocation((RsContext)con, (RsScript)script, (RsAllocation)alloc, slot);
1781 }
1782
1783 static void
nScriptSetVarI(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot,jint val)1784 nScriptSetVarI(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot, jint val)
1785 {
1786 if (kLogApi) {
1787 ALOGD("nScriptSetVarI, con(%p), s(%p), slot(%i), val(%i)", (RsContext)con, (void *)script,
1788 slot, val);
1789 }
1790 rsScriptSetVarI((RsContext)con, (RsScript)script, slot, val);
1791 }
1792
1793 static jint
nScriptGetVarI(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot)1794 nScriptGetVarI(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot)
1795 {
1796 if (kLogApi) {
1797 ALOGD("nScriptGetVarI, con(%p), s(%p), slot(%i)", (RsContext)con, (void *)script, slot);
1798 }
1799 int value = 0;
1800 rsScriptGetVarV((RsContext)con, (RsScript)script, slot, &value, sizeof(value));
1801 return value;
1802 }
1803
1804 static void
nScriptSetVarObj(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot,jlong val)1805 nScriptSetVarObj(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot, jlong val)
1806 {
1807 if (kLogApi) {
1808 ALOGD("nScriptSetVarObj, con(%p), s(%p), slot(%i), val(%" PRId64 ")", (RsContext)con, (void *)script,
1809 slot, val);
1810 }
1811 rsScriptSetVarObj((RsContext)con, (RsScript)script, slot, (RsObjectBase)val);
1812 }
1813
1814 static void
nScriptSetVarJ(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot,jlong val)1815 nScriptSetVarJ(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot, jlong val)
1816 {
1817 if (kLogApi) {
1818 ALOGD("nScriptSetVarJ, con(%p), s(%p), slot(%i), val(%" PRId64 ")", (RsContext)con, (void *)script,
1819 slot, val);
1820 }
1821 rsScriptSetVarJ((RsContext)con, (RsScript)script, slot, val);
1822 }
1823
1824 static jlong
nScriptGetVarJ(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot)1825 nScriptGetVarJ(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot)
1826 {
1827 if (kLogApi) {
1828 ALOGD("nScriptGetVarJ, con(%p), s(%p), slot(%i)", (RsContext)con, (void *)script, slot);
1829 }
1830 jlong value = 0;
1831 rsScriptGetVarV((RsContext)con, (RsScript)script, slot, &value, sizeof(value));
1832 return value;
1833 }
1834
1835 static void
nScriptSetVarF(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot,float val)1836 nScriptSetVarF(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot, float val)
1837 {
1838 if (kLogApi) {
1839 ALOGD("nScriptSetVarF, con(%p), s(%p), slot(%i), val(%f)", (RsContext)con, (void *)script,
1840 slot, val);
1841 }
1842 rsScriptSetVarF((RsContext)con, (RsScript)script, slot, val);
1843 }
1844
1845 static jfloat
nScriptGetVarF(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot)1846 nScriptGetVarF(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot)
1847 {
1848 if (kLogApi) {
1849 ALOGD("nScriptGetVarF, con(%p), s(%p), slot(%i)", (RsContext)con, (void *)script, slot);
1850 }
1851 jfloat value = 0;
1852 rsScriptGetVarV((RsContext)con, (RsScript)script, slot, &value, sizeof(value));
1853 return value;
1854 }
1855
1856 static void
nScriptSetVarD(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot,double val)1857 nScriptSetVarD(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot, double val)
1858 {
1859 if (kLogApi) {
1860 ALOGD("nScriptSetVarD, con(%p), s(%p), slot(%i), val(%lf)", (RsContext)con, (void *)script,
1861 slot, val);
1862 }
1863 rsScriptSetVarD((RsContext)con, (RsScript)script, slot, val);
1864 }
1865
1866 static jdouble
nScriptGetVarD(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot)1867 nScriptGetVarD(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot)
1868 {
1869 if (kLogApi) {
1870 ALOGD("nScriptGetVarD, con(%p), s(%p), slot(%i)", (RsContext)con, (void *)script, slot);
1871 }
1872 jdouble value = 0;
1873 rsScriptGetVarV((RsContext)con, (RsScript)script, slot, &value, sizeof(value));
1874 return value;
1875 }
1876
1877 static void
nScriptSetVarV(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot,jbyteArray data)1878 nScriptSetVarV(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot, jbyteArray data)
1879 {
1880 if (kLogApi) {
1881 ALOGD("nScriptSetVarV, con(%p), s(%p), slot(%i)", (RsContext)con, (void *)script, slot);
1882 }
1883 jint len = _env->GetArrayLength(data);
1884 jbyte *ptr = _env->GetByteArrayElements(data, nullptr);
1885 if (ptr == nullptr) {
1886 ALOGE("Failed to get Java array elements");
1887 return;
1888 }
1889 rsScriptSetVarV((RsContext)con, (RsScript)script, slot, ptr, len);
1890 _env->ReleaseByteArrayElements(data, ptr, JNI_ABORT);
1891 }
1892
1893 static void
nScriptGetVarV(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot,jbyteArray data)1894 nScriptGetVarV(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot, jbyteArray data)
1895 {
1896 if (kLogApi) {
1897 ALOGD("nScriptSetVarV, con(%p), s(%p), slot(%i)", (RsContext)con, (void *)script, slot);
1898 }
1899 jint len = _env->GetArrayLength(data);
1900 jbyte *ptr = _env->GetByteArrayElements(data, nullptr);
1901 if (ptr == nullptr) {
1902 ALOGE("Failed to get Java array elements");
1903 return;
1904 }
1905 rsScriptGetVarV((RsContext)con, (RsScript)script, slot, ptr, len);
1906 _env->ReleaseByteArrayElements(data, ptr, 0);
1907 }
1908
1909 static void
nScriptSetVarVE(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot,jbyteArray data,jlong elem,jintArray dims)1910 nScriptSetVarVE(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot, jbyteArray data,
1911 jlong elem, jintArray dims)
1912 {
1913 if (kLogApi) {
1914 ALOGD("nScriptSetVarVE, con(%p), s(%p), slot(%i)", (RsContext)con, (void *)script, slot);
1915 }
1916 jint len = _env->GetArrayLength(data);
1917 jbyte *ptr = _env->GetByteArrayElements(data, nullptr);
1918 if (ptr == nullptr) {
1919 ALOGE("Failed to get Java array elements");
1920 return;
1921 }
1922 jint dimsLen = _env->GetArrayLength(dims) * sizeof(int);
1923 jint *dimsPtr = _env->GetIntArrayElements(dims, nullptr);
1924 if (dimsPtr == nullptr) {
1925 ALOGE("Failed to get Java array elements");
1926 return;
1927 }
1928 rsScriptSetVarVE((RsContext)con, (RsScript)script, slot, ptr, len, (RsElement)elem,
1929 (const uint32_t*) dimsPtr, dimsLen);
1930 _env->ReleaseByteArrayElements(data, ptr, JNI_ABORT);
1931 _env->ReleaseIntArrayElements(dims, dimsPtr, JNI_ABORT);
1932 }
1933
1934
1935 static void
nScriptSetTimeZone(JNIEnv * _env,jobject _this,jlong con,jlong script,jbyteArray timeZone)1936 nScriptSetTimeZone(JNIEnv *_env, jobject _this, jlong con, jlong script, jbyteArray timeZone)
1937 {
1938 if (kLogApi) {
1939 ALOGD("nScriptCSetTimeZone, con(%p), s(%p)", (RsContext)con, (void *)script);
1940 }
1941
1942 jint length = _env->GetArrayLength(timeZone);
1943 jbyte* timeZone_ptr;
1944 timeZone_ptr = (jbyte *) _env->GetPrimitiveArrayCritical(timeZone, (jboolean *)0);
1945 if (timeZone_ptr == nullptr) {
1946 ALOGE("Failed to get Java array elements");
1947 return;
1948 }
1949
1950 rsScriptSetTimeZone((RsContext)con, (RsScript)script, (const char *)timeZone_ptr, length);
1951
1952 if (timeZone_ptr) {
1953 _env->ReleasePrimitiveArrayCritical(timeZone, timeZone_ptr, 0);
1954 }
1955 }
1956
1957 static void
nScriptInvoke(JNIEnv * _env,jobject _this,jlong con,jlong obj,jint slot)1958 nScriptInvoke(JNIEnv *_env, jobject _this, jlong con, jlong obj, jint slot)
1959 {
1960 if (kLogApi) {
1961 ALOGD("nScriptInvoke, con(%p), script(%p)", (RsContext)con, (void *)obj);
1962 }
1963 rsScriptInvoke((RsContext)con, (RsScript)obj, slot);
1964 }
1965
1966 static void
nScriptInvokeV(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot,jbyteArray data)1967 nScriptInvokeV(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot, jbyteArray data)
1968 {
1969 if (kLogApi) {
1970 ALOGD("nScriptInvokeV, con(%p), s(%p), slot(%i)", (RsContext)con, (void *)script, slot);
1971 }
1972 jint len = _env->GetArrayLength(data);
1973 jbyte *ptr = _env->GetByteArrayElements(data, nullptr);
1974 if (ptr == nullptr) {
1975 ALOGE("Failed to get Java array elements");
1976 return;
1977 }
1978 rsScriptInvokeV((RsContext)con, (RsScript)script, slot, ptr, len);
1979 _env->ReleaseByteArrayElements(data, ptr, JNI_ABORT);
1980 }
1981
1982 static void
nScriptForEach(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot,jlongArray ains,jlong aout,jbyteArray params,jintArray limits)1983 nScriptForEach(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot,
1984 jlongArray ains, jlong aout, jbyteArray params,
1985 jintArray limits)
1986 {
1987 if (kLogApi) {
1988 ALOGD("nScriptForEach, con(%p), s(%p), slot(%i) ains(%p) aout(%" PRId64 ")", (RsContext)con, (void *)script, slot, ains, aout);
1989 }
1990
1991 jint in_len = 0;
1992 jlong *in_ptr = nullptr;
1993
1994 RsAllocation *in_allocs = nullptr;
1995
1996 if (ains != nullptr) {
1997 in_len = _env->GetArrayLength(ains);
1998 if (in_len > (jint)RS_KERNEL_MAX_ARGUMENTS) {
1999 ALOGE("Too many arguments in kernel launch.");
2000 // TODO (b/20758983): Report back to Java and throw an exception
2001 return;
2002 }
2003
2004 in_ptr = _env->GetLongArrayElements(ains, nullptr);
2005 if (in_ptr == nullptr) {
2006 ALOGE("Failed to get Java array elements");
2007 return;
2008 }
2009
2010 if (sizeof(RsAllocation) == sizeof(jlong)) {
2011 in_allocs = (RsAllocation*)in_ptr;
2012 } else {
2013 // Convert from 64-bit jlong types to the native pointer type.
2014
2015 in_allocs = (RsAllocation*)alloca(in_len * sizeof(RsAllocation));
2016 if (in_allocs == nullptr) {
2017 ALOGE("Failed launching kernel for lack of memory.");
2018 _env->ReleaseLongArrayElements(ains, in_ptr, JNI_ABORT);
2019 return;
2020 }
2021
2022 for (int index = in_len; --index >= 0;) {
2023 in_allocs[index] = (RsAllocation)in_ptr[index];
2024 }
2025 }
2026 }
2027
2028 jint param_len = 0;
2029 jbyte *param_ptr = nullptr;
2030
2031 if (params != nullptr) {
2032 param_len = _env->GetArrayLength(params);
2033 param_ptr = _env->GetByteArrayElements(params, nullptr);
2034 if (param_ptr == nullptr) {
2035 ALOGE("Failed to get Java array elements");
2036 return;
2037 }
2038 }
2039
2040 RsScriptCall sc, *sca = nullptr;
2041 uint32_t sc_size = 0;
2042
2043 jint limit_len = 0;
2044 jint *limit_ptr = nullptr;
2045
2046 if (limits != nullptr) {
2047 limit_len = _env->GetArrayLength(limits);
2048 limit_ptr = _env->GetIntArrayElements(limits, nullptr);
2049 if (limit_ptr == nullptr) {
2050 ALOGE("Failed to get Java array elements");
2051 return;
2052 }
2053
2054 assert(limit_len == 6);
2055 UNUSED(limit_len); // As the assert might not be compiled.
2056
2057 sc.xStart = limit_ptr[0];
2058 sc.xEnd = limit_ptr[1];
2059 sc.yStart = limit_ptr[2];
2060 sc.yEnd = limit_ptr[3];
2061 sc.zStart = limit_ptr[4];
2062 sc.zEnd = limit_ptr[5];
2063 sc.strategy = RS_FOR_EACH_STRATEGY_DONT_CARE;
2064 sc.arrayStart = 0;
2065 sc.arrayEnd = 0;
2066 sc.array2Start = 0;
2067 sc.array2End = 0;
2068 sc.array3Start = 0;
2069 sc.array3End = 0;
2070 sc.array4Start = 0;
2071 sc.array4End = 0;
2072
2073 sca = ≻
2074 // sc_size is required, but unused, by the runtime and drivers.
2075 sc_size = sizeof(sc);
2076 }
2077
2078 rsScriptForEachMulti((RsContext)con, (RsScript)script, slot,
2079 in_allocs, in_len, (RsAllocation)aout,
2080 param_ptr, param_len, sca, sc_size);
2081
2082 if (ains != nullptr) {
2083 _env->ReleaseLongArrayElements(ains, in_ptr, JNI_ABORT);
2084 }
2085
2086 if (params != nullptr) {
2087 _env->ReleaseByteArrayElements(params, param_ptr, JNI_ABORT);
2088 }
2089
2090 if (limits != nullptr) {
2091 _env->ReleaseIntArrayElements(limits, limit_ptr, JNI_ABORT);
2092 }
2093 }
2094
2095 static void
nScriptReduce(JNIEnv * _env,jobject _this,jlong con,jlong script,jint slot,jlongArray ains,jlong aout,jintArray limits)2096 nScriptReduce(JNIEnv *_env, jobject _this, jlong con, jlong script, jint slot,
2097 jlongArray ains, jlong aout, jintArray limits)
2098 {
2099 if (kLogApi) {
2100 ALOGD("nScriptReduce, con(%p), s(%p), slot(%i) ains(%p) aout(%" PRId64 ")", (RsContext)con, (void *)script, slot, ains, aout);
2101 }
2102
2103 if (ains == nullptr) {
2104 ALOGE("At least one input required.");
2105 // TODO (b/20758983): Report back to Java and throw an exception
2106 return;
2107 }
2108 jint in_len = _env->GetArrayLength(ains);
2109 if (in_len > (jint)RS_KERNEL_MAX_ARGUMENTS) {
2110 ALOGE("Too many arguments in kernel launch.");
2111 // TODO (b/20758983): Report back to Java and throw an exception
2112 return;
2113 }
2114
2115 jlong *in_ptr = _env->GetLongArrayElements(ains, nullptr);
2116 if (in_ptr == nullptr) {
2117 ALOGE("Failed to get Java array elements");
2118 // TODO (b/20758983): Report back to Java and throw an exception
2119 return;
2120 }
2121
2122 RsAllocation *in_allocs = nullptr;
2123 if (sizeof(RsAllocation) == sizeof(jlong)) {
2124 in_allocs = (RsAllocation*)in_ptr;
2125 } else {
2126 // Convert from 64-bit jlong types to the native pointer type.
2127
2128 in_allocs = (RsAllocation*)alloca(in_len * sizeof(RsAllocation));
2129 if (in_allocs == nullptr) {
2130 ALOGE("Failed launching kernel for lack of memory.");
2131 // TODO (b/20758983): Report back to Java and throw an exception
2132 _env->ReleaseLongArrayElements(ains, in_ptr, JNI_ABORT);
2133 return;
2134 }
2135
2136 for (int index = in_len; --index >= 0;) {
2137 in_allocs[index] = (RsAllocation)in_ptr[index];
2138 }
2139 }
2140
2141 RsScriptCall sc, *sca = nullptr;
2142 uint32_t sc_size = 0;
2143
2144 jint limit_len = 0;
2145 jint *limit_ptr = nullptr;
2146
2147 if (limits != nullptr) {
2148 limit_len = _env->GetArrayLength(limits);
2149 limit_ptr = _env->GetIntArrayElements(limits, nullptr);
2150 if (limit_ptr == nullptr) {
2151 ALOGE("Failed to get Java array elements");
2152 // TODO (b/20758983): Report back to Java and throw an exception
2153 return;
2154 }
2155
2156 assert(limit_len == 6);
2157 UNUSED(limit_len); // As the assert might not be compiled.
2158
2159 sc.xStart = limit_ptr[0];
2160 sc.xEnd = limit_ptr[1];
2161 sc.yStart = limit_ptr[2];
2162 sc.yEnd = limit_ptr[3];
2163 sc.zStart = limit_ptr[4];
2164 sc.zEnd = limit_ptr[5];
2165 sc.strategy = RS_FOR_EACH_STRATEGY_DONT_CARE;
2166 sc.arrayStart = 0;
2167 sc.arrayEnd = 0;
2168 sc.array2Start = 0;
2169 sc.array2End = 0;
2170 sc.array3Start = 0;
2171 sc.array3End = 0;
2172 sc.array4Start = 0;
2173 sc.array4End = 0;
2174
2175 sca = ≻
2176 sc_size = sizeof(sc);
2177 }
2178
2179 rsScriptReduce((RsContext)con, (RsScript)script, slot,
2180 in_allocs, in_len, (RsAllocation)aout,
2181 sca, sc_size);
2182
2183 _env->ReleaseLongArrayElements(ains, in_ptr, JNI_ABORT);
2184
2185 if (limits != nullptr) {
2186 _env->ReleaseIntArrayElements(limits, limit_ptr, JNI_ABORT);
2187 }
2188 }
2189
2190 // -----------------------------------
2191
2192 static jlong
nScriptCCreate(JNIEnv * _env,jobject _this,jlong con,jstring resName,jstring cacheDir,jbyteArray scriptRef,jint length)2193 nScriptCCreate(JNIEnv *_env, jobject _this, jlong con,
2194 jstring resName, jstring cacheDir,
2195 jbyteArray scriptRef, jint length)
2196 {
2197 if (kLogApi) {
2198 ALOGD("nScriptCCreate, con(%p)", (RsContext)con);
2199 }
2200
2201 AutoJavaStringToUTF8 resNameUTF(_env, resName);
2202 AutoJavaStringToUTF8 cacheDirUTF(_env, cacheDir);
2203 jlong ret = 0;
2204 jbyte* script_ptr = nullptr;
2205 jint _exception = 0;
2206 jint remaining;
2207 if (!scriptRef) {
2208 _exception = 1;
2209 //jniThrowException(_env, "java/lang/IllegalArgumentException", "script == null");
2210 goto exit;
2211 }
2212 if (length < 0) {
2213 _exception = 1;
2214 //jniThrowException(_env, "java/lang/IllegalArgumentException", "length < 0");
2215 goto exit;
2216 }
2217 remaining = _env->GetArrayLength(scriptRef);
2218 if (remaining < length) {
2219 _exception = 1;
2220 //jniThrowException(_env, "java/lang/IllegalArgumentException",
2221 // "length > script.length - offset");
2222 goto exit;
2223 }
2224 script_ptr = (jbyte *)
2225 _env->GetPrimitiveArrayCritical(scriptRef, (jboolean *)0);
2226 if (script_ptr == nullptr) {
2227 ALOGE("Failed to get Java array elements");
2228 return ret;
2229 }
2230
2231 //rsScriptCSetText((RsContext)con, (const char *)script_ptr, length);
2232
2233 ret = (jlong)(uintptr_t)rsScriptCCreate((RsContext)con,
2234 resNameUTF.c_str(), resNameUTF.length(),
2235 cacheDirUTF.c_str(), cacheDirUTF.length(),
2236 (const char *)script_ptr, length);
2237
2238 exit:
2239 if (script_ptr) {
2240 _env->ReleasePrimitiveArrayCritical(scriptRef, script_ptr,
2241 _exception ? JNI_ABORT: 0);
2242 }
2243
2244 return (jlong)(uintptr_t)ret;
2245 }
2246
2247 static jlong
nScriptIntrinsicCreate(JNIEnv * _env,jobject _this,jlong con,jint id,jlong eid)2248 nScriptIntrinsicCreate(JNIEnv *_env, jobject _this, jlong con, jint id, jlong eid)
2249 {
2250 if (kLogApi) {
2251 ALOGD("nScriptIntrinsicCreate, con(%p) id(%i) element(%p)", (RsContext)con, id,
2252 (void *)eid);
2253 }
2254 return (jlong)(uintptr_t)rsScriptIntrinsicCreate((RsContext)con, id, (RsElement)eid);
2255 }
2256
2257 static jlong
nScriptKernelIDCreate(JNIEnv * _env,jobject _this,jlong con,jlong sid,jint slot,jint sig)2258 nScriptKernelIDCreate(JNIEnv *_env, jobject _this, jlong con, jlong sid, jint slot, jint sig)
2259 {
2260 if (kLogApi) {
2261 ALOGD("nScriptKernelIDCreate, con(%p) script(%p), slot(%i), sig(%i)", (RsContext)con,
2262 (void *)sid, slot, sig);
2263 }
2264 return (jlong)(uintptr_t)rsScriptKernelIDCreate((RsContext)con, (RsScript)sid, slot, sig);
2265 }
2266
2267 static jlong
nScriptInvokeIDCreate(JNIEnv * _env,jobject _this,jlong con,jlong sid,jint slot)2268 nScriptInvokeIDCreate(JNIEnv *_env, jobject _this, jlong con, jlong sid, jint slot)
2269 {
2270 if (kLogApi) {
2271 ALOGD("nScriptInvokeIDCreate, con(%p) script(%p), slot(%i)", (RsContext)con,
2272 (void *)sid, slot);
2273 }
2274 return (jlong)(uintptr_t)rsScriptInvokeIDCreate((RsContext)con, (RsScript)sid, slot);
2275 }
2276
2277 static jlong
nScriptFieldIDCreate(JNIEnv * _env,jobject _this,jlong con,jlong sid,jint slot)2278 nScriptFieldIDCreate(JNIEnv *_env, jobject _this, jlong con, jlong sid, jint slot)
2279 {
2280 if (kLogApi) {
2281 ALOGD("nScriptFieldIDCreate, con(%p) script(%p), slot(%i)", (RsContext)con, (void *)sid,
2282 slot);
2283 }
2284 return (jlong)(uintptr_t)rsScriptFieldIDCreate((RsContext)con, (RsScript)sid, slot);
2285 }
2286
2287 static jlong
nScriptGroupCreate(JNIEnv * _env,jobject _this,jlong con,jlongArray _kernels,jlongArray _src,jlongArray _dstk,jlongArray _dstf,jlongArray _types)2288 nScriptGroupCreate(JNIEnv *_env, jobject _this, jlong con, jlongArray _kernels, jlongArray _src,
2289 jlongArray _dstk, jlongArray _dstf, jlongArray _types)
2290 {
2291 if (kLogApi) {
2292 ALOGD("nScriptGroupCreate, con(%p)", (RsContext)con);
2293 }
2294
2295 jlong id = 0;
2296
2297 RsScriptKernelID* kernelsPtr;
2298 jint kernelsLen = _env->GetArrayLength(_kernels);
2299 jlong *jKernelsPtr = _env->GetLongArrayElements(_kernels, nullptr);
2300
2301 RsScriptKernelID* srcPtr;
2302 jint srcLen = _env->GetArrayLength(_src);
2303 jlong *jSrcPtr = _env->GetLongArrayElements(_src, nullptr);
2304
2305 RsScriptKernelID* dstkPtr;
2306 jint dstkLen = _env->GetArrayLength(_dstk);
2307 jlong *jDstkPtr = _env->GetLongArrayElements(_dstk, nullptr);
2308
2309 RsScriptKernelID* dstfPtr;
2310 jint dstfLen = _env->GetArrayLength(_dstf);
2311 jlong *jDstfPtr = _env->GetLongArrayElements(_dstf, nullptr);
2312
2313 RsType* typesPtr;
2314 jint typesLen = _env->GetArrayLength(_types);
2315 jlong *jTypesPtr = _env->GetLongArrayElements(_types, nullptr);
2316
2317 if (jKernelsPtr == nullptr) {
2318 ALOGE("Failed to get Java array elements: kernels");
2319 goto cleanup;
2320 }
2321 if (jSrcPtr == nullptr) {
2322 ALOGE("Failed to get Java array elements: src");
2323 goto cleanup;
2324 }
2325 if (jDstkPtr == nullptr) {
2326 ALOGE("Failed to get Java array elements: dstk");
2327 goto cleanup;
2328 }
2329 if (jDstfPtr == nullptr) {
2330 ALOGE("Failed to get Java array elements: dstf");
2331 goto cleanup;
2332 }
2333 if (jTypesPtr == nullptr) {
2334 ALOGE("Failed to get Java array elements: types");
2335 goto cleanup;
2336 }
2337
2338 kernelsPtr = (RsScriptKernelID*) malloc(sizeof(RsScriptKernelID) * kernelsLen);
2339 for(int i = 0; i < kernelsLen; ++i) {
2340 kernelsPtr[i] = (RsScriptKernelID)jKernelsPtr[i];
2341 }
2342
2343 srcPtr = (RsScriptKernelID*) malloc(sizeof(RsScriptKernelID) * srcLen);
2344 for(int i = 0; i < srcLen; ++i) {
2345 srcPtr[i] = (RsScriptKernelID)jSrcPtr[i];
2346 }
2347
2348 dstkPtr = (RsScriptKernelID*) malloc(sizeof(RsScriptKernelID) * dstkLen);
2349 for(int i = 0; i < dstkLen; ++i) {
2350 dstkPtr[i] = (RsScriptKernelID)jDstkPtr[i];
2351 }
2352
2353 dstfPtr = (RsScriptKernelID*) malloc(sizeof(RsScriptKernelID) * dstfLen);
2354 for(int i = 0; i < dstfLen; ++i) {
2355 dstfPtr[i] = (RsScriptKernelID)jDstfPtr[i];
2356 }
2357
2358 typesPtr = (RsType*) malloc(sizeof(RsType) * typesLen);
2359 for(int i = 0; i < typesLen; ++i) {
2360 typesPtr[i] = (RsType)jTypesPtr[i];
2361 }
2362
2363 id = (jlong)(uintptr_t)rsScriptGroupCreate((RsContext)con,
2364 (RsScriptKernelID *)kernelsPtr, kernelsLen * sizeof(RsScriptKernelID),
2365 (RsScriptKernelID *)srcPtr, srcLen * sizeof(RsScriptKernelID),
2366 (RsScriptKernelID *)dstkPtr, dstkLen * sizeof(RsScriptKernelID),
2367 (RsScriptFieldID *)dstfPtr, dstfLen * sizeof(RsScriptKernelID),
2368 (RsType *)typesPtr, typesLen * sizeof(RsType));
2369
2370 free(kernelsPtr);
2371 free(srcPtr);
2372 free(dstkPtr);
2373 free(dstfPtr);
2374 free(typesPtr);
2375
2376 cleanup:
2377 if (jKernelsPtr != nullptr) {
2378 _env->ReleaseLongArrayElements(_kernels, jKernelsPtr, 0);
2379 }
2380 if (jSrcPtr != nullptr) {
2381 _env->ReleaseLongArrayElements(_src, jSrcPtr, 0);
2382 }
2383 if (jDstkPtr != nullptr) {
2384 _env->ReleaseLongArrayElements(_dstk, jDstkPtr, 0);
2385 }
2386 if (jDstfPtr != nullptr) {
2387 _env->ReleaseLongArrayElements(_dstf, jDstfPtr, 0);
2388 }
2389 if (jTypesPtr != nullptr) {
2390 _env->ReleaseLongArrayElements(_types, jTypesPtr, 0);
2391 }
2392
2393 return id;
2394 }
2395
2396 static void
nScriptGroupSetInput(JNIEnv * _env,jobject _this,jlong con,jlong gid,jlong kid,jlong alloc)2397 nScriptGroupSetInput(JNIEnv *_env, jobject _this, jlong con, jlong gid, jlong kid, jlong alloc)
2398 {
2399 if (kLogApi) {
2400 ALOGD("nScriptGroupSetInput, con(%p) group(%p), kernelId(%p), alloc(%p)", (RsContext)con,
2401 (void *)gid, (void *)kid, (void *)alloc);
2402 }
2403 rsScriptGroupSetInput((RsContext)con, (RsScriptGroup)gid, (RsScriptKernelID)kid, (RsAllocation)alloc);
2404 }
2405
2406 static void
nScriptGroupSetOutput(JNIEnv * _env,jobject _this,jlong con,jlong gid,jlong kid,jlong alloc)2407 nScriptGroupSetOutput(JNIEnv *_env, jobject _this, jlong con, jlong gid, jlong kid, jlong alloc)
2408 {
2409 if (kLogApi) {
2410 ALOGD("nScriptGroupSetOutput, con(%p) group(%p), kernelId(%p), alloc(%p)", (RsContext)con,
2411 (void *)gid, (void *)kid, (void *)alloc);
2412 }
2413 rsScriptGroupSetOutput((RsContext)con, (RsScriptGroup)gid, (RsScriptKernelID)kid, (RsAllocation)alloc);
2414 }
2415
2416 static void
nScriptGroupExecute(JNIEnv * _env,jobject _this,jlong con,jlong gid)2417 nScriptGroupExecute(JNIEnv *_env, jobject _this, jlong con, jlong gid)
2418 {
2419 if (kLogApi) {
2420 ALOGD("nScriptGroupSetOutput, con(%p) group(%p)", (RsContext)con, (void *)gid);
2421 }
2422 rsScriptGroupExecute((RsContext)con, (RsScriptGroup)gid);
2423 }
2424
2425 // ---------------------------------------------------------------------------
2426
2427 static jlong
nProgramStoreCreate(JNIEnv * _env,jobject _this,jlong con,jboolean colorMaskR,jboolean colorMaskG,jboolean colorMaskB,jboolean colorMaskA,jboolean depthMask,jboolean ditherEnable,jint srcFunc,jint destFunc,jint depthFunc)2428 nProgramStoreCreate(JNIEnv *_env, jobject _this, jlong con,
2429 jboolean colorMaskR, jboolean colorMaskG, jboolean colorMaskB, jboolean colorMaskA,
2430 jboolean depthMask, jboolean ditherEnable,
2431 jint srcFunc, jint destFunc,
2432 jint depthFunc)
2433 {
2434 if (kLogApi) {
2435 ALOGD("nProgramStoreCreate, con(%p)", (RsContext)con);
2436 }
2437 return (jlong)(uintptr_t)rsProgramStoreCreate((RsContext)con, colorMaskR, colorMaskG, colorMaskB, colorMaskA,
2438 depthMask, ditherEnable, (RsBlendSrcFunc)srcFunc,
2439 (RsBlendDstFunc)destFunc, (RsDepthFunc)depthFunc);
2440 }
2441
2442 // ---------------------------------------------------------------------------
2443
2444 static void
nProgramBindConstants(JNIEnv * _env,jobject _this,jlong con,jlong vpv,jint slot,jlong a)2445 nProgramBindConstants(JNIEnv *_env, jobject _this, jlong con, jlong vpv, jint slot, jlong a)
2446 {
2447 if (kLogApi) {
2448 ALOGD("nProgramBindConstants, con(%p), vpf(%p), sloat(%i), a(%p)", (RsContext)con,
2449 (RsProgramVertex)vpv, slot, (RsAllocation)a);
2450 }
2451 rsProgramBindConstants((RsContext)con, (RsProgram)vpv, slot, (RsAllocation)a);
2452 }
2453
2454 static void
nProgramBindTexture(JNIEnv * _env,jobject _this,jlong con,jlong vpf,jint slot,jlong a)2455 nProgramBindTexture(JNIEnv *_env, jobject _this, jlong con, jlong vpf, jint slot, jlong a)
2456 {
2457 if (kLogApi) {
2458 ALOGD("nProgramBindTexture, con(%p), vpf(%p), slot(%i), a(%p)", (RsContext)con,
2459 (RsProgramFragment)vpf, slot, (RsAllocation)a);
2460 }
2461 rsProgramBindTexture((RsContext)con, (RsProgramFragment)vpf, slot, (RsAllocation)a);
2462 }
2463
2464 static void
nProgramBindSampler(JNIEnv * _env,jobject _this,jlong con,jlong vpf,jint slot,jlong a)2465 nProgramBindSampler(JNIEnv *_env, jobject _this, jlong con, jlong vpf, jint slot, jlong a)
2466 {
2467 if (kLogApi) {
2468 ALOGD("nProgramBindSampler, con(%p), vpf(%p), slot(%i), a(%p)", (RsContext)con,
2469 (RsProgramFragment)vpf, slot, (RsSampler)a);
2470 }
2471 rsProgramBindSampler((RsContext)con, (RsProgramFragment)vpf, slot, (RsSampler)a);
2472 }
2473
2474 // ---------------------------------------------------------------------------
2475
2476 static jlong
nProgramFragmentCreate(JNIEnv * _env,jobject _this,jlong con,jstring shader,jobjectArray texNames,jlongArray params)2477 nProgramFragmentCreate(JNIEnv *_env, jobject _this, jlong con, jstring shader,
2478 jobjectArray texNames, jlongArray params)
2479 {
2480 AutoJavaStringToUTF8 shaderUTF(_env, shader);
2481 jlong *jParamPtr = _env->GetLongArrayElements(params, nullptr);
2482 jint paramLen = _env->GetArrayLength(params);
2483 if (jParamPtr == nullptr) {
2484 ALOGE("Failed to get Java array elements");
2485 return 0;
2486 }
2487
2488 int texCount = _env->GetArrayLength(texNames);
2489 AutoJavaStringArrayToUTF8 names(_env, texNames, texCount);
2490 const char ** nameArray = names.c_str();
2491 size_t* sizeArray = names.c_str_len();
2492
2493 if (kLogApi) {
2494 ALOGD("nProgramFragmentCreate, con(%p), paramLen(%i)", (RsContext)con, paramLen);
2495 }
2496
2497 uintptr_t * paramPtr = (uintptr_t*) malloc(sizeof(uintptr_t) * paramLen);
2498 for(int i = 0; i < paramLen; ++i) {
2499 paramPtr[i] = (uintptr_t)jParamPtr[i];
2500 }
2501 jlong ret = (jlong)(uintptr_t)rsProgramFragmentCreate((RsContext)con, shaderUTF.c_str(), shaderUTF.length(),
2502 nameArray, texCount, sizeArray,
2503 paramPtr, paramLen);
2504
2505 free(paramPtr);
2506 _env->ReleaseLongArrayElements(params, jParamPtr, JNI_ABORT);
2507 return ret;
2508 }
2509
2510
2511 // ---------------------------------------------------------------------------
2512
2513 static jlong
nProgramVertexCreate(JNIEnv * _env,jobject _this,jlong con,jstring shader,jobjectArray texNames,jlongArray params)2514 nProgramVertexCreate(JNIEnv *_env, jobject _this, jlong con, jstring shader,
2515 jobjectArray texNames, jlongArray params)
2516 {
2517 AutoJavaStringToUTF8 shaderUTF(_env, shader);
2518 jlong *jParamPtr = _env->GetLongArrayElements(params, nullptr);
2519 jint paramLen = _env->GetArrayLength(params);
2520 if (jParamPtr == nullptr) {
2521 ALOGE("Failed to get Java array elements");
2522 return 0;
2523 }
2524
2525 if (kLogApi) {
2526 ALOGD("nProgramVertexCreate, con(%p), paramLen(%i)", (RsContext)con, paramLen);
2527 }
2528
2529 int texCount = _env->GetArrayLength(texNames);
2530 AutoJavaStringArrayToUTF8 names(_env, texNames, texCount);
2531 const char ** nameArray = names.c_str();
2532 size_t* sizeArray = names.c_str_len();
2533
2534 uintptr_t * paramPtr = (uintptr_t*) malloc(sizeof(uintptr_t) * paramLen);
2535 for(int i = 0; i < paramLen; ++i) {
2536 paramPtr[i] = (uintptr_t)jParamPtr[i];
2537 }
2538
2539 jlong ret = (jlong)(uintptr_t)rsProgramVertexCreate((RsContext)con, shaderUTF.c_str(), shaderUTF.length(),
2540 nameArray, texCount, sizeArray,
2541 paramPtr, paramLen);
2542
2543 free(paramPtr);
2544 _env->ReleaseLongArrayElements(params, jParamPtr, JNI_ABORT);
2545 return ret;
2546 }
2547
2548 // ---------------------------------------------------------------------------
2549
2550 static jlong
nProgramRasterCreate(JNIEnv * _env,jobject _this,jlong con,jboolean pointSprite,jint cull)2551 nProgramRasterCreate(JNIEnv *_env, jobject _this, jlong con, jboolean pointSprite, jint cull)
2552 {
2553 if (kLogApi) {
2554 ALOGD("nProgramRasterCreate, con(%p), pointSprite(%i), cull(%i)", (RsContext)con,
2555 pointSprite, cull);
2556 }
2557 return (jlong)(uintptr_t)rsProgramRasterCreate((RsContext)con, pointSprite, (RsCullMode)cull);
2558 }
2559
2560
2561 // ---------------------------------------------------------------------------
2562
2563 static void
nContextBindRootScript(JNIEnv * _env,jobject _this,jlong con,jlong script)2564 nContextBindRootScript(JNIEnv *_env, jobject _this, jlong con, jlong script)
2565 {
2566 if (kLogApi) {
2567 ALOGD("nContextBindRootScript, con(%p), script(%p)", (RsContext)con, (RsScript)script);
2568 }
2569 rsContextBindRootScript((RsContext)con, (RsScript)script);
2570 }
2571
2572 static void
nContextBindProgramStore(JNIEnv * _env,jobject _this,jlong con,jlong pfs)2573 nContextBindProgramStore(JNIEnv *_env, jobject _this, jlong con, jlong pfs)
2574 {
2575 if (kLogApi) {
2576 ALOGD("nContextBindProgramStore, con(%p), pfs(%p)", (RsContext)con, (RsProgramStore)pfs);
2577 }
2578 rsContextBindProgramStore((RsContext)con, (RsProgramStore)pfs);
2579 }
2580
2581 static void
nContextBindProgramFragment(JNIEnv * _env,jobject _this,jlong con,jlong pf)2582 nContextBindProgramFragment(JNIEnv *_env, jobject _this, jlong con, jlong pf)
2583 {
2584 if (kLogApi) {
2585 ALOGD("nContextBindProgramFragment, con(%p), pf(%p)", (RsContext)con,
2586 (RsProgramFragment)pf);
2587 }
2588 rsContextBindProgramFragment((RsContext)con, (RsProgramFragment)pf);
2589 }
2590
2591 static void
nContextBindProgramVertex(JNIEnv * _env,jobject _this,jlong con,jlong pf)2592 nContextBindProgramVertex(JNIEnv *_env, jobject _this, jlong con, jlong pf)
2593 {
2594 if (kLogApi) {
2595 ALOGD("nContextBindProgramVertex, con(%p), pf(%p)", (RsContext)con, (RsProgramVertex)pf);
2596 }
2597 rsContextBindProgramVertex((RsContext)con, (RsProgramVertex)pf);
2598 }
2599
2600 static void
nContextBindProgramRaster(JNIEnv * _env,jobject _this,jlong con,jlong pf)2601 nContextBindProgramRaster(JNIEnv *_env, jobject _this, jlong con, jlong pf)
2602 {
2603 if (kLogApi) {
2604 ALOGD("nContextBindProgramRaster, con(%p), pf(%p)", (RsContext)con, (RsProgramRaster)pf);
2605 }
2606 rsContextBindProgramRaster((RsContext)con, (RsProgramRaster)pf);
2607 }
2608
2609
2610 // ---------------------------------------------------------------------------
2611
2612 static jlong
nSamplerCreate(JNIEnv * _env,jobject _this,jlong con,jint magFilter,jint minFilter,jint wrapS,jint wrapT,jint wrapR,jfloat aniso)2613 nSamplerCreate(JNIEnv *_env, jobject _this, jlong con, jint magFilter, jint minFilter,
2614 jint wrapS, jint wrapT, jint wrapR, jfloat aniso)
2615 {
2616 if (kLogApi) {
2617 ALOGD("nSamplerCreate, con(%p)", (RsContext)con);
2618 }
2619 return (jlong)(uintptr_t)rsSamplerCreate((RsContext)con,
2620 (RsSamplerValue)magFilter,
2621 (RsSamplerValue)minFilter,
2622 (RsSamplerValue)wrapS,
2623 (RsSamplerValue)wrapT,
2624 (RsSamplerValue)wrapR,
2625 aniso);
2626 }
2627
2628 // ---------------------------------------------------------------------------
2629
2630 static jlong
nMeshCreate(JNIEnv * _env,jobject _this,jlong con,jlongArray _vtx,jlongArray _idx,jintArray _prim)2631 nMeshCreate(JNIEnv *_env, jobject _this, jlong con, jlongArray _vtx, jlongArray _idx, jintArray _prim)
2632 {
2633 if (kLogApi) {
2634 ALOGD("nMeshCreate, con(%p)", (RsContext)con);
2635 }
2636
2637 jlong id = 0;
2638
2639 RsAllocation* vtxPtr;
2640 jint vtxLen = _env->GetArrayLength(_vtx);
2641 jlong *jVtxPtr = _env->GetLongArrayElements(_vtx, nullptr);
2642
2643 RsAllocation* idxPtr;
2644 jint idxLen = _env->GetArrayLength(_idx);
2645 jlong *jIdxPtr = _env->GetLongArrayElements(_idx, nullptr);
2646
2647 jint primLen = _env->GetArrayLength(_prim);
2648 jint *primPtr = _env->GetIntArrayElements(_prim, nullptr);
2649
2650 if (jVtxPtr == nullptr) {
2651 ALOGE("Failed to get Java array elements: vtx");
2652 goto cleanupMesh;
2653 }
2654 if (jIdxPtr == nullptr) {
2655 ALOGE("Failed to get Java array elements: idx");
2656 goto cleanupMesh;
2657 }
2658 if (primPtr == nullptr) {
2659 ALOGE("Failed to get Java array elements: prim");
2660 goto cleanupMesh;
2661 }
2662
2663 vtxPtr = (RsAllocation*) malloc(sizeof(RsAllocation) * vtxLen);
2664 for(int i = 0; i < vtxLen; ++i) {
2665 vtxPtr[i] = (RsAllocation)(uintptr_t)jVtxPtr[i];
2666 }
2667
2668 idxPtr = (RsAllocation*) malloc(sizeof(RsAllocation) * idxLen);
2669 for(int i = 0; i < idxLen; ++i) {
2670 idxPtr[i] = (RsAllocation)(uintptr_t)jIdxPtr[i];
2671 }
2672
2673 id = (jlong)(uintptr_t)rsMeshCreate((RsContext)con,
2674 (RsAllocation *)vtxPtr, vtxLen,
2675 (RsAllocation *)idxPtr, idxLen,
2676 (uint32_t *)primPtr, primLen);
2677
2678 free(vtxPtr);
2679 free(idxPtr);
2680
2681 cleanupMesh:
2682 if (jVtxPtr != nullptr) {
2683 _env->ReleaseLongArrayElements(_vtx, jVtxPtr, 0);
2684 }
2685 if (jIdxPtr != nullptr) {
2686 _env->ReleaseLongArrayElements(_idx, jIdxPtr, 0);
2687 }
2688 if (primPtr != nullptr) {
2689 _env->ReleaseIntArrayElements(_prim, primPtr, 0);
2690 }
2691
2692 return id;
2693 }
2694
2695 static jint
nMeshGetVertexBufferCount(JNIEnv * _env,jobject _this,jlong con,jlong mesh)2696 nMeshGetVertexBufferCount(JNIEnv *_env, jobject _this, jlong con, jlong mesh)
2697 {
2698 if (kLogApi) {
2699 ALOGD("nMeshGetVertexBufferCount, con(%p), Mesh(%p)", (RsContext)con, (RsMesh)mesh);
2700 }
2701 jint vtxCount = 0;
2702 rsaMeshGetVertexBufferCount((RsContext)con, (RsMesh)mesh, &vtxCount);
2703 return vtxCount;
2704 }
2705
2706 static jint
nMeshGetIndexCount(JNIEnv * _env,jobject _this,jlong con,jlong mesh)2707 nMeshGetIndexCount(JNIEnv *_env, jobject _this, jlong con, jlong mesh)
2708 {
2709 if (kLogApi) {
2710 ALOGD("nMeshGetIndexCount, con(%p), Mesh(%p)", (RsContext)con, (RsMesh)mesh);
2711 }
2712 jint idxCount = 0;
2713 rsaMeshGetIndexCount((RsContext)con, (RsMesh)mesh, &idxCount);
2714 return idxCount;
2715 }
2716
2717 static void
nMeshGetVertices(JNIEnv * _env,jobject _this,jlong con,jlong mesh,jlongArray _ids,jint numVtxIDs)2718 nMeshGetVertices(JNIEnv *_env, jobject _this, jlong con, jlong mesh, jlongArray _ids, jint numVtxIDs)
2719 {
2720 if (kLogApi) {
2721 ALOGD("nMeshGetVertices, con(%p), Mesh(%p)", (RsContext)con, (RsMesh)mesh);
2722 }
2723
2724 RsAllocation *allocs = (RsAllocation*)malloc((uint32_t)numVtxIDs * sizeof(RsAllocation));
2725 rsaMeshGetVertices((RsContext)con, (RsMesh)mesh, allocs, (uint32_t)numVtxIDs);
2726
2727 for(jint i = 0; i < numVtxIDs; i ++) {
2728 const jlong alloc = (jlong)(uintptr_t)allocs[i];
2729 _env->SetLongArrayRegion(_ids, i, 1, &alloc);
2730 }
2731
2732 free(allocs);
2733 }
2734
2735 static void
nMeshGetIndices(JNIEnv * _env,jobject _this,jlong con,jlong mesh,jlongArray _idxIds,jintArray _primitives,jint numIndices)2736 nMeshGetIndices(JNIEnv *_env, jobject _this, jlong con, jlong mesh, jlongArray _idxIds, jintArray _primitives, jint numIndices)
2737 {
2738 if (kLogApi) {
2739 ALOGD("nMeshGetVertices, con(%p), Mesh(%p)", (RsContext)con, (RsMesh)mesh);
2740 }
2741
2742 RsAllocation *allocs = (RsAllocation*)malloc((uint32_t)numIndices * sizeof(RsAllocation));
2743 uint32_t *prims= (uint32_t*)malloc((uint32_t)numIndices * sizeof(uint32_t));
2744
2745 rsaMeshGetIndices((RsContext)con, (RsMesh)mesh, allocs, prims, (uint32_t)numIndices);
2746
2747 for(jint i = 0; i < numIndices; i ++) {
2748 const jlong alloc = (jlong)(uintptr_t)allocs[i];
2749 const jint prim = (jint)prims[i];
2750 _env->SetLongArrayRegion(_idxIds, i, 1, &alloc);
2751 _env->SetIntArrayRegion(_primitives, i, 1, &prim);
2752 }
2753
2754 free(allocs);
2755 free(prims);
2756 }
2757
2758 static jint
nSystemGetPointerSize(JNIEnv * _env,jobject _this)2759 nSystemGetPointerSize(JNIEnv *_env, jobject _this) {
2760 return (jint)sizeof(void*);
2761 }
2762
2763 static jobject
nAllocationGetByteBuffer(JNIEnv * _env,jobject _this,jlong con,jlong alloc,jlongArray strideArr,jint xBytesSize,jint dimY,jint dimZ)2764 nAllocationGetByteBuffer(JNIEnv *_env, jobject _this, jlong con, jlong alloc,
2765 jlongArray strideArr, jint xBytesSize,
2766 jint dimY, jint dimZ) {
2767 if (kLogApi) {
2768 ALOGD("nAllocationGetByteBuffer, con(%p), alloc(%p)", (RsContext)con, (RsAllocation)alloc);
2769 }
2770
2771 jlong *jStridePtr = _env->GetLongArrayElements(strideArr, nullptr);
2772 if (jStridePtr == nullptr) {
2773 ALOGE("Failed to get Java array elements: strideArr");
2774 return 0;
2775 }
2776
2777 size_t strideIn = xBytesSize;
2778 void* ptr = nullptr;
2779 if (alloc != 0) {
2780 ptr = rsAllocationGetPointer((RsContext)con, (RsAllocation)alloc, 0,
2781 RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X, 0, 0,
2782 &strideIn, sizeof(size_t));
2783 }
2784
2785 jobject byteBuffer = nullptr;
2786 if (ptr != nullptr) {
2787 size_t bufferSize = strideIn;
2788 jStridePtr[0] = strideIn;
2789 if (dimY > 0) {
2790 bufferSize *= dimY;
2791 }
2792 if (dimZ > 0) {
2793 bufferSize *= dimZ;
2794 }
2795 byteBuffer = _env->NewDirectByteBuffer(ptr, (jlong) bufferSize);
2796 }
2797 _env->ReleaseLongArrayElements(strideArr, jStridePtr, 0);
2798 return byteBuffer;
2799 }
2800 // ---------------------------------------------------------------------------
2801
2802
2803 static const char *classPathName = "android/renderscript/RenderScript";
2804
2805 static const JNINativeMethod methods[] = {
2806 {"_nInit", "()V", (void*)_nInit },
2807
2808 {"nDeviceCreate", "()J", (void*)nDeviceCreate },
2809 {"nDeviceDestroy", "(J)V", (void*)nDeviceDestroy },
2810 {"nDeviceSetConfig", "(JII)V", (void*)nDeviceSetConfig },
2811 {"nContextGetUserMessage", "(J[I)I", (void*)nContextGetUserMessage },
2812 {"nContextGetErrorMessage", "(J)Ljava/lang/String;", (void*)nContextGetErrorMessage },
2813 {"nContextPeekMessage", "(J[I)I", (void*)nContextPeekMessage },
2814
2815 {"nContextInitToClient", "(J)V", (void*)nContextInitToClient },
2816 {"nContextDeinitToClient", "(J)V", (void*)nContextDeinitToClient },
2817
2818
2819 // All methods below are thread protected in java.
2820 {"rsnContextCreate", "(JIII)J", (void*)nContextCreate },
2821 {"rsnContextCreateGL", "(JIIIIIIIIIIIIFI)J", (void*)nContextCreateGL },
2822 {"rsnContextFinish", "(J)V", (void*)nContextFinish },
2823 {"rsnContextSetPriority", "(JI)V", (void*)nContextSetPriority },
2824 {"rsnContextSetCacheDir", "(JLjava/lang/String;)V", (void*)nContextSetCacheDir },
2825 {"rsnContextSetSurface", "(JIILandroid/view/Surface;)V", (void*)nContextSetSurface },
2826 {"rsnContextDestroy", "(J)V", (void*)nContextDestroy },
2827 {"rsnContextDump", "(JI)V", (void*)nContextDump },
2828 {"rsnContextPause", "(J)V", (void*)nContextPause },
2829 {"rsnContextResume", "(J)V", (void*)nContextResume },
2830 {"rsnContextSendMessage", "(JI[I)V", (void*)nContextSendMessage },
2831 {"rsnClosureCreate", "(JJJ[J[J[I[J[J)J", (void*)nClosureCreate },
2832 {"rsnInvokeClosureCreate", "(JJ[B[J[J[I)J", (void*)nInvokeClosureCreate },
2833 {"rsnClosureSetArg", "(JJIJI)V", (void*)nClosureSetArg },
2834 {"rsnClosureSetGlobal", "(JJJJI)V", (void*)nClosureSetGlobal },
2835 {"rsnAssignName", "(JJ[B)V", (void*)nAssignName },
2836 {"rsnGetName", "(JJ)Ljava/lang/String;", (void*)nGetName },
2837 {"rsnObjDestroy", "(JJ)V", (void*)nObjDestroy },
2838
2839 {"rsnFileA3DCreateFromFile", "(JLjava/lang/String;)J", (void*)nFileA3DCreateFromFile },
2840 {"rsnFileA3DCreateFromAssetStream", "(JJ)J", (void*)nFileA3DCreateFromAssetStream },
2841 {"rsnFileA3DCreateFromAsset", "(JLandroid/content/res/AssetManager;Ljava/lang/String;)J", (void*)nFileA3DCreateFromAsset },
2842 {"rsnFileA3DGetNumIndexEntries", "(JJ)I", (void*)nFileA3DGetNumIndexEntries },
2843 {"rsnFileA3DGetIndexEntries", "(JJI[I[Ljava/lang/String;)V", (void*)nFileA3DGetIndexEntries },
2844 {"rsnFileA3DGetEntryByIndex", "(JJI)J", (void*)nFileA3DGetEntryByIndex },
2845
2846 {"rsnFontCreateFromFile", "(JLjava/lang/String;FI)J", (void*)nFontCreateFromFile },
2847 {"rsnFontCreateFromAssetStream", "(JLjava/lang/String;FIJ)J", (void*)nFontCreateFromAssetStream },
2848 {"rsnFontCreateFromAsset", "(JLandroid/content/res/AssetManager;Ljava/lang/String;FI)J", (void*)nFontCreateFromAsset },
2849
2850 {"rsnElementCreate", "(JJIZI)J", (void*)nElementCreate },
2851 {"rsnElementCreate2", "(J[J[Ljava/lang/String;[I)J", (void*)nElementCreate2 },
2852 {"rsnElementGetNativeData", "(JJ[I)V", (void*)nElementGetNativeData },
2853 {"rsnElementGetSubElements", "(JJ[J[Ljava/lang/String;[I)V", (void*)nElementGetSubElements },
2854
2855 {"rsnTypeCreate", "(JJIIIZZI)J", (void*)nTypeCreate },
2856 {"rsnTypeGetNativeData", "(JJ[J)V", (void*)nTypeGetNativeData },
2857
2858 {"rsnAllocationCreateTyped", "(JJIIJ)J", (void*)nAllocationCreateTyped },
2859 {"rsnAllocationCreateFromBitmap", "(JJILandroid/graphics/Bitmap;I)J", (void*)nAllocationCreateFromBitmap },
2860 {"rsnAllocationCreateBitmapBackedAllocation", "(JJILandroid/graphics/Bitmap;I)J", (void*)nAllocationCreateBitmapBackedAllocation },
2861 {"rsnAllocationCubeCreateFromBitmap","(JJILandroid/graphics/Bitmap;I)J", (void*)nAllocationCubeCreateFromBitmap },
2862
2863 {"rsnAllocationCopyFromBitmap", "(JJLandroid/graphics/Bitmap;)V", (void*)nAllocationCopyFromBitmap },
2864 {"rsnAllocationCopyToBitmap", "(JJLandroid/graphics/Bitmap;)V", (void*)nAllocationCopyToBitmap },
2865
2866 {"rsnAllocationSyncAll", "(JJI)V", (void*)nAllocationSyncAll },
2867 {"rsnAllocationSetupBufferQueue", "(JJI)V", (void*)nAllocationSetupBufferQueue },
2868 {"rsnAllocationShareBufferQueue", "(JJJ)V", (void*)nAllocationShareBufferQueue },
2869 {"rsnAllocationGetSurface", "(JJ)Landroid/view/Surface;", (void*)nAllocationGetSurface },
2870 {"rsnAllocationSetSurface", "(JJLandroid/view/Surface;)V", (void*)nAllocationSetSurface },
2871 {"rsnAllocationIoSend", "(JJ)V", (void*)nAllocationIoSend },
2872 {"rsnAllocationIoReceive", "(JJ)J", (void*)nAllocationIoReceive },
2873 {"rsnAllocationData1D", "(JJIIILjava/lang/Object;IIIZ)V", (void*)nAllocationData1D },
2874 {"rsnAllocationElementData", "(JJIIIII[BI)V", (void*)nAllocationElementData },
2875 {"rsnAllocationData2D", "(JJIIIIIILjava/lang/Object;IIIZ)V", (void*)nAllocationData2D },
2876 {"rsnAllocationData2D", "(JJIIIIIIJIIII)V", (void*)nAllocationData2D_alloc },
2877 {"rsnAllocationData3D", "(JJIIIIIIILjava/lang/Object;IIIZ)V", (void*)nAllocationData3D },
2878 {"rsnAllocationData3D", "(JJIIIIIIIJIIII)V", (void*)nAllocationData3D_alloc },
2879 {"rsnAllocationRead", "(JJLjava/lang/Object;IIZ)V", (void*)nAllocationRead },
2880 {"rsnAllocationRead1D", "(JJIIILjava/lang/Object;IIIZ)V", (void*)nAllocationRead1D },
2881 {"rsnAllocationElementRead", "(JJIIIII[BI)V", (void*)nAllocationElementRead },
2882 {"rsnAllocationRead2D", "(JJIIIIIILjava/lang/Object;IIIZ)V", (void*)nAllocationRead2D },
2883 {"rsnAllocationRead3D", "(JJIIIIIIILjava/lang/Object;IIIZ)V", (void*)nAllocationRead3D },
2884 {"rsnAllocationGetType", "(JJ)J", (void*)nAllocationGetType},
2885 {"rsnAllocationResize1D", "(JJI)V", (void*)nAllocationResize1D },
2886 {"rsnAllocationGenerateMipmaps", "(JJ)V", (void*)nAllocationGenerateMipmaps },
2887
2888 {"rsnAllocationAdapterCreate", "(JJJ)J", (void*)nAllocationAdapterCreate },
2889 {"rsnAllocationAdapterOffset", "(JJIIIIIIIII)V", (void*)nAllocationAdapterOffset },
2890
2891 {"rsnScriptBindAllocation", "(JJJI)V", (void*)nScriptBindAllocation },
2892 {"rsnScriptSetTimeZone", "(JJ[B)V", (void*)nScriptSetTimeZone },
2893 {"rsnScriptInvoke", "(JJI)V", (void*)nScriptInvoke },
2894 {"rsnScriptInvokeV", "(JJI[B)V", (void*)nScriptInvokeV },
2895
2896 {"rsnScriptForEach", "(JJI[JJ[B[I)V", (void*)nScriptForEach },
2897 {"rsnScriptReduce", "(JJI[JJ[I)V", (void*)nScriptReduce },
2898
2899 {"rsnScriptSetVarI", "(JJII)V", (void*)nScriptSetVarI },
2900 {"rsnScriptGetVarI", "(JJI)I", (void*)nScriptGetVarI },
2901 {"rsnScriptSetVarJ", "(JJIJ)V", (void*)nScriptSetVarJ },
2902 {"rsnScriptGetVarJ", "(JJI)J", (void*)nScriptGetVarJ },
2903 {"rsnScriptSetVarF", "(JJIF)V", (void*)nScriptSetVarF },
2904 {"rsnScriptGetVarF", "(JJI)F", (void*)nScriptGetVarF },
2905 {"rsnScriptSetVarD", "(JJID)V", (void*)nScriptSetVarD },
2906 {"rsnScriptGetVarD", "(JJI)D", (void*)nScriptGetVarD },
2907 {"rsnScriptSetVarV", "(JJI[B)V", (void*)nScriptSetVarV },
2908 {"rsnScriptGetVarV", "(JJI[B)V", (void*)nScriptGetVarV },
2909 {"rsnScriptSetVarVE", "(JJI[BJ[I)V", (void*)nScriptSetVarVE },
2910 {"rsnScriptSetVarObj", "(JJIJ)V", (void*)nScriptSetVarObj },
2911
2912 {"rsnScriptCCreate", "(JLjava/lang/String;Ljava/lang/String;[BI)J", (void*)nScriptCCreate },
2913 {"rsnScriptIntrinsicCreate", "(JIJ)J", (void*)nScriptIntrinsicCreate },
2914 {"rsnScriptKernelIDCreate", "(JJII)J", (void*)nScriptKernelIDCreate },
2915 {"rsnScriptInvokeIDCreate", "(JJI)J", (void*)nScriptInvokeIDCreate },
2916 {"rsnScriptFieldIDCreate", "(JJI)J", (void*)nScriptFieldIDCreate },
2917 {"rsnScriptGroupCreate", "(J[J[J[J[J[J)J", (void*)nScriptGroupCreate },
2918 {"rsnScriptGroup2Create", "(JLjava/lang/String;Ljava/lang/String;[J)J", (void*)nScriptGroup2Create },
2919 {"rsnScriptGroupSetInput", "(JJJJ)V", (void*)nScriptGroupSetInput },
2920 {"rsnScriptGroupSetOutput", "(JJJJ)V", (void*)nScriptGroupSetOutput },
2921 {"rsnScriptGroupExecute", "(JJ)V", (void*)nScriptGroupExecute },
2922 {"rsnScriptGroup2Execute", "(JJ)V", (void*)nScriptGroup2Execute },
2923
2924 {"rsnScriptIntrinsicBLAS_Single", "(JJIIIIIIIIIFJJFJIIII)V", (void*)nScriptIntrinsicBLAS_Single },
2925 {"rsnScriptIntrinsicBLAS_Double", "(JJIIIIIIIIIDJJDJIIII)V", (void*)nScriptIntrinsicBLAS_Double },
2926 {"rsnScriptIntrinsicBLAS_Complex", "(JJIIIIIIIIIFFJJFFJIIII)V", (void*)nScriptIntrinsicBLAS_Complex },
2927 {"rsnScriptIntrinsicBLAS_Z", "(JJIIIIIIIIIDDJJDDJIIII)V", (void*)nScriptIntrinsicBLAS_Z },
2928
2929 {"rsnScriptIntrinsicBLAS_BNNM", "(JJIIIJIJIJII)V", (void*)nScriptIntrinsicBLAS_BNNM },
2930
2931 {"rsnProgramStoreCreate", "(JZZZZZZIII)J", (void*)nProgramStoreCreate },
2932
2933 {"rsnProgramBindConstants", "(JJIJ)V", (void*)nProgramBindConstants },
2934 {"rsnProgramBindTexture", "(JJIJ)V", (void*)nProgramBindTexture },
2935 {"rsnProgramBindSampler", "(JJIJ)V", (void*)nProgramBindSampler },
2936
2937 {"rsnProgramFragmentCreate", "(JLjava/lang/String;[Ljava/lang/String;[J)J", (void*)nProgramFragmentCreate },
2938 {"rsnProgramRasterCreate", "(JZI)J", (void*)nProgramRasterCreate },
2939 {"rsnProgramVertexCreate", "(JLjava/lang/String;[Ljava/lang/String;[J)J", (void*)nProgramVertexCreate },
2940
2941 {"rsnContextBindRootScript", "(JJ)V", (void*)nContextBindRootScript },
2942 {"rsnContextBindProgramStore", "(JJ)V", (void*)nContextBindProgramStore },
2943 {"rsnContextBindProgramFragment", "(JJ)V", (void*)nContextBindProgramFragment },
2944 {"rsnContextBindProgramVertex", "(JJ)V", (void*)nContextBindProgramVertex },
2945 {"rsnContextBindProgramRaster", "(JJ)V", (void*)nContextBindProgramRaster },
2946
2947 {"rsnSamplerCreate", "(JIIIIIF)J", (void*)nSamplerCreate },
2948
2949 {"rsnMeshCreate", "(J[J[J[I)J", (void*)nMeshCreate },
2950
2951 {"rsnMeshGetVertexBufferCount", "(JJ)I", (void*)nMeshGetVertexBufferCount },
2952 {"rsnMeshGetIndexCount", "(JJ)I", (void*)nMeshGetIndexCount },
2953 {"rsnMeshGetVertices", "(JJ[JI)V", (void*)nMeshGetVertices },
2954 {"rsnMeshGetIndices", "(JJ[J[II)V", (void*)nMeshGetIndices },
2955
2956 {"rsnSystemGetPointerSize", "()I", (void*)nSystemGetPointerSize },
2957 {"rsnAllocationGetByteBuffer", "(JJ[JIII)Ljava/nio/ByteBuffer;", (void*)nAllocationGetByteBuffer },
2958 };
2959
registerFuncs(JNIEnv * _env)2960 static int registerFuncs(JNIEnv *_env)
2961 {
2962 return android::AndroidRuntime::registerNativeMethods(
2963 _env, classPathName, methods, NELEM(methods));
2964 }
2965
2966 // ---------------------------------------------------------------------------
2967
JNI_OnLoad(JavaVM * vm,void * reserved)2968 jint JNI_OnLoad(JavaVM* vm, void* reserved)
2969 {
2970 JNIEnv* env = nullptr;
2971 jint result = -1;
2972
2973 if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
2974 ALOGE("ERROR: GetEnv failed\n");
2975 goto bail;
2976 }
2977 assert(env != nullptr);
2978
2979 if (registerFuncs(env) < 0) {
2980 ALOGE("ERROR: Renderscript native registration failed\n");
2981 goto bail;
2982 }
2983
2984 /* success -- return valid version number */
2985 result = JNI_VERSION_1_4;
2986
2987 bail:
2988 return result;
2989 }
2990