@Override
    public void run() {
      Logger.debug("run()");
      try {
        hHook =
            USER32_INSTANCE.SetWindowsHookEx(
                WinUser.WH_MOUSE_LL,
                WindowsMouseHook.this,
                Kernel32.INSTANCE.GetModuleHandle(null),
                0);
        MSG msg = new MSG();
        while ((USER32_INSTANCE.GetMessage(msg, null, 0, 0)) != 0) {
          // This code is never reached
          USER32_INSTANCE.TranslateMessage(msg);
          USER32_INSTANCE.DispatchMessage(msg);
          if (getHook() == null) {
            break;
          }
        }
      } catch (Exception e) {
        Logger.error("Mouse hook failure", e);
      }

      Logger.debug("mouse hook runnable exits");
    }
 /**
  * Get the VLC installation directory.
  *
  * <p>If vlc is installed correctly, this should not be needed.
  *
  * @return fully-qualified directory name, or <code>null</code> if the value could not be obtained
  */
 public static String getVlcInstallDir() {
   Logger.debug("getVlcInstallDir()");
   try {
     return Advapi32Util.registryGetStringValue(
         WinReg.HKEY_LOCAL_MACHINE, VLC_REGISTRY_KEY, VLC_INSTALL_DIR_KEY);
   } catch (Exception e) {
     Logger.warn("Failed to get VLC installation directory from the registry", e);
     return null;
   }
 }
 public synchronized void release() {
   Logger.debug("release()");
   HHOOK hook = getHook();
   if (hook != null) {
     USER32_INSTANCE.UnhookWindowsHookEx(hHook);
     hook = null;
     // TODO ordinarily I'd interrupt the thread to force it to exit if it's
     // blocked, but in this case a fatal VM failure would occur
     // hookThread.interrupt();
   }
   Logger.debug("released");
 }
 /**
  * Create a new mouse hook.
  *
  * @param relativeTo component to report mouse coordinates relative to
  */
 public WindowsMouseHook(Component relativeTo) {
   Logger.debug("WindowsMouseHook(relativeTo={})", relativeTo);
   if (!Platform.isWindows()) {
     throw new IllegalStateException("Windows only");
   }
   this.relativeTo = relativeTo;
 }
  /**
   * Fire a mouse event to the registered listeners.
   *
   * @param eventType
   * @param button
   * @param lParam
   */
  private void fireMouseEvent(int eventType, int button, MSLLHOOKSTRUCT lParam) {
    Logger.trace("fireMouseEvent(eventType={},button={},lParam={})", eventType, button, lParam);
    MouseListener[] listeners = listenerList.getListeners(MouseListener.class);
    if (listeners.length > 0) {
      MouseEvent evt = createMouseEvent(eventType, button, lParam);
      for (int i = listeners.length - 1; i >= 0; i--) {
        switch (eventType) {
          case MouseEvent.MOUSE_PRESSED:
            listeners[i].mousePressed(evt);
            break;

          case MouseEvent.MOUSE_RELEASED:
            listeners[i].mouseReleased(evt);
            break;

          case MouseEvent.MOUSE_ENTERED:
            listeners[i].mouseEntered(evt);
            break;

          case MouseEvent.MOUSE_EXITED:
            listeners[i].mouseExited(evt);
            break;
        }
      }
    }
  }
Exemple #6
0
  public static void main(final String[] args) throws Exception {
    LibVlc libVlc = LibVlcFactory.factory().create();

    Logger.info("  version: {}", libVlc.libvlc_get_version());
    Logger.info(" compiler: {}", libVlc.libvlc_get_compiler());
    Logger.info("changeset: {}", libVlc.libvlc_get_changeset());

    setLookAndFeel();

    SwingUtilities.invokeLater(
        new Runnable() {
          @Override
          public void run() {
            new TestPlayer(args);
          }
        });
  }
 /** Start the hook. */
 public void start() {
   Logger.debug("start()");
   if (hookThread != null) {
     throw new IllegalStateException("Mouse hook already installed");
   }
   hookThread = new MouseHookThread();
   hookThread.start();
 }
