mpegplayer.java

JAVA的MPEG播放器

    }
    return getACValue();
  }

  /**
   * Returns AC luminance or chrominance coefficients
   */
  public int[] getACValue() throws IOException {
    int code = showBits(16);
    if (code >= 10240)
      code = (code >> 11) + 112;
    else if (code >= 8192)
      code = (code >> 8) + 72;
    else if (code >= 1024)
      code = (code >> 9) + 88;
    else if (code >= 512)
      code = (code >> 6) + 72;
    else if (code >= 256)
      code = (code >> 4) + 48;
    else if (code >= 128)
      code = (code >> 3) + 32;
    else if (code >= 64)
      code = (code >> 2) + 16;
    else if (code >= 32)
      code >>= 1;
    else if (code >= 16)
      code -= 16;
    else
      throw new IOException("Invalid DCT coefficient code");

    flushBits(DCTtable[code][1]);

    data[0] = DCTtable[code][0] & 0xFF;
    data[1] = DCTtable[code][0] >>> 8;
    if (data[0] == ESC) {
      data[0] = getBits(6);
      data[1] = getBits(8);
      if (data[1] == 0x00)
	data[1] = getBits(8);
      else if (data[1] == 0x80)
	data[1] = getBits(8) - 256;
      else if (data[1] >= 0x80)
	data[1] -= 256;
    }
    else if (data[0] != EOB) {
      if (getBits(1) != 0)
	data[1] = -data[1];
    }
    return data;
  }
}


/**
 * Fast inverse two-dimensional discrete cosine transform algorithm
 * by Chen-Wang using 32 bit integer arithmetic (8 bit coefficients).
 */
class IDCT {
  /**
   * The basic DCT block is 8x8 samples
   */
  private final static int DCTSIZE = 8;

  /**
   * Integer arithmetic precision constants
   */
  private final static int PASS_BITS = 3;
  private final static int CONST_BITS = 11;

  /**
   * Precomputed DCT cosine kernel functions:
   *  Ci = (2^CONST_BITS)*sqrt(2.0)*cos(i * PI / 16.0)
   */
  private final static int C1 = 2841;
  private final static int C2 = 2676;
  private final static int C3 = 2408;
  private final static int C5 = 1609;
  private final static int C6 = 1108;
  private final static int C7 = 565;

