#include <jni.h>
#include <jni.h>
#include <android/log.h>
#include <stdio.h>
#include <android/bitmap.h>
#include <cstring>
#include <unistd.h>

#define  LOG_TAG    "Applog"
#define  LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG,LOG_TAG,__VA_ARGS__)
#define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)

extern "C"
    {
//store
    JNIEXPORT jobject JNICALL Java_com_basic_security_utils_BitmapHolder_jniStoreBitmapData(
	    JNIEnv * env, jobject obj, jobject bitmap);
//get
    JNIEXPORT jobject JNICALL Java_com_basic_security_utils_BitmapHolder_jniGetBitmapFromStoredBitmapData(
	    JNIEnv * env, jobject obj, jobject handle);
//free
    JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniFreeBitmapData(
	    JNIEnv * env, jobject obj, jobject handle);
//rotate 90 degrees CCW
    JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniRotateBitmapCcw90(
	    JNIEnv * env, jobject obj, jobject handle);
//rotate 90 degrees CW
    JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniRotateBitmapCw90(
	    JNIEnv * env, jobject obj, jobject handle);
//rotate 180 degrees
    JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniRotateBitmap180(
	    JNIEnv * env, jobject obj, jobject handle);
//crop
    JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniCropBitmap(
	    JNIEnv * env, jobject obj, jobject handle, uint32_t left,
	    uint32_t top, uint32_t right, uint32_t bottom);
//scale using nearest neighbor
    JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniScaleNNBitmap(
	    JNIEnv * env, jobject obj, jobject handle, uint32_t newWidth,
	    uint32_t newHeight);

//scale using Bilinear Interpolation
    JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniScaleBIBitmap(
	    JNIEnv * env, jobject obj, jobject handle, uint32_t newWidth,
	    uint32_t newHeight);

    JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniFlipBitmapHorizontal(
	    JNIEnv * env, jobject obj, jobject handle);

    JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniFlipBitmapVertical(
	    JNIEnv * env, jobject obj, jobject handle);
    }

class JniBitmap
    {
public:
    uint32_t* _storedBitmapPixels;
    AndroidBitmapInfo _bitmapInfo;
    JniBitmap()
	{
	_storedBitmapPixels = NULL;
	}
    };

typedef struct
    {
    uint8_t alpha, red, green, blue;
    } ARGB;

int32_t convertArgbToInt(ARGB argb)
    {
    return (argb.alpha) | (argb.red << 24) | (argb.green << 16)
	    | (argb.blue << 8);
    }

void convertIntToArgb(uint32_t pixel, ARGB* argb)
    {
    argb->red = ((pixel >> 24) & 0xff);
    argb->green = ((pixel >> 16) & 0xff);
    argb->blue = ((pixel >> 8) & 0xff);
    argb->alpha = (pixel & 0xff);
    }

/**crops the bitmap within to be smaller. note that no validations are done*/ //
JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniCropBitmap(
	JNIEnv * env, jobject obj, jobject handle, uint32_t left, uint32_t top,
	uint32_t right, uint32_t bottom)
    {
    JniBitmap* jniBitmap = (JniBitmap*) env->GetDirectBufferAddress(handle);
    if (jniBitmap == NULL || jniBitmap->_storedBitmapPixels == NULL)
	return;
    uint32_t* previousData = jniBitmap->_storedBitmapPixels;
    uint32_t oldWidth = jniBitmap->_bitmapInfo.width;
    uint32_t newWidth = right - left, newHeight = bottom - top;
    uint32_t* newBitmapPixels = new uint32_t[newWidth * newHeight];
    uint32_t* whereToGet = previousData + left + top * oldWidth;
    uint32_t* whereToPut = newBitmapPixels;
    for (int y = top; y < bottom; ++y)
	{
	memcpy(whereToPut, whereToGet, sizeof(uint32_t) * newWidth);
	whereToGet += oldWidth;
	whereToPut += newWidth;
	}
    //done copying , so replace old data with new one
    delete[] previousData;
    jniBitmap->_storedBitmapPixels = newBitmapPixels;
    jniBitmap->_bitmapInfo.width = newWidth;
    jniBitmap->_bitmapInfo.height = newHeight;
    }

