AndroidJniBitmapOperations

Allows to perform various simple operations on bitmaps via JNI , while also providing some protection against OOM using the native Java environment on Android

Some of the operations are:

• store/restore bitmaps to/from JNI.
• rotate CW/CCW 90,180,270 degrees.
• crop image.
• flip image horizontally/vertically .
• scale image using either "Nearest-Neighbor" algorithm or "Bilinear-Interpolation" algorithm. The first is fast but might cause aliasing artifacts on some cases, and the other is a bit slower but resizes the images nicely and avoids having aliasing artifacts. However, it cause the output image to be a bit softer/blurry. More information about those algorithms here: http://en.wikipedia.org/wiki/Image_scaling

As the resizing algorithms deal with colors, they also show how to create your own algorithms for handling pixels. You can make filters and implement other ways to resize images. Please consider contributing your own code for such operations.

This library was first introduced via StackOverflow, and many of the notes written there still hold now. Please read it here: http://stackoverflow.com/questions/18250951/jni-bitmap-operations-for-helping-to-avoid-oom-when-using-large-images/18250952?noredirect=1

Screenshot

Here's a sample of what can be done:

How to add it to your project

1. Create a folder under the parent directory of your project and call it "libs" (if you dont have one already).
2. Download the Jar and .SO files, unzip it.
3. Copy and paste the armeabi folders into the "libs" folder you created in step 1.
4. Copy and paste the libJniBitmapOperationsLibrary.jar into the "libs" folder you created in step 1.
5. Thats all :)

Usage:

// The Bitmap we want to hold in JNI
Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.large_wallpaper);
   	
//hold the bitmap in JNI (this will also release the bitmap in the java "world")
JniBitmapHolder bitmapHolder = new JniBitmapHolder(bitmap);
				
//get the bitmap and free the memory
mImgeView.setImageBitmap(bitmapHolder.getBitmapAndFree());
				

This is just a simple overview. look at the example project for a more detailed overview. Enjoy :)

Known issues

Android-Studio still doesn't support C/C++ code well. It's easy to import the project and try it, but I think it's quite hard to do it for your own project.

Missing features (TODO)

The things I think this library should have :

1. using matrices for manipulating of the images.
2. decode the image directly within JNI, instead of giving it from the Java "world". This should be very handy.
3. use different bitmap formats. Also think how to manage them nicely.
4. get current bitmap info.
5. face detection
6. rotation by any angle.
7. other basic operations that are available on the Android framework.
8. Make more optimizations, perhaps by investigating the numebr of cache-misses, which is the biggest "enemy" for image manipulations in case of large bitmap. See this link for more information.

How to import the library project

Eclipse

Since ADT (at least till v22.6.2) still has problems importing Android libraries that have C/C++ code (made a post about it here) , the steps are:

1. in case the library has a ".cproject" file , delete it.
2. delete folders "libs","gen","bin",obj" from the library folder. In case you have libraries, just remove the files you didn't add yourself.
3. in case the library has "cnature" or "ccnature" entries in the ".project" file, delete them, which look like:

<nature>org.eclipse.cdt.core.cnature</nature>
<nature>org.eclipse.cdt.core.ccnature</nature>
<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>

Also, you might need to delete those whole "buildCommand" tags (and their children) :

org.eclipse.cdt.managedbuilder.core.genmakebuilder
org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder

4. right click the library, choose "add native support..." via the "android tools" context menu. make sure the name of the suggested file is the same as your C/C++ file. Make sure that it's being built using the NDK , or you won't be able to do it correctly.
5. build&compile the library.
6. you are ready to go.

For now, I've handled steps 1-2 (I just made Git to ignore those files), so all you need to do is the rest of the steps.

Android studio

Precondition: make sure that you have NDK installed and you either have this line in your local.properties

ndk.dir=/path/to/ndk

or you have ANDROID_NDK_HOME environment variable set.

Getting started

Just import the whole cloned project and run the sample.

Further configuring and using as the library

1. Copy JniBitmapOperationsLibrary.cpp into src/main/jni directory:

   

2. Add this minimum NDK config to your build.gradle

    android {
    ...
        defaultConfig {
        ...
            ndk {
                moduleName "JniBitmapOperationsLibrary"
                ldLibs "log",  "jnigraphics"
                //optional: filter abis to compile for: abiFilters "x86", "armeabi-v7a"
                //otherwise it will compile for all abis: "armeabi", "armeabi-v7a", "x86", and "mips"
            }
        }
    }
   

3. Copy JniBitmapHolder into the project, putting it into the same package (com.jni.bitmap_operations).

You now should be able to use JniBitmapHolder to process images on NDK side.

Similar libraries

If you are interested in more features, and don't want to modify the code of this library, you could try out those similar libraries:

• https://github.com/suckgamony/RapidDecoder
• https://github.com/facebook/fresco
• https://android-arsenal.com/tag/63