  public static void transform(int block[]) {
    /* pass 1: process rows */
    for (int i = 0, offset = 0; i < DCTSIZE; i++, offset += DCTSIZE) {

      /* get coefficients */
      int d0 = block[offset + 0];
      int d4 = block[offset + 1];
      int d3 = block[offset + 2];
      int d7 = block[offset + 3];
      int d1 = block[offset + 4];
      int d6 = block[offset + 5];
      int d2 = block[offset + 6];
      int d5 = block[offset + 7];
      int d8;

      /* AC terms all zero? */
      if ((d1 | d2 | d3 | d4 | d5 | d6 | d7) == 0) {
	d0 <<= PASS_BITS;
	block[offset + 0] = d0;
	block[offset + 1] = d0;
	block[offset + 2] = d0;
	block[offset + 3] = d0;
	block[offset + 4] = d0;
	block[offset + 5] = d0;
	block[offset + 6] = d0;
	block[offset + 7] = d0;
	continue;
      }

      /* first stage */
      d8 = (d4 + d5) * C7;
      d4 = d8 + d4 * (C1 - C7);
      d5 = d8 - d5 * (C1 + C7);
      d8 = (d6 + d7) * C3;
      d6 = d8 - d6 * (C3 - C5);
      d7 = d8 - d7 * (C3 + C5);

      /* second stage */
      d8 = ((d0 + d1) << CONST_BITS) + (1 << (CONST_BITS - PASS_BITS - 1));
      d0 = ((d0 - d1) << CONST_BITS) + (1 << (CONST_BITS - PASS_BITS - 1));
      d1 = (d2 + d3) * C6;
      d2 = d1 - d2 * (C2 + C6);
      d3 = d1 + d3 * (C2 - C6);
      d1 = d4 + d6;
      d4 = d4 - d6;
      d6 = d5 + d7;
      d5 = d5 - d7;

      /* third stage */
      d7 = d8 + d3;
      d8 = d8 - d3;
      d3 = d0 + d2;
      d0 = d0 - d2;
      d2 = ((d4 + d5) * 181) >> 8;
      d4 = ((d4 - d5) * 181) >> 8;

      /* output stage */
      block[offset + 0] = (d7 + d1) >> (CONST_BITS - PASS_BITS);
      block[offset + 7] = (d7 - d1) >> (CONST_BITS - PASS_BITS);
      block[offset + 1] = (d3 + d2) >> (CONST_BITS - PASS_BITS);
      block[offset + 6] = (d3 - d2) >> (CONST_BITS - PASS_BITS);
      block[offset + 2] = (d0 + d4) >> (CONST_BITS - PASS_BITS);
      block[offset + 5] = (d0 - d4) >> (CONST_BITS - PASS_BITS);
      block[offset + 3] = (d8 + d6) >> (CONST_BITS - PASS_BITS);
      block[offset + 4] = (d8 - d6) >> (CONST_BITS - PASS_BITS);
    }

    /* pass 2: process columns */
    for (int i = 0, offset = 0; i < DCTSIZE; i++, offset++) {

      /* get coefficients */
      int d0 = block[offset + DCTSIZE*0];
      int d4 = block[offset + DCTSIZE*1];
      int d3 = block[offset + DCTSIZE*2];
      int d7 = block[offset + DCTSIZE*3];
      int d1 = block[offset + DCTSIZE*4];
      int d6 = block[offset + DCTSIZE*5];
      int d2 = block[offset + DCTSIZE*6];
      int d5 = block[offset + DCTSIZE*7];
      int d8;

      /* AC terms all zero? */
      if ((d1 | d2 | d3 | d4 | d5 | d6 | d7) == 0) {
	d0 >>= PASS_BITS + 3;
	block[offset + DCTSIZE*0] = d0;
	block[offset + DCTSIZE*1] = d0;
	block[offset + DCTSIZE*2] = d0;
	block[offset + DCTSIZE*3] = d0;
	block[offset + DCTSIZE*4] = d0;
	block[offset + DCTSIZE*5] = d0;
	block[offset + DCTSIZE*6] = d0;
	block[offset + DCTSIZE*7] = d0;
	continue;
      }

      /* first stage */
      d8 = (d4 + d5) * C7;
      d4 = (d8 + d4 * (C1 - C7)) >> 3;
      d5 = (d8 - d5 * (C1 + C7)) >> 3;
      d8 = (d6 + d7) * C3;
      d6 = (d8 - d6 * (C3 - C5)) >> 3;
      d7 = (d8 - d7 * (C3 + C5)) >> 3;

      /* second stage */
      d8 = ((d0 + d1) << (CONST_BITS - 3)) + (1 << (CONST_BITS + PASS_BITS-1));
      d0 = ((d0 - d1) << (CONST_BITS - 3)) + (1 << (CONST_BITS + PASS_BITS-1));
      d1 = (d2 + d3) * C6;
      d2 = (d1 - d2 * (C2 + C6)) >> 3;
      d3 = (d1 + d3 * (C2 - C6)) >> 3;
      d1 = d4 + d6;
      d4 = d4 - d6;
      d6 = d5 + d7;
      d5 = d5 - d7;

      /* third stage */
      d7 = d8 + d3;
      d8 = d8 - d3;
      d3 = d0 + d2;
      d0 = d0 - d2;
      d2 = ((d4 + d5) * 181) >> 8;
      d4 = ((d4 - d5) * 181) >> 8;

      /* output stage */
      block[offset + DCTSIZE*0] = (d7 + d1) >> (CONST_BITS + PASS_BITS);
      block[offset + DCTSIZE*7] = (d7 - d1) >> (CONST_BITS + PASS_BITS);
      block[offset + DCTSIZE*1] = (d3 + d2) >> (CONST_BITS + PASS_BITS);
      block[offset + DCTSIZE*6] = (d3 - d2) >> (CONST_BITS + PASS_BITS);
      block[offset + DCTSIZE*2] = (d0 + d4) >> (CONST_BITS + PASS_BITS);
      block[offset + DCTSIZE*5] = (d0 - d4) >> (CONST_BITS + PASS_BITS);
      block[offset + DCTSIZE*3] = (d8 + d6) >> (CONST_BITS + PASS_BITS);
      block[offset + DCTSIZE*4] = (d8 - d6) >> (CONST_BITS + PASS_BITS);
    }
  }
}


