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

static intnAllocationCubeCreateFromBitmap(JNIEnv *_env, jobject _this, RsContext con, jint type, jint mip, jobject jbitmap, jint usage){    void *pixels = NULL;    AndroidBitmap_lockPixels(_env, jbitmap, &pixels);    jint id = 0;    if (pixels != NULL) {        id = (jint)dispatchTab.AllocationCubeCreateFromBitmap(con,                                                    (RsType)type, (RsAllocationMipmapControl)mip,                                                    pixels, GetBitmapSize(_env, jbitmap), usage);        AndroidBitmap_unlockPixels(_env, jbitmap);    }    return id;}

static intnAllocationCreateBitmapBackedAllocation(JNIEnv *_env, jobject _this, RsContext con, jint type, jint mip, jobject jbitmap, jint usage){    jint id = 0;    void *pixels = NULL;    AndroidBitmap_lockPixels(_env, jbitmap, &pixels);    if (pixels != NULL) {        id = (jint)dispatchTab.AllocationCreateTyped(con,                                          (RsType)type, (RsAllocationMipmapControl)mip,                                          (uint32_t)usage, (uintptr_t)pixels);        AndroidBitmap_unlockPixels(_env, jbitmap);    }    return id;}

/** LibVisualBitmapView.renderVisual() */JNIEXPORT void JNICALL Java_org_libvisual_android_LibVisualBitmapView_renderVisual(JNIEnv * env,                                                                                    jobject  obj,                                                                                    jobject bitmap,                                                                                   jint bin,                                                                                   jint video){    VisBin *b = (VisBin *) bin;    VisVideo *bvideo = (VisVideo *) video;            if(!visual_is_initialized() ||       !bvideo ||       !b ||        !b->input ||        !b->actor ||       !b->actvideo)    {        LOGE("Not initialized properly");            return;    }            /* start fps timing */    fps_startFrame(&_v.fps);    /* run libvisual pipeline */    visual_bin_run(b);            /* lock bitmap for drawing */    int ret;    void *pixels;    if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0)     {        LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);    }    /* set buffer to pixels */    visual_video_set_buffer(bvideo, pixels);        /* depth transform */    visual_video_convert_depth(bvideo, b->actvideo);            /* unlock bitmap */    AndroidBitmap_unlockPixels(env, bitmap);    /* stop fps timing */    fps_endFrame(&_v.fps);}

