| /* |
| * Copyright (C) 2019 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #ifndef ANDROID_GRAPHICS_BITMAP_H |
| #define ANDROID_GRAPHICS_BITMAP_H |
| |
| #include <android/bitmap.h> |
| #include <android/data_space.h> |
| #include <cutils/compiler.h> |
| #include <jni.h> |
| #include <sys/cdefs.h> |
| |
| struct AHardwareBuffer; |
| |
| __BEGIN_DECLS |
| |
| /** |
| * Opaque handle for a native graphics bitmap. |
| */ |
| typedef struct ABitmap ABitmap; |
| |
| /** |
| * Retrieve bitmapInfo for the provided java bitmap even if it has been recycled. In the case of a |
| * recycled bitmap the values contained in the bitmap before it was recycled are returned. |
| * |
| * NOTE: This API does not need to remain as an APEX API if/when we pull libjnigraphics into the |
| * UI module. |
| */ |
| ANDROID_API AndroidBitmapInfo ABitmap_getInfoFromJava(JNIEnv* env, jobject bitmapObj); |
| |
| /** |
| * |
| * @return ptr to an opaque handle to the native bitmap or null if the java bitmap has been recycled |
| * or does not exist. |
| */ |
| ANDROID_API ABitmap* ABitmap_acquireBitmapFromJava(JNIEnv* env, jobject bitmapObj); |
| |
| ANDROID_API ABitmap* ABitmap_copy(ABitmap* srcBitmap, AndroidBitmapFormat dstFormat); |
| |
| ANDROID_API void ABitmap_acquireRef(ABitmap* bitmap); |
| ANDROID_API void ABitmap_releaseRef(ABitmap* bitmap); |
| |
| ANDROID_API AndroidBitmapInfo ABitmap_getInfo(ABitmap* bitmap); |
| ANDROID_API ADataSpace ABitmap_getDataSpace(ABitmap* bitmap); |
| |
| ANDROID_API void* ABitmap_getPixels(ABitmap* bitmap); |
| ANDROID_API void ABitmap_notifyPixelsChanged(ABitmap* bitmap); |
| |
| ANDROID_API AndroidBitmapFormat ABitmapConfig_getFormatFromConfig(JNIEnv* env, jobject bitmapConfigObj); |
| ANDROID_API jobject ABitmapConfig_getConfigFromFormat(JNIEnv* env, AndroidBitmapFormat format); |
| |
| // NDK access |
| ANDROID_API int ABitmap_compress(const AndroidBitmapInfo* info, ADataSpace dataSpace, const void* pixels, |
| AndroidBitmapCompressFormat format, int32_t quality, void* userContext, |
| AndroidBitmap_CompressWriteFunc); |
| /** |
| * Retrieve the native object associated with a HARDWARE Bitmap. |
| * |
| * Client must not modify it while a Bitmap is wrapping it. |
| * |
| * @param bitmap Handle to an android.graphics.Bitmap. |
| * @return on success, a pointer to the |
| * AHardwareBuffer associated with bitmap. This acquires |
| * a reference on the buffer, and the client must call |
| * AHardwareBuffer_release when finished with it. |
| */ |
| ANDROID_API AHardwareBuffer* ABitmap_getHardwareBuffer(ABitmap* bitmap); |
| |
| __END_DECLS |
| |
| #ifdef __cplusplus |
| namespace android { |
| namespace graphics { |
| class Bitmap { |
| public: |
| Bitmap() : mBitmap(nullptr) {} |
| Bitmap(JNIEnv* env, jobject bitmapObj) : |
| mBitmap(ABitmap_acquireBitmapFromJava(env, bitmapObj)) {} |
| Bitmap(const Bitmap& src) : mBitmap(src.mBitmap) { ABitmap_acquireRef(src.mBitmap); } |
| ~Bitmap() { ABitmap_releaseRef(mBitmap); } |
| |
| // copy operator |
| Bitmap& operator=(const Bitmap& other) { |
| if (&other != this) { |
| ABitmap_releaseRef(mBitmap); |
| mBitmap = other.mBitmap; |
| ABitmap_acquireRef(mBitmap); |
| } |
| return *this; |
| } |
| |
| // move operator |
| Bitmap& operator=(Bitmap&& other) { |
| if (&other != this) { |
| ABitmap_releaseRef(mBitmap); |
| mBitmap = other.mBitmap; |
| other.mBitmap = nullptr; |
| } |
| return *this; |
| } |
| |
| Bitmap copy(AndroidBitmapFormat dstFormat) const { |
| return Bitmap(ABitmap_copy(mBitmap, dstFormat)); |
| } |
| |
| bool isValid() const { return mBitmap != nullptr; } |
| bool isEmpty() const { |
| AndroidBitmapInfo info = getInfo(); |
| return info.width <= 0 || info.height <= 0; |
| } |
| void reset() { |
| ABitmap_releaseRef(mBitmap); |
| mBitmap = nullptr; |
| } |
| |
| ABitmap* get() const { return mBitmap; } |
| |
| AndroidBitmapInfo getInfo() const { return ABitmap_getInfo(mBitmap); } |
| ADataSpace getDataSpace() const { return ABitmap_getDataSpace(mBitmap); } |
| void* getPixels() const { return ABitmap_getPixels(mBitmap); } |
| void notifyPixelsChanged() const { ABitmap_notifyPixelsChanged(mBitmap); } |
| AHardwareBuffer* getHardwareBuffer() const { return ABitmap_getHardwareBuffer(mBitmap); } |
| |
| private: |
| // takes ownership of the provided ABitmap |
| Bitmap(ABitmap* bitmap) : mBitmap(bitmap) {} |
| |
| ABitmap* mBitmap; |
| }; |
| }; // namespace graphics |
| }; // namespace android |
| #endif // __cplusplus |
| |
| #endif // ANDROID_GRAPHICS_BITMAP_H |