jni_jpegstream/src/jpegstream.cpp

   1 /*
   2  * Copyright (C) 2013 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "error_codes.h"
  18 #include "jni_defines.h"
  19 #include "jpeg_writer.h"
  20 #include "jpeg_reader.h"
  21 #include "jpeg_config.h"
  22 #include "outputstream_wrapper.h"
  23 #include "inputstream_wrapper.h"
  24
  25 #include <stdint.h>
  26
  27 #ifdef __cplusplus
  28 extern "C" {
  29 #endif
  30
  31 static jint OutputStream_setup(JNIEnv* env, jobject thiz, jobject out,
  32         jint width, jint height, jint format, jint quality) {
  33     // Get a reference to this object's class
  34     jclass thisClass = env->GetObjectClass(thiz);
  35     if (env->ExceptionCheck() || thisClass == NULL) {
  36         return J_EXCEPTION;
  37     }
  38     // Get field for storing C pointer
  39     jfieldID fidNumber = env->GetFieldID(thisClass, "JNIPointer", "J");
  40     if (NULL == fidNumber || env->ExceptionCheck()) {
  41         return J_EXCEPTION;
  42     }
  43
  44     // Check size
  45     if (width <= 0 || height <= 0) {
  46         return J_ERROR_BAD_ARGS;
  47     }
  48     Jpeg_Config::Format fmt = static_cast<Jpeg_Config::Format>(format);
  49     // Check format
  50     switch (fmt) {
  51     case Jpeg_Config::FORMAT_GRAYSCALE:
  52     case Jpeg_Config::FORMAT_RGB:
  53     case Jpeg_Config::FORMAT_RGBA:
  54     case Jpeg_Config::FORMAT_ABGR:
  55         break;
  56     default:
  57         return J_ERROR_BAD_ARGS;
  58     }
  59
  60     uint32_t w = static_cast<uint32_t>(width);
  61     uint32_t h = static_cast<uint32_t>(height);
  62     int32_t q = static_cast<int32_t>(quality);
  63     // Clamp quality to (0, 100]
  64     q = (q > 100) ? 100 : ((q < 1) ? 1 : q);
  65
  66     JpegWriter* w_ptr = new JpegWriter();
  67
  68     // Do JpegWriter setup.
  69     int32_t errorFlag = w_ptr->setup(env, out, w, h, fmt, q);
  70     if (env->ExceptionCheck() || errorFlag != J_SUCCESS) {
  71         delete w_ptr;
  72         return errorFlag;
  73     }
  74
  75     // Store C pointer for writer
  76     env->SetLongField(thiz, fidNumber, reinterpret_cast<jlong>(w_ptr));
  77     if (env->ExceptionCheck()) {
  78         delete w_ptr;
  79         return J_EXCEPTION;
  80     }
  81     return J_SUCCESS;
  82 }
  83
  84 static jint InputStream_setup(JNIEnv* env, jobject thiz, jobject dimens,
  85         jobject in, jint format) {
  86     // Get a reference to this object's class
  87     jclass thisClass = env->GetObjectClass(thiz);
  88     if (env->ExceptionCheck() || thisClass == NULL) {
  89         return J_EXCEPTION;
  90     }
  91     jmethodID setMethod = NULL;
  92
  93     // Get dimensions object setter method
  94     if (dimens != NULL) {
  95         jclass pointClass = env->GetObjectClass(dimens);
  96         if (env->ExceptionCheck() || pointClass == NULL) {
  97             return J_EXCEPTION;
  98         }
  99         setMethod = env->GetMethodID(pointClass, "set", "(II)V");
 100         if (env->ExceptionCheck() || setMethod == NULL) {
 101             return J_EXCEPTION;
 102         }
 103     }
 104     // Get field for storing C pointer
 105     jfieldID fidNumber = env->GetFieldID(thisClass, "JNIPointer", "J");
 106     if (NULL == fidNumber || env->ExceptionCheck()) {
 107         return J_EXCEPTION;
 108     }
 109     Jpeg_Config::Format fmt = static_cast<Jpeg_Config::Format>(format);
 110     // Check format
 111     switch (fmt) {
 112     case Jpeg_Config::FORMAT_GRAYSCALE:
 113     case Jpeg_Config::FORMAT_RGB:
 114     case Jpeg_Config::FORMAT_RGBA:
 115     case Jpeg_Config::FORMAT_ABGR:
 116         break;
 117     default:
 118         return J_ERROR_BAD_ARGS;
 119     }
 120
 121     JpegReader* r_ptr = new JpegReader();
 122     int32_t w = 0, h = 0;
 123     // Do JpegReader setup.
 124     int32_t errorFlag = r_ptr->setup(env, in, &w, &h, fmt);
 125     if (env->ExceptionCheck() || errorFlag != J_SUCCESS) {
 126         delete r_ptr;
 127         return errorFlag;
 128     }
 129
 130     // Set dimensions to return
 131     if (dimens != NULL) {
 132         env->CallVoidMethod(dimens, setMethod, static_cast<jint>(w),
 133                 static_cast<jint>(h));
 134         if (env->ExceptionCheck()) {
 135             delete r_ptr;
 136             return J_EXCEPTION;
 137         }
 138     }
 139     // Store C pointer for reader
 140     env->SetLongField(thiz, fidNumber, reinterpret_cast<jlong>(r_ptr));
 141     if (env->ExceptionCheck()) {
 142         delete r_ptr;
 143         return J_EXCEPTION;
 144     }
 145     return J_SUCCESS;
 146 }
 147
 148 static JpegWriter* getWPtr(JNIEnv* env, jobject thiz, jfieldID* fid) {
 149     jclass thisClass = env->GetObjectClass(thiz);
 150     if (env->ExceptionCheck() || thisClass == NULL) {
 151         return NULL;
 152     }
 153     jfieldID fidNumber = env->GetFieldID(thisClass, "JNIPointer", "J");
 154     if (NULL == fidNumber || env->ExceptionCheck()) {
 155         return NULL;
 156     }
 157     jlong ptr = env->GetLongField(thiz, fidNumber);
 158     if (env->ExceptionCheck()) {
 159         return NULL;
 160     }
 161     // Get writer C pointer out of java field.
 162     JpegWriter* w_ptr = reinterpret_cast<JpegWriter*>(ptr);
 163     if (fid != NULL) {
 164         *fid = fidNumber;
 165     }
 166     return w_ptr;
 167 }
 168
 169 static JpegReader* getRPtr(JNIEnv* env, jobject thiz, jfieldID* fid) {
 170     jclass thisClass = env->GetObjectClass(thiz);
 171     if (env->ExceptionCheck() || thisClass == NULL) {
 172         return NULL;
 173     }
 174     jfieldID fidNumber = env->GetFieldID(thisClass, "JNIPointer", "J");
 175     if (NULL == fidNumber || env->ExceptionCheck()) {
 176         return NULL;
 177     }
 178     jlong ptr = env->GetLongField(thiz, fidNumber);
 179     if (env->ExceptionCheck()) {
 180         return NULL;
 181     }
 182     // Get reader C pointer out of java field.
 183     JpegReader* r_ptr = reinterpret_cast<JpegReader*>(ptr);
 184     if (fid != NULL) {
 185         *fid = fidNumber;
 186     }
 187     return r_ptr;
 188 }
 189
 190 static void OutputStream_cleanup(JNIEnv* env, jobject thiz) {
 191     jfieldID fidNumber = NULL;
 192     JpegWriter* w_ptr = getWPtr(env, thiz, &fidNumber);
 193     if (w_ptr == NULL) {
 194         return;
 195     }
 196     // Update environment
 197     w_ptr->updateEnv(env);
 198     // Destroy writer object
 199     delete w_ptr;
 200     w_ptr = NULL;
 201     // Set the java field to null
 202     env->SetLongField(thiz, fidNumber, reinterpret_cast<jlong>(w_ptr));
 203 }
 204
 205 static void InputStream_cleanup(JNIEnv* env, jobject thiz) {
 206     jfieldID fidNumber = NULL;
 207     JpegReader* r_ptr = getRPtr(env, thiz, &fidNumber);
 208     if (r_ptr == NULL) {
 209         return;
 210     }
 211     // Update environment
 212     r_ptr->updateEnv(env);
 213     // Destroy the reader object
 214     delete r_ptr;
 215     r_ptr = NULL;
 216     // Set the java field to null
 217     env->SetLongField(thiz, fidNumber, reinterpret_cast<jlong>(r_ptr));
 218 }
 219
 220 static jint OutputStream_writeInputBytes(JNIEnv* env, jobject thiz,
 221         jbyteArray inBuffer, jint offset, jint inCount) {
 222     JpegWriter* w_ptr = getWPtr(env, thiz, NULL);
 223     if (w_ptr == NULL) {
 224         return J_EXCEPTION;
 225     }
 226     // Pin input buffer
 227     jbyte* in_buf = (jbyte*) env->GetByteArrayElements(inBuffer, 0);
 228     if (env->ExceptionCheck() || in_buf == NULL) {
 229         return J_EXCEPTION;
 230     }
 231
 232     int8_t* in_bytes = static_cast<int8_t*>(in_buf);
 233     int32_t in_len = static_cast<int32_t>(inCount);
 234     int32_t off = static_cast<int32_t>(offset);
 235     in_bytes += off;
 236     int32_t written = 0;
 237
 238     // Update environment
 239     w_ptr->updateEnv(env);
 240     // Write out and unpin buffer.
 241     written = w_ptr->write(in_bytes, in_len);
 242     env->ReleaseByteArrayElements(inBuffer, in_buf, JNI_ABORT);
 243     return written;
 244 }
 245
 246 static jint InputStream_readDecodedBytes(JNIEnv* env, jobject thiz,
 247         jbyteArray inBuffer, jint offset, jint inCount) {
 248     JpegReader* r_ptr = getRPtr(env, thiz, NULL);
 249     if (r_ptr == NULL) {
 250         return J_EXCEPTION;
 251     }
 252     // Pin input buffer
 253     jbyte* in_buf = (jbyte*) env->GetByteArrayElements(inBuffer, 0);
 254     if (env->ExceptionCheck() || in_buf == NULL) {
 255         return J_EXCEPTION;
 256     }
 257     int8_t* in_bytes = static_cast<int8_t*>(in_buf);
 258     int32_t in_len = static_cast<int32_t>(inCount);
 259     int32_t off = static_cast<int32_t>(offset);
 260     int32_t read = 0;
 261
 262     // Update environment
 263     r_ptr->updateEnv(env);
 264     // Read into buffer
 265     read = r_ptr->read(in_bytes, off, in_len);
 266
 267     // Unpin buffer
 268     if (read < 0) {
 269         env->ReleaseByteArrayElements(inBuffer, in_buf, JNI_ABORT);
 270     } else {
 271         env->ReleaseByteArrayElements(inBuffer, in_buf, JNI_COMMIT);
 272     }
 273     return read;
 274 }
 275
 276 static jint InputStream_skipDecodedBytes(JNIEnv* env, jobject thiz,
 277         jint bytes) {
 278     if (bytes <= 0) {
 279         return J_ERROR_BAD_ARGS;
 280     }
 281     JpegReader* r_ptr = getRPtr(env, thiz, NULL);
 282     if (r_ptr == NULL) {
 283         return J_EXCEPTION;
 284     }
 285
 286     // Update environment
 287     r_ptr->updateEnv(env);
 288     int32_t skip = 0;
 289     // Read with null buffer to skip
 290     skip = r_ptr->read(NULL, 0, bytes);
 291     return skip;
 292 }
 293
 294 static const char *outClassPathName =
 295         "com/android/gallery3d/jpegstream/JPEGOutputStream";
 296 static const char *inClassPathName =
 297         "com/android/gallery3d/jpegstream/JPEGInputStream";
 298
 299 static JNINativeMethod writeMethods[] = { { "setup",
 300         "(Ljava/io/OutputStream;IIII)I", (void*) OutputStream_setup }, {
 301         "cleanup", "()V", (void*) OutputStream_cleanup }, { "writeInputBytes",
 302         "([BII)I", (void*) OutputStream_writeInputBytes } };
 303
 304 static JNINativeMethod readMethods[] = { { "setup",
 305         "(Landroid/graphics/Point;Ljava/io/InputStream;I)I",
 306         (void*) InputStream_setup }, { "cleanup", "()V",
 307         (void*) InputStream_cleanup }, { "readDecodedBytes", "([BII)I",
 308         (void*) InputStream_readDecodedBytes }, { "skipDecodedBytes", "(I)I",
 309         (void*) InputStream_skipDecodedBytes } };
 310
 311 static int registerNativeMethods(JNIEnv* env, const char* className,
 312         JNINativeMethod* gMethods, int numMethods) {
 313     jclass clazz;
 314     clazz = env->FindClass(className);
 315     if (clazz == NULL) {
 316         LOGE("Native registration unable to find class '%s'", className);
 317         return JNI_FALSE;
 318     }
 319     if (env->RegisterNatives(clazz, gMethods, numMethods) < 0) {
 320         LOGE("RegisterNatives failed for '%s'", className);
 321         return JNI_FALSE;
 322     }
 323     return JNI_TRUE;
 324 }
 325
 326 jint JNI_OnLoad(JavaVM* vm, void* reserved __unused) {
 327     JNIEnv* env;
 328     if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
 329         LOGE("Error: GetEnv failed in JNI_OnLoad");
 330         return -1;
 331     }
 332     if (!registerNativeMethods(env, outClassPathName, writeMethods,
 333             sizeof(writeMethods) / sizeof(writeMethods[0]))) {
 334         LOGE("Error: could not register native methods for JPEGOutputStream");
 335         return -1;
 336     }
 337     if (!registerNativeMethods(env, inClassPathName, readMethods,
 338             sizeof(readMethods) / sizeof(readMethods[0]))) {
 339         LOGE("Error: could not register native methods for JPEGInputStream");
 340         return -1;
 341     }
 342     // cache method IDs for OutputStream
 343     jclass outCls = env->FindClass("java/io/OutputStream");
 344     if (outCls == NULL) {
 345         LOGE("Unable to find class 'OutputStream'");
 346         return -1;
 347     }
 348     jmethodID cachedWriteFun = env->GetMethodID(outCls, "write", "([BII)V");
 349     if (cachedWriteFun == NULL) {
 350         LOGE("Unable to find write function in class 'OutputStream'");
 351         return -1;
 352     }
 353     OutputStreamWrapper::setWriteMethodID(cachedWriteFun);
 354
 355     // cache method IDs for InputStream
 356     jclass inCls = env->FindClass("java/io/InputStream");
 357     if (inCls == NULL) {
 358         LOGE("Unable to find class 'InputStream'");
 359         return -1;
 360     }
 361     jmethodID cachedReadFun = env->GetMethodID(inCls, "read", "([BII)I");
 362     if (cachedReadFun == NULL) {
 363         LOGE("Unable to find read function in class 'InputStream'");
 364         return -1;
 365     }
 366     jmethodID cachedSkipFun = env->GetMethodID(inCls, "skip", "(J)J");
 367     if (cachedSkipFun == NULL) {
 368         LOGE("Unable to find skip function in class 'InputStream'");
 369         return -1;
 370     }
 371     InputStreamWrapper::setReadSkipMethodIDs(cachedReadFun, cachedSkipFun);
 372     return JNI_VERSION_1_6;
 373 }
 374
 375 #ifdef __cplusplus
 376 }
 377 #endif