1/*
2 * Copyright (C) 2011 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#include "android/bitmap.h"
18
19#include "jni/jni_gl_frame.h"
20#include "jni/jni_util.h"
21
22#include "native/core/gl_env.h"
23#include "native/core/gl_frame.h"
24#include "native/core/native_frame.h"
25
26using android::filterfw::GLEnv;
27using android::filterfw::GLFrame;
28using android::filterfw::NativeFrame;
29
30// Helper functions ////////////////////////////////////////////////////////////////////////////////
31void ConvertFloatsToRGBA(const float* floats, int length, uint8_t* result) {
32  for (int i = 0; i < length; ++i) {
33    result[i] = static_cast<uint8_t>(floats[i] * 255.0);
34  }
35}
36
37void ConvertRGBAToFloats(const uint8_t* rgba, int length, float* result) {
38  for (int i = 0; i < length; ++i) {
39    result[i] = rgba[i] / 255.0;
40  }
41}
42
43// GLFrame JNI implementation //////////////////////////////////////////////////////////////////////
44jboolean Java_android_filterfw_core_GLFrame_nativeAllocate(JNIEnv* env,
45                                                           jobject thiz,
46                                                           jobject gl_env,
47                                                           jint width,
48                                                           jint height) {
49  GLEnv* gl_env_ptr = ConvertFromJava<GLEnv>(env, gl_env);
50  if (!gl_env_ptr) return JNI_FALSE;
51  std::unique_ptr<GLFrame> frame(new GLFrame(gl_env_ptr));
52  if (frame->Init(width, height)) {
53    return ToJBool(WrapOwnedObjectInJava(std::move(frame), env, thiz, true));
54  }
55  return JNI_FALSE;
56}
57
58jboolean Java_android_filterfw_core_GLFrame_nativeAllocateWithTexture(JNIEnv* env,
59                                                                      jobject thiz,
60                                                                      jobject gl_env,
61                                                                      jint tex_id,
62                                                                      jint width,
63                                                                      jint height) {
64  GLEnv* gl_env_ptr = ConvertFromJava<GLEnv>(env, gl_env);
65  if (!gl_env_ptr) return JNI_FALSE;
66  std::unique_ptr<GLFrame> frame(new GLFrame(gl_env_ptr));
67  if (frame->InitWithTexture(tex_id, width, height)) {
68    return ToJBool(WrapOwnedObjectInJava(std::move(frame), env, thiz, true));
69  }
70  return JNI_FALSE;
71}
72
73jboolean Java_android_filterfw_core_GLFrame_nativeAllocateWithFbo(JNIEnv* env,
74                                                                  jobject thiz,
75                                                                  jobject gl_env,
76                                                                  jint fbo_id,
77                                                                  jint width,
78                                                                  jint height) {
79  GLEnv* gl_env_ptr = ConvertFromJava<GLEnv>(env, gl_env);
80  if (!gl_env_ptr) return JNI_FALSE;
81  std::unique_ptr<GLFrame> frame(new GLFrame(gl_env_ptr));
82  if (frame->InitWithFbo(fbo_id, width, height)) {
83    return ToJBool(WrapOwnedObjectInJava(std::move(frame), env, thiz, true));
84  }
85  return JNI_FALSE;
86}
87
88jboolean Java_android_filterfw_core_GLFrame_nativeAllocateExternal(JNIEnv* env,
89                                                                   jobject thiz,
90                                                                   jobject gl_env) {
91  GLEnv* gl_env_ptr = ConvertFromJava<GLEnv>(env, gl_env);
92  if (!gl_env_ptr) return JNI_FALSE;
93  std::unique_ptr<GLFrame> frame(new GLFrame(gl_env_ptr));
94  if (frame->InitWithExternalTexture()) {
95    return ToJBool(WrapOwnedObjectInJava(std::move(frame), env, thiz, true));
96  }
97  return JNI_FALSE;
98}
99
100jboolean Java_android_filterfw_core_GLFrame_nativeDeallocate(JNIEnv* env, jobject thiz) {
101  return ToJBool(DeleteNativeObject<GLFrame>(env, thiz));
102}
103
104jboolean Java_android_filterfw_core_GLFrame_setNativeData(JNIEnv* env,
105                                                          jobject thiz,
106                                                          jbyteArray data,
107                                                          jint offset,
108                                                          jint length) {
109  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
110  if (frame && data) {
111    jbyte* bytes = env->GetByteArrayElements(data, NULL);
112    if (bytes) {
113      const bool success = frame->WriteData(reinterpret_cast<const uint8_t*>(bytes + offset), length);
114      env->ReleaseByteArrayElements(data, bytes, JNI_ABORT);
115      return ToJBool(success);
116    }
117  }
118  return JNI_FALSE;
119}
120
121jbyteArray Java_android_filterfw_core_GLFrame_getNativeData(JNIEnv* env, jobject thiz) {
122  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
123  if (frame && frame->Size() > 0) {
124    jbyteArray result = env->NewByteArray(frame->Size());
125    jbyte* data = env->GetByteArrayElements(result, NULL);
126    frame->CopyDataTo(reinterpret_cast<uint8_t*>(data), frame->Size());
127    env->ReleaseByteArrayElements(result, data, 0);
128    return result;
129  }
130  return NULL;
131}
132
133jboolean Java_android_filterfw_core_GLFrame_setNativeInts(JNIEnv* env,
134                                                          jobject thiz,
135                                                          jintArray ints) {
136  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
137  if (frame && ints) {
138    jint* int_ptr = env->GetIntArrayElements(ints, NULL);
139    const int length = env->GetArrayLength(ints);
140    if (int_ptr) {
141      const bool success = frame->WriteData(reinterpret_cast<const uint8_t*>(int_ptr),
142                                            length * sizeof(jint));
143      env->ReleaseIntArrayElements(ints, int_ptr, JNI_ABORT);
144      return ToJBool(success);
145    }
146  }
147  return JNI_FALSE;
148}
149
150jintArray Java_android_filterfw_core_GLFrame_getNativeInts(JNIEnv* env, jobject thiz) {
151  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
152  if (frame && frame->Size() > 0 && (frame->Size() % sizeof(jint) == 0)) {
153    jintArray result = env->NewIntArray(frame->Size() / sizeof(jint));
154    jint* data = env->GetIntArrayElements(result, NULL);
155    frame->CopyDataTo(reinterpret_cast<uint8_t*>(data), frame->Size());
156    env->ReleaseIntArrayElements(result, data, 0);
157    return result;
158   }
159   return NULL;
160}
161
162jboolean Java_android_filterfw_core_GLFrame_setNativeFloats(JNIEnv* env,
163                                                            jobject thiz,
164                                                            jfloatArray floats) {
165  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
166  if (frame && floats) {
167    jfloat* float_ptr = env->GetFloatArrayElements(floats, NULL);
168    const int length = env->GetArrayLength(floats);
169    if (float_ptr) {
170      // Convert floats to RGBA buffer
171      uint8_t* rgba_buffer = new uint8_t[length];
172      ConvertFloatsToRGBA(float_ptr, length, rgba_buffer);
173      env->ReleaseFloatArrayElements(floats, float_ptr, JNI_ABORT);
174
175      // Write RGBA buffer to frame
176      const bool success = frame->WriteData(rgba_buffer, length);
177
178      // Clean-up
179      delete[] rgba_buffer;
180      return ToJBool(success);
181    }
182  }
183  return JNI_FALSE;
184}
185
186jfloatArray Java_android_filterfw_core_GLFrame_getNativeFloats(JNIEnv* env, jobject thiz) {
187  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
188  if (frame && frame->Size() > 0) {
189    // Create the result array
190    jfloatArray result = env->NewFloatArray(frame->Size());
191    jfloat* float_array = env->GetFloatArrayElements(result, NULL);
192
193    // Read the frame pixels
194    uint8_t* pixels = new uint8_t[frame->Size()];
195    frame->CopyDataTo(pixels, frame->Size());
196
197    // Convert them to floats
198    ConvertRGBAToFloats(pixels, frame->Size(), float_array);
199
200    // Clean-up
201    delete[] pixels;
202    env->ReleaseFloatArrayElements(result, float_array, 0);
203    return result;
204  }
205  return NULL;
206}
207
208jboolean Java_android_filterfw_core_GLFrame_setNativeBitmap(JNIEnv* env,
209                                                            jobject thiz,
210                                                            jobject bitmap,
211                                                            jint size) {
212  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
213  if (frame && bitmap) {
214    uint8_t* pixels;
215    const int result = AndroidBitmap_lockPixels(env, bitmap, reinterpret_cast<void**>(&pixels));
216    if (result == ANDROID_BITMAP_RESULT_SUCCESS) {
217      const bool success = frame->WriteData(pixels, size);
218      return ToJBool(success &&
219                     AndroidBitmap_unlockPixels(env, bitmap) == ANDROID_BITMAP_RESULT_SUCCESS);
220    }
221  }
222  return JNI_FALSE;
223}
224
225jboolean Java_android_filterfw_core_GLFrame_getNativeBitmap(JNIEnv* env,
226                                                            jobject thiz,
227                                                            jobject bitmap) {
228  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
229  if (frame && bitmap) {
230    uint8_t* pixels;
231    const int result = AndroidBitmap_lockPixels(env, bitmap, reinterpret_cast<void**>(&pixels));
232    if (result == ANDROID_BITMAP_RESULT_SUCCESS) {
233      frame->CopyDataTo(pixels, frame->Size());
234      return (AndroidBitmap_unlockPixels(env, bitmap) == ANDROID_BITMAP_RESULT_SUCCESS);
235    }
236  }
237  return JNI_FALSE;
238}
239
240jboolean Java_android_filterfw_core_GLFrame_setNativeViewport(JNIEnv* env,
241                                                              jobject thiz,
242                                                              jint x,
243                                                              jint y,
244                                                              jint width,
245                                                              jint height) {
246  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
247  return frame ? ToJBool(frame->SetViewport(x, y, width, height)) : JNI_FALSE;
248}
249
250jint Java_android_filterfw_core_GLFrame_getNativeTextureId(JNIEnv* env, jobject thiz) {
251  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
252  return frame ? frame->GetTextureId() : -1;
253}
254
255jint Java_android_filterfw_core_GLFrame_getNativeFboId(JNIEnv* env, jobject thiz) {
256  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
257  return frame ? frame->GetFboId() : -1;
258}
259
260jboolean Java_android_filterfw_core_GLFrame_generateNativeMipMap(JNIEnv* env, jobject thiz) {
261  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
262  return frame ? ToJBool(frame->GenerateMipMap()) : JNI_FALSE;
263}
264
265jboolean Java_android_filterfw_core_GLFrame_setNativeTextureParam(JNIEnv* env,
266                                                                  jobject thiz,
267                                                                  jint param,
268                                                                  jint value) {
269  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
270  return frame ? ToJBool(frame->SetTextureParameter(param, value)) : JNI_FALSE;
271}
272
273jboolean Java_android_filterfw_core_GLFrame_nativeResetParams(JNIEnv* env, jobject thiz) {
274  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
275  return frame ? ToJBool(frame->ResetTexParameters()) : JNI_FALSE;
276}
277
278jboolean Java_android_filterfw_core_GLFrame_nativeCopyFromNative(JNIEnv* env,
279                                                                 jobject thiz,
280                                                                 jobject frame) {
281  GLFrame* this_frame = ConvertFromJava<GLFrame>(env, thiz);
282  NativeFrame* other_frame = ConvertFromJava<NativeFrame>(env, frame);
283  if (this_frame && other_frame) {
284    return ToJBool(this_frame->WriteData(other_frame->Data(), other_frame->Size()));
285  }
286  return JNI_FALSE;
287}
288
289jboolean Java_android_filterfw_core_GLFrame_nativeCopyFromGL(JNIEnv* env,
290                                                             jobject thiz,
291                                                             jobject frame) {
292  GLFrame* this_frame = ConvertFromJava<GLFrame>(env, thiz);
293  GLFrame* other_frame = ConvertFromJava<GLFrame>(env, frame);
294  if (this_frame && other_frame) {
295    return ToJBool(this_frame->CopyPixelsFrom(other_frame));
296  }
297  return JNI_FALSE;
298}
299
300jboolean Java_android_filterfw_core_GLFrame_nativeFocus(JNIEnv* env, jobject thiz) {
301  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
302  return ToJBool(frame && frame->FocusFrameBuffer());
303}
304
305jboolean Java_android_filterfw_core_GLFrame_nativeReattachTexToFbo(JNIEnv* env, jobject thiz) {
306  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
307  return ToJBool(frame && frame->ReattachTextureToFbo());
308}
309
310jboolean Java_android_filterfw_core_GLFrame_nativeDetachTexFromFbo(JNIEnv* env, jobject thiz) {
311  GLFrame* frame = ConvertFromJava<GLFrame>(env, thiz);
312  return ToJBool(frame && frame->DetachTextureFromFbo());
313}
314
315