Ejemplo n.º 1
0
  @Override
  public final void create(ProxySurface surface) {
    final String dbgPrefix;
    if (DEBUG) {
      dbgPrefix =
          getThreadName()
              + ": EGLUpstreamSurfaceHook.create( up "
              + upstreamSurface.getClass().getSimpleName()
              + " -> this "
              + surface.getClass().getSimpleName()
              + " ): ";
      System.err.println(dbgPrefix + this);
    } else {
      dbgPrefix = null;
    }

    if (upstreamSurface instanceof ProxySurface) {
      // propagate createNotify(..) so upstreamSurface will be created
      ((ProxySurface) upstreamSurface).createNotify();
    }

    // lock upstreamSurface, so it can be used in case EGLDisplay is derived from it!
    if (NativeSurface.LOCK_SURFACE_NOT_READY >= upstreamSurface.lockSurface()) {
      throw new GLException("Could not lock: " + upstreamSurface);
    }
    try {
      evalUpstreamSurface(dbgPrefix, surface);
    } finally {
      upstreamSurface.unlockSurface();
    }
  }
Ejemplo n.º 2
0
    @Override
    public synchronized void setVisibleActionPost(boolean visible, boolean nativeWindowCreated) {
      long t0;
      if (Window.DEBUG_IMPLEMENTATION) {
        t0 = System.nanoTime();
        System.err.println(
            "GLWindow.setVisibleActionPost("
                + visible
                + ", "
                + nativeWindowCreated
                + ") "
                + WindowImpl.getThreadName()
                + ", start");
      } else {
        t0 = 0;
      }

      if (null == drawable
          && visible
          && 0 != window.getWindowHandle()
          && 0 < getWidth() * getHeight()) {
        if ((null != context)) {
          throw new InternalError(
              "GLWindow.LifecycleHook.setVisiblePost: "
                  + WindowImpl.getThreadName()
                  + " - Null drawable, but valid context - "
                  + GLWindow.this);
        }
        final NativeSurface ns;
        {
          final NativeSurface wrapped_ns = window.getWrappedSurface();
          ns = null != wrapped_ns ? wrapped_ns : window;
        }
        final GLCapabilitiesImmutable glCaps =
            (GLCapabilitiesImmutable) ns.getGraphicsConfiguration().getChosenCapabilities();
        if (null == factory) {
          factory = GLDrawableFactory.getFactory(glCaps.getGLProfile());
        }
        drawable = (GLDrawableImpl) factory.createGLDrawable(ns);
        drawable.setRealized(true);

        if (!GLWindow.this.pushGLEventListenerState()) {
          context = (GLContextImpl) drawable.createContext(sharedContext);
          context.setContextCreationFlags(additionalCtxCreationFlags);
        }
      }
      if (Window.DEBUG_IMPLEMENTATION) {
        System.err.println(
            "GLWindow.setVisibleActionPost("
                + visible
                + ", "
                + nativeWindowCreated
                + ") "
                + WindowImpl.getThreadName()
                + ", fin: dt "
                + (System.nanoTime() - t0) / 1e6
                + "ms");
      }
    }
Ejemplo n.º 3
0
  @Override
  protected final GLDrawableImpl createOffscreenDrawableImpl(NativeSurface target) {
    if (target == null) {
      throw new IllegalArgumentException("Null target");
    }
    AbstractGraphicsConfiguration config = target.getGraphicsConfiguration();
    GLCapabilitiesImmutable caps = (GLCapabilitiesImmutable) config.getChosenCapabilities();
    if (!caps.isPBuffer()) {
      return new X11PixmapGLXDrawable(this, target);
    }

    // PBuffer GLDrawable Creation
    GLDrawableImpl pbufferDrawable;
    AbstractGraphicsDevice device = config.getScreen().getDevice();

    /**
     * Due to the ATI Bug https://bugzilla.mozilla.org/show_bug.cgi?id=486277, we need to have a
     * context current on the same Display to create a PBuffer. The dummy context shall also use the
     * same Display, since switching Display in this regard is another ATI bug.
     */
    SharedResource sr = (SharedResource) sharedResourceRunner.getOrCreateShared(device);
    if (null != sr && sr.isGLXVendorATI() && null == GLContext.getCurrent()) {
      sr.getContext().makeCurrent();
      try {
        pbufferDrawable = new X11PbufferGLXDrawable(this, target);
      } finally {
        sr.getContext().release();
      }
    } else {
      pbufferDrawable = new X11PbufferGLXDrawable(this, target);
    }
    return pbufferDrawable;
  }
