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

Commit 50ba3d2c authored by Wei-Ta Chen's avatar Wei-Ta Chen
Browse files

Rename LargeBitmap to BitmapRegionDecoder for having a better API. 

Move AssetStreamAdaptor, AutoFDSeek and nullObjectReturn to Utils.h because
BitmapFactory.cpp and BitmapRegionDecoder.cpp both need to use these utility functions.

Change-Id: I3e60c7fe4abd0289e1384e69a08fd20fe6fb0e10
parent 960b31e3

core/jni/Android.mk

+2 −1
Original line number Diff line number Diff line
@@ -102,11 +102,12 @@ LOCAL_SRC_FILES:= \ 
	android_graphics_PixelFormat.cpp \

	android/graphics/Picture.cpp \

	android/graphics/PorterDuff.cpp \

	android/graphics/LargeBitmap.cpp \

	android/graphics/BitmapRegionDecoder.cpp \

	android/graphics/Rasterizer.cpp \

	android/graphics/Region.cpp \

	android/graphics/Shader.cpp \

	android/graphics/Typeface.cpp \

	android/graphics/Utils.cpp \

	android/graphics/Xfermode.cpp \

	android/graphics/YuvToJpegEncoder.cpp \

	android_media_AudioRecord.cpp \

core/jni/AndroidRuntime.cpp

+2 −2
Original line number Diff line number Diff line
@@ -53,7 +53,7 @@ extern int register_android_os_Binder(JNIEnv* env); 
extern int register_android_os_Process(JNIEnv* env);

extern int register_android_graphics_Bitmap(JNIEnv*);

extern int register_android_graphics_BitmapFactory(JNIEnv*);

extern int register_android_graphics_LargeBitmap(JNIEnv*);

extern int register_android_graphics_BitmapRegionDecoder(JNIEnv*);

extern int register_android_graphics_Camera(JNIEnv* env);

extern int register_android_graphics_Graphics(JNIEnv* env);

extern int register_android_graphics_Interpolator(JNIEnv* env);
@@ -1244,7 +1244,7 @@ static const RegJNIRec gRegJNI[] = { 


    REG_JNI(register_android_graphics_Bitmap),

    REG_JNI(register_android_graphics_BitmapFactory),

    REG_JNI(register_android_graphics_LargeBitmap),

    REG_JNI(register_android_graphics_BitmapRegionDecoder),

    REG_JNI(register_android_graphics_Camera),

    REG_JNI(register_android_graphics_Canvas),

    REG_JNI(register_android_graphics_ColorFilter),

core/jni/android/graphics/BitmapFactory.cpp

+1 −195
Original line number Diff line number Diff line
@@ -10,6 +10,7 @@ 
#include "SkUtils.h"

#include "CreateJavaOutputStreamAdaptor.h"

#include "AutoDecodeCancel.h"

#include "Utils.h"



#include <android_runtime/AndroidRuntime.h>

#include <utils/Asset.h>
@@ -98,57 +99,6 @@ public: 
    }

};



class AssetStreamAdaptor : public SkStream {

public:

    AssetStreamAdaptor(Asset* a) : fAsset(a) {}

    

    virtual bool rewind() {

        off_t pos = fAsset->seek(0, SEEK_SET);

        if (pos == (off_t)-1) {

            SkDebugf("----- fAsset->seek(rewind) failed\n");

            return false;

        }

        return true;

    }

    

    virtual size_t read(void* buffer, size_t size) {

        ssize_t amount;

        

        if (NULL == buffer) {

            if (0 == size) {  // caller is asking us for our total length

                return fAsset->getLength();

            }

            // asset->seek returns new total offset

            // we want to return amount that was skipped



            off_t oldOffset = fAsset->seek(0, SEEK_CUR);

            if (-1 == oldOffset) {

                SkDebugf("---- fAsset->seek(oldOffset) failed\n");

                return 0;

            }

            off_t newOffset = fAsset->seek(size, SEEK_CUR);

            if (-1 == newOffset) {

                SkDebugf("---- fAsset->seek(%d) failed\n", size);

                return 0;

            }

            amount = newOffset - oldOffset;

        } else {

            amount = fAsset->read(buffer, size);

            if (amount <= 0) {

                SkDebugf("---- fAsset->read(%d) returned %d\n", size, amount);

            }

        }

        

        if (amount < 0) {

            amount = 0;

        }

        return amount;

    }

    

private:

    Asset*  fAsset;

};



///////////////////////////////////////////////////////////////////////////////



