Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6c41ab13 authored by Derek Sollenberger's avatar Derek Sollenberger
Browse files

Consolidate NDK and APEX implementations 

the NDK APIs are implemented in terms of the APEX APIs to
reduce the number of different implementations serving the
same fundamental purpose.

Bug: 137655431
Test: CtsGraphicsTestCases
Change-Id: Idc7b85403a7e546843b9c1d822acc0a1e740059a
parent 17c36347

core/jni/android/graphics/Bitmap.cpp

+12 −77
Original line number Diff line number Diff line
@@ -223,103 +223,38 @@ void toSkBitmap(jlong bitmapHandle, SkBitmap* outBitmap) { 
    bitmap->getSkBitmap(outBitmap);

}



Bitmap& toBitmap(JNIEnv* env, jobject bitmap) {

    SkASSERT(env);

    SkASSERT(bitmap);

    SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class));

    jlong bitmapHandle = env->GetLongField(bitmap, gBitmap_nativePtr);

    LocalScopedBitmap localBitmap(bitmapHandle);

    return localBitmap->bitmap();

}



Bitmap& toBitmap(jlong bitmapHandle) {

    LocalScopedBitmap localBitmap(bitmapHandle);

    return localBitmap->bitmap();

}



void imageInfo(JNIEnv* env, jobject bitmap, AndroidBitmapInfo* info) {

    jlong bitmapHandle = env->GetLongField(bitmap, gBitmap_nativePtr);

    LocalScopedBitmap localBitmap(bitmapHandle);

} // namespace bitmap



    const SkImageInfo& imageInfo = localBitmap->info();

    info->width = imageInfo.width();

    info->height = imageInfo.height();

    info->stride = localBitmap->rowBytes();

    info->flags = 0;

    switch (imageInfo.colorType()) {

        case kN32_SkColorType:

            info->format = ANDROID_BITMAP_FORMAT_RGBA_8888;

            break;

        case kRGB_565_SkColorType:

            info->format = ANDROID_BITMAP_FORMAT_RGB_565;

            break;

        case kARGB_4444_SkColorType:

            info->format = ANDROID_BITMAP_FORMAT_RGBA_4444;

            break;

        case kAlpha_8_SkColorType:

            info->format = ANDROID_BITMAP_FORMAT_A_8;

            break;

        case kRGBA_F16_SkColorType:

            info->format = ANDROID_BITMAP_FORMAT_RGBA_F16;

            break;

        default:

            info->format = ANDROID_BITMAP_FORMAT_NONE;

            break;

    }

    switch (imageInfo.alphaType()) {

        case kUnknown_SkAlphaType:

            LOG_ALWAYS_FATAL("Bitmap has no alpha type");

            break;

        case kOpaque_SkAlphaType:

            info->flags |= ANDROID_BITMAP_FLAGS_ALPHA_OPAQUE;

            break;

        case kPremul_SkAlphaType:

            info->flags |= ANDROID_BITMAP_FLAGS_ALPHA_PREMUL;

            break;

        case kUnpremul_SkAlphaType:

            info->flags |= ANDROID_BITMAP_FLAGS_ALPHA_UNPREMUL;

            break;

    }

}

} // namespace android



void* lockPixels(JNIEnv* env, jobject bitmap) {

using namespace android;

using namespace android::bitmap;



Bitmap* GraphicsJNI::getNativeBitmap(JNIEnv* env, jobject bitmap) {

    SkASSERT(env);

    SkASSERT(bitmap);

    SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class));

    jlong bitmapHandle = env->GetLongField(bitmap, gBitmap_nativePtr);



    LocalScopedBitmap localBitmap(bitmapHandle);

    if (!localBitmap->valid()) return nullptr;



    SkPixelRef& pixelRef = localBitmap->bitmap();

    if (!pixelRef.pixels()) {

        return nullptr;

    }

    pixelRef.ref();

    return pixelRef.pixels();

    return localBitmap.valid() ? &localBitmap->bitmap() : nullptr;

}



