void
glFBDevDestroyContext( GLFBDevContextPtr context )
{
GLFBDevContextPtr fbdevctx = glFBDevGetCurrentContext();
if (context) {
GLcontext *mesaCtx = &context->glcontext;
_swsetup_DestroyContext( mesaCtx );
_swrast_DestroyContext( mesaCtx );
_tnl_DestroyContext( mesaCtx );
_vbo_DestroyContext( mesaCtx );
if (fbdevctx == context) {
/* destroying current context */
_mesa_make_current(NULL, NULL, NULL);
}
_mesa_free_context_data(&context->glcontext);
free(context);
}
}
/**
* Destroy an Off-Screen Mesa rendering context.
*
* \param osmesa the context to destroy
*/
GLAPI void GLAPIENTRY
OSMesaDestroyContext( OSMesaContext osmesa )
{
if (osmesa) {
if (osmesa->srb)
_mesa_reference_renderbuffer((struct gl_renderbuffer **) &osmesa->srb, NULL);
_mesa_meta_free( &osmesa->mesa );
_swsetup_DestroyContext( &osmesa->mesa );
_tnl_DestroyContext( &osmesa->mesa );
_vbo_DestroyContext( &osmesa->mesa );
_swrast_DestroyContext( &osmesa->mesa );
_mesa_destroy_visual( osmesa->gl_visual );
_mesa_reference_framebuffer( &osmesa->gl_buffer, NULL );
_mesa_free_context_data( &osmesa->mesa );
free( osmesa );
}
}
BOOL sw_DeleteContext(DHGLRC dhglrc)
{
struct sw_context* sw_ctx = (struct sw_context*)dhglrc;
/* Those get clobbered by _mesa_free_context_data via _glapi_set{context,dispath_table} */
void* icd_save = IntGetCurrentICDPrivate();
const GLDISPATCHTABLE* table_save = IntGetCurrentDispatchTable();
/* Destroy everything */
_mesa_meta_free( &sw_ctx->mesa );
_swsetup_DestroyContext( &sw_ctx->mesa );
_tnl_DestroyContext( &sw_ctx->mesa );
_vbo_DestroyContext( &sw_ctx->mesa );
_swrast_DestroyContext( &sw_ctx->mesa );
_mesa_free_context_data( &sw_ctx->mesa );
free( sw_ctx );
/* Restore this */
IntSetCurrentDispatchTable(table_save);
IntSetCurrentICDPrivate(icd_save);
return TRUE;
}
GLboolean
_swrast_CreateContext( struct gl_context *ctx )
{
GLuint i;
SWcontext *swrast = calloc(1, sizeof(SWcontext));
#ifdef _OPENMP
const GLuint maxThreads = omp_get_max_threads();
#else
const GLuint maxThreads = 1;
#endif
assert(ctx->Const.MaxViewportWidth <= SWRAST_MAX_WIDTH);
assert(ctx->Const.MaxViewportHeight <= SWRAST_MAX_WIDTH);
assert(ctx->Const.MaxRenderbufferSize <= SWRAST_MAX_WIDTH);
/* make sure largest texture image is <= SWRAST_MAX_WIDTH in size */
assert((1 << (ctx->Const.MaxTextureLevels - 1)) <= SWRAST_MAX_WIDTH);
assert((1 << (ctx->Const.MaxCubeTextureLevels - 1)) <= SWRAST_MAX_WIDTH);
assert((1 << (ctx->Const.Max3DTextureLevels - 1)) <= SWRAST_MAX_WIDTH);
assert(PROG_MAX_WIDTH == SWRAST_MAX_WIDTH);
if (SWRAST_DEBUG) {
_mesa_debug(ctx, "_swrast_CreateContext\n");
}
if (!swrast)
return GL_FALSE;
swrast->NewState = ~0;
swrast->choose_point = _swrast_choose_point;
swrast->choose_line = _swrast_choose_line;
swrast->choose_triangle = _swrast_choose_triangle;
swrast->InvalidatePointMask = _SWRAST_NEW_POINT;
swrast->InvalidateLineMask = _SWRAST_NEW_LINE;
swrast->InvalidateTriangleMask = _SWRAST_NEW_TRIANGLE;
swrast->Point = _swrast_validate_point;
swrast->Line = _swrast_validate_line;
swrast->Triangle = _swrast_validate_triangle;
swrast->InvalidateState = _swrast_sleep;
swrast->BlendFunc = _swrast_validate_blend_func;
swrast->AllowVertexFog = GL_TRUE;
swrast->AllowPixelFog = GL_TRUE;
swrast->Driver.SpanRenderStart = _swrast_span_render_start;
swrast->Driver.SpanRenderFinish = _swrast_span_render_finish;
for (i = 0; i < ARRAY_SIZE(swrast->TextureSample); i++)
swrast->TextureSample[i] = NULL;
/* SpanArrays is global and shared by all SWspan instances. However, when
* using multiple threads, it is necessary to have one SpanArrays instance
* per thread.
*/
swrast->SpanArrays = malloc(maxThreads * sizeof(SWspanarrays));
if (!swrast->SpanArrays) {
free(swrast);
return GL_FALSE;
}
for(i = 0; i < maxThreads; i++) {
swrast->SpanArrays[i].ChanType = CHAN_TYPE;
#if CHAN_TYPE == GL_UNSIGNED_BYTE
swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].rgba8;
#elif CHAN_TYPE == GL_UNSIGNED_SHORT
swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].rgba16;
#else
swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].attribs[VARYING_SLOT_COL0];
#endif
}
/* init point span buffer */
swrast->PointSpan.primitive = GL_POINT;
swrast->PointSpan.end = 0;
swrast->PointSpan.facing = 0;
swrast->PointSpan.array = swrast->SpanArrays;
init_program_native_limits(&ctx->Const.Program[MESA_SHADER_VERTEX]);
init_program_native_limits(&ctx->Const.Program[MESA_SHADER_GEOMETRY]);
init_program_native_limits(&ctx->Const.Program[MESA_SHADER_FRAGMENT]);
ctx->swrast_context = swrast;
swrast->stencil_temp.buf1 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
swrast->stencil_temp.buf2 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
swrast->stencil_temp.buf3 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
swrast->stencil_temp.buf4 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
if (!swrast->stencil_temp.buf1 ||
!swrast->stencil_temp.buf2 ||
!swrast->stencil_temp.buf3 ||
!swrast->stencil_temp.buf4) {
_swrast_DestroyContext(ctx);
return GL_FALSE;
}
return GL_TRUE;
}
/* Destroy the Mesa and driver specific context data.
*/
void r200DestroyContext( __DRIcontextPrivate *driContextPriv )
{
GET_CURRENT_CONTEXT(ctx);
r200ContextPtr rmesa = (r200ContextPtr) driContextPriv->driverPrivate;
r200ContextPtr current = ctx ? R200_CONTEXT(ctx) : NULL;
/* check if we're deleting the currently bound context */
if (rmesa == current) {
R200_FIREVERTICES( rmesa );
_mesa_make_current(NULL, NULL, NULL);
}
/* Free r200 context resources */
assert(rmesa); /* should never be null */
if ( rmesa ) {
GLboolean release_texture_heaps;
release_texture_heaps = (rmesa->glCtx->Shared->RefCount == 1);
_swsetup_DestroyContext( rmesa->glCtx );
_tnl_DestroyContext( rmesa->glCtx );
_vbo_DestroyContext( rmesa->glCtx );
_swrast_DestroyContext( rmesa->glCtx );
r200DestroySwtcl( rmesa->glCtx );
r200ReleaseArrays( rmesa->glCtx, ~0 );
if (rmesa->dma.current.buf) {
r200ReleaseDmaRegion( rmesa, &rmesa->dma.current, __FUNCTION__ );
r200FlushCmdBuf( rmesa, __FUNCTION__ );
}
if (rmesa->state.scissor.pClipRects) {
FREE(rmesa->state.scissor.pClipRects);
rmesa->state.scissor.pClipRects = NULL;
}
if ( release_texture_heaps ) {
/* This share group is about to go away, free our private
* texture object data.
*/
int i;
for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
driDestroyTextureHeap( rmesa->texture_heaps[ i ] );
rmesa->texture_heaps[ i ] = NULL;
}
assert( is_empty_list( & rmesa->swapped ) );
}
/* free the Mesa context */
rmesa->glCtx->DriverCtx = NULL;
_mesa_destroy_context( rmesa->glCtx );
/* free the option cache */
driDestroyOptionCache (&rmesa->optionCache);
FREE( rmesa );
}
}
/* Destroy the Mesa and driver specific context data.
*/
void radeonDestroyContext( __DRIcontextPrivate *driContextPriv )
{
GET_CURRENT_CONTEXT(ctx);
radeonContextPtr rmesa = (radeonContextPtr) driContextPriv->driverPrivate;
radeonContextPtr current = ctx ? RADEON_CONTEXT(ctx) : NULL;
/* check if we're deleting the currently bound context */
if (rmesa == current) {
RADEON_FIREVERTICES( rmesa );
_mesa_make_current2(NULL, NULL, NULL);
}
/* Free radeon context resources */
assert(rmesa); /* should never be null */
if ( rmesa ) {
GLboolean release_texture_heaps;
release_texture_heaps = (rmesa->glCtx->Shared->RefCount == 1);
_swsetup_DestroyContext( rmesa->glCtx );
_tnl_DestroyContext( rmesa->glCtx );
_ac_DestroyContext( rmesa->glCtx );
_swrast_DestroyContext( rmesa->glCtx );
radeonDestroySwtcl( rmesa->glCtx );
radeonReleaseArrays( rmesa->glCtx, ~0 );
if (rmesa->dma.current.buf) {
radeonReleaseDmaRegion( rmesa, &rmesa->dma.current, __FUNCTION__ );
radeonFlushCmdBuf( rmesa, __FUNCTION__ );
}
if (!rmesa->TclFallback & RADEON_TCL_FALLBACK_TCL_DISABLE)
if (!getenv("RADEON_NO_VTXFMT"))
radeonVtxfmtDestroy( rmesa->glCtx );
/* free the Mesa context */
rmesa->glCtx->DriverCtx = NULL;
_mesa_destroy_context( rmesa->glCtx );
if (rmesa->state.scissor.pClipRects) {
FREE(rmesa->state.scissor.pClipRects);
rmesa->state.scissor.pClipRects = 0;
}
if ( release_texture_heaps ) {
/* This share group is about to go away, free our private
* texture object data.
*/
int i;
for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
driDestroyTextureHeap( rmesa->texture_heaps[ i ] );
rmesa->texture_heaps[ i ] = NULL;
}
assert( is_empty_list( & rmesa->swapped ) );
}
FREE( rmesa );
}
}
void
intelDestroyContext(__DRIcontext * driContextPriv)
{
struct brw_context *brw =
(struct brw_context *) driContextPriv->driverPrivate;
struct gl_context *ctx = &brw->ctx;
assert(brw); /* should never be null */
if (!brw)
return;
/* Dump a final BMP in case the application doesn't call SwapBuffers */
if (INTEL_DEBUG & DEBUG_AUB) {
intel_batchbuffer_flush(brw);
aub_dump_bmp(&brw->ctx);
}
_mesa_meta_free(&brw->ctx);
if (INTEL_DEBUG & DEBUG_SHADER_TIME) {
/* Force a report. */
brw->shader_time.report_time = 0;
brw_collect_and_report_shader_time(brw);
brw_destroy_shader_time(brw);
}
brw_destroy_state(brw);
brw_draw_destroy(brw);
drm_intel_bo_unreference(brw->curbe.curbe_bo);
drm_intel_bo_unreference(brw->vs.base.const_bo);
drm_intel_bo_unreference(brw->wm.base.const_bo);
free(brw->curbe.last_buf);
free(brw->curbe.next_buf);
drm_intel_gem_context_destroy(brw->hw_ctx);
if (ctx->swrast_context) {
_swsetup_DestroyContext(&brw->ctx);
_tnl_DestroyContext(&brw->ctx);
}
_vbo_DestroyContext(&brw->ctx);
if (ctx->swrast_context)
_swrast_DestroyContext(&brw->ctx);
intel_batchbuffer_free(brw);
drm_intel_bo_unreference(brw->first_post_swapbuffers_batch);
brw->first_post_swapbuffers_batch = NULL;
driDestroyOptionCache(&brw->optionCache);
/* free the Mesa context */
_mesa_free_context_data(&brw->ctx);
ralloc_free(brw);
driContextPriv->driverPrivate = NULL;
}