mpegplayer.java

JAVA的MPEG播放器

	Y = 512 + data[offset++];
	YCbCr = frameBuffer[address];
	frameBuffer[address++] =
	  (clip[((YCbCr >> 0)  & 0xFF) + Y ] << 0) +
	  (clip[((YCbCr >> 8)  & 0xFF) + Cb] << 8) +
	  (clip[((YCbCr >> 16) & 0xFF) + Cr] << 16);

	Y = 512 + data[offset++];
	YCbCr = frameBuffer[address];
	frameBuffer[address++] =
	  (clip[((YCbCr >> 0)  & 0xFF) + Y ] << 0) +
	  (clip[((YCbCr >> 8)  & 0xFF) + Cb] << 8) +
	  (clip[((YCbCr >> 16) & 0xFF) + Cr] << 16);

	offset += 16-2;
	address += width-2;

	Y = 512 + data[offset++];
	YCbCr = frameBuffer[address];
	frameBuffer[address++] =
	  (clip[((YCbCr >> 0)  & 0xFF) + Y ] << 0) +
	  (clip[((YCbCr >> 8)  & 0xFF) + Cb] << 8) +
	  (clip[((YCbCr >> 16) & 0xFF) + Cr] << 16);

	Y = 512 + data[offset++];
	YCbCr = frameBuffer[address];
	frameBuffer[address++] =
	  (clip[((YCbCr >> 0)  & 0xFF) + Y ] << 0) +
	  (clip[((YCbCr >> 8)  & 0xFF) + Cb] << 8) +
	  (clip[((YCbCr >> 16) & 0xFF) + Cr] << 16);

	offset -= 16;
	address -= width;
	index++;
      }
      offset += 16;
      address += width+width-16;
    }
  }

  private static int data[] = new int[256];
  private static int clip[] = new int[1024];

  static {
    for (int i = 0; i < 1024; i++) {
      clip[i] = Math.min(Math.max(i - 512, 0), 255);
    }
  }
}


/**
 * The MPEG-1 video stream decoder according to ISO 11172-2.
 */
class MPEGVideoStream {
  /**
   * MPEG-1 video frame rate table
   */
  private static final int frameRateTable[] = {
    30, 24, 24, 25, 30, 30, 50, 60, 60, 12, 30, 30, 30, 30, 30, 30
  };

  /**
   * MPEG-1 video stream frame rate (frames per second)
   */
  private int frameRate;

  /**
   * MPEG-1 video stream bit rate (bits per second)
   */
  private int bitRate;

  /**
   * MPEG-1 video stream VBV buffer size (16 kbit steps)
   */
  private int bufferSize;

  /**
   * MPEG-1 video stream time record (in frames)
   */
  private int hour, minute, second, frame;

  /**
   * MPEG-1 video stream current picture
   */
  private Picture picture;

  /**
   * MPEG-1 video stream boolean fields
   */
  private boolean constrained, dropped, closed, broken;

  /**
   * The last MPEG-1 picture frame parsed
   */
  private int frameBuffer[];

  /**
   * The underlaying VLC input stream
   */
  private VLCInputStream stream;

  /**
   * Initializes the MPEG-1 video input stream object
   */
  public MPEGVideoStream(InputStream inputStream) throws IOException {
    /* set ups the VLC input stream */
    stream = new VLCInputStream(inputStream);

    /* set ups the picture decoder */
    picture = new Picture();

    /* reset rates and buffer size */
    frameRate = 0;
    bitRate = 0;
    bufferSize = 0;

    /* reset time record */
    hour = 0;
    minute = 0;
    second = 0;
    frame = 0;

    /* reset boolean fields */
    constrained = false;
    dropped = false;
    closed = false;
    broken = false;

    /* reset last frame buffer */
    frameBuffer = getFrame();
  }

  /**
   * Returns the MPEG-1 video stream frame rate
   */
  public int getFrameRate() {
    return frameRate;
  }

  /**
   * Changes the MPEG-1 video stream frame rate
   */
  public void setFrameRate(int rate) {
    frameRate = rate;
  }

  /**
   * Returns the MPEG-1 video stream bit rate
   */
  public int getBitRate() {
    return bitRate;
  }

  /**
   * Changes the MPEG-1 video stream bit rate
   */
  public void setBitRate(int rate) {
    bitRate = rate;
  }

  /**
   * Returns the MPEG-1 video stream VBV buffer size
   */
  public int getBufferSize() {
    return bufferSize;
  }

  /**
   * Changes the MPEG-1 video stream VBV buffer size
   */
  public void setBufferSize(int size) {
    bufferSize = size;
  }

  /**
   * Returns the MPEG-1 video stream time record
   */
  public long getTime() {
    return frame + getFrameRate() * (second + 60L * minute + 3600L * hour);
  }

