自学教程：C++ AndroidBitmap_getInfo函数代码示例

JNIEXPORT void JNICALL Java_com_jiangpeng_android_antrace_Utils_unsharpMask(JNIEnv* env, jobject thiz, jobject input, jobject output){	AndroidBitmapInfo inputInfo;	AndroidBitmapInfo outputInfo;	void* src_pixels = 0;	void* dst_pixels = 0;	int ret = 0;	if ((ret = AndroidBitmap_getInfo(env, input, &inputInfo)) < 0) {		return;	}	if (inputInfo.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {		return;	}	if ((ret = AndroidBitmap_lockPixels(env, input, &src_pixels)) < 0) {		return;	}	if ((ret = AndroidBitmap_getInfo(env, output, &outputInfo)) < 0) {		return;	}	if (outputInfo.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {		return;	}	if ((ret = AndroidBitmap_lockPixels(env, output, &dst_pixels)) < 0) {		return;	}	unsharpMask(src_pixels, dst_pixels, outputInfo.width, outputInfo.height, inputInfo.stride, 5);	AndroidBitmap_unlockPixels(env, input);	AndroidBitmap_unlockPixels(env, output);}

JNIEXPORT void JNICALL Java_com_leth_convertimage_MainActivity_convertImage	(JNIEnv *env, jobject  obj, jobject origbm,jobject graybm){		AndroidBitmapInfo  infocolor;	    void				*pixelscolor;	    AndroidBitmapInfo  infogray;	    void 				*pixelsgray;	    int 			    y;	    int          	    x;	    LOGI("Before convert");	    AndroidBitmap_getInfo(env, origbm, &infocolor);	    LOGI("infocolor :: width-%d height-%d format-%d stride-%ld"	    				   ,infocolor.width						   ,infocolor.height						   ,infocolor.stride);	    AndroidBitmap_getInfo(env, graybm, &infogray);	    AndroidBitmap_lockPixels(env, origbm, &pixelscolor);	    AndroidBitmap_lockPixels(env, graybm, &pixelsgray);	    LOGI("Start convert");	    uint8_t tmp;	    for ( y=0; y<infocolor.height; y++) {	    	rgba * line = (rgba *) pixelscolor;	    	uint32_t * grayline = (uint32_t *) pixelsgray;	    	for ( x=0; x < infocolor.width; x++){	    		tmp =	    				line[x].red * 0.33	    				+ line[x].green  * 0.33						+ line[x].blue * 0.33						;	    		grayline[x] =	    					  (line[x].alpha & 0xff) << 24							| (tmp & 0xff) << 16							| (tmp & 0xff) << 8							| (tmp & 0xff)							//| line[x].red << 16							//| line[x].green << 8	    					//| line[x].blue							;	    	}	    	pixelscolor = (int8_t *)pixelscolor + infocolor.stride;	    	pixelsgray = (int8_t *) pixelsgray + infogray.stride;	    }	    LOGI("Finish convert");	    AndroidBitmap_unlockPixels(env, origbm);	    AndroidBitmap_unlockPixels(env, graybm);}

void bitmap_to_mat(JNIEnv *env, jobject &srcBitmap, Mat &srcMat) {    void *srcPixels = 0;    AndroidBitmapInfo srcBitmapInfo;    try {        AndroidBitmap_getInfo(env, srcBitmap, &srcBitmapInfo);        AndroidBitmap_lockPixels(env, srcBitmap, &srcPixels);        uint32_t srcHeight = srcBitmapInfo.height;        uint32_t srcWidth = srcBitmapInfo.width;        srcMat.create(srcHeight, srcWidth, CV_8UC4);        if (srcBitmapInfo.format == ANDROID_BITMAP_FORMAT_RGBA_8888) {            Mat tmp(srcHeight, srcWidth, CV_8UC4, srcPixels);            tmp.copyTo(srcMat);        } else {            Mat tmp = Mat(srcHeight, srcWidth, CV_8UC2, srcPixels);            cvtColor(tmp, srcMat, COLOR_BGR5652RGBA);        }        AndroidBitmap_unlockPixels(env, srcBitmap);        return;    } catch (cv::Exception &e) {        AndroidBitmap_unlockPixels(env, srcBitmap);        jclass je = env->FindClass("java/lang/Exception");        env -> ThrowNew(je, e.what());        return;    } catch (...) {        AndroidBitmap_unlockPixels(env, srcBitmap);        jclass je = env->FindClass("java/lang/Exception");        env -> ThrowNew(je, "unknown");        return;    }}

JNIEXPORT void JNICALL Java_makemachine_android_examples_Nati_greyscale(JNIEnv * env, jclass klass, jobject bitmap,jint wind){      void * raw;      uint32_t * pixels;      int ret,j;      int grey;      AndroidBitmapInfo  info;      if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) return;      if ((ret = AndroidBitmap_lockPixels(env, bitmap, &raw)) < 0) return;      pixels=(uint32_t*) raw;#define USE_CONTRAST STRETCH#ifdef USE_CONTRAST_STRETCH      determine_contrast(&pixels,info.height,info.width);#else      Qwe::mingrey=0;      Qwe::maxgrey=255;#endif      greyscale(&pixels,info.height,info.width);      make_mean(info.height,info.width,wind);#ifdef USE_DEVIATION      make_dev(info.height,info.width,wind);#endif      imtoin(info.height,info.width);      thresh(info.height,info.width);      close(info.height,info.width,2);      open(info.height,info.width,2);      AndroidBitmap_unlockPixels(env, bitmap);}

JNIEXPORT void JNICALL Java_com_daemon_aroundcircleviewdemo_ImageBlur_blurBitMap(JNIEnv *env, jclass obj, jobject bitmapIn, jint r){AndroidBitmapInfo infoIn;void* pixelsIn;int ret;// Get image infoif ((ret = AndroidBitmap_getInfo(env, bitmapIn, &infoIn)) < 0)return;// Check imageif (infoIn.format != ANDROID_BITMAP_FORMAT_RGBA_8888)return;// Lock all imagesif ((ret = AndroidBitmap_lockPixels(env, bitmapIn, &pixelsIn)) < 0) {//AndroidBitmap_lockPixels failed!}//height widthint h = infoIn.height;int w = infoIn.width;//StartpixelsIn = StackBlur((int*)pixelsIn, w, h, r);//End// Unlocks everythingAndroidBitmap_unlockPixels(env, bitmapIn);}

GF_Err RAW_Setup(GF_VideoOutput *dr, void *os_handle, void *os_display, u32 init_flags){	AndroidBitmapInfo  info;	RAWCTX;	void * pixels;	int ret;	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("Android vout RAW_Setup/n"));	if (!rc->width)	{		rc->env = (JNIEnv *)os_handle;		rc->bitmap = (jobject *)os_display;		AndroidBitmap_getInfo(rc->env, *(rc->bitmap), &info);		rc->width = info.width;		rc->height = info.height;		rc->locked_data = NULL;	}	else	{		rc->env = (JNIEnv *)os_handle;		rc->bitmap = (jobject *)os_display;	}	GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("Android vout rc dims: %d:%d/n", rc->height, rc->width));	return GF_OK;}

JNIEXPORT void JNICALLJava_si_majcn_frameoffame_MainActivity_applyEffect(JNIEnv  *env,                                                   jobject  obj,                                                   jobject  bitmap,                                                   jint     effectNumber){    AndroidBitmapInfo  info;    int ret;    void *pixels;    if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0)    {        LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);        return;    }    if (info.format != ANDROID_BITMAP_FORMAT_RGB_565)    {        LOGE("Bitmap format is not RGBA_565 !");        return;    }    if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0)    {        LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);    }    applyEffect(&info, pixels, effectNumber);    AndroidBitmap_unlockPixels(env, bitmap);}