Ejemplo n.º 4
0
 @Override
 public String toString() {
   final String us_s =
       null != upstreamSurface
           ? (upstreamSurface.getClass().getName()
               + ": 0x"
               + Long.toHexString(upstreamSurface.getSurfaceHandle()))
           : "nil";
   return "EGLUpstreamSurfaceHook[ "
       + upstreamSurface.getSurfaceWidth()
       + "x"
       + upstreamSurface.getSurfaceHeight()
       + ", "
       + us_s
       + "]";
 }
Ejemplo n.º 5
0
 @Override
 protected GLDrawableImpl createOffscreenDrawableImpl(NativeSurface target) {
   if (target == null) {
     throw new IllegalArgumentException("Null target");
   }
   AbstractGraphicsConfiguration config = target.getGraphicsConfiguration();
   GLCapabilitiesImmutable caps = (GLCapabilitiesImmutable) config.getChosenCapabilities();
   if (!caps.isPBuffer()) {
     throw new GLException("Non pbuffer not yet implemented");
   }
   // PBuffer GLDrawable Creation
   return new EGLPbufferDrawable(this, EGLWrappedSurface.get(target));
 }
Ejemplo n.º 6
0
  /**
   * Calls {@link #destroy()} directly if the following requirements are met:
   *
   * <ul>
   *   <li>An {@link GLAnimatorControl} is bound (see {@link #getAnimator()}) and running on another
   *       thread. Here we pause the animation while issuing the destruction.
   *   <li>Surface is not locked by another thread (considered anonymous).
   * </ul>
   *
   * <p>Otherwise destroy is being flagged to be called within the next call of display().
   *
   * <p>This method is being used to avoid deadlock if destruction is desired by <i>other</i>
   * threads, e.g. the window manager.
   *
   * @see #defaultWindowDestroyNotifyOp()
   * @see #defaultDisplay()
   */
  protected final void destroyAvoidAwareOfLocking() {
    final NativeSurface ns = getNativeSurface();

    final GLAnimatorControl ctrl = helper.getAnimator();

    // Is an animator thread perform rendering?
    if (helper.isAnimatorStartedOnOtherThread()) {
      // Pause animations before initiating safe destroy.
      final boolean isPaused = ctrl.pause();
      destroy();
      if (isPaused) {
        ctrl.resume();
      }
    } else if (null != ns && ns.isSurfaceLockedByOtherThread()) {
      // Surface is locked by another thread.
      // Flag that destroy should be performed on the next
      // attempt to display.
      sendDestroy = true; // async, but avoiding deadlock
    } else {
      // Without an external thread animating or locking the
      // surface, we are safe.
      destroy();
    }
  }