  /**
   * Changes the MPEG-1 video stream time record
   */
  public void setTime(int hour, int minute, int second, int frame) {
    this.hour = hour;
    this.minute = minute;
    this.second = second;
    this.frame = frame;
  }

  /**
   * Returns true if the video parameters are constrained
   */
  public boolean isConstrained() {
    return constrained;
  }

  /**
   * Enables or disables the video parameters constrains
   */
  public void setConstrained(boolean constrained) {
    this.constrained = constrained;
  }

  /**
   * Returns true if the group of pictures drops frames
   */
  public boolean isDropped() {
    return dropped;
  }

  /**
   * Changes the dropped flag of the group of pictures
   */
  public void setDropped(boolean dropped) {
    this.dropped = dropped;
  }

  /**
   * Returns true if the group of pictures is closed
   */
  public boolean isClosed() {
    return closed;
  }

  /**
   * Changes the closed flag of the group of pictures
   */
  public void setClosed(boolean closed) {
    this.closed = closed;
  }

  /**
   * Returns true if there is a broken link
   */
  public boolean isBroken() {
    return broken;
  }

  /**
   * Changes the broken flag of the group of pictures
   */
  public void setBroken(boolean broken) {
    this.broken = broken;
  }

  /**
   * Returns the MPEG-1 video picture dimensions
   */
  public int getWidth() {
    return picture.getWidth();
  }

  public int getHeight() {
    return picture.getHeight();
  }

  public int getStride() {
    return picture.getStride();
  }

  /**
   * Parses the next frame of the MPEG-1 video stream
   */
  public int[] getFrame() throws IOException {
    while (stream.showCode() != BitInputStream.SEQ_END_CODE) {
      switch (stream.getCode()) {
      case BitInputStream.SEQ_START_CODE:
	getSequenceHeader(stream);
	break;
      case BitInputStream.GOP_START_CODE:
	getGroupPictures(stream);
	break;
      case BitInputStream.PIC_START_CODE:
	return getPictureFrame(stream);
      case BitInputStream.USER_START_CODE:
      case BitInputStream.EXT_START_CODE:
	break;
      default:
	// throw new IOException("Unknown MPEG-1 video layer start code");
	break;
      }
    }
    if (frameBuffer != picture.getLastFrame()) {
      frameBuffer = picture.getLastFrame();
      return frameBuffer;
    }
    return null;
  }

  /**
   * Parses the sequence header from the MPEG-1 video stream
   */
  private void getSequenceHeader(VLCInputStream stream) throws IOException {
    /* read picture dimensions in pixels */
    int width = stream.getBits(12);
    int height = stream.getBits(12);
    int aspectRatio = stream.getBits(4);

    /* changes the MPEG-1 picture dimension */
    if (picture.getWidth() == 0 && picture.getHeight() == 0)
      picture.setSize(width, height);

    /* read picture and bit rates */
    setFrameRate(frameRateTable[stream.getBits(4)]);
    setBitRate(400 * stream.getBits(18));
    stream.getBits(1);

    /* read VBV buffer size */
    setBufferSize(stream.getBits(10));

    /* read constrained parameters flag */
    setConstrained(stream.getBits(1) != 0);

    /* read quantization matrix for intra coded blocks */
    int intraMatrix[] = picture.getMacroblock().getIntraMatrix();
    if (stream.getBits(1) != 0) {
      for (int i = 0; i < 64; i++)
	intraMatrix[i] = stream.getBits(8);
    }

    /* read quantization matrix for inter coded blocks */
    int interMatrix[] = picture.getMacroblock().getInterMatrix();
    if (stream.getBits(1) != 0) {
      for (int i = 0; i < 64; i++)
	interMatrix[i] = stream.getBits(8);
    }
  }

  /**
   * Parses group of pictures header from the MPEG-1 video stream
   */
  private void getGroupPictures(VLCInputStream stream) throws IOException {
    /* read the drop frame flag */
    setDropped(stream.getBits(1) != 0);

    /* read the time record */
    int hour = stream.getBits(5);
    int minute = stream.getBits(6);
    int marker = stream.getBits(1);
    int second = stream.getBits(6);
    int frame = stream.getBits(6);
    setTime(hour, minute, second, frame);

    /* read closed and broken link flags */
    setClosed(stream.getBits(1) != 0);
    setBroken(stream.getBits(1) != 0);
  }

  /**
   * Parses the next picture from the MPEG-1 video stream
   */
  private int[] getPictureFrame(VLCInputStream stream) throws IOException {
    return picture.getFrame(stream);
  }
}






/**
 * The MPEG-1 video stream decoder applet that is intended to run
 * embedded inside of a Web page or another application.
 
 */