/**rotates the inner bitmap data by 90 degrees counter clock wise*/ //
JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniRotateBitmapCcw90(
	JNIEnv * env, jobject obj, jobject handle)
    {
    JniBitmap* jniBitmap = (JniBitmap*) env->GetDirectBufferAddress(handle);
    if (jniBitmap == NULL || jniBitmap->_storedBitmapPixels == NULL)
	return;
    uint32_t* previousData = jniBitmap->_storedBitmapPixels;
    uint32_t newWidth = jniBitmap->_bitmapInfo.height;
    uint32_t newHeight = jniBitmap->_bitmapInfo.width;
    jniBitmap->_bitmapInfo.width = newWidth;
    jniBitmap->_bitmapInfo.height = newHeight;
    uint32_t* newBitmapPixels = new uint32_t[newWidth * newHeight];
    int whereToGet = 0;
    // XY. ... ... ..X
    // ...>Y..>...>..Y
    // ... X.. .YX ...
    for (int x = 0; x < newWidth; ++x)
	for (int y = newHeight - 1; y >= 0; --y)
	    {
	    //take from each row (up to bottom), from left to right
	    uint32_t pixel = previousData[whereToGet++];
	    newBitmapPixels[newWidth * y + x] = pixel;
	    }
    delete[] previousData;
    jniBitmap->_storedBitmapPixels = newBitmapPixels;
    }

/**rotates the inner bitmap data by 90 degrees clock wise*/ //
JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniRotateBitmapCw90(
	JNIEnv * env, jobject obj, jobject handle)
    {
    JniBitmap* jniBitmap = (JniBitmap*) env->GetDirectBufferAddress(handle);
    if (jniBitmap == NULL || jniBitmap->_storedBitmapPixels == NULL)
	return;
    uint32_t* previousData = jniBitmap->_storedBitmapPixels;
    uint32_t newWidth = jniBitmap->_bitmapInfo.height;
    uint32_t newHeight = jniBitmap->_bitmapInfo.width;
    jniBitmap->_bitmapInfo.width = newWidth;
    jniBitmap->_bitmapInfo.height = newHeight;
    uint32_t* newBitmapPixels = new uint32_t[newWidth * newHeight];
    int whereToGet = 0;
    // XY. ..X ... ...
    // ...>..Y>...>Y..
    // ... ... .YX X..
    jniBitmap->_storedBitmapPixels = newBitmapPixels;
    for (int x = newWidth - 1; x >= 0; --x)
	for (int y = 0; y < newHeight; ++y)
	    {
	    //take from each row (up to bottom), from left to right
	    uint32_t pixel = previousData[whereToGet++];
	    newBitmapPixels[newWidth * y + x] = pixel;
	    }
    delete[] previousData;
    }

/**rotates the inner bitmap data by 180 degrees (*/ //
JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniRotateBitmap180(
	JNIEnv * env, jobject obj, jobject handle)
    {
    JniBitmap* jniBitmap = (JniBitmap*) env->GetDirectBufferAddress(handle);
    if (jniBitmap == NULL || jniBitmap->_storedBitmapPixels == NULL)
	return;
    uint32_t* pixels = jniBitmap->_storedBitmapPixels;
    uint32_t* pixels2 = jniBitmap->_storedBitmapPixels;
    uint32_t width = jniBitmap->_bitmapInfo.width;
    uint32_t height = jniBitmap->_bitmapInfo.height;
    //no need to create a totally new bitmap - it's the exact same size as the original
    // 1234 fedc
    // 5678>ba09
    // 90ab>8765
    // cdef 4321
    int whereToGet = 0;
    for (int y = height - 1; y >= height / 2; --y)
	for (int x = width - 1; x >= 0; --x)
	    {
	    //take from each row (up to bottom), from left to right
	    uint32_t tempPixel = pixels2[width * y + x];
	    pixels2[width * y + x] = pixels[whereToGet];
	    pixels[whereToGet] = tempPixel;
	    ++whereToGet;
	    }
    //if the height isn't even, flip the middle row :
    if (height % 2 == 1)
	{
	int y = height / 2;
	whereToGet = width * y;
	int lastXToHandle = width % 2 == 0 ? (width / 2) : (width / 2) - 1;
	for (int x = width - 1; x >= lastXToHandle; --x)
	    {
	    uint32_t tempPixel = pixels2[width * y + x];
	    pixels2[width * y + x] = pixels[whereToGet];
	    pixels[whereToGet] = tempPixel;
	    ++whereToGet;
	    }
	}
    }