Ejemplo n.º 7
0
  private final void evalUpstreamSurface(String dbgPrefix, ProxySurface surface) {
    //
    // evaluate nature of upstreamSurface, may create EGL instances if required
    //

    boolean isEGLSurfaceValid = true; // assume yes

    final EGLGraphicsDevice eglDevice;
    final AbstractGraphicsConfiguration aConfig;
    {
      final AbstractGraphicsConfiguration surfaceConfig = surface.getGraphicsConfiguration();
      final AbstractGraphicsDevice surfaceDevice =
          null != surfaceConfig ? surfaceConfig.getScreen().getDevice() : null;
      if (DEBUG) {
        System.err.println(
            dbgPrefix
                + "SurfaceDevice: "
                + surfaceDevice.getClass().getSimpleName()
                + ", hash 0x"
                + Integer.toHexString(surfaceDevice.hashCode())
                + ", "
                + surfaceDevice);
        System.err.println(
            dbgPrefix
                + "SurfaceConfig: "
                + surfaceConfig.getClass().getSimpleName()
                + ", hash 0x"
                + Integer.toHexString(surfaceConfig.hashCode())
                + ", "
                + surfaceConfig);
      }

      final AbstractGraphicsConfiguration upstreamConfig =
          upstreamSurface.getGraphicsConfiguration();
      final AbstractGraphicsDevice upstreamDevice = upstreamConfig.getScreen().getDevice();
      if (DEBUG) {
        System.err.println(
            dbgPrefix
                + "UpstreamDevice: "
                + upstreamDevice.getClass().getSimpleName()
                + ", hash 0x"
                + Integer.toHexString(upstreamDevice.hashCode())
                + ", "
                + upstreamDevice);
        System.err.println(
            dbgPrefix
                + "UpstreamConfig: "
                + upstreamConfig.getClass().getSimpleName()
                + ", hash 0x"
                + Integer.toHexString(upstreamConfig.hashCode())
                + ", "
                + upstreamConfig);
      }

      if (surfaceDevice instanceof EGLGraphicsDevice) {
        eglDevice = (EGLGraphicsDevice) surfaceDevice;
        aConfig = surfaceConfig;
        if (DEBUG) {
          System.err.println(
              dbgPrefix
                  + "Reusing this eglDevice: "
                  + eglDevice
                  + ", using this config "
                  + aConfig.getClass().getSimpleName()
                  + " "
                  + aConfig);
        }
        if (EGL.EGL_NO_DISPLAY == eglDevice.getHandle()) {
          eglDevice.open();
          isEGLSurfaceValid = false;
          surface.addUpstreamOptionBits(ProxySurface.OPT_PROXY_OWNS_UPSTREAM_DEVICE);
        }
      } else if (upstreamDevice instanceof EGLGraphicsDevice) {
        eglDevice = (EGLGraphicsDevice) upstreamDevice;
        aConfig = upstreamConfig;
        if (DEBUG) {
          System.err.println(
              dbgPrefix
                  + "Reusing upstream eglDevice: "
                  + eglDevice
                  + ", using upstream config "
                  + aConfig.getClass().getSimpleName()
                  + " "
                  + aConfig);
        }
        if (EGL.EGL_NO_DISPLAY == eglDevice.getHandle()) {
          eglDevice.open();
          isEGLSurfaceValid = false;
          surface.addUpstreamOptionBits(ProxySurface.OPT_PROXY_OWNS_UPSTREAM_DEVICE);
        }
      } else {
        eglDevice = EGLDisplayUtil.eglCreateEGLGraphicsDevice(upstreamSurface);
        eglDevice.open();
        aConfig = upstreamConfig;
        isEGLSurfaceValid = false;
        surface.addUpstreamOptionBits(ProxySurface.OPT_PROXY_OWNS_UPSTREAM_DEVICE);
      }
    }

    final GLCapabilitiesImmutable capsRequested =
        (GLCapabilitiesImmutable) aConfig.getRequestedCapabilities();
    final EGLGraphicsConfiguration eglConfig;
    if (aConfig instanceof EGLGraphicsConfiguration) {
      // Config is already in EGL type - reuse ..
      final EGLGLCapabilities capsChosen = (EGLGLCapabilities) aConfig.getChosenCapabilities();
      if (!isEGLSurfaceValid
          || !EGLGraphicsConfiguration.isEGLConfigValid(
              eglDevice.getHandle(), capsChosen.getEGLConfig())) {
        // 'refresh' the native EGLConfig handle
        capsChosen.setEGLConfig(
            EGLGraphicsConfiguration.EGLConfigId2EGLConfig(
                eglDevice.getHandle(), capsChosen.getEGLConfigID()));
        if (0 == capsChosen.getEGLConfig()) {
          throw new GLException(
              "Refreshing native EGLConfig handle failed with error "
                  + EGLContext.toHexString(EGL.eglGetError())
                  + ": "
                  + eglDevice
                  + ", "
                  + capsChosen
                  + " of "
                  + aConfig);
        }
        final AbstractGraphicsScreen eglScreen =
            new DefaultGraphicsScreen(eglDevice, aConfig.getScreen().getIndex());
        eglConfig = new EGLGraphicsConfiguration(eglScreen, capsChosen, capsRequested, null);
        if (DEBUG) {
          System.err.println(dbgPrefix + "Refreshing eglConfig: " + eglConfig);
        }
        isEGLSurfaceValid = false;
      } else {
        eglConfig = (EGLGraphicsConfiguration) aConfig;
        if (DEBUG) {
          System.err.println(dbgPrefix + "Reusing eglConfig: " + eglConfig);
        }
      }
    } else {
      final AbstractGraphicsScreen eglScreen =
          new DefaultGraphicsScreen(eglDevice, aConfig.getScreen().getIndex());
      eglConfig =
          EGLGraphicsConfigurationFactory.chooseGraphicsConfigurationStatic(
              capsRequested,
              capsRequested,
              null,
              eglScreen,
              aConfig.getVisualID(VIDType.NATIVE),
              false /* forceTransparencyFlag */);

      if (null == eglConfig) {
        throw new GLException("Couldn't create EGLGraphicsConfiguration from " + eglScreen);
      } else if (DEBUG) {
        System.err.println(dbgPrefix + "Chosen eglConfig: " + eglConfig);
      }
      isEGLSurfaceValid = false;
    }
    surface.setGraphicsConfiguration(eglConfig);

    if (isEGLSurfaceValid) {
      isEGLSurfaceValid =
          EGLDrawable.isValidEGLSurface(eglDevice.getHandle(), upstreamSurface.getSurfaceHandle());
    }
    if (isEGLSurfaceValid) {
      surface.setSurfaceHandle(upstreamSurface.getSurfaceHandle());
      surface.clearUpstreamOptionBits(ProxySurface.OPT_PROXY_OWNS_UPSTREAM_SURFACE);
      if (DEBUG) {
        System.err.println(
            dbgPrefix + "Fin: Already valid EGL surface - use as-is: " + upstreamSurface);
      }
    } else {
      surface.setSurfaceHandle(EGL.EGL_NO_SURFACE);
      surface.addUpstreamOptionBits(
          ProxySurface.OPT_PROXY_OWNS_UPSTREAM_SURFACE); // create/destroy in EGLDrawable
      if (DEBUG) {
        System.err.println(dbgPrefix + "Fin: EGL surface n/a - TBD: " + upstreamSurface);
      }
    }
  }