/**
 * Motion vector information used for MPEG-1 motion prediction.
 */
class MotionVector {
  /**
   * Motion vector displacements (6 bits)
   */
  public int horizontal;
  public int vertical;

  /**
   * Motion vector displacement residual size
   */
  private int residualSize;

  /**
   * Motion displacement in half or full pixels?
   */
  private boolean pixelSteps;


  /**
   * Initializes the motion vector object
   */
  public MotionVector() {
    horizontal = vertical = 0;
    residualSize = 0;
    pixelSteps = false;
  }

  /**
   * Changes the current motion vector predictors
   */
  public void setVector(int horizontal, int vertical) {
    this.horizontal = horizontal;
    this.vertical = vertical;
  }

  /**
   * Reads the picture motion vector information
   */
  public void getMotionInfo(BitInputStream stream) throws IOException {
    pixelSteps = (stream.getBits(1) != 0);
    residualSize = (stream.getBits(3) - 1);
  }

  /**
   * Reads the macro block motion vectors
   */
  public void getMotionVector(VLCInputStream stream) throws IOException {
    horizontal = getMotionDisplacement(stream, horizontal);
    vertical = getMotionDisplacement(stream, vertical);
  }

  /**
   * Reads and reconstructs the motion vector displacements
   */
  private int getMotionDisplacement(VLCInputStream stream, int vector)
    throws IOException {
    int code = stream.getMVCode();
    int residual = (code != 0 && residualSize != 0 ?
		    stream.getBits(residualSize) : 0);
    int limit = 16 << residualSize;
    if (pixelSteps)
      vector >>= 1;
    if (code > 0) {
      if ((vector += ((code - 1) << residualSize) + residual + 1) >= limit)
	vector -= limit << 1;
    }
    else if (code < 0) {
      if ((vector -= ((-code - 1) << residualSize) + residual + 1) < -limit)
	vector += limit << 1;
    }
    if (pixelSteps)
      vector <<= 1;
    return vector;
  }
}


/**
 * Macroblock decoder and dequantizer for MPEG-1 video streams.
 */
class Macroblock {
  /**
   * Macroblock type encoding
   */
  public final static int I_TYPE   = 1;
  public final static int P_TYPE   = 2;
  public final static int B_TYPE   = 3;
  public final static int D_TYPE   = 4;

  /**
   * Macroblock type bit fields
   */
  public final static int INTRA    = 0x01;
  public final static int PATTERN  = 0x02;
  public final static int BACKWARD = 0x04;
  public final static int FORWARD  = 0x08;
  public final static int QUANT    = 0x10;
  public final static int EMPTY    = 0x80;

  /**
   * Default quantization matrix for intra coded macro blocks
   */
  private final static int defaultIntraMatrix[] = {
    8, 16, 16, 19, 16, 19, 22, 22,
    22, 22, 22, 22, 26, 24, 26, 27,
    27, 27, 26, 26, 26, 26, 27, 27,
    27, 29, 29, 29, 34, 34, 34, 29,
    29, 29, 27, 27, 29, 29, 32, 32,
    34, 34, 37, 38, 37, 35, 35, 34,
    35, 38, 38, 40, 40, 40, 48, 48,
    46, 46, 56, 56, 58, 69, 69, 83
  };

  /**
   * Mapping for zig-zag scan ordering
   */
  private final static int zigzag[] = {
    0,	1,  8, 16,  9,	2,  3, 10,
    17, 24, 32, 25, 18, 11,  4,  5,
    12, 19, 26, 33, 40, 48, 41, 34,
    27, 20, 13,  6,  7, 14, 21, 28,
    35, 42, 49, 56, 57, 50, 43, 36,
    29, 22, 15, 23, 30, 37, 44, 51,
    58, 59, 52, 45, 38, 31, 39, 46,
    53, 60, 61, 54, 47, 55, 62, 63
  };

  /**
   * Quantization scale for macro blocks
   */
  private int scale;

