Hey guys,

While trying to create a screenshot from a JMF MediaPlayer, I ran into
the following problem: If the Player has been started once, even if it's
 stopped later, any screenshots taken from it show just a black
rectangle.
I've tried both
"java.awt.Robot#createScreenCapture(Player.getVisualComponent().getBounds());"
and
"Player.getVisualComponent().paint(java.awt.image.BufferedImage#createGraphics());"
, but the only frame I've managed to capture is the one initially visible.
Has anyone ran into similiar problems with the JMF? Is there a solution
or a work-around for this?

Here's a program demonstrating the problem:

<SSCCE(?)>

import java.awt.Frame;
import java.awt.Button;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.BorderLayout;
import java.awt.image.BufferedImage;
import java.awt.Robot;
import java.awt.AWTException;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import javax.imageio.ImageIO;
import java.io.File;
import javax.media.bean.playerbean.MediaPlayer;

public class VideoCaptureDemo {

  /**
   * Can probably be any MPEG or AVI video.
   * All files I used to test the program caused the same problem.
   * */
  private static final String VID_FILE = "file:H:mortalfighter.mpg";

  /**
   * Screenshots go to this dir.
   * */
  private static final String TARGET_DIR = "h:\\test\\";

  private Frame appFrame;
  private MediaPlayer vid = new MediaPlayer();
  private Button testButton;
  private Robot screenCapturer;
  private int capturesCreated;

  public VideoCaptureDemo() {
    capturesCreated = 0;
  }

  /**
   * Test harness
   * @param args not used
   * */

  public static void main(String[] args) {
    VideoCaptureDemo theDemo = new VideoCaptureDemo();
    theDemo.initGUI();
  }

  /**
   * Populate appFrame and set it visible.
   * */

  private void initGUI() {
    appFrame = new Frame("Pixel Grabbing Test");
    testButton = new Button("Press to test");
    testButton.addActionListener(new TestButtonListener());
    appFrame.setLayout(new BorderLayout());
    appFrame.addWindowListener(new TestFrameListener());
    appFrame.add(vid,BorderLayout.CENTER);
    appFrame.add(testButton, BorderLayout.SOUTH);
    appFrame.pack();
    appFrame.setExtendedState(Frame.MAXIMIZED_BOTH);
    vid.setVisible(true);
    appFrame.validate();
    appFrame.setVisible(true);
    vid.setControlPanelVisible(true);
    vid.setMediaLocation(VID_FILE);

    vid.prefetch();
    vid.setVisible(true);
    vid.setIgnoreRepaint(false);
    appFrame.repaint();
    try {
      screenCapturer = new Robot();
    }
    catch (AWTException ex) {
      ex.printStackTrace();
      System.exit(1);
    }
  }

  private class TestButtonListener implements ActionListener {
    /**
     * Simplified response to button click, validity checks etc.
     * omitted.
     *
     * @param e ActionEvent detected
     */
    public void actionPerformed(ActionEvent e) {

      try {
        if(screenCapturer == null){}
        else{
            boolean isPlaying;
            int vidMode = vid.getState();
            if(vidMode==vid.Started){
              isPlaying = true;
            }
            else{
              isPlaying = false;
            }
            vid.prefetch();
            vid.stop();
            vid.repaint();
            vid.getVisualComponent().repaint();
            BufferedImage screenImage =
screenCapturer.createScreenCapture(vid.getVisualComponent().getBounds());

            if(isPlaying){
              vid.start();
            }
            else{}
            ImageIO.write(screenImage, "jpeg",
new File(TARGET_DIR+"vid"+Integer.toString(capturesCreated)+".jpg"));

            capturesCreated++;
        }
      }
      catch (Exception exc) {
        exc.printStackTrace();
      }
    }
  }

  class TestFrameListener implements WindowListener {
    //Obligatory WindowListener boilerplate
    public void windowDeactivated(WindowEvent e) {}
    public void windowDeiconified(WindowEvent e) {}
    public void windowIconified(WindowEvent e) {}
    public void windowOpened(WindowEvent e) {}
    public void windowActivated(WindowEvent e) {}
    public void windowClosed(WindowEvent e) {}

    /**
     * React to window closing
     * @param e WindowClosingEvent detected
     * */
    public void windowClosing(WindowEvent e) {
      System.exit( -1);
    }
  }
}

</SSCCE>