Ejemplo n.º 8
0
 @Override
 public final int getSurfaceHeight(ProxySurface s) {
   return upstreamSurface.getSurfaceHeight();
 }
Ejemplo n.º 9
0
 @Override
 public final int getSurfaceWidth(ProxySurface s) {
   return upstreamSurface.getSurfaceWidth();
 }
Ejemplo n.º 10
0
  /**
   * Moves all GLEventListenerState components to the given {@link GLAutoDrawable} from this
   * instance, while loosing {@link #isOwner() ownership}.
   *
   * <p>If the previous {@link GLAutoDrawable} was removed from a {@link GLAnimatorControl} by
   * previous {@link #moveFrom(GLAutoDrawable)}, the given {@link GLAutoDrawable} is added to the
   * cached {@link GLAnimatorControl}. This operation is skipped, if the given {@link
   * GLAutoDrawable} is already added to a {@link GLAnimatorControl} instance.
   *
   * <p>Note: After this operation, the GLEventListenerState reference should be released.
   *
   * @param a {@link GLAutoDrawable} destination to move GLEventListenerState components to
   * @throws GLException if the {@link GLAutoDrawable}'s configuration is incompatible, i.e.
   *     different {@link GLCapabilitiesImmutable}.
   * @see #moveFrom(GLAutoDrawable)
   * @see #isOwner()
   */
  public final void moveTo(GLAutoDrawable a) {
    final List<GLRunnable> aGLCmds = new ArrayList<GLRunnable>();
    final int aSz = listenerCount();

    final NativeSurface aSurface = a.getNativeSurface();
    final MutableGraphicsConfiguration aCfg =
        (MutableGraphicsConfiguration) aSurface.getGraphicsConfiguration();
    final GLCapabilitiesImmutable aCaps = (GLCapabilitiesImmutable) aCfg.getChosenCapabilities();
    if (caps.getVisualID(VisualIDHolder.VIDType.INTRINSIC)
            != aCaps.getVisualID(VisualIDHolder.VIDType.INTRINSIC)
        || caps.getVisualID(VisualIDHolder.VIDType.NATIVE)
            != aCaps.getVisualID(VisualIDHolder.VIDType.NATIVE)) {
      throw new GLException(
          "Incompatible Capabilities - Prev-Holder: " + caps + ", New-Holder " + caps);
    }
    // Destroy and remove currently associated GLContext, if any (will be replaced)
    {
      final GLContext ctx = a.getContext();
      if (null != ctx) {
        ctx.destroy();
      }
      a.setContext(null);
    }
    final boolean aRealized = a.isRealized();
    if (aRealized) {
      a.setRealized(false);
    }
    // Set new Screen and close previous one
    {
      if (DEBUG) {
        System.err.println(
            "XX0 NativeSurface:              " + aSurface.getClass().getName() + ", " + aSurface);
      }
      final AbstractGraphicsScreen aScreen1 = aCfg.getScreen();
      aCfg.setScreen(screen);
      aScreen1.getDevice().close();
      System.err.println(
          "XXX NativeSurface:              " + aSurface.getClass().getName() + ", " + aSurface);
    }
    // If using a ProxySurface w/ an upstream surface, set new Screen and close previous one on it
    {
      boolean upstreamSet = false;
      if (aSurface instanceof ProxySurface) {
        final ProxySurface aProxy = (ProxySurface) aSurface;
        final NativeSurface aUpSurface = aProxy.getUpstreamSurface();
        if (null != aUpSurface) {
          final MutableGraphicsConfiguration aUpCfg =
              (MutableGraphicsConfiguration) aUpSurface.getGraphicsConfiguration();
          final AbstractGraphicsScreen aUpScreen1 = aUpCfg.getScreen();
          if (null != upstreamScreen) {
            System.err.println(
                "XX0 UpstreamSurface:            "
                    + aUpSurface.getClass().getName()
                    + ", "
                    + aUpSurface);
            aUpCfg.setScreen(upstreamScreen);
            aUpScreen1.getDevice().close();
            upstreamSet = true;
            System.err.println(
                "XXX UpstreamSurface:            "
                    + aUpSurface.getClass().getName()
                    + ", "
                    + aUpSurface);
          } else {
            throw new GLException(
                "Incompatible Surface config - Has Upstream-Surface: Prev-Holder = false, New-Holder = true");
          }
        }
      }
      if (!upstreamSet && null != upstreamScreen) {
        throw new GLException(
            "Incompatible Surface config - Has Upstream-Surface: Prev-Holder = true, New-Holder = false");
      }
    }

    if (aRealized) {
      a.setRealized(true);
    }
    final boolean surfaceLocked =
        false; // NativeSurface.LOCK_SURFACE_NOT_READY < aSurface.lockSurface();
    try {
      a.setContext(context);
    } finally {
      if (surfaceLocked) {
        aSurface.unlockSurface();
      }
    }
    owner = false;

    //
    // Trigger GL-Viewport reset and reshape of all initialized GLEventListeners
    //
    aGLCmds.add(setViewport);
    for (int i = 0; i < aSz; i++) {
      if (listenersInit[i]) {
        aGLCmds.add(new ReshapeGLEventListener(listeners[i]));
      }
    }
    aGLCmds.add(glFinish);
    a.invoke(aRealized, aGLCmds); // only wait if already realized

    // add all cached GLEventListener to their destination and fix their init-state
    for (int i = 0; i < aSz; i++) {
      final GLEventListener l = listeners[i];
      a.addGLEventListener(l);
      a.setGLEventListenerInitState(l, listenersInit[i]);
      listeners[i] = null;
    }

    if (null != anim && null == a.getAnimator()) {
      anim.add(a); // also handles ECT
    }
  }
