void GpuManager::prepare(GpuDynamicTaskPtr ) {
UNIMPLEMENTED();
}
LIB_EXPORT int
jack_recompute_total_latency(jack_client_t* client, jack_port_t* port)
{
UNIMPLEMENTED();
return -1;
}
LIB_EXPORT void
jack_internal_client_close(const char* name)
{
UNIMPLEMENTED();
}
LIB_EXPORT jack_nframes_t
jack_port_get_latency(jack_port_t* port)
{
UNIMPLEMENTED();
return -1;
}
LIB_EXPORT int
jack_port_tie(jack_port_t* source, jack_port_t* dest)
{
UNIMPLEMENTED();
return -1;
}
std::string DisplayVk::getVendorString() const
{
UNIMPLEMENTED();
return std::string();
}
egl::Error DisplayVk::waitClient() const
{
UNIMPLEMENTED();
return egl::Error(EGL_BAD_ACCESS);
}
bool
DispatchTable::isEndOfChunk (FrameCnt, ModelPort port)
{
UNIMPLEMENTED ("determine when to finish a planning chunk");
}
JobTicket&
DispatchTable::accessJobTicket (ModelPort, TimeValue nominalTime)
{
UNIMPLEMENTED ("hook into the real implementation of the model backbone / segmentation");
}
EGLBoolean EGLAPIENTRY MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface draw = 0x%0.8p, EGLSurface read = 0x%0.8p, EGLContext ctx = 0x%0.8p)",
dpy, draw, read, ctx);
Display *display = static_cast<Display*>(dpy);
gl::Context *context = static_cast<gl::Context*>(ctx);
bool noContext = (ctx == EGL_NO_CONTEXT);
bool noSurface = (draw == EGL_NO_SURFACE || read == EGL_NO_SURFACE);
if (noContext != noSurface)
{
SetGlobalError(Error(EGL_BAD_MATCH));
return EGL_FALSE;
}
if (dpy == EGL_NO_DISPLAY)
{
SetGlobalError(Error(EGL_BAD_DISPLAY, "'dpy' not a valid EGLDisplay handle"));
return EGL_FALSE;
}
// EGL 1.5 spec: dpy can be uninitialized if all other parameters are null
if (!display->isInitialized() && (ctx != EGL_NO_CONTEXT || draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE))
{
SetGlobalError(Error(EGL_NOT_INITIALIZED, "'dpy' not initialized"));
return EGL_FALSE;
}
if (ctx != EGL_NO_CONTEXT)
{
Error error = ValidateContext(display, context);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
}
if (display->isInitialized())
{
if (display->testDeviceLost())
{
display->notifyDeviceLost();
return EGL_FALSE;
}
if (display->isDeviceLost())
{
SetGlobalError(Error(EGL_CONTEXT_LOST));
return EGL_FALSE;
}
}
Surface *drawSurface = static_cast<Surface*>(draw);
if (draw != EGL_NO_SURFACE)
{
Error error = ValidateSurface(display, drawSurface);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
}
Surface *readSurface = static_cast<Surface*>(read);
if (read != EGL_NO_SURFACE)
{
Error error = ValidateSurface(display, readSurface);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
}
if (readSurface)
{
Error readCompatError = ValidateCompatibleConfigs(readSurface->getConfig(), context->getConfig(), readSurface->getType());
if (readCompatError.isError())
{
SetGlobalError(readCompatError);
return EGL_FALSE;
}
}
if (draw != read)
{
UNIMPLEMENTED(); // FIXME
if (drawSurface)
{
Error drawCompatError = ValidateCompatibleConfigs(drawSurface->getConfig(), context->getConfig(), drawSurface->getType());
if (drawCompatError.isError())
{
SetGlobalError(drawCompatError);
return EGL_FALSE;
}
}
}
Error makeCurrentError = display->makeCurrent(drawSurface, readSurface, context);
if (makeCurrentError.isError())
{
SetGlobalError(makeCurrentError);
return EGL_FALSE;
}
gl::Context *previousContext = GetGlobalContext();
SetGlobalDisplay(display);
SetGlobalDrawSurface(drawSurface);
SetGlobalReadSurface(readSurface);
SetGlobalContext(context);
// Release the surface from the previously-current context, to allow
// destroyed surfaces to delete themselves.
if (previousContext != nullptr && context != previousContext)
{
previousContext->releaseSurface();
}
SetGlobalError(Error(EGL_SUCCESS));
return EGL_TRUE;
}
FrameCoord
DispatchTable::locateRelative (FrameCoord const&, FrameCnt frameOffset)
{
UNIMPLEMENTED ("real implementation of the core dispatch operation");
}
EGLBoolean EGLAPIENTRY QuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint attribute = %d, EGLint *value = 0x%0.8p)",
dpy, surface, attribute, value);
Display *display = static_cast<Display*>(dpy);
Surface *eglSurface = (Surface*)surface;
Error error = ValidateSurface(display, eglSurface);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
if (surface == EGL_NO_SURFACE)
{
SetGlobalError(Error(EGL_BAD_SURFACE));
return EGL_FALSE;
}
switch (attribute)
{
case EGL_VG_ALPHA_FORMAT:
UNIMPLEMENTED(); // FIXME
break;
case EGL_VG_COLORSPACE:
UNIMPLEMENTED(); // FIXME
break;
case EGL_CONFIG_ID:
*value = eglSurface->getConfig()->configID;
break;
case EGL_HEIGHT:
*value = eglSurface->getHeight();
break;
case EGL_HORIZONTAL_RESOLUTION:
UNIMPLEMENTED(); // FIXME
break;
case EGL_LARGEST_PBUFFER:
UNIMPLEMENTED(); // FIXME
break;
case EGL_MIPMAP_TEXTURE:
UNIMPLEMENTED(); // FIXME
break;
case EGL_MIPMAP_LEVEL:
UNIMPLEMENTED(); // FIXME
break;
case EGL_MULTISAMPLE_RESOLVE:
UNIMPLEMENTED(); // FIXME
break;
case EGL_PIXEL_ASPECT_RATIO:
*value = eglSurface->getPixelAspectRatio();
break;
case EGL_RENDER_BUFFER:
*value = eglSurface->getRenderBuffer();
break;
case EGL_SWAP_BEHAVIOR:
*value = eglSurface->getSwapBehavior();
break;
case EGL_TEXTURE_FORMAT:
*value = eglSurface->getTextureFormat();
break;
case EGL_TEXTURE_TARGET:
*value = eglSurface->getTextureTarget();
break;
case EGL_VERTICAL_RESOLUTION:
UNIMPLEMENTED(); // FIXME
break;
case EGL_WIDTH:
*value = eglSurface->getWidth();
break;
case EGL_POST_SUB_BUFFER_SUPPORTED_NV:
if (!display->getExtensions().postSubBuffer)
{
SetGlobalError(Error(EGL_BAD_ATTRIBUTE));
return EGL_FALSE;
}
*value = eglSurface->isPostSubBufferSupported();
break;
case EGL_FIXED_SIZE_ANGLE:
if (!display->getExtensions().windowFixedSize)
{
SetGlobalError(Error(EGL_BAD_ATTRIBUTE));
return EGL_FALSE;
}
*value = eglSurface->isFixedSize();
break;
default:
SetGlobalError(Error(EGL_BAD_ATTRIBUTE));
return EGL_FALSE;
}
SetGlobalError(Error(EGL_SUCCESS));
return EGL_TRUE;
}
bool GpuManager::copyout(GpuDynamicTaskPtr ) {
UNIMPLEMENTED();
return false;
}
void GpuManager::run(GpuDynamicTaskPtr ) {
UNIMPLEMENTED();
}
egl::Error DisplayVk::restoreLostDevice()
{
UNIMPLEMENTED();
return egl::Error(EGL_BAD_ACCESS);
}
gl::Version DisplayVk::getMaxSupportedESVersion() const
{
UNIMPLEMENTED();
return gl::Version(0, 0);
}
bool DisplayVk::isValidNativeWindow(EGLNativeWindowType window) const
{
UNIMPLEMENTED();
return bool();
}
void DisplayVk::generateExtensions(egl::DisplayExtensions *outExtensions) const
{
UNIMPLEMENTED();
}
egl::Error DisplayVk::getDevice(DeviceImpl **device)
{
UNIMPLEMENTED();
return egl::Error(EGL_BAD_ACCESS);
}
void DisplayVk::generateCaps(egl::Caps *outCaps) const
{
UNIMPLEMENTED();
}
LIB_EXPORT void
jack_port_set_latency(jack_port_t* port, jack_nframes_t frames)
{
UNIMPLEMENTED();
}
egl::Error DisplayVk::initialize(egl::Display *display)
{
UNIMPLEMENTED();
return egl::Error(EGL_BAD_ACCESS);
}
LIB_EXPORT jack_nframes_t
jack_port_get_total_latency(jack_client_t* client, jack_port_t* port)
{
UNIMPLEMENTED();
return -1;
}
void DisplayVk::terminate()
{
UNIMPLEMENTED();
}
LIB_EXPORT int
jack_port_untie(jack_port_t* port)
{
UNIMPLEMENTED();
return -1;
}
egl::ConfigSet DisplayVk::generateConfigs()
{
UNIMPLEMENTED();
return egl::ConfigSet();
}
LIB_EXPORT jack_client_t*
jack_client_new(const char* name)
{
UNIMPLEMENTED();
return NULL;
}
bool DisplayVk::testDeviceLost()
{
UNIMPLEMENTED();
return bool();
}
LIB_EXPORT int
jack_engine_takeover_timebase(jack_client_t* client)
{
UNIMPLEMENTED();
return -1;
}
void
SchedulerFrontend::disableTracing()
{
UNIMPLEMENTED ("tracing/diagnostics mode of the render engine");
///////////TODO ensure this is EX_FREE
}