/**free bitmap*/ //
JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniFreeBitmapData(
	JNIEnv * env, jobject obj, jobject handle)
    {
    JniBitmap* jniBitmap = (JniBitmap*) env->GetDirectBufferAddress(handle);
    if (jniBitmap == NULL || jniBitmap->_storedBitmapPixels == NULL)
	return;
    delete[] jniBitmap->_storedBitmapPixels;
    jniBitmap->_storedBitmapPixels = NULL;
    delete jniBitmap;
    }

/**restore java bitmap (from JNI data)*/ //
JNIEXPORT jobject JNICALL Java_com_basic_security_utils_BitmapHolder_jniGetBitmapFromStoredBitmapData(
	JNIEnv * env, jobject obj, jobject handle)
    {
    JniBitmap* jniBitmap = (JniBitmap*) env->GetDirectBufferAddress(handle);
    if (jniBitmap == NULL || jniBitmap->_storedBitmapPixels == NULL)
	{
	LOGD("no bitmap data was stored. returning null...");
	return NULL;
	}
    //
    //creating a new bitmap to put the pixels into it - using Bitmap Bitmap.createBitmap (int width, int height, Bitmap.Config config) :
    //
    jclass bitmapCls = env->FindClass("android/graphics/Bitmap");
    jmethodID createBitmapFunction = env->GetStaticMethodID(bitmapCls,
	    "createBitmap",
	    "(IILandroid/graphics/Bitmap$Config;)Landroid/graphics/Bitmap;");
    jstring configName = env->NewStringUTF("ARGB_8888");
    jclass bitmapConfigClass = env->FindClass("android/graphics/Bitmap$Config");
    jmethodID valueOfBitmapConfigFunction = env->GetStaticMethodID(
	    bitmapConfigClass, "valueOf",
	    "(Ljava/lang/String;)Landroid/graphics/Bitmap$Config;");
    jobject bitmapConfig = env->CallStaticObjectMethod(bitmapConfigClass,
	    valueOfBitmapConfigFunction, configName);
    jobject newBitmap = env->CallStaticObjectMethod(bitmapCls,
	    createBitmapFunction, jniBitmap->_bitmapInfo.width,
	    jniBitmap->_bitmapInfo.height, bitmapConfig);
    //
    // putting the pixels into the new bitmap:
    //
    int ret;
    void* bitmapPixels;
    if ((ret = AndroidBitmap_lockPixels(env, newBitmap, &bitmapPixels)) < 0)
	{
	LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
	return NULL;
	}
    uint32_t* newBitmapPixels = (uint32_t*) bitmapPixels;
    int pixelsCount = jniBitmap->_bitmapInfo.height
	    * jniBitmap->_bitmapInfo.width;
    memcpy(newBitmapPixels, jniBitmap->_storedBitmapPixels,
	    sizeof(uint32_t) * pixelsCount);
    AndroidBitmap_unlockPixels(env, newBitmap);
    //LOGD("returning the new bitmap");
    return newBitmap;
    }