Exemple #8
0
 /** @param enable */
 @SuppressWarnings("unused")
 private void enableMousePointer(boolean enable) {
   Logger.debug("enableMousePointer(enable={})", enable);
   if (enable) {
     videoSurface.setCursor(null);
   } else {
     Image blankImage = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);
     videoSurface.setCursor(
         Toolkit.getDefaultToolkit().createCustomCursor(blankImage, new Point(0, 0), ""));
   }
 }
 /**
  * Fire a mouse wheel event to the registered listeners.
  *
  * @param eventType
  * @param button
  * @param lParam
  */
 private void fireMouseWheelEvent(int eventType, MSLLHOOKSTRUCT lParam) {
   Logger.trace("fireMouseWheelEvent(eventType={},lParam={})", eventType, lParam);
   MouseWheelListener[] listeners = listenerList.getListeners(MouseWheelListener.class);
   if (listeners.length > 0) {
     MouseWheelEvent evt = createMouseWheelEvent(eventType, lParam);
     for (int i = listeners.length - 1; i >= 0; i--) {
       switch (eventType) {
         case MouseEvent.MOUSE_WHEEL:
           listeners[i].mouseWheelMoved(evt);
           break;
       }
     }
   }
 }
Exemple #10
0
 @Override
 public void playing(MediaPlayer mediaPlayer) {
   Logger.debug("playing(mediaPlayer={})", mediaPlayer);
   MediaDetails mediaDetails = mediaPlayer.getMediaDetails();
   Logger.info("mediaDetails={}", mediaDetails);
 }
 /** @param listener */
 public void removeMouseWheelListener(MouseWheelListener listener) {
   Logger.debug("removeMouseWheelListener(listener={})", listener);
   listenerList.remove(MouseWheelListener.class, listener);
 }
 /** @param listener */
 public void addMouseWheelListener(MouseWheelListener listener) {
   Logger.debug("addMouseWheelListener(listener={})", listener);
   listenerList.add(MouseWheelListener.class, listener);
 }
Exemple #13
0
 @Override
 public void stopped(MediaPlayer mediaPlayer) {
   Logger.debug("stopped(mediaPlayer={})", mediaPlayer);
 }
Exemple #14
0
    @Override
    public void videoOutput(MediaPlayer mediaPlayer, int newCount) {
      Logger.debug("videoOutput(mediaPlayer={},newCount={})", mediaPlayer, newCount);
      if (newCount == 0) {
        return;
      }

      MediaDetails mediaDetails = mediaPlayer.getMediaDetails();
      Logger.info("mediaDetails={}", mediaDetails);

      MediaMeta mediaMeta = mediaPlayer.getMediaMeta();
      Logger.info("mediaMeta={}", mediaMeta);

      final Dimension dimension = mediaPlayer.getVideoDimension();
      Logger.debug("dimension={}", dimension);
      if (dimension != null) {
        SwingUtilities.invokeLater(
            new Runnable() {
              @Override
              public void run() {
                videoSurface.setSize(dimension);
                mainFrame.pack();
              }
            });
      }

      // You can set a logo like this if you like...
      File logoFile = new File("./etc/vlcj-logo.png");
      if (logoFile.exists()) {
        mediaPlayer.setLogoFile(logoFile.getAbsolutePath());
        mediaPlayer.setLogoOpacity(0.5f);
        mediaPlayer.setLogoLocation(10, 10);
        mediaPlayer.enableLogo(true);
      }

      // Demo the marquee
      mediaPlayer.setMarqueeText("vlcj java bindings for vlc");
      mediaPlayer.setMarqueeSize(40);
      mediaPlayer.setMarqueeOpacity(95);
      mediaPlayer.setMarqueeColour(Color.white);
      mediaPlayer.setMarqueeTimeout(5000);
      mediaPlayer.setMarqueeLocation(50, 120);
      mediaPlayer.enableMarquee(true);

      // Not quite sure how crop geometry is supposed to work...
      //
      // Assertions in libvlc code:
      //
      // top + height must be less than visible height
      // left + width must be less than visible width
      //
      // With DVD source material:
      //
      // Reported size is 1024x576 - this is what libvlc reports when you call
      // get video size
      //
      // mpeg size is 720x576 - this is what is reported in the native log
      //
      // The crop geometry relates to the mpeg size, not the size reported
      // through the API
      //
      // For 720x576, attempting to set geometry to anything bigger than
      // 719x575 results in the assertion failures above (seems like it should
      // allow 720x576) to me

      // mediaPlayer.setCropGeometry("4:3");
    }