int lockPixels(JNIEnv *env, jobject jbitmap, GifInfo *info, void **pixels) {    AndroidBitmapInfo bitmapInfo;    if (AndroidBitmap_getInfo(env, jbitmap, &bitmapInfo) == ANDROID_BITMAP_RESULT_SUCCESS)        info->stride = bitmapInfo.width;    else {        throwException(env, ILLEGAL_STATE_EXCEPTION_BARE, "Could not get bitmap info");        return -2;    }    const int lockPixelsResult = AndroidBitmap_lockPixels(env, jbitmap, pixels);    if (lockPixelsResult == ANDROID_BITMAP_RESULT_SUCCESS)        return 0;    char *message;    switch (lockPixelsResult) {        case ANDROID_BITMAP_RESULT_ALLOCATION_FAILED:#ifdef DEBUG            LOGE("bitmap lock allocation failed");#endif            return -1; //#122 workaround        case ANDROID_BITMAP_RESULT_BAD_PARAMETER:            message = "Lock pixels error, bad parameter";            break;        case ANDROID_BITMAP_RESULT_JNI_EXCEPTION:            message = "Lock pixels error, JNI exception";            break;        default:            message = "Lock pixels error";    }    throwException(env, ILLEGAL_STATE_EXCEPTION_BARE, message);    return -2;}

static jlong JNICALL nativeGetFrame(        JNIEnv* env, jobject clazz, jlong frameSequenceStateLong, jint frameNr,        jobject bitmap, jint previousFrameNr) {    FrameSequenceState* frameSequenceState =            reinterpret_cast<FrameSequenceState*>(frameSequenceStateLong);    int ret;    AndroidBitmapInfo info;    void* pixels;    if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {        jniThrowException(env, ILLEGAL_STATE_EXEPTION,                "Couldn't get info from Bitmap ");        return 0;    }    if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {        jniThrowException(env, ILLEGAL_STATE_EXEPTION,                "Bitmap pixels couldn't be locked");        return 0;    }    int pixelStride = info.stride >> 2;    jlong delayMs = frameSequenceState->drawFrame(frameNr,            (Color8888*) pixels, pixelStride, previousFrameNr);    AndroidBitmap_unlockPixels(env, bitmap);    return delayMs;}

/*fill in data for a bitmap*/JNIEXPORT jint JNICALL Java_feipeng_andzop_render_RenderView_naRenderAFrame(JNIEnv * pEnv, jobject pObj, jobject pBitmap, int _width, int _height, float _roiSh, float _roiSw, float _roiEh, float _roiEw) {    AndroidBitmapInfo lInfo;    //void* lPixels;    int lRet;    int li, lj, lk;    int lPos;    unsigned char* ltmp;    LOGI(3, "start of render_a_frame");        //1. retrieve information about the bitmap    if ((lRet = AndroidBitmap_getInfo(pEnv, pBitmap, &lInfo)) < 0) {        LOGE(1, "AndroidBitmap_getInfo failed! error = %d", lRet);        return;    }    if (lInfo.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {        LOGE(1, "Bitmap format is not RGBA_8888!");        return;    }    //2. lock the pixel buffer and retrieve a pointer to it    if ((lRet = AndroidBitmap_lockPixels(pEnv, pBitmap, &gBitmap)) < 0) {        LOGE(1, "AndroidBitmap_lockPixels() failed! error = %d", lRet);    }    //3. modify the pixel buffer    //decode a video frame: the pBitmap will be filled with decoded pixels    lRet = decode_a_frame(_width, _height, _roiSh, _roiSw, _roiEh, _roiEw);    AndroidBitmap_unlockPixels(pEnv, pBitmap);    LOGI(3, "~~~~~~~~~~end of rendering a frame~~~~~~~~~~~~~~~~~`");    return lRet;}

jobject Java_com_packpublishing_asynchronousandroid_chapter9_GrayImageLoader_convertImageToGray        (JNIEnv *env, jobject obj, jobject bitmap) {    AndroidBitmapInfo info;    void *pixels;    int ret;    if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {        jclass clazz = env->FindClass("java/lang/RuntimeException");        env->ThrowNew(clazz, "Failed to get Information from the Bitmap!");        return 0;    }    if ((ret = AndroidBitmap_lockPixels(env, bitmap, (void **) &pixels)) < 0) {        jclass clazz = env->FindClass("java/lang/RuntimeException");        env->ThrowNew(clazz, "Failed to lock Bitmap pixels !");        return 0;    }    rgba *rgba_pixels = (rgba *) pixels;    for (int i = 0; i < (info.width * info.height); i++) {        uint8_t red = rgba_pixels[i].red;        uint8_t green = rgba_pixels[i].green;        uint8_t blue = rgba_pixels[i].blue;        uint8_t gray = red * 0.3 + green * 0.59 + blue * 0.11;        rgba_pixels[i].red = gray;        rgba_pixels[i].green = gray;        rgba_pixels[i].blue = gray;    }    AndroidBitmap_unlockPixels(env, bitmap);    return bitmap;}

JNIEXPORT void JNICALL Java_net_qiujuer_genius_app_BlurNative_fastBlurBitmap(JNIEnv *env, jclass obj, jobject bitmapIn, jint r){	AndroidBitmapInfo infoIn;	void* pixelsIn;	int ret;	// Get image info	if ((ret = AndroidBitmap_getInfo(env, bitmapIn, &infoIn)) < 0)		return;	// Check image	if (infoIn.format != ANDROID_BITMAP_FORMAT_RGBA_8888)		return;	// Lock all images	if ((ret = AndroidBitmap_lockPixels(env, bitmapIn, &pixelsIn)) < 0) {		//AndroidBitmap_lockPixels failed!	}	// height width	int h = infoIn.height;	int w = infoIn.width;	// Start	pixelsIn = stackBlur((int*)pixelsIn, w, h, r);	// End	// Unlocks everything	AndroidBitmap_unlockPixels(env, bitmapIn);}

JNIEXPORT jboolean JNICALL jni_freerdp_update_graphics(	JNIEnv *env, jclass cls, jint instance, jobject bitmap, jint x, jint y, jint width, jint height){	int ret;	void* pixels;	AndroidBitmapInfo info;	freerdp* inst = (freerdp*)instance;	rdpGdi *gdi = inst->context->gdi;	if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0)	{		DEBUG_ANDROID("AndroidBitmap_getInfo() failed ! error=%d", ret);		return JNI_FALSE;	}	if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0)	{		DEBUG_ANDROID("AndroidBitmap_lockPixels() failed ! error=%d", ret);		return JNI_FALSE;	}	copy_pixel_buffer(pixels, gdi->primary_buffer, x, y, width, height, gdi->width, gdi->height, gdi->bytesPerPixel);	AndroidBitmap_unlockPixels(env, bitmap);	return JNI_TRUE;}

voidJava_org_yabause_android_YabauseRunnable_stateSlotScreenshot( JNIEnv* env, jobject obj, jobject dirpath, jobject itemnum, int slot, jobject bitmap ){    int outputwidth, outputheight;    u32 * buffer, * cur;    AndroidBitmapInfo info;    void * pixels;    int x, y;    jboolean dummy;    const char * dp = (*env)->GetStringUTFChars(env, dirpath, &dummy);    const char * in = (*env)->GetStringUTFChars(env, itemnum, &dummy);    if (0 != LoadStateSlotScreenshot(dp, in, slot, &outputwidth, &outputheight, &buffer)) return;    AndroidBitmap_getInfo(env, bitmap, &info);    AndroidBitmap_lockPixels(env, bitmap, &pixels);    cur = buffer;    for(y = 0;y < info.height;y++) {        for(x = 0;x < info.width;x++) {            *((uint32_t *) pixels + x) = *(cur + x);        }        pixels += info.stride;        cur += outputwidth;    }    free(buffer);    AndroidBitmap_unlockPixels(env, bitmap);}

JNIEXPORT void JNICALL Java_jp_dego_sample_ipcv_MainActivity_getHairArea(JNIEnv *env, jobject obj, jobject bmp,        jint eyes_cp, jint eyes_w){    AndroidBitmapInfo info;    void* pixels;    // Bitmapの情
C++ AndroidBitmap_lockPixels函数代码示例
C++ Analyze函数代码示例