public class MPEGPlayer extends Applet implements Runnable {
  /**
   * The MPEG-1 video input stream
   */
  private MPEGVideoStream stream;

  /**
   * The picture frame buffer
   */
  private int pixels[], width, height, stride;

  /**
   * The memory image color model
   */
  private DirectColorModel model = null;

  /**
   * The memory image source
   */
  private MemoryImageSource source = null;

  /**
   * The memory image object
   */
  private Image image = null;

  /**
   * The applet's execution thread
   */
  private Thread kicker = null;

  /**
   * The video stream location
   */
  private URL url = null;

  /**
   * The repeat boolean parameter
   */
  private boolean repeat = true;


  /**
   * Applet information
   */
  public String getAppletInfo() {
    return "MPEGPlayer 0.9 (15 Apr 1998), Carlos Hasan ([e-mail])";
  }

  /**
   * Parameters information
   */
  public String[][] getParameterInfo() {
    String info[][] = {
      { "source", "URL", "MPEG-1 video stream location" },
      { "repeat", "boolean", "repeat the video sequence" } };
    return info;
  }

  /**
   * Applet initialization
   */
  public void init() {
    try {
      if (getParameter("source") != null)
	url = new URL(getDocumentBase(), getParameter("source"));
      if (getParameter("repeat") != null)
	repeat = getParameter("repeat").equalsIgnoreCase("true");
    }
    catch (MalformedURLException exception) {
      showStatus("MPEG Exception: " + exception);
    }
  }

  /**
   * Start the execution of the applet
   */
  public void start() {
    if (kicker == null && url != null) {
      kicker = new Thread(this);
      kicker.start();
    }
    showStatus(getAppletInfo());
  }

  /**
   * Stop the execution of the applet
   */
  public void stop() {
    if (kicker != null && kicker.isAlive()) {
      kicker.stop();
    }
    kicker = null;
  }

  /**
   * The applet main execution code
   */
  public void run() {
    int frame[];
    long time;
    try {
      do {
	stream = new MPEGVideoStream(url.openStream());
	width = stream.getWidth();
	height = stream.getHeight();
	stride = stream.getStride();
	resize(width, height);
	pixels = new int[stride * height];
        model = new DirectColorModel(24, 0x0000ff, 0x00ff00, 0xff0000);
	time = System.currentTimeMillis();
        while ((frame = readFrame()) != null) {
	  drawFrame(frame, width, height, stride);
	  source = new MemoryImageSource(width, height, model,pixels,0,stride);
	  image = createImage(source);
	  paint(getGraphics());
          time += 1000L / stream.getFrameRate();
	  try {
	    Thread.sleep(Math.max(time - System.currentTimeMillis(), 0));
	  }
	  catch (InterruptedException exception) {
	  }
          image.flush();
	}
      } while (repeat);
    }
    catch (IOException exception) {
      showStatus("MPEG I/O Exception: " + exception);
    }
  }
  
  /**
   * Paint the current frame
   */
  public void paint(Graphics graphics) {
    if (image != null)
      graphics.drawImage(image, 0, 0, null);
  }
  
  /**
   * Reads the next MPEG-1 video frame
   */
  private int[] readFrame() {
    while (true) {
      try {
	return stream.getFrame();
      }
      catch (Exception exception) {
	showStatus("MPEG Exception: " + exception);
      }
    }
  }
  
  /**
   * Draws the current MPEG-1 video frame
   */
  private void drawFrame(int frame[], int width, int height, int stride) {
    int offset = 0;
    for (int y = 0; y < height; y++) {
      for (int x = 0; x < width; x++) {
	int YCbCr = frame[offset];
	int Y  = 512 +	((YCbCr >>  0) & 0xff);
	int Cb = cbtable[(YCbCr >>  8) & 0xff];
	int Cr = crtable[(YCbCr >> 16) & 0xff];
	pixels[offset++] =
	  (clip[Y + (Cr >> 16)] << 0) +
	  (clip[Y + (((Cb + Cr) << 16) >> 16)] << 8) +
	  (clip[Y + (Cb >> 16)] << 16);
      }
      offset += stride - width;
    }
  }
  
  /**
   * Color conversion lookup tables
   */
  private static int clip[], cbtable[], crtable[];
  static {
    clip = new int[1024];
    cbtable = new int[256];
    crtable = new int[256];
    for (int i = 0; i < 1024; i++) {
      clip[i] = Math.min(Math.max(i - 512, 0), 255);
    }
    for (int i = 0; i < 256; i++) {
      int level = i - 128;
      cbtable[i] = (((int)(1.77200 * level)) << 16) - ((int)(0.34414 * level));
      crtable[i] = (((int)(1.40200 * level)) << 16) - ((int)(0.71414 * level));
    }
  }
}