Exemple #15
0
 @Override
 public void mediaDurationChanged(MediaPlayer mediaPlayer, long newDuration) {
   Logger.debug("mediaDurationChanged(mediaPlayer={},newDuration={})", mediaPlayer, newDuration);
 }
Exemple #16
0
 @Override
 public void finished(MediaPlayer mediaPlayer) {
   Logger.debug("finished(mediaPlayer={})", mediaPlayer);
 }
Exemple #17
0
 @Override
 public void mouseWheelMoved(MouseWheelEvent e) {
   Logger.debug("mouseWheelMoved(e={})", e);
 }
Exemple #18
0
 @Override
 public void mediaChanged(MediaPlayer mediaPlayer, libvlc_media_t media, String mrl) {
   Logger.debug("mediaChanged(mediaPlayer={},media={},mrl={})", mediaPlayer, media, mrl);
 }
Exemple #19
0
 @Override
 public void error(MediaPlayer mediaPlayer) {
   Logger.debug("error(mediaPlayer={})", mediaPlayer);
 }
Exemple #20
0
 @Override
 public void mediaMetaChanged(MediaPlayer mediaPlayer, int metaType) {
   Logger.debug("mediaMetaChanged(mediaPlayer={},metaType={})", mediaPlayer, metaType);
 }
Exemple #21
0
 @Override
 public void mediaStateChanged(MediaPlayer mediaPlayer, int newState) {
   Logger.debug("mediaStateChanged(mediaPlayer={},newState={})", mediaPlayer, newState);
 }
Exemple #22
0
 @Override
 public void mediaFreed(MediaPlayer mediaPlayer) {
   Logger.debug("mediaFreed(mediaPlayer={})", mediaPlayer);
 }
Exemple #23
0
 @Override
 public void mediaParsedChanged(MediaPlayer mediaPlayer, int newStatus) {
   Logger.debug("mediaParsedChanged(mediaPlayer={},newStatus={})", mediaPlayer, newStatus);
 }