bool unlockPixels(JNIEnv* env, jobject bitmap) {

SkImageInfo GraphicsJNI::getBitmapInfo(JNIEnv* env, jobject bitmap, uint32_t* outRowBytes) {

    SkASSERT(env);

    SkASSERT(bitmap);

    SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class));

    jlong bitmapHandle = env->GetLongField(bitmap, gBitmap_nativePtr);



    LocalScopedBitmap localBitmap(bitmapHandle);

    if (!localBitmap->valid()) return false;



    SkPixelRef& pixelRef = localBitmap->bitmap();

    pixelRef.notifyPixelsChanged();

    pixelRef.unref();

    return true;

    if (outRowBytes) {

        *outRowBytes = localBitmap->rowBytes();

    }

    return localBitmap->info();

}



} // namespace bitmap



} // namespace android



using namespace android;

using namespace android::bitmap;



bool GraphicsJNI::SetPixels(JNIEnv* env, jintArray srcColors, int srcOffset, int srcStride,

        int x, int y, int width, int height, SkBitmap* dstBitmap) {

core/jni/android/graphics/Bitmap.h

+0 −9
Original line number Diff line number Diff line
@@ -38,17 +38,8 @@ jobject createBitmap(JNIEnv* env, Bitmap* bitmap, 
            int bitmapCreateFlags, jbyteArray ninePatchChunk = nullptr,

            jobject ninePatchInsets = nullptr, int density = -1);





Bitmap& toBitmap(JNIEnv* env, jobject bitmap);

Bitmap& toBitmap(jlong bitmapHandle);



// NDK access

void imageInfo(JNIEnv* env, jobject bitmap, AndroidBitmapInfo* info);

// Returns a pointer to the pixels or nullptr if the bitmap is not valid

void* lockPixels(JNIEnv* env, jobject bitmap);

// Returns true if unlocked, false if the bitmap is no longer valid (destroyed)

bool unlockPixels(JNIEnv* env, jobject bitmap);



/** Reinitialize a bitmap. bitmap must already have its SkAlphaType set in

    sync with isPremultiplied

*/

core/jni/android/graphics/Graphics.cpp

+0 −4
Original line number Diff line number Diff line
@@ -342,10 +342,6 @@ SkColorType GraphicsJNI::legacyBitmapConfigToColorType(jint legacyConfig) { 
    return static_cast<SkColorType>(gConfig2ColorType[legacyConfig]);

}



void GraphicsJNI::getSkBitmap(JNIEnv* env, jobject bitmap, SkBitmap* outBitmap) {

    bitmap::toBitmap(env, bitmap).getSkBitmap(outBitmap);

}



AndroidBitmapFormat GraphicsJNI::getFormatFromConfig(JNIEnv* env, jobject jconfig) {

    ALOG_ASSERT(env);

    if (NULL == jconfig) {

core/jni/android/graphics/GraphicsJNI.h

+2 −1
Original line number Diff line number Diff line
@@ -61,7 +61,8 @@ public: 
    static void point_to_jpointf(const SkPoint& point, JNIEnv*, jobject jpointf);



    static android::Canvas* getNativeCanvas(JNIEnv*, jobject canvas);

    static void getSkBitmap(JNIEnv*, jobject bitmap, SkBitmap* outBitmap);

    static android::Bitmap* getNativeBitmap(JNIEnv*, jobject bitmap);

    static SkImageInfo getBitmapInfo(JNIEnv*, jobject bitmap, uint32_t* outRowBytes);

    static SkRegion* getNativeRegion(JNIEnv*, jobject region);



    /*

core/jni/android/graphics/apex/android_bitmap.cpp

+52 −14
Original line number Diff line number Diff line
@@ -14,19 +14,25 @@ 
 * limitations under the License.

 */



#define LOG_TAG "Bitmap"

#include <log/log.h>



#include "android/graphics/bitmap.h"

#include "Bitmap.h"

#include "TypeCast.h"

#include "GraphicsJNI.h"



#include <GraphicsJNI.h>

#include <hwui/Bitmap.h>



using namespace android;



ABitmap* ABitmap_acquireBitmapFromJava(JNIEnv* env, jobject bitmapObj) {

    Bitmap& bitmap = android::bitmap::toBitmap(env, bitmapObj);

    bitmap.ref();

    return TypeCast::toABitmap(&bitmap);

    Bitmap* bitmap = GraphicsJNI::getNativeBitmap(env, bitmapObj);

    if (bitmap) {

        bitmap->ref();

        return TypeCast::toABitmap(bitmap);

    }

    return nullptr;

}



void ABitmap_acquireRef(ABitmap* bitmap) {
@@ -37,8 +43,8 @@ void ABitmap_releaseRef(ABitmap* bitmap) { 
    SkSafeUnref(TypeCast::toBitmap(bitmap));

}



static AndroidBitmapFormat getFormat(Bitmap* bitmap) {

    switch (bitmap->colorType()) {

static AndroidBitmapFormat getFormat(const SkImageInfo& info) {

    switch (info.colorType()) {

        case kN32_SkColorType:

            return ANDROID_BITMAP_FORMAT_RGBA_8888;

        case kRGB_565_SkColorType:
@@ -71,6 +77,20 @@ static SkColorType getColorType(AndroidBitmapFormat format) { 
    }

}



static uint32_t getInfoFlags(const SkImageInfo& info) {

    switch (info.alphaType()) {

        case kUnknown_SkAlphaType:

            LOG_ALWAYS_FATAL("Bitmap has no alpha type");

            break;

        case kOpaque_SkAlphaType:

            return ANDROID_BITMAP_FLAGS_ALPHA_OPAQUE;

        case kPremul_SkAlphaType:

            return ANDROID_BITMAP_FLAGS_ALPHA_PREMUL;

        case kUnpremul_SkAlphaType:

            return ANDROID_BITMAP_FLAGS_ALPHA_UNPREMUL;

    }

}



ABitmap* ABitmap_copy(ABitmap* srcBitmapHandle, AndroidBitmapFormat dstFormat) {

    SkColorType dstColorType = getColorType(dstFormat);

    if (srcBitmapHandle && dstColorType != kUnknown_SkColorType) {
@@ -87,15 +107,25 @@ ABitmap* ABitmap_copy(ABitmap* srcBitmapHandle, AndroidBitmapFormat dstFormat) { 
    return nullptr;

}



static AndroidBitmapInfo getInfo(const SkImageInfo& imageInfo, uint32_t rowBytes) {

    AndroidBitmapInfo info;

    info.width = imageInfo.width();

    info.height = imageInfo.height();

    info.stride = rowBytes;

    info.format = getFormat(imageInfo);

    info.flags = getInfoFlags(imageInfo);

    return info;

}



AndroidBitmapInfo ABitmap_getInfo(ABitmap* bitmapHandle) {

    Bitmap* bitmap = TypeCast::toBitmap(bitmapHandle);

    return getInfo(bitmap->info(), bitmap->rowBytes());

}



    AndroidBitmapInfo info;

    info.width = bitmap->width();

    info.height = bitmap->height();

    info.stride = bitmap->rowBytes();

    info.format = getFormat(bitmap);

    return info;

AndroidBitmapInfo ABitmap_getInfoFromJava(JNIEnv* env, jobject bitmapObj) {

    uint32_t rowBytes = 0;

    SkImageInfo imageInfo = GraphicsJNI::getBitmapInfo(env, bitmapObj, &rowBytes);

    return getInfo(imageInfo, rowBytes);

}



void* ABitmap_getPixels(ABitmap* bitmapHandle) {
@@ -113,3 +143,11 @@ AndroidBitmapFormat ABitmapConfig_getFormatFromConfig(JNIEnv* env, jobject bitma 
jobject ABitmapConfig_getConfigFromFormat(JNIEnv* env, AndroidBitmapFormat format) {

    return GraphicsJNI::getConfigFromFormat(env, format);

}



void ABitmap_notifyPixelsChanged(ABitmap* bitmapHandle) {

    Bitmap* bitmap = TypeCast::toBitmap(bitmapHandle);

    if (bitmap->isImmutable()) {

        ALOGE("Attempting to modify an immutable Bitmap!");

    }

    return bitmap->notifyPixelsChanged();

}