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

// Sets new native window for creating EGLSurface.void gl_ThreadSetWindow(ANativeWindow* window) {	// We accept new window only when rendering	// thread is active. Otherwise we can't promise	// it gets released as expected.	if (!gl_ThreadRunning()) {		ANativeWindow_release(window);		return;	}	// Acquire thread lock.	gl_ThreadLock();	// If we have new nativeWin.	if (GLOBALS.window != window) {		// If there is old one, release it first.		if (GLOBALS.window) {			ANativeWindow_release(GLOBALS.window);		}		// Store new nativeWin and mark it changed.		GLOBALS.window = window;		GLOBALS.windowChanged = GL_THREAD_TRUE;		// Set window size to zero and mark it changed.		GLOBALS.windowWidth = GLOBALS.windowHeight = 0;		GLOBALS.windowSizeChanged = GL_THREAD_TRUE;	}	// Else if window != NULL.	else if (window) {		// Release window instantly.		ANativeWindow_release(window);	}	// Release thread lock.	gl_ThreadUnlock();}

int UVCPreview::stopPreview() {	ENTER();	bool b = isRunning();	if (LIKELY(b)) {		mIsRunning = false;		pthread_cond_signal(&preview_sync);		pthread_cond_signal(&capture_sync);		if (pthread_join(capture_thread, NULL) != EXIT_SUCCESS) {			LOGW("UVCPreview::terminate capture thread: pthread_join failed");		}		if (pthread_join(preview_thread, NULL) != EXIT_SUCCESS) {			LOGW("UVCPreview::terminate preview thread: pthread_join failed");		}		clearDisplay();	}	clearPreviewFrame();	clearCaptureFrame();	pthread_mutex_lock(&preview_mutex);	if (mPreviewWindow) {		ANativeWindow_release(mPreviewWindow);		mPreviewWindow = NULL;	}	pthread_mutex_unlock(&preview_mutex);	pthread_mutex_lock(&capture_mutex);	if (mCaptureWindow) {		ANativeWindow_release(mCaptureWindow);		mCaptureWindow = NULL;	}	pthread_mutex_unlock(&capture_mutex);	RETURN(0, int);}