Ejemplo n.º 11
0
  /**
   * Moves all GLEventListenerState components from the given {@link GLAutoDrawable} to a newly
   * created instance.
   *
   * <p>Note that all components are removed from the {@link GLAutoDrawable}, i.e. the {@link
   * GLContext}, all {@link GLEventListener}.
   *
   * <p>If the {@link GLAutoDrawable} was added to a {@link GLAnimatorControl}, it is removed and
   * the {@link GLAnimatorControl} added to the GLEventListenerState.
   *
   * <p>The returned GLEventListenerState instance is the {@link #isOwner() owner of the
   * components}.
   *
   * @param a {@link GLAutoDrawable} source to move components from
   * @return new GLEventListenerState instance {@link #isOwner() owning} moved components.
   * @see #moveTo(GLAutoDrawable)
   */
  public static GLEventListenerState moveFrom(GLAutoDrawable a) {
    final int aSz = a.getGLEventListenerCount();

    // Create new AbstractGraphicsScreen w/ cloned AbstractGraphicsDevice for future GLAutoDrawable
    // allowing this AbstractGraphicsDevice to loose ownership -> not closing display/device!
    final NativeSurface aSurface = a.getNativeSurface();
    final AbstractGraphicsConfiguration aCfg = aSurface.getGraphicsConfiguration();
    final AbstractGraphicsScreen aScreen1 = aCfg.getScreen();
    final GLCapabilitiesImmutable caps = (GLCapabilitiesImmutable) aCfg.getChosenCapabilities();
    final AbstractGraphicsScreen aScreen2 = cloneScreen(aScreen1);
    if (DEBUG) {
      System.err.println(
          "X00 NativeSurface:              " + aSurface.getClass().getName() + ", " + aSurface);
    }
    aScreen1.getDevice().clearHandleOwner(); // don't close device handle

    final AbstractGraphicsScreen aUpScreen2;
    {
      AbstractGraphicsScreen _aUpScreen2 = null;
      if (aSurface instanceof ProxySurface) {
        final ProxySurface aProxy = (ProxySurface) aSurface;
        final NativeSurface aUpSurface = aProxy.getUpstreamSurface();
        if (null != aUpSurface) {
          System.err.println(
              "X00 UpstreamSurface:            "
                  + aUpSurface.getClass().getName()
                  + ", "
                  + aUpSurface);
        }
        aProxy.clearUpstreamOptionBits(
            ProxySurface.OPT_PROXY_OWNS_UPSTREAM_DEVICE); // don't close device handle
        if (null != aUpSurface) {
          final AbstractGraphicsScreen aUpScreen1 =
              aUpSurface.getGraphicsConfiguration().getScreen();
          _aUpScreen2 = cloneScreen(aUpScreen1);
          if (null != aUpScreen1) {
            aUpScreen1.getDevice().clearHandleOwner(); // don't close device handle
          }
          System.err.println(
              "X0X NativeSurface:              " + aSurface.getClass().getName() + ", " + aSurface);
          System.err.println(
              "X0X UpstreamSurface:            "
                  + aUpSurface.getClass().getName()
                  + ", "
                  + aUpSurface);
        }
      }
      aUpScreen2 = _aUpScreen2;
    }

    final GLAnimatorControl aAnim = a.getAnimator();
    if (null != aAnim) {
      aAnim.remove(a); // also handles ECT
    }

    final GLEventListenerState glls =
        new GLEventListenerState(aUpScreen2, aScreen2, caps, a.getContext(), aSz, aAnim);

    //
    // remove and cache all GLEventListener and their init-state
    //
    for (int i = 0; i < aSz; i++) {
      final GLEventListener l = a.getGLEventListener(0);
      glls.listenersInit[i] = a.getGLEventListenerInitState(l);
      glls.listeners[i] = a.removeGLEventListener(l);
    }

    //
    // trigger glFinish to sync GL ctx
    //
    a.invoke(true, glFinish);

    a.setContext(null);

    return glls;
  }