1/*
2 * Copyright (C) 2014 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 "BitmapSerializeUtils"
18
19#include <jni.h>
20#include <JNIHelp.h>
21
22#include <android/bitmap.h>
23#include <android/log.h>
24
25namespace android {
26
27#define RGBA_8888_COLOR_DEPTH 4
28
29static bool writeAllBytes(const int fd, void* buffer, const size_t byteCount) {
30    char* writeBuffer = static_cast<char*>(buffer);
31    size_t remainingBytes = byteCount;
32    while (remainingBytes > 0) {
33        ssize_t writtenByteCount = write(fd, writeBuffer, remainingBytes);
34        if (writtenByteCount == -1) {
35            if (errno == EINTR) {
36                continue;
37            }
38            __android_log_print(ANDROID_LOG_ERROR, LOG_TAG,
39                    "Error writing to buffer: %d", errno);
40            return false;
41        }
42        remainingBytes -= writtenByteCount;
43        writeBuffer += writtenByteCount;
44    }
45    return true;
46}
47
48static bool readAllBytes(const int fd, void* buffer, const size_t byteCount) {
49    char* readBuffer = static_cast<char*>(buffer);
50    size_t remainingBytes = byteCount;
51    while (remainingBytes > 0) {
52        ssize_t readByteCount = read(fd, readBuffer, remainingBytes);
53        if (readByteCount == -1) {
54            if (errno == EINTR) {
55                continue;
56            }
57            __android_log_print(ANDROID_LOG_ERROR, LOG_TAG,
58                    "Error reading from buffer: %d", errno);
59            return false;
60        }
61        remainingBytes -= readByteCount;
62        readBuffer += readByteCount;
63    }
64    return true;
65}
66
67static void throwException(JNIEnv* env, const char* className, const char* message) {
68    jclass exceptionClass = env->FindClass(className);
69    env->ThrowNew(exceptionClass, message);
70}
71
72static void throwIllegalStateException(JNIEnv* env, char *message) {
73    const char* className = "java/lang/IllegalStateException";
74    throwException(env, className, message);
75}
76
77static void throwIllegalArgumentException(JNIEnv* env, char* message) {
78    const char* className = "java/lang/IllegalArgumentException";
79    throwException(env, className, message);
80}
81
82static void readBitmapPixels(JNIEnv* env, jclass clazz, jobject jbitmap, jint fd) {
83    // Read the info.
84    AndroidBitmapInfo readInfo;
85    bool read = readAllBytes(fd, (void*) &readInfo, sizeof(AndroidBitmapInfo));
86    if (!read) {
87        throwIllegalStateException(env, (char*) "Cannot read bitmap info");
88        return;
89    }
90
91    // Get the info of the target bitmap.
92    AndroidBitmapInfo targetInfo;
93    int result = AndroidBitmap_getInfo(env, jbitmap, &targetInfo);
94    if (result < 0) {
95        throwIllegalStateException(env, (char*) "Cannot get bitmap info");
96        return;
97    }
98
99    // Enforce we can reuse the bitmap.
100    if (readInfo.width != targetInfo.width || readInfo.height != targetInfo.height
101            || readInfo.stride != targetInfo.stride || readInfo.format != targetInfo.format
102            || readInfo.flags != targetInfo.flags) {
103        throwIllegalArgumentException(env, (char*) "Cannot reuse bitmap");
104        return;
105    }
106
107    // Lock the pixels.
108    void* pixels;
109    result = AndroidBitmap_lockPixels(env, jbitmap, &pixels);
110    if (result < 0) {
111        throwIllegalStateException(env, (char*) "Cannot lock bitmap pixels");
112        return;
113    }
114
115    // Read the pixels.
116    size_t byteCount = readInfo.stride * readInfo.height;
117    read = readAllBytes(fd, (void*) pixels, byteCount);
118    if (!read) {
119        throwIllegalStateException(env, (char*) "Cannot read bitmap pixels");
120        return;
121    }
122
123    // Unlock the pixels.
124    result = AndroidBitmap_unlockPixels(env, jbitmap);
125    if (result < 0) {
126        throwIllegalStateException(env, (char*) "Cannot unlock bitmap pixels");
127    }
128}
129
130static void writeBitmapPixels(JNIEnv* env, jclass clazz, jobject jbitmap, jint fd) {
131    // Get the info.
132    AndroidBitmapInfo info;
133    int result = AndroidBitmap_getInfo(env, jbitmap, &info);
134    if (result < 0) {
135        throwIllegalStateException(env, (char*) "Cannot get bitmap info");
136        return;
137    }
138
139    // Write the info.
140    bool written = writeAllBytes(fd, (void*) &info, sizeof(AndroidBitmapInfo));
141    if (!written) {
142        throwIllegalStateException(env, (char*) "Cannot write bitmap info");
143        return;
144    }
145
146    // Lock the pixels.
147    void* pixels;
148    result = AndroidBitmap_lockPixels(env, jbitmap, &pixels);
149    if (result < 0) {
150        throwIllegalStateException(env, (char*) "Cannot lock bitmap pixels");
151        return;
152    }
153
154    // Write the pixels.
155    size_t byteCount = info.stride * info.height;
156    written = writeAllBytes(fd, (void*) pixels, byteCount);
157    if (!written) {
158        throwIllegalStateException(env, (char*) "Cannot write bitmap pixels");
159        return;
160    }
161
162    // Unlock the pixels.
163    result = AndroidBitmap_unlockPixels(env, jbitmap);
164    if (result < 0) {
165        throwIllegalStateException(env, (char*) "Cannot unlock bitmap pixels");
166    }
167}
168
169static JNINativeMethod sMethods[] = {
170    {"nativeReadBitmapPixels", "(Landroid/graphics/Bitmap;I)V", (void *) readBitmapPixels},
171    {"nativeWriteBitmapPixels", "(Landroid/graphics/Bitmap;I)V", (void *) writeBitmapPixels},
172};
173
174int register_com_android_printspooler_util_BitmapSerializeUtils(JNIEnv* env) {
175    return jniRegisterNativeMethods(env, "com/android/printspooler/util/BitmapSerializeUtils",
176        sMethods, NELEM(sMethods));
177}
178
179}
180
181jint JNI_OnLoad(JavaVM* jvm, void*) {
182    JNIEnv *env = NULL;
183    if (jvm->GetEnv((void**) &env, JNI_VERSION_1_6)) {
184        return JNI_ERR;
185    }
186
187    if (android::register_com_android_printspooler_util_BitmapSerializeUtils(env) == -1) {
188        return JNI_ERR;
189    }
190
191    return JNI_VERSION_1_6;
192}
193