void gl_ThreadDestroy() {	// If there's thread running.	if (GLOBALS.threadCreated) {		// Mark exit flag.		GLOBALS.threadExit = GL_THREAD_TRUE;		// Notify thread.		pthread_cond_signal(&GLOBALS.cond);		// Wait until thread has exited.		pthread_join(GLOBALS.thread, NULL);		// If there are pending mutex locks let		// them execute before destroying it.		// This is needed because otherwise		// pthread_mutex_destroy will fail.		pthread_mutex_lock(&GLOBALS.mutex);		while (GLOBALS.mutexCounter > 0) {			pthread_cond_wait(&GLOBALS.cond, &GLOBALS.mutex);		}		pthread_mutex_unlock(&GLOBALS.mutex);		// Release all GLOBALS data.		pthread_cond_destroy(&GLOBALS.cond);		pthread_mutex_destroy(&GLOBALS.mutex);		// If we're holding a window release it.		if (GLOBALS.window) {			ANativeWindow_release(GLOBALS.window);		}		memset(&GLOBALS, 0, sizeof GLOBALS);	}}

// This function must be called after// decoding is finishedvoid nv_avc_destroy(void) {	if (decoder_ctx) {		avcodec_close(decoder_ctx);		av_free(decoder_ctx);		decoder_ctx = NULL;	}	if (scaler_ctx) {		sws_freeContext(scaler_ctx);		scaler_ctx = NULL;	}	if (dec_frame) {		av_frame_free(&dec_frame);		dec_frame = NULL;	}	if (yuv_frame) {		av_frame_free(&yuv_frame);		yuv_frame = NULL;	}	if (rgb_frame) {		av_frame_free(&rgb_frame);		rgb_frame = NULL;	}	if (rgb_frame_buf) {		av_free(rgb_frame_buf);		rgb_frame_buf = NULL;	}#ifdef __ANDROID_API__	if (window) {		ANativeWindow_release(window);		window = NULL;	}#endif	pthread_mutex_destroy(&mutex);}

static void SDL_VoutAndroid_SetNativeWindow_l(SDL_Vout *vout, ANativeWindow *native_window){    AMCTRACE("%s(%p, %p)/n", __func__, vout, native_window);    SDL_Vout_Opaque *opaque = vout->opaque;    if (opaque->native_window == native_window) {        if (native_window == NULL) {            // always invalidate buffers, if native_window is changed            SDL_VoutAndroid_invalidateAllBuffers_l(vout);        }        return;    } else    IJK_EGL_terminate(opaque->egl);    SDL_VoutAndroid_invalidateAllBuffers_l(vout);    if (opaque->native_window)        ANativeWindow_release(opaque->native_window);    if (native_window)        ANativeWindow_acquire(native_window);    opaque->native_window = native_window;    opaque->null_native_window_warned = 0;}

static pj_status_t deinit_opengl(void * data){    struct andgl_stream *stream = (struct andgl_stream *)data;    if (stream->gl_buf) {        pjmedia_vid_dev_opengl_destroy_buffers(stream->gl_buf);        stream->gl_buf = NULL;    }    if (stream->display != EGL_NO_DISPLAY) {        eglMakeCurrent(stream->display, EGL_NO_SURFACE, EGL_NO_SURFACE,                       EGL_NO_CONTEXT);        if (stream->context != EGL_NO_CONTEXT)            eglDestroyContext(stream->display, stream->context);        if (stream->surface != EGL_NO_SURFACE)            eglDestroySurface(stream->display, stream->surface);        eglTerminate(stream->display);    }        if (stream->window) {        ANativeWindow_release(stream->window);        stream->window = NULL;    }        stream->display = EGL_NO_DISPLAY;    stream->surface = EGL_NO_SURFACE;    stream->context = EGL_NO_CONTEXT;        return PJ_SUCCESS;}

	void Java_com_test_surfaceview_TestNative_Destroye(JNIEnv* env,jobject obj)	{		ANativeWindow_release(g_nativeWindow);		g_nWidth = 0;		g_nHeight = 0;		g_nativeWindow = NULL;	}

/* * Class:     com_mcxiaoke_ndk_Native * Method:    initNW * Signature: (JLandroid/view/Surface;)V */JNIEXPORT void JNICALL Java_com_mcxiaoke_ndk_Native_initNW(JNIEnv *env, jclass clazz, jlong avi, jobject surface){    // Get the native window from the surface    ANativeWindow* nativeWindow = ANativeWindow_fromSurface(                                      env, surface);    if (0 == nativeWindow)    {        ThrowException(env, "java/lang/RuntimeException",                       "Unable to get native window from surface.");        goto exit;    }    // Set the buffers geometry to AVI movie frame dimensions    // If these are different than the window's physical size    // then the buffer will be scaled to match that size.    if (0 > ANativeWindow_setBuffersGeometry(nativeWindow,            AVI_video_width((avi_t*) avi),            AVI_video_height((avi_t*) avi),            WINDOW_FORMAT_RGB_565))    {        ThrowException(env, "java/lang/RuntimeException",                       "Unable to set buffers geometry.");    }    // Release the native window    ANativeWindow_release(nativeWindow);    nativeWindow = 0;exit:    return;}

void SwViewport::DrawToWindow(){    VERBOSE("Releasing native window");    Surface.reset();    ANativeWindow_unlockAndPost(NativeWindow);    ANativeWindow_release(NativeWindow);}

voidAndroid_DestroyWindow(_THIS, SDL_Window * window){    SDL_WindowData *data;        if (window == Android_Window) {        Android_Window = NULL;        if (Android_PauseSem) SDL_DestroySemaphore(Android_PauseSem);        if (Android_ResumeSem) SDL_DestroySemaphore(Android_ResumeSem);        Android_PauseSem = NULL;        Android_ResumeSem = NULL;                if(window->driverdata) {            data = (SDL_WindowData *) window->driverdata;            if (data->egl_surface != EGL_NO_SURFACE) {                SDL_EGL_DestroySurface(_this, data->egl_surface);            }            if (data->native_window) {                ANativeWindow_release(data->native_window);            }            SDL_free(window->driverdata);            window->driverdata = NULL;        }    }}

static voidcom_stainberg_MediaPlayer_MediaPlayer_setSurface(JNIEnv* env, jobject thiz, jobject surface) {//	if(surface != NULL) {//		if(spWindow != NULL) {//			ANativeWindow_release(spWindow);//			spWindow = NULL;//		}//		spWindow = ANativeWindow_fromSurface(env, surface);//		if(spMediaPlayer != NULL) {//			spMediaPlayer->initSurface(spWindow);//		}//	}	if(spWindow != NULL) {		ANativeWindow_release(spWindow);		spWindow = NULL;	}	if(spMediaPlayer != NULL) {		spMediaPlayer->initSurface(NULL);	}	if(surface != NULL) {		spWindow = ANativeWindow_fromSurface(env, surface);		if(spMediaPlayer != NULL) {			spMediaPlayer->initSurface(spWindow);		}	}}

NDKCamera::~NDKCamera() {  valid_ = false;  // stop session if it is on:  if (captureSessionState_ == CaptureSessionState::ACTIVE) {    ACameraCaptureSession_stopRepeating(captureSession_);  }  ACameraCaptureSession_close(captureSession_);  for (auto& req : requests_) {    CALL_REQUEST(removeTarget(req.request_, req.target_));    ACaptureRequest_free(req.request_);    ACameraOutputTarget_free(req.target_);    CALL_CONTAINER(remove(outputContainer_, req.sessionOutput_));    ACaptureSessionOutput_free(req.sessionOutput_);    ANativeWindow_release(req.outputNativeWindow_);  }  requests_.resize(0);  ACaptureSessionOutputContainer_free(outputContainer_);  for (auto& cam : cameras_) {    if (cam.second.device_) {      CALL_DEV(close(cam.second.device_));    }  }  cameras_.clear();  if (cameraMgr_) {    CALL_MGR(unregisterAvailabilityCallback(cameraMgr_, GetManagerListener()));    ACameraManager_delete(cameraMgr_);    cameraMgr_ = nullptr;  }}

//renderingJNIEXPORT void JNICALL Java_me_lake_librestreaming_core_ColorHelper_renderingSurface(JNIEnv * env, jobject thiz,jobject javaSurface,jbyteArray pixelsArray,jint w,jint h,jint size) {	ANativeWindow* window = ANativeWindow_fromSurface(env, javaSurface);	if(window!=NULL)	{		ANativeWindow_setBuffersGeometry(window,w,h,COLOR_FORMAT_NV21);		ANativeWindow_Buffer buffer;		if (ANativeWindow_lock(window, &buffer, NULL) == 0) {			unsigned char *pixels = (unsigned char*)(*env)->GetByteArrayElements(env,pixelsArray, 0);			if(buffer.width==buffer.stride){				memcpy(buffer.bits, pixels,  size);			}else{				int height = h*3/2;				int width = w;				int i=0;				for(;i<height;++i)					memcpy(buffer.bits +  buffer.stride * i						, pixels + width * i						, width);			}			(*env)->ReleaseByteArrayElements(env,pixelsArray,pixels,JNI_ABORT);			ANativeWindow_unlockAndPost(window);		}		ANativeWindow_release(window);	}	return;}

void DeleteMCDec(GF_BaseDecoder *ifcg){    MCDec *ctx = (MCDec *)ifcg->privateStack;    if(ctx->format && AMediaFormat_delete(ctx->format) != AMEDIA_OK){         GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC,("AMediaFormat_delete failed"));    }       if(ctx->codec && AMediaCodec_delete(ctx->codec) != AMEDIA_OK) {         GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC,("AMediaCodec_delete failed"));    }        if(ctx->window) {		ANativeWindow_release(ctx->window);		ctx->window = NULL;    }	    gf_free(ctx);    gf_free(ifcg);		MCDec_DelParamList(ctx->SPSs);	ctx->SPSs = NULL;	MCDec_DelParamList(ctx->PPSs);	ctx->PPSs = NULL;}

static void func_free_l(SDL_Vout *vout){    if (!vout)        return;    SDL_Vout_Opaque *opaque = vout->opaque;    if (opaque) {        SDL_AMediaCodecBufferProxy **begin = (SDL_AMediaCodecBufferProxy **)ISDL_Array__begin(&opaque->overlay_manager);        SDL_AMediaCodecBufferProxy **end   = (SDL_AMediaCodecBufferProxy **)ISDL_Array__end(&opaque->overlay_manager);        for (; begin < end; ++begin) {            SDL_AMediaCodecBufferProxy_destroyP(begin);        }        ISDL_Array__clear(&opaque->overlay_pool);        ISDL_Array__clear(&opaque->overlay_manager);        if (opaque->native_window) {            ANativeWindow_release(opaque->native_window);            opaque->native_window = NULL;        }        IJK_EGL_freep(&opaque->egl);        SDL_AMediaCodec_decreaseReferenceP(&opaque->acodec);    }    SDL_Vout_FreeInternal(vout);}

bool CEGLNativeTypeAndroid::GetNativeResolution(RESOLUTION_INFO *res) const{  EGLNativeWindowType *nativeWindow = (EGLNativeWindowType*)CXBMCApp::GetNativeWindow(30000);  if (!nativeWindow)    return false;  if (!m_width || !m_height)  {    ANativeWindow_acquire(*nativeWindow);    res->iWidth = ANativeWindow_getWidth(*nativeWindow);    res->iHeight= ANativeWindow_getHeight(*nativeWindow);    ANativeWindow_release(*nativeWindow);  }  else  {    res->iWidth = m_width;    res->iHeight = m_height;  }  res->fRefreshRate = currentRefreshRate();  res->dwFlags= D3DPRESENTFLAG_PROGRESSIVE;  res->iScreen       = 0;  res->bFullScreen   = true;  res->iSubtitles    = (int)(0.965 * res->iHeight);  res->fPixelRatio   = 1.0f;  res->iScreenWidth  = res->iWidth;  res->iScreenHeight = res->iHeight;  res->strMode       = StringUtils::Format("%dx%d @ %.2f%s - Full Screen", res->iScreenWidth, res->iScreenHeight, res->fRefreshRate,  res->dwFlags & D3DPRESENTFLAG_INTERLACED ? "i" : "");  CLog::Log(LOGNOTICE,"Current resolution: %s/n",res->strMode.c_str());  return true;}

	JNIEXPORT void JNICALL nativeSetSurface(JNIEnv* jenv, jobject obj, jobject surface) {		if(surface != 0) {			nativeWindow = ANativeWindow_fromSurface(jenv, surface);		} else {			ANativeWindow_release(nativeWindow);		}		return;	}

extern void GetPlatformWindowDimensions(void* nativeHandle, int* width, int* height){    ANativeWindow* w = ANativeWindow_fromSurface(Jni, (jobject)nativeHandle);    VERBOSE("Got native window for measurements %p", w);    *width = ANativeWindow_getWidth(w);    *height = ANativeWindow_getHeight(w);    ANativeWindow_release(w);}

//-----------------------------------------------------------------------------OsWindow::~OsWindow(){	if (m_window)	{		ANativeWindow_release(m_window);	}}

static void Run(JNIEnv* env, const std::vector<std::string>& paths, bool first_open,                std::optional<std::string> savestate_path = {}, bool delete_savestate = false){  ASSERT(!paths.empty());  __android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Running : %s", paths[0].c_str());  RegisterMsgAlertHandler(&MsgAlert);  Common::AndroidSetReportHandler(&ReportSend);  DolphinAnalytics::AndroidSetGetValFunc(&GetAnalyticValue);  std::unique_lock<std::mutex> guard(s_host_identity_lock);  UICommon::Init();  if (first_open)  {    DolphinAnalytics::Instance()->ReportDolphinStart(GetAnalyticValue("DEVICE_TYPE"));  }  WiimoteReal::InitAdapterClass();  // No use running the loop when booting fails  s_have_wm_user_stop = false;  std::unique_ptr<BootParameters> boot = BootParameters::GenerateFromFile(paths, savestate_path);  boot->delete_savestate = delete_savestate;  WindowSystemInfo wsi(WindowSystemType::Android, nullptr, s_surf);  wsi.render_surface_scale = GetRenderSurfaceScale(env);  if (BootManager::BootCore(std::move(boot), wsi))  {    ButtonManager::Init(SConfig::GetInstance().GetGameID());    static constexpr int TIMEOUT = 10000;    static constexpr int WAIT_STEP = 25;    int time_waited = 0;    // A Core::CORE_ERROR state would be helpful here.    while (!Core::IsRunning() && time_waited < TIMEOUT && !s_have_wm_user_stop)    {      std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_STEP));      time_waited += WAIT_STEP;    }    while (Core::IsRunning())    {      guard.unlock();      s_update_main_frame_event.Wait();      guard.lock();      Core::HostDispatchJobs();    }  }  Core::Shutdown();  ButtonManager::Shutdown();  UICommon::Shutdown();  guard.unlock();  if (s_surf)  {    ANativeWindow_release(s_surf);    s_surf = nullptr;  }}

intAndroid_CreateWindow(_THIS, SDL_Window * window){    SDL_WindowData *data;        if (Android_Window) {        return SDL_SetError("Android only supports one window");    }        Android_PauseSem = SDL_CreateSemaphore(0);    Android_ResumeSem = SDL_CreateSemaphore(0);    /* Adjust the window data to match the screen */    window->x = 0;    window->y = 0;    window->w = Android_ScreenWidth;    window->h = Android_ScreenHeight;    window->flags &= ~SDL_WINDOW_RESIZABLE;     /* window is NEVER resizeable */    window->flags |= SDL_WINDOW_FULLSCREEN;     /* window is always fullscreen */    window->flags &= ~SDL_WINDOW_HIDDEN;    window->flags |= SDL_WINDOW_SHOWN;          /* only one window on Android */    window->flags |= SDL_WINDOW_INPUT_FOCUS;    /* always has input focus */    /* One window, it always has focus */    SDL_SetMouseFocus(window);    SDL_SetKeyboardFocus(window);        data = (SDL_WindowData *) SDL_calloc(1, sizeof(*data));    if (!data) {        return SDL_OutOfMemory();    }        data->native_window = Android_JNI_GetNativeWindow();        if (!data->native_window) {        SDL_free(data);        return SDL_SetError("Could not fetch native window");    }    /* Do not create EGLSurface for Vulkan window since it will then make the window       incompatible with vkCreateAndroidSurfaceKHR */    if ((window->flags & SDL_WINDOW_VULKAN) == 0) {        data->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) data->native_window);        if (data->egl_surface == EGL_NO_SURFACE) {            ANativeWindow_release(data->native_window);            SDL_free(data);            return SDL_SetError("Could not create GLES window surface");        }    }    window->driverdata = data;    Android_Window = window;        return 0;}

void AndroidEGLGraphicsContext::Shutdown() {	delete draw_;	draw_ = nullptr;	NativeShutdownGraphics();	gl->ClearCurrent();	gl->Shutdown();	delete gl;	ANativeWindow_release(wnd_);	finalize_glslang();}

void naSetSurface(JNIEnv *pEnv, jobject pObj, jobject pSurface) {	if (0 != pSurface) {		// get the native window reference		window = ANativeWindow_fromSurface(pEnv, pSurface);		// set format and size of window buffer		ANativeWindow_setBuffersGeometry(window, 0, 0, WINDOW_FORMAT_RGBA_8888);	} else {		// release the native window		ANativeWindow_release(window);	}}

// set the surfacevoid Java_com_example_nativecodec_NativeCodec_setSurface(JNIEnv *env, jclass clazz, jobject surface){   // obtain a native window from a Java surface   if (data.window)   {      ANativeWindow_release(data.window);      data.window = NULL;   }   data.window = ANativeWindow_fromSurface(env, surface);   LOGV("@@@ setsurface %p", data.window);}

 /*  * Class:     com_ericsson_lispmediaplayer_Player  * Method:    playerDestroy  * Signature: ()I  */ JNIEXPORT jint JNICALL Java_com_ericsson_lispmediaplayer_Player_playerDestroy (JNIEnv *env, jobject object) {          int ret = Player_Destory();     if (theNativeWindow != NULL)     {         ANativeWindow_release(theNativeWindow);         theNativeWindow = NULL;     }     return ret; }

void Java_com_oculus_vrappframework_VrApp_nativeSurfaceDestroyed( JNIEnv *jni, jclass clazz,		jlong appPtr, jobject surface ){	LOG( "%p nativeSurfaceDestroyed()", (void *)appPtr );	OVR::AppLocal * appLocal = (OVR::AppLocal *)appPtr;	appLocal->GetMessageQueue().SendPrintf( "surfaceDestroyed " );	LOG( "    ANativeWindow_release( %p )", appLocal->pendingNativeWindow );	ANativeWindow_release( appLocal->pendingNativeWindow );	appLocal->pendingNativeWindow = NULL;}

JNIEXPORT void JNICALL Java_com_orcchg_openglsample_NativeInterface_setSurface  (JNIEnv *jenv, jobject, jlong descriptor, jobject surface) {  NativeInterface* ptr = (NativeInterface*) descriptor;  if (surface == nullptr) {    ANativeWindow_release(ptr->window);    ptr->window = nullptr;  } else {    ptr->window = ANativeWindow_fromSurface(jenv, surface);    ptr->render->setSurface(ptr->window);    ptr->render->draw();  }}

status_t Surface_close(void* window){	LOGI("Surface_close() %p", window);	ANativeWindow *native_window = (ANativeWindow *)window;	if (native_window) {		ANativeWindow_release(native_window);		native_window = NULL;	}	return OK;}