/**store java bitmap as JNI data*/ //
JNIEXPORT jobject JNICALL Java_com_basic_security_utils_BitmapHolder_jniStoreBitmapData(
	JNIEnv * env, jobject obj, jobject bitmap)
    {
    AndroidBitmapInfo bitmapInfo;
    uint32_t* storedBitmapPixels = NULL;
    //LOGD("reading bitmap info...");
    int ret;
    if ((ret = AndroidBitmap_getInfo(env, bitmap, &bitmapInfo)) < 0)
	{
	LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
	return NULL;
	}
    //LOGD("width:%d height:%d stride:%d", bitmapInfo.width, bitmapInfo.height, bitmapInfo.stride);
    if (bitmapInfo.format != ANDROID_BITMAP_FORMAT_RGBA_8888)
	{
	LOGE("Bitmap format is not RGBA_8888!");
	return NULL;
	}
    //
    //read pixels of bitmap into native memory :
    //
    //LOGD("reading bitmap pixels...");
    void* bitmapPixels;
    if ((ret = AndroidBitmap_lockPixels(env, bitmap, &bitmapPixels)) < 0)
	{
	LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
	return NULL;
	}
    uint32_t* src = (uint32_t*) bitmapPixels;
    storedBitmapPixels = new uint32_t[bitmapInfo.height * bitmapInfo.width];
    int pixelsCount = bitmapInfo.height * bitmapInfo.width;
    memcpy(storedBitmapPixels, src, sizeof(uint32_t) * pixelsCount);
    AndroidBitmap_unlockPixels(env, bitmap);
    JniBitmap *jniBitmap = new JniBitmap();
    jniBitmap->_bitmapInfo = bitmapInfo;
    jniBitmap->_storedBitmapPixels = storedBitmapPixels;
    return env->NewDirectByteBuffer(jniBitmap, 0);
    }

/**scales the image using the fastest, simplest algorithm called "nearest neighbor" */ //
JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniScaleNNBitmap(
	JNIEnv * env, jobject obj, jobject handle, uint32_t newWidth,
	uint32_t newHeight)
    {
    JniBitmap* jniBitmap = (JniBitmap*) env->GetDirectBufferAddress(handle);
    if (jniBitmap == NULL || jniBitmap->_storedBitmapPixels == NULL)
	return;
    uint32_t oldWidth = jniBitmap->_bitmapInfo.width;
    uint32_t oldHeight = jniBitmap->_bitmapInfo.height;
    uint32_t* previousData = jniBitmap->_storedBitmapPixels;
    uint32_t* newBitmapPixels = new uint32_t[newWidth * newHeight];
    int x2, y2;
    int whereToPut = 0;
    for (int y = 0; y < newHeight; ++y)
	{
	for (int x = 0; x < newWidth; ++x)
	    {
	    x2 = x * oldWidth / newWidth;
	    if (x2 < 0)
		x2 = 0;
	    else if (x2 >= oldWidth)
		x2 = oldWidth - 1;
	    y2 = y * oldHeight / newHeight;
	    if (y2 < 0)
		y2 = 0;
	    else if (y2 >= oldHeight)
		y2 = oldHeight - 1;
	    newBitmapPixels[whereToPut++] = previousData[(y2 * oldWidth) + x2];
	    //same as : newBitmapPixels[(y * newWidth) + x] = previousData[(y2 * oldWidth) + x2];
	    }
	}

    delete[] previousData;
    jniBitmap->_storedBitmapPixels = newBitmapPixels;
    jniBitmap->_bitmapInfo.width = newWidth;
    jniBitmap->_bitmapInfo.height = newHeight;
    }

/**scales the image using a high-quality algorithm called "Bilinear Interpolation"
 * code is based on old university code I've made in Java: http://stackoverflow.com/questions/23230047/trying-to-convert-bilinear-interpolation-code-from-java-to-c-c-on-android/23302384#23302384
 * */ //
JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniScaleBIBitmap(
	JNIEnv * env, jobject obj, jobject handle, uint32_t newWidth,
	uint32_t newHeight)
    {

    JniBitmap* jniBitmap = (JniBitmap*) env->GetDirectBufferAddress(handle);
    if (jniBitmap == NULL || jniBitmap->_storedBitmapPixels == NULL)
	return;
    uint32_t oldWidth = jniBitmap->_bitmapInfo.width;
    uint32_t oldHeight = jniBitmap->_bitmapInfo.height;
    uint32_t* previousData = jniBitmap->_storedBitmapPixels;
    uint32_t* newBitmapPixels = new uint32_t[newWidth * newHeight];
    // position of the top left pixel of the 4 pixels to use interpolation on
    int xTopLeft, yTopLeft;
    int x, y, lastTopLefty;
    float xRatio = (float) newWidth / (float) oldWidth, yratio =
	    (float) newHeight / (float) oldHeight;
    // Y color ratio to use on left and right pixels for interpolation
    float ycRatio2 = 0, ycRatio1 = 0;
    // pixel target in the src
    float xt, yt;
    // X color ratio to use on left and right pixels for interpolation
    float xcRatio2 = 0, xcratio1 = 0;
    ARGB rgbTopLeft, rgbTopRight, rgbBottomLeft, rgbBottomRight, rgbTopMiddle,
	    rgbBottomMiddle, result;
    for (x = 0; x < newWidth; ++x)
	{
	xTopLeft = (int) (xt = x / xRatio);
	// when meeting the most right edge, move left a little
	if (xTopLeft >= oldWidth - 1)
	    xTopLeft--;
	if (xt <= xTopLeft + 1)
	    {
	    // we are between the left and right pixel
	    xcratio1 = xt - xTopLeft;
	    // color ratio in favor of the right pixel color
	    xcRatio2 = 1 - xcratio1;
	    }
	for (y = 0, lastTopLefty = -30000; y < newHeight; ++y)
	    {
	    yTopLeft = (int) (yt = y / yratio);
	    // when meeting the most bottom edge, move up a little
	    if (yTopLeft >= oldHeight - 1)
		--yTopLeft;
	    if (lastTopLefty == yTopLeft - 1)
		{
		// we went down only one rectangle
		rgbTopLeft = rgbBottomLeft;
		rgbTopRight = rgbBottomRight;
		rgbTopMiddle = rgbBottomMiddle;
		//rgbBottomLeft=startingImageData[xTopLeft][yTopLeft+1];
		convertIntToArgb(
			previousData[((yTopLeft + 1) * oldWidth) + xTopLeft],
			&rgbBottomLeft);
		//rgbBottomRight=startingImageData[xTopLeft+1][yTopLeft+1];
		convertIntToArgb(
			previousData[((yTopLeft + 1) * oldWidth)
				+ (xTopLeft + 1)], &rgbBottomRight);
		rgbBottomMiddle.alpha = rgbBottomLeft.alpha * xcRatio2
			+ rgbBottomRight.alpha * xcratio1;
		rgbBottomMiddle.red = rgbBottomLeft.red * xcRatio2
			+ rgbBottomRight.red * xcratio1;
		rgbBottomMiddle.green = rgbBottomLeft.green * xcRatio2
			+ rgbBottomRight.green * xcratio1;
		rgbBottomMiddle.blue = rgbBottomLeft.blue * xcRatio2
			+ rgbBottomRight.blue * xcratio1;
		}
	    else if (lastTopLefty != yTopLeft)
		{
		// we went to a totally different rectangle (happens in every loop start,and might happen more when making the picture smaller)
		//rgbTopLeft=startingImageData[xTopLeft][yTopLeft];
		convertIntToArgb(previousData[(yTopLeft * oldWidth) + xTopLeft],
			&rgbTopLeft);
		//rgbTopRight=startingImageData[xTopLeft+1][yTopLeft];
		convertIntToArgb(
			previousData[((yTopLeft + 1) * oldWidth) + xTopLeft],
			&rgbTopRight);
		rgbTopMiddle.alpha = rgbTopLeft.alpha * xcRatio2
			+ rgbTopRight.alpha * xcratio1;
		rgbTopMiddle.red = rgbTopLeft.red * xcRatio2
			+ rgbTopRight.red * xcratio1;
		rgbTopMiddle.green = rgbTopLeft.green * xcRatio2
			+ rgbTopRight.green * xcratio1;
		rgbTopMiddle.blue = rgbTopLeft.blue * xcRatio2
			+ rgbTopRight.blue * xcratio1;
		//rgbBottomLeft=startingImageData[xTopLeft][yTopLeft+1];
		convertIntToArgb(
			previousData[((yTopLeft + 1) * oldWidth) + xTopLeft],
			&rgbBottomLeft);
		//rgbBottomRight=startingImageData[xTopLeft+1][yTopLeft+1];
		convertIntToArgb(
			previousData[((yTopLeft + 1) * oldWidth)
				+ (xTopLeft + 1)], &rgbBottomRight);
		rgbBottomMiddle.alpha = rgbBottomLeft.alpha * xcRatio2
			+ rgbBottomRight.alpha * xcratio1;
		rgbBottomMiddle.red = rgbBottomLeft.red * xcRatio2
			+ rgbBottomRight.red * xcratio1;
		rgbBottomMiddle.green = rgbBottomLeft.green * xcRatio2
			+ rgbBottomRight.green * xcratio1;
		rgbBottomMiddle.blue = rgbBottomLeft.blue * xcRatio2
			+ rgbBottomRight.blue * xcratio1;
		}
	    lastTopLefty = yTopLeft;
	    if (yt <= yTopLeft + 1)
		{
		// color ratio in favor of the bottom pixel color
		ycRatio1 = yt - yTopLeft;
		ycRatio2 = 1 - ycRatio1;
		}
	    // prepared all pixels to look at, so finally set the new pixel data
	    result.alpha = rgbTopMiddle.alpha * ycRatio2
		    + rgbBottomMiddle.alpha * ycRatio1;
	    result.blue = rgbTopMiddle.blue * ycRatio2
		    + rgbBottomMiddle.blue * ycRatio1;
	    result.red = rgbTopMiddle.red * ycRatio2
		    + rgbBottomMiddle.red * ycRatio1;
	    result.green = rgbTopMiddle.green * ycRatio2
		    + rgbBottomMiddle.green * ycRatio1;
	    newBitmapPixels[(y * newWidth) + x] = convertArgbToInt(result);
	    }
	}
    //get rid of old data, and replace it with new one
    delete[] previousData;
    jniBitmap->_storedBitmapPixels = newBitmapPixels;
    jniBitmap->_bitmapInfo.width = newWidth;
    jniBitmap->_bitmapInfo.height = newHeight;
    }