  /**
   * Quantization matrix for intra coded blocks
   */
  private int intraMatrix[];

  /**
   * Quantization matrix for inter coded blocks
   */
  private int interMatrix[];

  /**
   * Color components sample blocks (8 bits)
   */
  private int block[][];

  /**
   * Predictors for DC coefficients (10 bits)
   */
  private int predictor[];

  /**
   * Macroblock type encoding
   */
  private int type;

  /**
   * Macroblock type flags
   */
  private int flags;

  /**
   * Motion prediction vectors
   */
  private MotionVector forward;
  private MotionVector backward;


  /**
   * Initializes the MPEG-1 macroblock decoder object
   */
  public Macroblock() {
    /* create quantization matrices */
    intraMatrix = new int[64];
    interMatrix = new int[64];

    /* create motion prediction vectors */
    forward = new MotionVector();
    backward = new MotionVector();

    /* create DCT blocks and predictors */
    block = new int[6][64];
    predictor = new int[3];

    /* set up default macro block types */
    type = I_TYPE;
    flags = EMPTY;

    /* set up default quantization scale */
    scale = 0;

    /* set up default quantization matrices */
    for (int i = 0; i < 64; i++) {
      intraMatrix[i] = defaultIntraMatrix[i];
      interMatrix[i] = 16;
    }

    /* set up default DC coefficient predictors */
    for (int i = 0; i < 3; i++)
      predictor[i] = 1024;
  }

  /**
   * Returns the quantization scale
   */
  public int getScale() {
    return scale;
  }

  /**
   * Changes the quantization scale
   */
  public void setScale(int scale) {
    this.scale = scale;
  }

  /**
   * Returns the quantization matrix for intra coded blocks
   */
  public int[] getIntraMatrix() {
    return intraMatrix;
  }

  /**
   * Changes the quantization matrix for intra coded blocks
   */
  public void setIntraMatrix(int matrix[]) {
    for (int i = 0; i < 64; i++)
      intraMatrix[i] = matrix[i];
  }

  /**
   * Returns the quantization matrix for inter coded blocks
   */
  public int[] getInterMatrix() {
    return interMatrix;
  }

  /**
   * Changes the quantization matrix for inter coded blocks
   */
  public void setInterMatrix(int matrix[]) {
    for (int i = 0; i < 64; i++)
      interMatrix[i] = matrix[i];
  }

  /**
   * Returns the macroblock type encoding
   */
  public int getType() {
    return type;
  }

  /**
   * Changes the macroblock type encoding
   */
  public void setType(int type) {
    this.type = type;
  }

  /**
   * Returns the component block of samples
   */
  public int[][] getData() {
    return block;
  }

  /**
   * Changes the component block of samples
   */
  public void setData(int component, int data[]) {
    for (int i = 0; i < 64; i++)
      block[component][i] = data[i];
  }

  /**
   * Returns the macro block type flags
   */
  public int getFlags() {
    return flags;
  }

  /**
   * Changes the macro block type flags
   */
  public void setFlags(int flags) {
    this.flags = flags;
  }

  /**
   * Returns true if the block is empty
   */
  public boolean isEmpty() {
    return (flags & EMPTY) != 0;
  }

  /**
   * Returns true if the block is intra coded
   */
  public boolean isIntraCoded() {
    return (flags & INTRA) != 0;
  }

  /**
   * Returns true if the block is pattern coded
   */
  public boolean isPatternCoded() {
    return ((flags & PATTERN) != 0);
  }

  /**
   * Returns true if the block is forward predicted
   */
  public boolean isBackwardPredicted() {
    return (flags & BACKWARD) != 0;
  }

  /**
   * Returns true if the block is backward predicted
   */
  public boolean isForwardPredicted() {
    return (flags & FORWARD) != 0;
  }

  /**
   * Returns true if the block is forward and backward predicted
   */
  public boolean isBidirPredicted() {
    return ((flags & FORWARD) != 0) && ((flags & BACKWARD) != 0);
  }

  /**
   * Returns true if the block has a quantization scale
   */
  public boolean isQuantScaled() {
    return ((flags & QUANT) != 0);
  }

  /**
   * Returns the forward motion vector
   */
  public MotionVector getForwardVector() {