Exemple #24
0
 @Override
 public void paused(MediaPlayer mediaPlayer) {
   Logger.debug("paused(mediaPlayer={})", mediaPlayer);
 }
  @Override
  public LRESULT callback(int nCode, WPARAM wParam, MSLLHOOKSTRUCT lParam) {
    Logger.trace("callback(nCode={},wParam={},lParam={})", nCode, wParam, lParam);
    if (nCode >= 0) {
      Window window = SwingUtilities.getWindowAncestor(relativeTo);
      Logger.trace("window={}", window);
      // Is the window active...
      if (window != null && window.isActive()) {
        Logger.trace("window is active");
        // Is the component showing...
        // TODO is this still needed or is isActive good enough?
        if (relativeTo.isShowing() && relativeTo.isValid()) {
          Logger.trace("window is visible");
          // Did the event occur inside the component bounds...
          int absX = lParam.pt.x;
          int absY = lParam.pt.y;
          // FIXME there is a race here where relativeTo may no longer be visible, should
          // I lock the component tree - is that OK from non-EDT?
          Point componentPoint = relativeTo.getLocationOnScreen();
          int relX = componentPoint.x;
          int relY = componentPoint.y;
          int relW = relX + relativeTo.getWidth();
          int relH = relY + relativeTo.getHeight();
          if (absX >= relX && absY >= relY && absX < relW && absY < relH) {
            Logger.trace("event inside component bounds");
            if (!this.mouseEntered) {
              this.mouseEntered = true;
              fireMouseEvent(MouseEvent.MOUSE_ENTERED, MouseEvent.NOBUTTON, lParam);
            }
            // The event did occur inside the component bounds, so translate it...
            switch (wParam.intValue()) {
              case WM_MOUSEMOVE:
                fireMouseMotionEvent(MouseEvent.MOUSE_MOVED, MouseEvent.NOBUTTON, lParam);
                break;

              case WM_LBUTTONDOWN:
                fireMouseEvent(MouseEvent.MOUSE_PRESSED, MouseEvent.BUTTON1, lParam);
                break;

              case WM_LBUTTONUP:
                fireMouseEvent(MouseEvent.MOUSE_RELEASED, MouseEvent.BUTTON1, lParam);
                break;

              case WM_RBUTTONDOWN:
                fireMouseEvent(MouseEvent.MOUSE_PRESSED, MouseEvent.BUTTON2, lParam);
                break;

              case WM_RBUTTONUP:
                fireMouseEvent(MouseEvent.MOUSE_RELEASED, MouseEvent.BUTTON2, lParam);
                break;

              case WM_MBUTTONDOWN:
                fireMouseEvent(MouseEvent.MOUSE_PRESSED, MouseEvent.BUTTON3, lParam);
                break;

              case WM_MBUTTONUP:
                fireMouseEvent(MouseEvent.MOUSE_RELEASED, MouseEvent.BUTTON3, lParam);
                break;

              case WM_MOUSEWHEEL:
                fireMouseWheelEvent(MouseEvent.MOUSE_WHEEL, lParam);
                break;

              default:
                break;
            }
          } else {
            Logger.trace("event outside component bounds");

            if (this.mouseEntered) {
              this.mouseEntered = false;
              fireMouseEvent(MouseEvent.MOUSE_EXITED, MouseEvent.NOBUTTON, lParam);
            }
          }
        }
      }
    }
    return USER32_INSTANCE.CallNextHookEx(hHook, nCode, wParam, lParam.getPointer());
  }
Exemple #26
0
 @Override
 public void mouseExited(MouseEvent e) {
   Logger.debug("mouseExited(e={})", e);
 }
Exemple #27
0
 @Override
 public void keyTyped(KeyEvent e) {
   Logger.debug("keyTyped(e={})", e);
 }
Exemple #28
0
 @Override
 public void mediaSubItemAdded(MediaPlayer mediaPlayer, libvlc_media_t subItem) {
   Logger.debug("mediaSubItemAdded(mediaPlayer={},subItem={})", mediaPlayer, subItem);
 }
Exemple #29
0
 @Override
 public void mouseMoved(MouseEvent e) {
   Logger.trace("mouseMoved(e={})", e);
 }
