movie.java

来自「This is processing for java examples.」· Java 代码 · 共 737 行 · 第 1/2 页

        // 0106: tried adding sleep time so this doesn't spin out of control
        // works fine but doesn't really help anything
        //try {
        //Thread.sleep(5);
        //} catch (InterruptedException e) { }
      }
      movie.setRate(1);
      fps = ifps;

      runner = new Thread(this);
      runner.start();


      // register methods

      parent.registerDispose(this);

      try {
        movieEventMethod =
          parent.getClass().getMethod("movieEvent",
                                      new Class[] { Movie.class });
      } catch (Exception e) {
        // no such method, or an error.. which is fine, just ignore
      }

    } catch (QTException qte) {
      qte.printStackTrace();

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  */


  public boolean available() {
    return available;
  }


  public void read() {
    try {
      if (firstFrame) {
        movieRect = movie.getBox();
        //movieGraphics = new QDGraphics(movieRect);
        if (quicktime.util.EndianOrder.isNativeLittleEndian()) {
          movieGraphics =
            new QDGraphics(QDConstants.k32BGRAPixelFormat, movieRect);
        } else {
          movieGraphics =
            new QDGraphics(QDGraphics.kDefaultPixelFormat, movieRect);
        }
      }

      Pict pict = movie.getPict(movie.getTime());  // returns an int
      pict.draw(movieGraphics, movieRect);
      PixMap pixmap = movieGraphics.getPixMap();
      raw = pixmap.getPixelData();

      // It needs to get at least a small part
      // of the video to get the parameters
      if (firstFrame) {
        //int intsPerRow = pixmap.getRowBytes() / 4;
        int movieWidth = movieRect.getWidth();
        int movieHeight = movieRect.getHeight();
        int j = raw.getRowBytes() - movieWidth*4;
        // this doesn't round up.. does it need to?
        int k = j / 4;
        int dataWidth = movieWidth + k;

        if (dataWidth != movieWidth) {
          if (removeBorders) {
            borderImage = new PImage(dataWidth, movieHeight, RGB);
          } else {
            movieWidth = dataWidth;
          }
        }
        //int vpixels[] = new int[movieWidth * movieHeight];
        //image = new PImage(vpixels, movieWidth, movieHeight, RGB);
        super.init(movieWidth, movieHeight, RGB);
        //parent.video = image;
        firstFrame = false;
      }
      // this happens later (found by hernando)
      //raw.copyToArray(0, image.pixels, 0, image.width * image.height);

      loadPixels();
      // this is identical to a chunk of code inside PCamera
      // this might be a candidate to move up to PVideo or something
      if (borderImage != null) {  // need to remove borders
        raw.copyToArray(0, borderImage.pixels,
                        0, borderImage.width * borderImage.height);
        int borderIndex = 0;
        int targetIndex = 0;
        for (int i = 0; i < height; i++) {
          System.arraycopy(borderImage.pixels, borderIndex,
                           pixels, targetIndex, width);
          borderIndex += borderImage.width;
          targetIndex += width;
        }
      } else {  // just copy directly
        raw.copyToArray(0, pixels, 0, width * height);
      }

      // ready to rock
      //System.out.println("updating pixels");
      //updatePixels();  // mark as modified
      updatePixels();

    } catch (QTException qte) {
      qte.printStackTrace();
      //QTSession.close();  // let dispose() handle it
    }
  }


  /**
   * Begin playing the movie, with no repeat.
   */
  public void play() {
//    if (runner != null) {
//      stop();
//    }
    play = true;
//    runner = new Thread(this);
//    runner.start();
  }


  /**
   * Begin playing the movie, with repeat.
   */
  public void loop() {
    play();
    repeat = true;
  }


  /**
   * Shut off the repeating loop.
   */
  public void noLoop() {
    repeat = false;
  }


  /**
   * Pause the movie at its current time.
   */
  public void pause() {
    play = false;
    //System.out.println("pause");
  }


  /**
   * Stop the movie, and rewind.
   */
  public void stop() {
    play = false;
//    runner = null;

    try {
      movie.setTimeValue(0);

    } catch (StdQTException e) {
      errorMessage("stop", e);
    }
  }


  /**
   * Set how often new frames are to be read from the movie.
   * Does not actually set the speed of the movie playback,
   * that's handled by the speed() method.
   */
  public void frameRate(int ifps) {
    if (ifps <= 0) {
      System.err.println("Movie: ignoring bad frame rate of " +
                         ifps + " fps.");
    } else {
      fps = ifps;
    }
  }


  /**
   * Set a multiplier for how fast/slow the movie should be run.
   * The default is 1.0.
   * <UL>
   * <LI>speed(2) will play the movie at double speed (2x).
   * <LI>speed(0.5) will play at half speed.
   * <LI>speed(-1) will play backwards at regular speed.
   * </UL>
   */
  public void speed(float rate) {
    //rate = irate;
    try {
      movie.setRate(rate);

    } catch (StdQTException e) {
      errorMessage("speed", e);
    }
  }


  /**
   * Return the current time in seconds.
   * The number is a float so fractions of seconds can be used.
   */
  public float time() {
    try {
      return (float)movie.getTime() / (float)movie.getTimeScale();

    } catch (StdQTException e) {
      errorMessage("time", e);
    }
    return -1;
  }


  /**
   * Jump to a specific location (in seconds).
   * The number is a float so fractions of seconds can be used.
   */
  public void jump(float where) {
    try {
      //movie.setTime(new TimeRecord(rate, where));  // scale, value
      //movie.setTime(new TimeRecord(1, where));  // scale, value
      int scaledTime = (int) (where * movie.getTimeScale());
      movie.setTimeValue(scaledTime);

    } catch (StdQTException e) {
      errorMessage("jump", e);
    }
  }


  /**
   * Get the full length of this movie (in seconds).
   */
  public float duration() {
    try {
      return (float)movie.getDuration() / (float)movie.getTimeScale();

    } catch (StdQTException e) {
      errorMessage("length", e);
    }
    return -1;
  }


  /*
  public void play() {
    if(!play) {
      play = true;
    }
    start();
    while( image == null) {
      try {
        Thread.sleep(5);
      } catch (InterruptedException e) { }
    }
    pixels = image.pixels;
    width = image.width;
    height = image.height;
  }


  public void repeat() {
    loop = true;
    if(!play) {
      play = true;
    }
    start();
    while( image == null) {
      try {
        Thread.sleep(5);
      } catch (InterruptedException e) { }
    }
    pixels = image.pixels;
    width = image.width;
    height = image.height;
  }


  public void pause() {
    play = false;
  }
  */


  public void run() {
    //System.out.println("entering thread");
    while (Thread.currentThread() == runner) {
      //System.out.print("<");
      try {
        //Thread.sleep(5);
        Thread.sleep(1000 / fps);
      } catch (InterruptedException e) { }
      //System.out.print(">");

      // this could be a lie, but..
      if (play) {
        //read();
        //System.out.println("play");
        available = true;

        if (movieEventMethod == null) {
          // If no special handling, then automatically read from the movie.
          read();

        } else {
          try {
            movieEventMethod.invoke(parent, new Object[] { this });
          } catch (Exception e) {
            System.err.println("error, disabling movieEvent() for " +
                               filename);
            e.printStackTrace();
            movieEventMethod = null;
          }
        }

        try {
          if (movie.isDone() && repeat) {
            movie.goToBeginning();
          }
        } catch (StdQTException e) {
          play = false;
          errorMessage("rewinding", e);
        }
        //} else {
        //System.out.println("no play");
      }

      //try {
      //read();
      //if (movie.isDone() && loop) movie.goToBeginning();

      //} catch (QTException e) {
      //System.err.println("Movie exception");
      //e.printStackTrace();
      //QTSession.close(); ??
      //}
    }
  }


  /**
   * Call this to halt the movie from running, and stop its thread.
   */
  public void dispose() {
    stop();
    runner = null;
    QTSession.close();
  }


  /**
   * General error reporting, all corraled here just in case
   * I think of something slightly more intelligent to do.
   */
  protected void errorMessage(String where, Exception e) {
    parent.die("Error inside Movie." + where + "()", e);
  }
}