if (surf->SwapInterval != interval) {
if (drv->SwapInterval)
- ret = drv->SwapInterval(drv, disp, surf, interval);
+ ret = drv->SwapInterval(disp, surf, interval);
else
- ret = _eglSwapInterval(drv, disp, surf, interval);
+ ret = _eglSwapInterval(disp, surf, interval);
}
else {
ret = EGL_TRUE;
if (surf->Lost)
RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_WINDOW, EGL_FALSE);
- ret = drv->SwapBuffers(drv, disp, surf);
+ ret = drv->SwapBuffers(disp, surf);
/* EGL_KHR_partial_update
* Frame boundary successfully reached,
if ((n_rects > 0 && rects == NULL) || n_rects < 0)
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
- ret = drv->SwapBuffersWithDamageEXT(drv, disp, surf, rects, n_rects);
+ ret = drv->SwapBuffersWithDamageEXT(disp, surf, rects, n_rects);
/* EGL_KHR_partial_update
* Frame boundary successfully reached,
RETURN_EGL_ERROR(disp, EGL_BAD_ACCESS, EGL_FALSE);
_eglSetDamageRegionKHRClampRects(disp, surf, rects, n_rects);
- ret = drv->SetDamageRegion(drv, disp, surf, rects, n_rects);
+ ret = drv->SetDamageRegion(disp, surf, rects, n_rects);
if (ret)
surf->SetDamageRegionCalled = EGL_TRUE;
native_pixmap_ptr = (void*) target;
_EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
- ret = drv->CopyBuffers(drv, disp, surf, native_pixmap_ptr);
+ ret = drv->CopyBuffers(disp, surf, native_pixmap_ptr);
RETURN_EGL_EVAL(disp, ret);
}
{
_EGLContext *ctx = _eglGetCurrentContext();
_EGLDisplay *disp;
- const _EGLDriver *drv;
EGLBoolean ret;
if (!ctx)
/* a valid current context implies an initialized current display */
assert(disp->Initialized);
- drv = disp->Driver;
- ret = drv->WaitClient(drv, disp, ctx);
+ ret = disp->Driver->WaitClient(disp, ctx);
RETURN_EGL_EVAL(disp, ret);
}
{
_EGLContext *ctx = _eglGetCurrentContext();
_EGLDisplay *disp;
- const _EGLDriver *drv;
EGLBoolean ret;
if (!ctx)
/* a valid current context implies an initialized current display */
assert(disp->Initialized);
- drv = disp->Driver;
- ret = drv->WaitNative(drv, disp, engine);
+ ret = disp->Driver->WaitNative(engine);
RETURN_EGL_EVAL(disp, ret);
}
if (ctx != EGL_NO_CONTEXT && target == EGL_LINUX_DMA_BUF_EXT)
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
- img = drv->CreateImageKHR(drv, disp, context, target,
- buffer, attr_list);
+ img = drv->CreateImageKHR(disp, context, target, buffer, attr_list);
ret = (img) ? _eglLinkImage(img) : EGL_NO_IMAGE_KHR;
RETURN_EGL_EVAL(disp, ret);
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
_eglUnlinkImage(img);
- ret = drv->DestroyImageKHR(drv, disp, img);
+ ret = drv->DestroyImageKHR(disp, img);
RETURN_EGL_EVAL(disp, ret);
}
RETURN_EGL_ERROR(disp, invalid_type_error, EGL_NO_SYNC_KHR);
}
- sync = drv->CreateSyncKHR(drv, disp, type, attrib_list);
+ sync = drv->CreateSyncKHR(disp, type, attrib_list);
ret = (sync) ? _eglLinkSync(sync) : EGL_NO_SYNC_KHR;
RETURN_EGL_EVAL(disp, ret);
disp->Extensions.ANDROID_native_fence_sync);
_eglUnlinkSync(s);
- ret = drv->DestroySyncKHR(drv, disp, s);
+ ret = drv->DestroySyncKHR(disp, s);
RETURN_EGL_EVAL(disp, ret);
}
if (s->Type == EGL_SYNC_REUSABLE_KHR)
_eglUnlockDisplay(dpy);
- ret = drv->ClientWaitSyncKHR(drv, disp, s, flags, timeout);
+ ret = drv->ClientWaitSyncKHR(disp, s, flags, timeout);
/*
* 'disp' is already unlocked for reusable sync type,
if (flags != 0)
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
- ret = drv->WaitSyncKHR(drv, disp, s);
+ ret = drv->WaitSyncKHR(disp, s);
RETURN_EGL_EVAL(disp, ret);
}
_EGL_CHECK_SYNC(disp, s, EGL_FALSE, drv);
assert(disp->Extensions.KHR_reusable_sync);
- ret = drv->SignalSyncKHR(drv, disp, s, mode);
+ ret = drv->SignalSyncKHR(disp, s, mode);
RETURN_EGL_EVAL(disp, ret);
}
_EGL_CHECK_SYNC(disp, s, EGL_NO_NATIVE_FENCE_FD_ANDROID, drv);
assert(disp->Extensions.ANDROID_native_fence_sync);
- ret = drv->DupNativeFenceFDANDROID(drv, disp, s);
+ ret = drv->DupNativeFenceFDANDROID(disp, s);
RETURN_EGL_EVAL(disp, ret);
}
surf != ctx->DrawSurface)
RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
- ret = drv->SwapBuffersRegionNOK(drv, disp, surf, numRects, rects);
+ ret = drv->SwapBuffersRegionNOK(disp, surf, numRects, rects);
RETURN_EGL_EVAL(disp, ret);
}
if (!disp->Extensions.MESA_drm_image)
RETURN_EGL_EVAL(disp, EGL_NO_IMAGE_KHR);
- img = drv->CreateDRMImageMESA(drv, disp, attr_list);
+ img = drv->CreateDRMImageMESA(disp, attr_list);
ret = (img) ? _eglLinkImage(img) : EGL_NO_IMAGE_KHR;
RETURN_EGL_EVAL(disp, ret);
if (!img)
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
- ret = drv->ExportDRMImageMESA(drv, disp, img, name, handle, stride);
+ ret = drv->ExportDRMImageMESA(disp, img, name, handle, stride);
RETURN_EGL_EVAL(disp, ret);
}
if (!display)
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
- ret = drv->BindWaylandDisplayWL(drv, disp, display);
+ ret = drv->BindWaylandDisplayWL(disp, display);
RETURN_EGL_EVAL(disp, ret);
}
if (!display)
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
- ret = drv->UnbindWaylandDisplayWL(drv, disp, display);
+ ret = drv->UnbindWaylandDisplayWL(disp, display);
RETURN_EGL_EVAL(disp, ret);
}
if (!buffer)
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
- ret = drv->QueryWaylandBufferWL(drv, disp, buffer, attribute, value);
+ ret = drv->QueryWaylandBufferWL(disp, buffer, attribute, value);
RETURN_EGL_EVAL(disp, ret);
}
if (!img)
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, NULL);
- ret = drv->CreateWaylandBufferFromImageWL(drv, disp, img);
+ ret = drv->CreateWaylandBufferFromImageWL(disp, img);
RETURN_EGL_EVAL(disp, ret);
}
if (!disp->Extensions.NV_post_sub_buffer)
RETURN_EGL_EVAL(disp, EGL_FALSE);
- ret = drv->PostSubBufferNV(drv, disp, surf, x, y, width, height);
+ ret = drv->PostSubBufferNV(disp, surf, x, y, width, height);
RETURN_EGL_EVAL(disp, ret);
}
if (!img)
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
- ret = drv->ExportDMABUFImageQueryMESA(drv, disp, img, fourcc, nplanes,
- modifiers);
+ ret = drv->ExportDMABUFImageQueryMESA(disp, img, fourcc, nplanes, modifiers);
RETURN_EGL_EVAL(disp, ret);
}
if (!img)
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
- ret = drv->ExportDMABUFImageMESA(drv, disp, img, fds, strides, offsets);
+ ret = drv->ExportDMABUFImageMESA(disp, img, fds, strides, offsets);
RETURN_EGL_EVAL(disp, ret);
}