Exemple #30
0
  public TestPlayer(String[] args) {
    if (RuntimeUtil.isWindows()) {
      // If running on Windows and you want the mouse/keyboard event hack...
      videoSurface = new WindowsCanvas();
    } else {
      videoSurface = new Canvas();
    }

    Logger.debug("videoSurface={}", videoSurface);

    videoSurface.setBackground(Color.black);
    videoSurface.setSize(800, 600); // Only for initial layout

    // Since we're mixing lightweight Swing components and heavyweight AWT
    // components this is probably a good idea
    JPopupMenu.setDefaultLightWeightPopupEnabled(false);

    TestPlayerMouseListener mouseListener = new TestPlayerMouseListener();
    videoSurface.addMouseListener(mouseListener);
    videoSurface.addMouseMotionListener(mouseListener);
    videoSurface.addMouseWheelListener(mouseListener);
    videoSurface.addKeyListener(new TestPlayerKeyListener());

    List<String> vlcArgs = new ArrayList<String>();

    vlcArgs.add("--no-plugins-cache");
    vlcArgs.add("--no-video-title-show");
    vlcArgs.add("--no-snapshot-preview");
    vlcArgs.add("--quiet");
    vlcArgs.add("--quiet-synchro");
    vlcArgs.add("--intf");
    vlcArgs.add("dummy");

    // Special case to help out users on Windows (supposedly this is not actually needed)...
    // if(RuntimeUtil.isWindows()) {
    // vlcArgs.add("--plugin-path=" + WindowsRuntimeUtil.getVlcInstallDir() + "\\plugins");
    // }
    // else {
    // vlcArgs.add("--plugin-path=/home/linux/vlc/lib");
    // }

    // vlcArgs.add("--plugin-path=" + System.getProperty("user.home") + "/.vlcj");

    Logger.debug("vlcArgs={}", vlcArgs);

    mainFrame = new JFrame("VLCJ Test Player");
    mainFrame.setIconImage(
        new ImageIcon(getClass().getResource("/icons/vlcj-logo.png")).getImage());

    FullScreenStrategy fullScreenStrategy = new DefaultFullScreenStrategy(mainFrame);

    mediaPlayerFactory = new MediaPlayerFactory(vlcArgs.toArray(new String[vlcArgs.size()]));
    mediaPlayerFactory.setUserAgent("vlcj test player");

    List<AudioOutput> audioOutputs = mediaPlayerFactory.getAudioOutputs();
    Logger.debug("audioOutputs={}", audioOutputs);

    mediaPlayer = mediaPlayerFactory.newEmbeddedMediaPlayer(fullScreenStrategy);
    mediaPlayer.setVideoSurface(mediaPlayerFactory.newVideoSurface(videoSurface));
    mediaPlayer.setPlaySubItems(true);

    mediaPlayer.setEnableKeyInputHandling(false);
    mediaPlayer.setEnableMouseInputHandling(false);

    controlsPanel = new PlayerControlsPanel(mediaPlayer);
    videoAdjustPanel = new PlayerVideoAdjustPanel(mediaPlayer);

    mainFrame.setLayout(new BorderLayout());
    mainFrame.setBackground(Color.black);
    mainFrame.add(videoSurface, BorderLayout.CENTER);
    mainFrame.add(controlsPanel, BorderLayout.SOUTH);
    mainFrame.add(videoAdjustPanel, BorderLayout.EAST);
    mainFrame.setJMenuBar(buildMenuBar());
    mainFrame.pack();
    mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    mainFrame.addWindowListener(
        new WindowAdapter() {
          @Override
          public void windowClosing(WindowEvent evt) {
            Logger.debug("windowClosing(evt={})", evt);

            if (videoSurface instanceof WindowsCanvas) {
              ((WindowsCanvas) videoSurface).release();
            }

            if (mediaPlayer != null) {
              mediaPlayer.release();
              mediaPlayer = null;
            }

            if (mediaPlayerFactory != null) {
              mediaPlayerFactory.release();
              mediaPlayerFactory = null;
            }
          }
        });

    // Global AWT key handler, you're better off using Swing's InputMap and
    // ActionMap with a JFrame - that would solve all sorts of focus issues too
    Toolkit.getDefaultToolkit()
        .addAWTEventListener(
            new AWTEventListener() {
              @Override
              public void eventDispatched(AWTEvent event) {
                if (event instanceof KeyEvent) {
                  KeyEvent keyEvent = (KeyEvent) event;
                  if (keyEvent.getID() == KeyEvent.KEY_PRESSED) {
                    if (keyEvent.getKeyCode() == KeyEvent.VK_F12) {
                      controlsPanel.setVisible(!controlsPanel.isVisible());
                      videoAdjustPanel.setVisible(!videoAdjustPanel.isVisible());
                      mainFrame.getJMenuBar().setVisible(!mainFrame.getJMenuBar().isVisible());
                      mainFrame.invalidate();
                      mainFrame.validate();
                    } else if (keyEvent.getKeyCode() == KeyEvent.VK_A) {
                      mediaPlayer.setAudioDelay(mediaPlayer.getAudioDelay() - 50000);
                    } else if (keyEvent.getKeyCode() == KeyEvent.VK_S) {
                      mediaPlayer.setAudioDelay(mediaPlayer.getAudioDelay() + 50000);
                    }
                    // else if(keyEvent.getKeyCode() == KeyEvent.VK_N) {
                    // mediaPlayer.nextFrame();
                    // }
                    else if (keyEvent.getKeyCode() == KeyEvent.VK_1) {
                      mediaPlayer.setTime(60000 * 1);
                    } else if (keyEvent.getKeyCode() == KeyEvent.VK_2) {
                      mediaPlayer.setTime(60000 * 2);
                    } else if (keyEvent.getKeyCode() == KeyEvent.VK_3) {
                      mediaPlayer.setTime(60000 * 3);
                    } else if (keyEvent.getKeyCode() == KeyEvent.VK_4) {
                      mediaPlayer.setTime(60000 * 4);
                    } else if (keyEvent.getKeyCode() == KeyEvent.VK_5) {
                      mediaPlayer.setTime(60000 * 5);
                    } else if (keyEvent.getKeyCode() == KeyEvent.VK_6) {
                      mediaPlayer.setTime(60000 * 6);
                    } else if (keyEvent.getKeyCode() == KeyEvent.VK_7) {
                      mediaPlayer.setTime(60000 * 7);
                    } else if (keyEvent.getKeyCode() == KeyEvent.VK_8) {
                      mediaPlayer.setTime(60000 * 8);
                    } else if (keyEvent.getKeyCode() == KeyEvent.VK_9) {
                      mediaPlayer.setTime(60000 * 9);
                    }
                  }
                }
              }
            },
            AWTEvent.KEY_EVENT_MASK);

    mainFrame.setVisible(true);

    mediaPlayer.addMediaPlayerEventListener(new TestPlayerMediaPlayerEventListener());

    // Won't work with OpenJDK or JDK1.7, requires a Sun/Oracle JVM (currently)
    boolean transparentWindowsSupport = true;
    try {
      Class.forName("com.sun.awt.AWTUtilities");
    } catch (Exception e) {
      transparentWindowsSupport = false;
    }

    Logger.debug("transparentWindowsSupport={}", transparentWindowsSupport);

    if (transparentWindowsSupport) {
      final Window test =
          new Window(null, WindowUtils.getAlphaCompatibleGraphicsConfiguration()) {
            private static final long serialVersionUID = 1L;

            @Override
            public void paint(Graphics g) {
              Graphics2D g2 = (Graphics2D) g;

              g2.setRenderingHint(
                  RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
              g2.setRenderingHint(
                  RenderingHints.KEY_TEXT_ANTIALIASING,
                  RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB);

              g.setColor(Color.white);
              g.fillRoundRect(100, 150, 100, 100, 32, 32);

              g.setFont(new Font("Sans", Font.BOLD, 32));
              g.drawString("Heavyweight overlay test", 100, 300);
            }
          };

      AWTUtilities.setWindowOpaque(test, false); // Doesn't work in full-screen exclusive
      // mode, you would have to use 'simulated'
      // full-screen - requires Sun/Oracle JDK
      test.setBackground(new Color(0, 0, 0, 0)); // This is what you do in JDK7

      // mediaPlayer.setOverlay(test);
      // mediaPlayer.enableOverlay(true);
    }

    // This might be useful
    // enableMousePointer(false);
  }