Exemple #1
0
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;
}
Exemple #13
0
bool GpuManager::copyout(GpuDynamicTaskPtr ) {
  UNIMPLEMENTED();
  return false;
}
Exemple #14
0
void GpuManager::run(GpuDynamicTaskPtr ) {
  UNIMPLEMENTED();
}
Exemple #15
0
egl::Error DisplayVk::restoreLostDevice()
{
    UNIMPLEMENTED();
    return egl::Error(EGL_BAD_ACCESS);
}
Exemple #16
0
gl::Version DisplayVk::getMaxSupportedESVersion() const
{
    UNIMPLEMENTED();
    return gl::Version(0, 0);
}
Exemple #17
0
bool DisplayVk::isValidNativeWindow(EGLNativeWindowType window) const
{
    UNIMPLEMENTED();
    return bool();
}
Exemple #18
0
void DisplayVk::generateExtensions(egl::DisplayExtensions *outExtensions) const
{
    UNIMPLEMENTED();
}
Exemple #19
0
egl::Error DisplayVk::getDevice(DeviceImpl **device)
{
    UNIMPLEMENTED();
    return egl::Error(EGL_BAD_ACCESS);
}
Exemple #20
0
void DisplayVk::generateCaps(egl::Caps *outCaps) const
{
    UNIMPLEMENTED();
}
LIB_EXPORT void
jack_port_set_latency(jack_port_t* port, jack_nframes_t frames)
{
	UNIMPLEMENTED();
}
Exemple #22
0
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;
}
Exemple #24
0
void DisplayVk::terminate()
{
    UNIMPLEMENTED();
}
LIB_EXPORT int
jack_port_untie(jack_port_t* port)
{
	UNIMPLEMENTED();
	return -1;
}
Exemple #26
0
egl::ConfigSet DisplayVk::generateConfigs()
{
    UNIMPLEMENTED();
    return egl::ConfigSet();
}
LIB_EXPORT jack_client_t*
jack_client_new(const char* name)
{
	UNIMPLEMENTED();
	return NULL;
}
Exemple #28
0
bool DisplayVk::testDeviceLost()
{
    UNIMPLEMENTED();
    return bool();
}
LIB_EXPORT int
jack_engine_takeover_timebase(jack_client_t* client)
{
	UNIMPLEMENTED();
	return -1;
}
Exemple #30
0
 void
 SchedulerFrontend::disableTracing()
 {
   UNIMPLEMENTED ("tracing/diagnostics mode of the render engine");
   ///////////TODO ensure this is EX_FREE
 }