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

Commit f1ced992 authored by Derek Sollenberger's avatar Derek Sollenberger Committed by Android (Google) Code Review
Browse files

Merge "Consolidate NDK and APEX implementations"

parents d643c8a4 6c41ab13

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();

}