static voidnAllocationCopyToBitmap(JNIEnv *_env, jobject _this, RsContext con, jint alloc, jobject jbitmap){    AndroidBitmapInfo info;    memset(&info, 0, sizeof(info));    AndroidBitmap_getInfo(_env, jbitmap, &info);    void *pixels = NULL;    AndroidBitmap_lockPixels(_env, jbitmap, &pixels);    if (pixels != NULL) {        dispatchTab.AllocationCopyToBitmap(con, (RsAllocation)alloc, pixels, GetBitmapSize(_env, jbitmap));        AndroidBitmap_unlockPixels(_env, jbitmap);    }    //bitmap.notifyPixelsChanged();}

JNIEXPORT jfloatArray JNICALL Java_com_lge_ccdevs_tracker_CameraPreview_native_1cv_1match(JNIEnv *env, jobject thiz, jobject srcimg) {	AndroidBitmapInfo bInfo;    char *bPixs;	int bRet;    // convert img	if ((bRet = AndroidBitmap_getInfo(env, srcimg, &bInfo)) < 0) {		LOGE("AndroidBitmap_getInfo failed(src)! error = %d", bRet);		return 0;	}	if (bInfo.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {		LOGE("Bitmap(src) format is not RGBA_8888!");		return 0;	}	if ((bRet = AndroidBitmap_lockPixels(env, srcimg, (void**)&bPixs)) < 0) {		LOGE("AndroidBitmap_lockPixels() failed(src)! error = %d", bRet);		return 0;	}	IplImage* bimg = cvCreateImage(cvSize(bInfo.width,bInfo.height), IPL_DEPTH_8U, 4);	memcpy(bimg->imageData, bPixs, bimg->imageSize);	AndroidBitmap_unlockPixels(env, srcimg);	IplImage* img = cvCreateImage(cvSize(bInfo.width,bInfo.height), IPL_DEPTH_8U, 3);    cvCvtColor(bimg, img, CV_RGBA2BGR);        res_pts = matcher->match(img);    // test capture    stringstream ss;    ss << "/sdcard/tracker/tracker_match" << ncount_match++ << ".jpg";    Converter::saveJPG(ss.str().c_str(), img);    LOGE("#### matched pts = (%f,%f), (%f,%f), (%f,%f), (%f,%f) )",            res_pts[0], res_pts[1], res_pts[2], res_pts[3],            res_pts[4], res_pts[5], res_pts[6], res_pts[7] );    cvReleaseImage( &bimg );    cvReleaseImage( &img );    jfloatArray result;    result = env->NewFloatArray(8);    env->SetFloatArrayRegion(result,0,8,res_pts);    return result;}

static void readBitmapPixels(JNIEnv* env, jclass /* clazz */, jobject jbitmap, jint fd) {    // Read the info.    AndroidBitmapInfo readInfo;    bool read = readAllBytes(fd, (void*) &readInfo, sizeof(AndroidBitmapInfo));    if (!read) {        throwIllegalStateException(env, (char*) "Cannot read bitmap info");        return;    }    // Get the info of the target bitmap.    AndroidBitmapInfo targetInfo;    int result = AndroidBitmap_getInfo(env, jbitmap, &targetInfo);    if (result < 0) {        throwIllegalStateException(env, (char*) "Cannot get bitmap info");        return;    }    // Enforce we can reuse the bitmap.    if (readInfo.width != targetInfo.width || readInfo.height != targetInfo.height            || readInfo.stride != targetInfo.stride || readInfo.format != targetInfo.format            || readInfo.flags != targetInfo.flags) {        throwIllegalArgumentException(env, (char*) "Cannot reuse bitmap");        return;    }    // Lock the pixels.    void* pixels;    result = AndroidBitmap_lockPixels(env, jbitmap, &pixels);    if (result < 0) {        throwIllegalStateException(env, (char*) "Cannot lock bitmap pixels");        return;    }    // Read the pixels.    size_t byteCount = readInfo.stride * readInfo.height;    read = readAllBytes(fd, (void*) pixels, byteCount);    if (!read) {        throwIllegalStateException(env, (char*) "Cannot read bitmap pixels");        return;    }    // Unlock the pixels.    result = AndroidBitmap_unlockPixels(env, jbitmap);    if (result < 0) {        throwIllegalStateException(env, (char*) "Cannot unlock bitmap pixels");    }}

/** Program having access to java Bitmap through JNI */cv::Mat getMatWrapper(JNIEnv *env, jobject bmap){  AndroidBitmapInfo info;  CV_Assert( AndroidBitmap_getInfo(env, bmap, &info) >= 0 ); // Get info  CV_Assert( info.format == ANDROID_BITMAP_FORMAT_RGBA_8888 ); // Compatible format  void *pixels = 0;  CV_Assert( AndroidBitmap_lockPixels(env, bmap, &pixels) >= 0 ); // Get pixels  CV_Assert( pixels );  cv::Mat m(info.height, info.width, CV_8UC4, pixels);  cv::Mat frame; // CV_8UC3  cvtColor(m, frame, CV_RGBA2BGR);  AndroidBitmap_unlockPixels(env, bmap);  return frame;}

static voidnAllocationCopyFromBitmap(JNIEnv *_env, jobject _this, RsContext con, jint alloc, jobject jbitmap){    AndroidBitmapInfo info;    memset(&info, 0, sizeof(info));    AndroidBitmap_getInfo(_env, jbitmap, &info);    void *pixels = NULL;    AndroidBitmap_lockPixels(_env, jbitmap, &pixels);    if (pixels != NULL) {        dispatchTab.Allocation2DData(con, (RsAllocation)alloc, 0, 0,                           0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X,                           info.width, info.height, pixels, GetBitmapSize(_env, jbitmap), 0);        AndroidBitmap_unlockPixels(_env, jbitmap);    }}

void MyRenderer::Render(JNIEnv *env, jobject bitmap) noexcept{	int ret = 0;	AndroidBitmapInfo bitmapInfo;	if ((ret = AndroidBitmap_getInfo(env, bitmap, &bitmapInfo)) < 0)	{		info("MyRenderer", "AndroidBitmap_getInfo failed!");		return;	}	else {		info("MyRenderer", "bitmapInfo width = %d, height = %d", bitmapInfo.width, bitmapInfo.height);	}	GLuint textureId;	GLint location = glGetUniformLocation(m_Program->GetProgramId(), "s_texture");	glGenTextures(1, &textureId);	glActiveTexture(GL_TEXTURE0);	glBindTexture(GL_TEXTURE_2D, textureId);	glUniform1i(location, 0);	void *pixels = nullptr;	AndroidBitmap_lockPixels(env, bitmap, &pixels);	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bitmapInfo.width, bitmapInfo.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);	this->OnRender(m_Width, m_Height);	AndroidBitmap_unlockPixels(env, bitmap);	//GLenum format = GL_RGB;	//if (bitmapInfo.format == ANDROID_BITMAP_FORMAT_RGBA_8888) {	//	info("MyRenderer", "bitmapInfo format = ANDROID_BITMAP_FORMAT_RGBA_8888");	//}	//else if (bitmapInfo.format ==  ANDROID_BITMAP_FORMAT_RGB_565) {	//	info("MyRenderer", "bitmapInfo format = ANDROID_BITMAP_FORMAT_RGB_565");	//}	//else if (bitmapInfo.format ==  ANDROID_BITMAP_FORMAT_RGBA_4444) {	//	info("MyRenderer", "bitmapInfo format = ANDROID_BITMAP_FORMAT_RGBA_4444");	//}	//else if (bitmapInfo.format ==  ANDROID_BITMAP_FORMAT_A_8) {	//	info("MyRenderer", "bitmapInfo format = ANDROID_BITMAP_FORMAT_A_8");	//}}

voidJava_ch_nuicell_ecam_CameraPreview_pixeltobmp( JNIEnv* env,jobject thiz,jobject bitmap) {    jboolean bo;    AndroidBitmapInfo  info;    void*              pixels;    int                ret;    int i;    int *colors;    int width=0;    int height=0;    if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {        LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);        return;    }    width = info.width;    height = info.height;    if(!rgb || !ybuf) return;    if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {        LOGE("Bitmap format is not RGBA_8888 !");        return;    }    if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {        LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);    }    colors = (int*)pixels;    int *lrgb =NULL;    lrgb = &rgb[0];    for(i=0 ; i<width*height ; i++) {        *colors++ = *lrgb++;    }    AndroidBitmap_unlockPixels(env, bitmap);}

JNIEXPORT jobject JNICALL Java_com_jni_bitmap_1operations_JniBitmapHolder_jniGetBitmapFromStoredBitmapData(	JNIEnv * env, jobject obj, jobject handle)    {    JniBitmap* jniBitmap = (JniBitmap*) env->GetDirectBufferAddress(handle);    if (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;    }

jlong Java_com_googlecode_leptonica_android_ReadFile_nativeReadBitmap(JNIEnv *env, jclass clazz,                                                                      jobject bitmap) {	LOGV(__FUNCTION__);	l_int32 w, h, d;	AndroidBitmapInfo info;	void* pixels;	int ret;	if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {		LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);		return JNI_FALSE;	}	if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {		LOGE("Bitmap format is not RGBA_8888 !");		return JNI_FALSE;	}	if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {		LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);		return JNI_FALSE;	}	PIX *pixd = pixCreate(info.width, info.height, 32);	l_uint8 *src = (l_uint8 *) pixels;	l_uint8 *dst = (l_uint8 *) pixGetData(pixd);	l_int32 srcBpl = (info.stride);	l_int32 dstBpl = pixGetWpl(pixd)*4;	for (int dy = 0; dy < info.height; dy++) {		memcpy(dst, src, 4 * info.width);		dst += dstBpl;		src += srcBpl;	}	  pixEndianByteSwap(pixd);	AndroidBitmap_unlockPixels(env, bitmap);	return (jlong) pixd;}

    virtual LVDrawBuf * lock(JNIEnv* env, jobject jbitmap) {		AndroidBitmapInfo info;		if ( ANDROID_BITMAP_RESUT_SUCCESS!=AndroidBitmap_getInfo(env, jbitmap, &info) ) {			return NULL;		}		int width = info.width;		int height = info.height;		int stride = info.stride;		int format = info.format;		if ( format!=ANDROID_BITMAP_FORMAT_RGBA_8888 && format!=ANDROID_BITMAP_FORMAT_RGB_565  && format!=8 ) {			return NULL;		}		int bpp = (format==ANDROID_BITMAP_FORMAT_RGBA_8888) ? 32 : 16;		lUInt8 * pixels = NULL; 		if ( ANDROID_BITMAP_RESUT_SUCCESS!=AndroidBitmap_lockPixels(env, jbitmap, (void**)&pixels) ) {		    pixels = NULL;		}		return new LVColorDrawBufEx( width, height, pixels, bpp );    } 

void Java_org_opentalking_drawskill_SurfaceDiff_applyAndSwap(JNIEnv *env, jobject obj, jobject dest, jint boundTop, jint boundBottom, jint boundLeft, jint boundRight, jbooleanArray bitmask, jintArray pixels) {    AndroidBitmapInfo  info;    uint32_t*          destPixels;    int                ret;    if ((ret = AndroidBitmap_getInfo(env, dest, &info)) < 0) {        LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);        return;    }    if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {        LOGE("Destination bitmap format is not RGBA_8888!");        return;    }    AndroidBitmap_lockPixels(env, dest, (void*)&destPixels);    jint* pixelsPtr = (*env)->GetIntArrayElements(env, pixels, 0);    jboolean* bitmaskPtr = (*env)->GetBooleanArrayElements(env, bitmask, 0);    uint32_t* destPixelsPtr;    for (int y = boundTop; y <= boundBottom; y += 1) {        destPixelsPtr = destPixels + y * info.width + boundLeft;        for (int x = boundLeft; x <= boundRight; x += 1) {            if (*bitmaskPtr) {                int swapPixel = *destPixelsPtr;                *destPixelsPtr = *pixelsPtr;                *pixelsPtr = swapPixel;                pixelsPtr += 1;            }            destPixelsPtr += 1;            bitmaskPtr += 1;        }    }    (*env)->ReleaseIntArrayElements(env, pixels, pixelsPtr, 0);    (*env)->ReleaseBooleanArrayElements(env, bitmask, bitmaskPtr, 0);    AndroidBitmap_unlockPixels(env, dest);}