static inline int32_t validOrNeg1(bool isValid, int32_t value) {
@@ -200,12 +150,6 @@ static bool optionsReportSizeToVM(JNIEnv* env, jobject options) { 
            !env->GetBooleanField(options, gOptions_nativeAllocFieldID);

}



static jobject nullObjectReturn(const char msg[]) {

    if (msg) {

        SkDebugf("--- %s\n", msg);

    }

    return NULL;

}



static SkPixelRef* installPixelRef(SkBitmap* bitmap, SkStream* stream,

                                   int sampleSize, bool ditherImage) {
@@ -376,23 +320,6 @@ static ssize_t getFDSize(int fd) { 
    return size;

}



/** Restore the file descriptor's offset in our destructor

 */

class AutoFDSeek {

public:

    AutoFDSeek(int fd) : fFD(fd) {

        fCurr = ::lseek(fd, 0, SEEK_CUR);

    }

    ~AutoFDSeek() {

        if (fCurr >= 0) {

            ::lseek(fFD, fCurr, SEEK_SET);

        }

    }

private:

    int     fFD;

    off_t   fCurr;

};



static jobject nativeDecodeFileDescriptor(JNIEnv* env, jobject clazz,

                                          jobject fileDescriptor,

                                          jobject padding,
@@ -559,107 +486,6 @@ static void nativeSetDefaultConfig(JNIEnv* env, jobject, int nativeConfig) { 
    }

}



static jobject doBuildTileIndex(JNIEnv* env, SkStream* stream, bool isShareable) {

    SkImageDecoder* decoder = SkImageDecoder::Factory(stream);

    int width, height;

    if (NULL == decoder) {

        doThrowIOE(env, "Image format not supported");

        return nullObjectReturn("SkImageDecoder::Factory returned null");

    }



    JavaPixelAllocator *javaAllocator = new JavaPixelAllocator(env, true);

    decoder->setAllocator(javaAllocator);

    JavaMemoryUsageReporter *javaMemoryReporter = new JavaMemoryUsageReporter(env);

    decoder->setReporter(javaMemoryReporter);

    javaAllocator->unref();

    javaMemoryReporter->unref();



    if (!decoder->buildTileIndex(stream, &width, &height, isShareable)) {

        char msg[1024];

        snprintf(msg, 1023, "Image failed to decode using %s decoder", decoder->getFormatName());

        doThrowIOE(env, msg);

        return nullObjectReturn("decoder->buildTileIndex returned false");

    }



    SkLargeBitmap *bm = new SkLargeBitmap(decoder, width, height);



    return GraphicsJNI::createLargeBitmap(env, bm);

}



static jobject nativeCreateLargeBitmapFromByteArray(JNIEnv* env, jobject, jbyteArray byteArray,

                                     int offset, int length, jboolean isShareable) {

    AutoJavaByteArray ar(env, byteArray);

    SkStream* stream = new SkMemoryStream(ar.ptr() + offset, length, false);

    SkAutoUnref aur(stream);

    if (isShareable) {

        aur.detach();

    }

    return doBuildTileIndex(env, stream, isShareable);

}



static jobject nativeCreateLargeBitmapFromFileDescriptor(JNIEnv* env, jobject clazz,

                                          jobject fileDescriptor, jboolean isShareable) {

    NPE_CHECK_RETURN_ZERO(env, fileDescriptor);



    jint descriptor = env->GetIntField(fileDescriptor,

                                       gFileDescriptor_descriptor);

    bool weOwnTheFD = false;



    if (isShareable) {

        int newFD = ::dup(descriptor);

        if (-1 != newFD) {

            weOwnTheFD = true;

            descriptor = newFD;

        }

    }



    SkFDStream* stream = new SkFDStream(descriptor, weOwnTheFD);

    SkAutoUnref aur(stream);

    if (!stream->isValid()) {

        return NULL;

    }



    if (isShareable) {

        aur.detach();

    }



    /* Restore our offset when we leave, so we can be called more than once

       with the same descriptor. This is only required if we didn't dup the

       file descriptor, but it is OK to do it all the time.

    */

    AutoFDSeek as(descriptor);



    return doBuildTileIndex(env, stream, isShareable);

}



static jobject nativeCreateLargeBitmapFromStream(JNIEnv* env, jobject clazz,

                                  jobject is,       // InputStream

                                  jbyteArray storage, // byte[]

                                  jboolean isShareable) {

    jobject largeBitmap = NULL;

    SkStream* stream = CreateJavaInputStreamAdaptor(env, is, storage, 1024);



    if (stream) {

        // for now we don't allow shareable with java inputstreams

        largeBitmap = doBuildTileIndex(env, stream, false);

        stream->unref();

    }

    return largeBitmap;

}



static jobject nativeCreateLargeBitmapFromAsset(JNIEnv* env, jobject clazz,

                                 jint native_asset, // Asset

                                 jboolean isShareable) {

    SkStream* stream;

    Asset* asset = reinterpret_cast<Asset*>(native_asset);

    stream = new AssetStreamAdaptor(asset);

    SkAutoUnref aur(stream);

    if (isShareable) {

        aur.detach();

    }

    return doBuildTileIndex(env, stream, isShareable);

}



///////////////////////////////////////////////////////////////////////////////



static JNINativeMethod gMethods[] = {
@@ -689,26 +515,6 @@ static JNINativeMethod gMethods[] = { 
    },



    {   "nativeSetDefaultConfig", "(I)V", (void*)nativeSetDefaultConfig },



    {   "nativeCreateLargeBitmap",

        "([BIIZ)Landroid/graphics/LargeBitmap;",

        (void*)nativeCreateLargeBitmapFromByteArray

    },



    {   "nativeCreateLargeBitmap",

        "(Ljava/io/InputStream;[BZ)Landroid/graphics/LargeBitmap;",

        (void*)nativeCreateLargeBitmapFromStream

    },



    {   "nativeCreateLargeBitmap",

        "(Ljava/io/FileDescriptor;Z)Landroid/graphics/LargeBitmap;",

        (void*)nativeCreateLargeBitmapFromFileDescriptor

    },



    {   "nativeCreateLargeBitmap",

        "(IZ)Landroid/graphics/LargeBitmap;",

        (void*)nativeCreateLargeBitmapFromAsset

    },

};



static JNINativeMethod gOptionsMethods[] = {

core/jni/android/graphics/LargeBitmap.cpp→core/jni/android/graphics/BitmapRegionDecoder.cpp

+277 −0
Original line number Diff line number Diff line 
#define LOG_TAG "LargeBitmap"

/*

 * Copyright (C) 2010 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.

 */



#define LOG_TAG "BitmapRegionDecoder"



#include "SkBitmap.h"

#include "SkImageEncoder.h"

#include "SkColorPriv.h"

#include "GraphicsJNI.h"

#include "SkDither.h"

#include "SkUnPreMultiply.h"

#include "SkUtils.h"

#include "SkTemplates.h"

#include "SkPixelRef.h"

#include "SkStream.h"

#include "BitmapFactory.h"

#include "AutoDecodeCancel.h"

#include "SkLargeBitmap.h"

#include "SkBitmapRegionDecoder.h"

#include "CreateJavaOutputStreamAdaptor.h"

#include "Utils.h"



#include <binder/Parcel.h>

#include <android_runtime/AndroidRuntime.h>

#include "android_util_Binder.h"

#include "android_nio_utils.h"

#include "CreateJavaOutputStreamAdaptor.h"



#include <binder/Parcel.h>

#include <jni.h>

#include <utils/Asset.h>



static jclass gFileDescriptor_class;

static jfieldID gFileDescriptor_descriptor;



#if 0

    #define TRACE_BITMAP(code)  code
@@ -26,22 +47,118 @@ 
    #define TRACE_BITMAP(code)

#endif



static jobject nullObjectReturn(const char msg[]) {

    if (msg) {

        SkDebugf("--- %s\n", msg);

using namespace android;



static jobject doBuildTileIndex(JNIEnv* env, SkStream* stream, bool isShareable) {

    SkImageDecoder* decoder = SkImageDecoder::Factory(stream);

    int width, height;

    if (NULL == decoder) {

        doThrowIOE(env, "Image format not supported");

        return nullObjectReturn("SkImageDecoder::Factory returned null");

    }



    JavaPixelAllocator *javaAllocator = new JavaPixelAllocator(env, true);

    decoder->setAllocator(javaAllocator);

    JavaMemoryUsageReporter *javaMemoryReporter = new JavaMemoryUsageReporter(env);

    decoder->setReporter(javaMemoryReporter);

    javaAllocator->unref();

    javaMemoryReporter->unref();



    if (!decoder->buildTileIndex(stream, &width, &height, isShareable)) {

        char msg[1024];

        snprintf(msg, 1023, "Image failed to decode using %s decoder", decoder->getFormatName());

        doThrowIOE(env, msg);

        return nullObjectReturn("decoder->buildTileIndex returned false");

    }



    SkBitmapRegionDecoder *brd = new SkBitmapRegionDecoder(decoder, width, height);



    return GraphicsJNI::createBitmapRegionDecoder(env, brd);

}



static jobject nativeNewInstanceFromByteArray(JNIEnv* env,

        jobject, jbyteArray byteArray, int offset, int length,

        jboolean isShareable) {

    AutoJavaByteArray ar(env, byteArray);

    SkStream* stream = new SkMemoryStream(ar.ptr() + offset, length, false);

    SkAutoUnref aur(stream);

    if (isShareable) {

        aur.detach();

    }

    return doBuildTileIndex(env, stream, isShareable);

}



static jobject nativeNewInstanceFromFileDescriptor(JNIEnv* env,

        jobject clazz, jobject fileDescriptor, jboolean isShareable) {

    NPE_CHECK_RETURN_ZERO(env, fileDescriptor);



    jint descriptor = env->GetIntField(fileDescriptor,

                                       gFileDescriptor_descriptor);

    bool weOwnTheFD = false;



    if (isShareable) {

        int newFD = ::dup(descriptor);

        if (-1 != newFD) {

            weOwnTheFD = true;

            descriptor = newFD;

        }

    }



    SkFDStream* stream = new SkFDStream(descriptor, weOwnTheFD);

    SkAutoUnref aur(stream);

    if (!stream->isValid()) {

        return NULL;

    }



    if (isShareable) {

        aur.detach();

    }



    // Restore our offset when we leave, so we can be called more than once

    // with the same descriptor. This is only required if we didn't dup the

    // file descriptor, but it is OK to do it all the time.

    AutoFDSeek as(descriptor);



    return doBuildTileIndex(env, stream, isShareable);

}



static jobject nativeNewInstanceFromStream(JNIEnv* env, jobject clazz,

                                  jobject is,       // InputStream

                                  jbyteArray storage, // byte[]

                                  jboolean isShareable) {

    jobject BitmapRegionDecoder = NULL;

    SkStream* stream = CreateJavaInputStreamAdaptor(env, is, storage, 1024);



    if (stream) {

        // for now we don't allow shareable with java inputstreams

        BitmapRegionDecoder = doBuildTileIndex(env, stream, false);

        stream->unref();

    }

    return BitmapRegionDecoder;

}



static jobject nativeNewInstanceFromAsset(JNIEnv* env, jobject clazz,

                                 jint native_asset, // Asset

                                 jboolean isShareable) {

    SkStream* stream;

    Asset* asset = reinterpret_cast<Asset*>(native_asset);

    stream = new AssetStreamAdaptor(asset);

    SkAutoUnref aur(stream);

    if (isShareable) {

        aur.detach();

    }

    return doBuildTileIndex(env, stream, isShareable);

}



/*

 * nine patch not supported

 *

 * purgeable not supported

 * reportSizeToVM not supported

 */

static jobject nativeDecodeRegion(JNIEnv* env, jobject, SkLargeBitmap *bm,

static jobject nativeDecodeRegion(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd,

        int start_x, int start_y, int width, int height, jobject options) {

    SkImageDecoder *decoder = bm->getDecoder();

    SkImageDecoder *decoder = brd->getDecoder();

    int sampleSize = 1;

    SkBitmap::Config prefConfig = SkBitmap::kNo_Config;

    bool doDither = true;
@@ -76,7 +193,7 @@ static jobject nativeDecodeRegion(JNIEnv* env, jobject, SkLargeBitmap *bm, 
    region.fRight = start_x + width;

    region.fBottom = start_y + height;



    if (!bm->decodeRegion(bitmap, region, prefConfig, sampleSize)) {

    if (!brd->decodeRegion(bitmap, region, prefConfig, sampleSize)) {

        return nullObjectReturn("decoder->decodeRegion returned false");

    }
@@ -102,37 +219,59 @@ static jobject nativeDecodeRegion(JNIEnv* env, jobject, SkLargeBitmap *bm, 
    return GraphicsJNI::createBitmap(env, bitmap, false, NULL);

}



static int nativeGetHeight(JNIEnv* env, jobject, SkLargeBitmap *bm) {

    return bm->getHeight();

static int nativeGetHeight(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd) {

    return brd->getHeight();

}



static int nativeGetWidth(JNIEnv* env, jobject, SkLargeBitmap *bm) {

    return bm->getWidth();

static int nativeGetWidth(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd) {

    return brd->getWidth();

}



static void nativeClean(JNIEnv* env, jobject, SkLargeBitmap *bm) {

    delete bm;

static void nativeClean(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd) {

    delete brd;

}



///////////////////////////////////////////////////////////////////////////////



#include <android_runtime/AndroidRuntime.h>



static JNINativeMethod gLargeBitmapMethods[] = {

static JNINativeMethod gBitmapRegionDecoderMethods[] = {

    {   "nativeDecodeRegion",

        "(IIIIILandroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;",

        (void*)nativeDecodeRegion},



    {   "nativeGetHeight", "(I)I", (void*)nativeGetHeight},



    {   "nativeGetWidth", "(I)I", (void*)nativeGetWidth},



    {   "nativeClean", "(I)V", (void*)nativeClean},



    {   "nativeNewInstance",

        "([BIIZ)Landroid/graphics/BitmapRegionDecoder;",

        (void*)nativeNewInstanceFromByteArray

    },



    {   "nativeNewInstance",

        "(Ljava/io/InputStream;[BZ)Landroid/graphics/BitmapRegionDecoder;",

        (void*)nativeNewInstanceFromStream

    },



    {   "nativeNewInstance",

        "(Ljava/io/FileDescriptor;Z)Landroid/graphics/BitmapRegionDecoder;",

        (void*)nativeNewInstanceFromFileDescriptor

    },



    {   "nativeNewInstance",

        "(IZ)Landroid/graphics/BitmapRegionDecoder;",

        (void*)nativeNewInstanceFromAsset

    },

};



#define kClassPathName  "android/graphics/LargeBitmap"

#define kClassPathName  "android/graphics/BitmapRegionDecoder"



int register_android_graphics_LargeBitmap(JNIEnv* env);

int register_android_graphics_LargeBitmap(JNIEnv* env)

int register_android_graphics_BitmapRegionDecoder(JNIEnv* env);

int register_android_graphics_BitmapRegionDecoder(JNIEnv* env)

{

    return android::AndroidRuntime::registerNativeMethods(env, kClassPathName,

                                gLargeBitmapMethods, SK_ARRAY_COUNT(gLargeBitmapMethods));

            gBitmapRegionDecoderMethods, SK_ARRAY_COUNT(gBitmapRegionDecoderMethods));

}

core/jni/android/graphics/Graphics.cpp

+8 −8
Original line number Diff line number Diff line
@@ -169,8 +169,8 @@ static jmethodID gBitmap_allocBufferMethodID; 
static jclass   gBitmapConfig_class;

static jfieldID gBitmapConfig_nativeInstanceID;



static jclass   gLargeBitmap_class;

static jmethodID gLargeBitmap_constructorMethodID;

static jclass   gBitmapRegionDecoder_class;

static jmethodID gBitmapRegionDecoder_constructorMethodID;



static jclass   gCanvas_class;

static jfieldID gCanvas_nativeInstanceID;
@@ -377,17 +377,18 @@ jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, bool isMutable, 
    }

    return obj;

}

jobject GraphicsJNI::createLargeBitmap(JNIEnv* env, SkLargeBitmap* bitmap)



jobject GraphicsJNI::createBitmapRegionDecoder(JNIEnv* env, SkBitmapRegionDecoder* bitmap)

{

    SkASSERT(bitmap != NULL);



    jobject obj = env->AllocObject(gLargeBitmap_class);

    jobject obj = env->AllocObject(gBitmapRegionDecoder_class);

    if (hasException(env)) {

        obj = NULL;

        return obj;

    }

    if (obj) {

        env->CallVoidMethod(obj, gLargeBitmap_constructorMethodID, (jint)bitmap);

        env->CallVoidMethod(obj, gBitmapRegionDecoder_constructorMethodID, (jint)bitmap);

        if (hasException(env)) {

            obj = NULL;

        }
@@ -613,8 +614,8 @@ int register_android_graphics_Graphics(JNIEnv* env) 
    gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>",

                                            "(IZ[BI)V");



    gLargeBitmap_class = make_globalref(env, "android/graphics/LargeBitmap");

    gLargeBitmap_constructorMethodID = env->GetMethodID(gLargeBitmap_class, "<init>", "(I)V");

    gBitmapRegionDecoder_class = make_globalref(env, "android/graphics/BitmapRegionDecoder");

    gBitmapRegionDecoder_constructorMethodID = env->GetMethodID(gBitmapRegionDecoder_class, "<init>", "(I)V");



    gBitmapConfig_class = make_globalref(env, "android/graphics/Bitmap$Config");

    gBitmapConfig_nativeInstanceID = getFieldIDCheck(env, gBitmapConfig_class,
@@ -654,4 +655,3 @@ int register_android_graphics_Graphics(JNIEnv* env) 


    return 0;

}