/**flips a bitmap horizontally, as such:
 *
 * 123    321
 * 456 => 654
 * 789    987
 *
 * */ //
JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniFlipBitmapHorizontal(
	JNIEnv * env, jobject obj, jobject handle)
    {
    JniBitmap* jniBitmap = (JniBitmap*) env->GetDirectBufferAddress(handle);
    if (jniBitmap == NULL || jniBitmap->_storedBitmapPixels == NULL)
	return;
    uint32_t* previousData = jniBitmap->_storedBitmapPixels;
    int width = jniBitmap->_bitmapInfo.width, middle = width / 2, height =
	    jniBitmap->_bitmapInfo.height;
    for (int y = 0; y < height; ++y)
	{
	//for each row, switch between the first pixels and the last ones
	uint32_t* idx1 = previousData + width * y;
	uint32_t* idx2 = previousData + width * (y + 1) - 1;
	for (int x = 0; x < middle; ++x)
	    {
	    uint32_t pixel = *idx1; //pixel= previousData[rowStart + x];
	    *idx1 = *idx2; //previousData[rowStart + x] =previousData[rowStart + (width - x - 1)];
	    *idx2 = pixel; //previousData[rowStart + (width - x - 1)] = pixel;
	    ++idx1;
	    --idx2;
	    }
	}
    }

/**flips a bitmap vertically, as such:
 *
 * 123    789
 * 456 => 456
 * 789    123
 *
 * */ //
JNIEXPORT void JNICALL Java_com_basic_security_utils_BitmapHolder_jniFlipBitmapVertical(
	JNIEnv * env, jobject obj, jobject handle)
    {
    JniBitmap* jniBitmap = (JniBitmap*) env->GetDirectBufferAddress(handle);
    if (jniBitmap == NULL || jniBitmap->_storedBitmapPixels == NULL)
	return;
    uint32_t* previousData = jniBitmap->_storedBitmapPixels;
    int width = jniBitmap->_bitmapInfo.width, height =
	    jniBitmap->_bitmapInfo.height, middle = height / 2;
    for (int y = 0; y < middle; ++y)
	{
	//for each row till the middle row, switch its pixels with the one at the bottom
	uint32_t* idx1 = previousData + width * y;
	uint32_t* idx2 = previousData + width * (height - y - 1);
	for (int x = 0; x < width; ++x)
	    {
	    uint32_t pixel =*idx1;
	    *idx1=*idx2;
	    *idx2=pixel;
	    ++idx2;
	    ++idx1;
	    }
	}
    }