static void filter_bitmap(JNIEnv* env, jobject obj, jobject bitmap,    float intensity, Filter t){    AndroidBitmapInfo info;    int ret = checkInfo(env, bitmap, &info);    if (ret < 0) {        return;    }    void* pixels;    if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {        LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);    }    do_filter(&info, pixels, intensity, t);    AndroidBitmap_unlockPixels(env, bitmap);}

JNIEXPORT jint JNICALL Java_com_jazzros_ffmpegtest_AVThread_nativeSetBitmapBuffer(JNIEnv* env, jobject thiz, jobject bitmap){    __android_log_print(ANDROID_LOG_INFO, "com.jazzros.ffmpegtest", "nativeSetBitmapBuffer()");    if ((*env)->IsSameObject(env, bitmap, NULL))    {        __android_log_print(ANDROID_LOG_ERROR, "com.jazzros.ffmpegtest", "invalid arguments");        return -2;    }    // Do not forget release previous instance of resources    releaseBitmap (env, thiz);    gBitmapRef = (*env)->NewGlobalRef(env, bitmap); //lock the bitmap preventing the garbage collector from destructing it    if (gBitmapRef == NULL)    {        __android_log_print(ANDROID_LOG_ERROR, "com.jazzros.ffmpegtest", "NewGlobalRef() failed");        return -4;    }    int result = AndroidBitmap_lockPixels(env, gBitmapRef, &gBitmapRefPixelBuffer);    if (result != 0)    {        __android_log_print(ANDROID_LOG_ERROR, "com.jazzros.ffmpegtest", "AndroidBitmap_lockPixels() failed with %d", result);        gBitmapRefPixelBuffer = NULL;        return -5;    }    if (AndroidBitmap_getInfo(env, gBitmapRef, &gAbi) != 0)    {        __android_log_print(ANDROID_LOG_ERROR, "com.jazzros.ffmpegtest", "AndroidBitmap_getInfo() failed");        return -6;    }    __android_log_print(ANDROID_LOG_INFO, "com.jazzros.ffmpegtest", "bitmap width: %d", gAbi.width);    __android_log_print(ANDROID_LOG_INFO, "com.jazzros.ffmpegtest", "bitmap height: %d", gAbi.height);    __android_log_print(ANDROID_LOG_INFO, "com.jazzros.ffmpegtest", "bitmap stride: %d", gAbi.stride);    __android_log_print(ANDROID_LOG_INFO, "com.jazzros.ffmpegtest", "bitmap format: %d", gAbi.format);    __android_log_print(ANDROID_LOG_INFO, "com.jazzros.ffmpegtest", "bitmap flags: %d", gAbi.flags);    return 0;}

    jobject createBitmap(QImage img, JNIEnv *env)    {        if (img.format() != QImage::Format_ARGB32 && img.format() != QImage::Format_RGB16)            img = img.convertToFormat(QImage::Format_ARGB32);        jobject bitmap = env->CallStaticObjectMethod(m_bitmapClass,                                                     m_createBitmapMethodID,                                                     img.width(),                                                     img.height(),                                                     img.format() == QImage::Format_ARGB32                                                        ? m_ARGB_8888_BitmapConfigValue                                                        : m_RGB_565_BitmapConfigValue);        if (!bitmap)            return 0;        AndroidBitmapInfo info;        if (AndroidBitmap_getInfo(env, bitmap, &info) < 0) {            env->DeleteLocalRef(bitmap);            return 0;        }        void *pixels;        if (AndroidBitmap_lockPixels(env, bitmap, &pixels) < 0) {            env->DeleteLocalRef(bitmap);            return 0;        }        if (info.stride == uint(img.bytesPerLine())                && info.width == uint(img.width())                && info.height == uint(img.height())) {            memcpy(pixels, img.constBits(), info.stride * info.height);        } else {            uchar *bmpPtr = static_cast<uchar *>(pixels);            const unsigned width = qMin(info.width, (uint)img.width()); //should be the same            const unsigned height = qMin(info.height, (uint)img.height()); //should be the same            for (unsigned y = 0; y < height; y++, bmpPtr += info.stride)                memcpy(bmpPtr, img.constScanLine(y), width);        }        AndroidBitmap_unlockPixels(env, bitmap);        return bitmap;    }

JNIEXPORT jboolean JNICALL Java_com_ly_widget_GifDrawable_updateFrame(JNIEnv * env, jobject obj, jlong jgif_handle,  jobject bitmap, jint level){  GifFileType* gif_handle = (GifFileType *)jgif_handle;  int frame = getFrame(gif_handle, level);  if (((GifAnimInfo *)gif_handle->UserData)->current_frame == frame) {    return JNI_FALSE;  }  AndroidBitmapInfo  info;  void*              pixels;  int                ret;  if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {    LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);    return;  }  if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {    LOGE("Bitmap format is not RGBA_8888 !");    return;  }  if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {    LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);  }  //double now = now_ms();  drawFrame(gif_handle, &info, (int*)pixels, frame, false);  //now = now_ms() - now;  //LOGE("Gif Time Taken : %.2f", now);  AndroidBitmap_unlockPixels(env, bitmap);  ((GifAnimInfo *)gif_handle->UserData)->current_frame = frame;  /*   * TODO : Check if you actually need to draw the frame, if not return JNI_FALSE   */  return JNI_TRUE;}

JniBitmap* getJniBitmap(JNIEnv *env, jobject bitmap){	AndroidBitmapInfo bitmapInfo;	uint32_t* storedBitmapPixels = NULL;	uint32_t* src = NULL;	void* bitmapPixels;	//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;	}	//LOGD("reading bitmap pixels...");	if ((ret = AndroidBitmap_lockPixels(env, bitmap, &bitmapPixels)) < 0){		LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);		return NULL;	}	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->_bitmapInfo = bitmapInfo;	jniBitmap->_storedBitmapPixels = storedBitmapPixels;	//delete(storedBitmapPixels);	return jniBitmap;}

void mat_to_bitmap(JNIEnv *env, Mat &srcMat, jobject &dstBitmap) {    void *dstPixels = 0;    AndroidBitmapInfo dstBitmapInfo;    try {        AndroidBitmap_getInfo(env, dstBitmap, &dstBitmapInfo);        AndroidBitmap_lockPixels(env, dstBitmap, &dstPixels);        uint32_t dstHeight = dstBitmapInfo.height;        uint32_t dstWidth = dstBitmapInfo.width;        if (dstBitmapInfo.format == ANDROID_BITMAP_FORMAT_RGBA_8888) {            Mat tmp(dstHeight, dstWidth, CV_8UC4, dstPixels);            if(srcMat.type() == CV_8UC1) {                cvtColor(srcMat, tmp, COLOR_GRAY2RGBA);            } else if (srcMat.type() == CV_8UC3) {                cvtColor(srcMat, tmp, COLOR_RGB2RGBA);            } else if (srcMat.type() == CV_8UC4) {                srcMat.copyTo(tmp);            }        } else {            Mat tmp = Mat(dstHeight, dstWidth, CV_8UC2, dstPixels);            if(srcMat.type() == CV_8UC1) {                cvtColor(srcMat, tmp, COLOR_GRAY2BGR565);            } else if (srcMat.type() == CV_8UC3) {                cvtColor(srcMat, tmp, COLOR_RGB2BGR565);            } else if (srcMat.type() == CV_8UC4) {                cvtColor(srcMat, tmp, COLOR_RGBA2BGR565);            }        }        AndroidBitmap_unlockPixels(env, dstBitmap);    }catch (cv::Exception &e) {        AndroidBitmap_unlockPixels(env, dstBitmap);        jclass je = env->FindClass("java/lang/Exception");        env -> ThrowNew(je, e.what());        return;    } catch (...) {        AndroidBitmap_unlockPixels(env, dstBitmap);        jclass je = env->FindClass("java/lang/Exception");        env -> ThrowNew(je, "unknown");        return;    }}

jboolean Java_com_mcxiaoke_ndk_Native_renderBitmap(    JNIEnv* env,    jclass clazz,    jlong avi,    jobject bitmap){    jboolean isFrameRead = JNI_FALSE;    char* frameBuffer = 0;    long frameSize = 0;    int keyFrame = 0;    // Lock bitmap and get the raw bytes    if (0 > AndroidBitmap_lockPixels(env, bitmap, (void**) &frameBuffer))    {        ThrowException(env, "java/io/IOException",                       "Unable to lock pixels.");        goto exit;    }    // Read AVI frame bytes to bitmap    frameSize = AVI_read_frame((avi_t*) avi, frameBuffer, &keyFrame);    // Unlock bitmap    if (0 > AndroidBitmap_unlockPixels(env, bitmap))    {        ThrowException(env, "java/io/IOException",                       "Unable to unlock pixels.");        goto exit;    }    // Check if frame is successfully read    if (0 < frameSize)    {        isFrameRead = JNI_TRUE;    }exit:    return isFrameRead;}

static void* create_buffer(BufferContainer* container, uint32_t width, uint32_t height, int32_t config) {  BitmapContainerData* data = container->data;  void *pixels = NULL;  if (data->bitmap != NULL) {    LOGE("Can't call create_buffer twice.");    return NULL;  }  data->bitmap = (*data->env)->CallStaticObjectMethod(data->env, data->clazz, data->method, width, height, config);  if (data->bitmap == NULL) {    LOGE("Can't create bitmap.");    return NULL;  }  AndroidBitmap_lockPixels(data->env, data->bitmap, &pixels);  if (pixels == NULL) {    LOGE("Can't lock pixels of Bitmap.");  }  return pixels;}

void JNIFUNCF(ImageFilterWBalance, nativeApplyFilter, jobject bitmap, jint width, jint height, int locX,int locY){    char* destination = 0;    AndroidBitmap_lockPixels(env, bitmap, (void**) &destination);    int i;    int len = width * height * 4;    unsigned char * rgb = (unsigned char * )destination;    int wr;    int wg;    int wb;    if (locX==-1)        estmateWhite(rgb,len,&wr,&wg,&wb);    else        estmateWhiteBox(rgb, width, height,locX,locY,&wr,&wg,&wb);    int min = MIN(wr, MIN(wg, wb));    int max = MAX(wr, MAX(wg, wb));    float avg = (min+max)/2.f;    float scaleR =  avg/wr;    float scaleG =  avg/wg;    float scaleB =  avg/wb;    for (i = 0; i < len; i+=4)    {        int r = rgb[RED];        int g = rgb[GREEN];        int b = rgb[BLUE];        float Rc =  r*scaleR;        float Gc =  g*scaleG;        float Bc =  b*scaleB;        rgb[RED]   = clamp(Rc);        rgb[GREEN] = clamp(Gc);        rgb[BLUE]  = clamp(Bc);    }    AndroidBitmap_unlockPixels(env, bitmap);}

JNIEXPORT void JNICALL Java_jp_dego_sample_ipcv_MainActivity_toGrayScale(JNIEnv *env, jobject obj, jobject bmp){    AndroidBitmapInfo info;    void* pixels;    int ret, i, j;    // Bitmapの情
C++ AndroidBitmap_unlockPixels函数代码示例
C++ AndroidBitmap_getInfo函数代码示例