import java.io.*;import java.net.*;import java.awt.*;import java.awt.image.*;import java.applet.*;/** * This class represents a buffered input stream which can read * variable length codes from MPEG-1 video streams. */class BitInputStream {  /**   * MPEG video layers start codes   */  public final static int SYNC_START_CODE = 0x000001;  public final static int PIC_START_CODE  = 0x00000100;  public final static int SLICE_MIN_CODE  = 0x00000101;  public final static int SLICE_MAX_CODE  = 0x000001af;  public final static int USER_START_CODE = 0x000001b2;  public final static int SEQ_START_CODE  = 0x000001b3;  public final static int EXT_START_CODE  = 0x000001b5;  public final static int SEQ_END_CODE	  = 0x000001b7;  public final static int GOP_START_CODE  = 0x000001b8;  /**   * The underlying input stream   */  private InputStream stream;  /**   * The bit buffer variables   */  private int bitbuffer, bitcount;  /**   * The 32 bit buffer variables   */  private int buffer[], count, position;  /**   * Initializes the bit input stream object   */  public BitInputStream(InputStream inputStream) {    stream = inputStream;    buffer = new int[1024];    bitbuffer = bitcount = 0;    count = position = 0;  }  /**   * Reads the next MPEG-1 layer start code   */  public int getCode() throws IOException {    alignBits(8);    while (showBits(24) != SYNC_START_CODE)      flushBits(8);    return getBits(32);  }  /**   * Shows the next MPEG-1 layer start code   */  public int showCode() throws IOException {    alignBits(8);    while (showBits(24) != SYNC_START_CODE)      flushBits(8);    return showBits(32);  }  /**   * Reads the next variable length code   */  public int getBits(int nbits) throws IOException {    int bits;    if (nbits <= bitcount) {      bits = bitbuffer >>> (32 - nbits);      bitbuffer <<= nbits;      bitcount -= nbits;    }    else {      bits = bitbuffer >>> (32 - nbits);      nbits -= bitcount;      bitbuffer = get32Bits();      bits |= bitbuffer >>> (32 - nbits);      bitbuffer <<= nbits;      bitcount = 32 - nbits;    }    if (nbits >= 32)      bitbuffer = 0;    return bits;  }  /**   * Shows the next variable length code   */  public int showBits(int nbits) throws IOException {    int bits = bitbuffer >>> (32 - nbits);    if (nbits > bitcount) {      bits |= show32Bits() >>> (32 + bitcount - nbits);    }    return bits;  }  /**   * Flushes the current variable length code   */  public void flushBits(int nbits) throws IOException {    if (nbits <= bitcount) {      bitbuffer <<= nbits;      bitcount -= nbits;    }    else {      nbits -= bitcount;      bitbuffer = get32Bits() << nbits;      bitcount = 32 - nbits;    }  }  /**   * Aligns the input stream pointer to a given boundary   */  public void alignBits(int nbits) throws IOException {    flushBits(bitcount % nbits);  }  /**   * Reads the next 32-bit code from the buffered stream   */  private int get32Bits() throws IOException {    if (position >= count) {      position = 0;      for (count = 0; count < buffer.length; count++)	buffer[count] = read32Bits();    }    return buffer[position++];  }  /**   * Shows the next 32-bit code from the buffered stream   */  private int show32Bits() throws IOException {    if (position >= count) {      position = 0;      for (count = 0; count < buffer.length; count++)	buffer[count] = read32Bits();    }    return buffer[position];  }  /**   * Reads 32-bit big endian codes from the stream   */  private int read32Bits() throws IOException {    if (stream.available() <= 0)      return SEQ_END_CODE;    int a0 = stream.read() & 0xff;    int a1 = stream.read() & 0xff;    int a2 = stream.read() & 0xff;    int a3 = stream.read() & 0xff;    return (a0 << 24) + (a1 << 16) + (a2 << 8) + (a3 << 0);  }}/** * Huffman VLC entropy decoder for MPEG-1 video streams. The tables * are from ISO/IEC 13818-2 DIS, Annex B, variable length code tables. */class VLCInputStream extends BitInputStream {  /**   * Table B-1, variable length codes for macroblock address increments   */  private final static byte MBAtable[][] = {    // 00000011xxx    { 33,11 }, { 32,11 }, { 31,11 }, { 30,11 },    { 29,11 }, { 28,11 }, { 27,11 }, { 26,11 },    // 0000010xxxx    { 25,11 }, { 24,11 }, { 23,11 }, { 22,11 },    { 21,10 }, { 21,10 }, { 20,10 }, { 20,10 },    { 19,10 }, { 19,10 }, { 18,10 }, { 18,10 },    { 17,10 }, { 17,10 }, { 16,10 }, { 16,10 },    // 0000xxxx...    {  0, 0 }, {  0, 0 }, {  0, 0 }, { 33,11 },    { 25,11 }, { 19,10 }, { 15, 8 }, { 14, 8 },    { 13, 8 }, { 12, 8 }, { 11, 8 }, { 10, 8 },    {  9, 7 }, {  9, 7 }, {  8, 7 }, {	8, 7 },    // 00xxx......    {  0, 0 }, { 13, 8 }, {  7, 5 }, {	6, 5 },    {  5, 4 }, {  5, 4 }, {  4, 4 }, {	4, 4 },    // xxx........    {  0, 0 }, {  5, 4 }, {  3, 3 }, {	2, 3 },    {  1, 1 }, {  1, 1 }, {  1, 1 }, {	1, 1 }  };  /**   * Table B-2, variable length codes for I-picture macroblock types   */  private final static byte IMBtable[][] = {    // xx    { 0, 0 }, { 17,2 }, { 1,1 }, { 1,1 }  };  /**   * Table B-3, variable length codes for P-picture macroblock types   */  private final static byte PMBtable[][] = {    // 000xxx    {  0,0 }, { 17,6 }, { 18,5 }, { 18,5 },    { 26,5 }, { 26,5 }, {  1,5 }, {  1,5 },    // xxx...    {  0,0 }, {  8,3 }, {  2,2 }, {  2,2 },    { 10,1 }, { 10,1 }, { 10,1 }, { 10,1 }  };  /**   * Table B-4, variable length codes for B-picture macroblock types   */  private final static byte BMBtable[][] = {    // 00xxxx    {  0,0 }, { 17,6 }, { 22,6 }, { 26,6 },    { 30,5 }, { 30,5 }, {  1,5 }, {  1,5 },    {  8,4 }, {  8,4 }, {  8,4 }, {  8,4 },    { 10,4 }, { 10,4 }, { 10,4 }, { 10,4 },    // xxx...    {  0,0 }, {  8,4 }, {  4,3 }, {  6,3 },    { 12,2 }, { 12,2 }, { 14,2 }, { 14,2 },  };  /**   * Table B-9, variable length codes for coded block patterns   */  private final static byte CBPtable[][] = {    // 000000xxx    {  0,0 }, {  0,9 }, { 39,9 }, { 27,9 },    { 59,9 }, { 55,9 }, { 47,9 }, { 31,9 },    // 000xxxxx.    {  0,0 }, { 39,9 }, { 59,9 }, { 47,9 },    { 58,8 }, { 54,8 }, { 46,8 }, { 30,8 },    { 57,8 }, { 53,8 }, { 45,8 }, { 29,8 },    { 38,8 }, { 26,8 }, { 37,8 }, { 25,8 },    { 43,8 }, { 23,8 }, { 51,8 }, { 15,8 },    { 42,8 }, { 22,8 }, { 50,8 }, { 14,8 },    { 41,8 }, { 21,8 }, { 49,8 }, { 13,8 },    { 35,8 }, { 19,8 }, { 11,8 }, {  7,8 },    // 001xxxx..    { 34,7 }, { 18,7 }, { 10,7 }, {  6,7 },    { 33,7 }, { 17,7 }, {  9,7 }, {  5,7 },    { 63,6 }, { 63,6 }, {  3,6 }, {  3,6 },    { 36,6 }, { 36,6 }, { 24,6 }, { 24,6 },    // xxxxx....    {  0,0 }, { 57,8 }, { 43,8 }, { 41,8 },    { 34,7 }, { 33,7 }, { 63,6 }, { 36,6 },    { 62,5 }, {  2,5 }, { 61,5 }, {  1,5 },    { 56,5 }, { 52,5 }, { 44,5 }, { 28,5 },    { 40,5 }, { 20,5 }, { 48,5 }, { 12,5 },    { 32,4 }, { 32,4 }, { 16,4 }, { 16,4 },    {  8,4 }, {  8,4 }, {  4,4 }, {  4,4 },    { 60,3 }, { 60,3 }, { 60,3 }, { 60,3 }  };  /**   * Table B-10, variable length codes for motion vector codes   */  private final static byte MVtable[][] = {    // 00000011xx    { 16,10 }, { 15,10 }, { 14,10 }, { 13,10 },    // 0000010xxx    { 12,10 }, { 11,10 }, { 10, 9 }, { 10, 9 },    {  9, 9 }, {  9, 9 }, {  8, 9 }, {	8, 9 },    // 000xxxx...    {  0, 0 }, {  0, 0 }, { 12,10 }, {	7, 7 },    {  6, 7 }, {  5, 7 }, {  4, 6 }, {	4, 6 },    {  3, 4 }, {  3, 4 }, {  3, 4 }, {	3, 4 },    {  3, 4 }, {  3, 4 }, {  3, 4 }, {	3, 4 },    // xxx.......    {  0, 0 }, {  2, 3 }, {  1, 2 }, {	1, 2 },    {  0, 0 }, {  0, 0 }, {  0, 0 }, {	0, 0 }  };  /**   * Table B-12, variable length codes for DC luminance sizes   */  private final static byte DClumtable[][] = {    // xxx......    {  1,2 }, {  1,2 }, {  2,2 }, {  2,2 },    {  0,3 }, {  3,3 }, {  4,3 }, {  5,4 },    // 111xxx...    {  5,4 }, {  5,4 }, {  5,4 }, {  5,4 },    {  6,5 }, {  6,5 }, {  7,6 }, {  8,7 },    // 111111xxx    {  8,7 }, {  8,7 }, {  8,7 }, {  8,7 },    {  9,8 }, {  9,8 }, { 10,9 }, { 11,9 }  };  /**   * Table B-13, variable length codes for DC chrominance sizes   */  private final static byte DCchrtable[][] = {    // xxxx......    {  0,2 }, {  0,2 }, {  0,2 }, {  0,2 },    {  1,2 }, {  1,2 }, {  1,2 }, {  1,2 },    {  2,2 }, {  2,2 }, {  2,2 }, {  2,2 },    {  3,3 }, {  3,3 }, {  4,4 }, {  5,5 },    // 1111xxx...    {  5,5 }, {  5,5 }, {  5,5 }, {  5,5 },    {  6,6 }, {  6,6 }, {  7,7 }, {  8,8 },    // 1111111xxx    {  8,8 }, {  8,8 }, {  8,8 }, {  8,8 },    {  9,9 }, {  9,9 }, { 10,10 }, { 11,10 }  };  public final static short EOB = 64;  public final static short ESC = 65;  /**   * Table B-14, variable length codes for DCT coefficients   */  private final static short DCTtable[][] = {    // 000000000001xxxx    { 4609,16 }, { 4353,16 }, { 4097,16 }, { 3841,16 },    {  774,16 }, {  528,16 }, {  527,16 }, {  526,16 },    {  525,16 }, {  524,16 }, {  523,16 }, {  287,16 },    {  286,16 }, {  285,16 }, {  284,16 }, {  283,16 },    // 00000000001xxxx.    {10240,15 }, { 9984,15 }, { 9728,15 }, { 9472,15 },    { 9216,15 }, { 8960,15 }, { 8704,15 }, { 8448,15 },    { 8192,15 }, { 3585,15 }, { 3329,15 }, { 3073,15 },    { 2817,15 }, { 2561,15 }, { 2305,15 }, { 2049,15 },    // 0000000001xxxx..    { 7936,14 }, { 7680,14 }, { 7424,14 }, { 7168,14 },    { 6912,14 }, { 6656,14 }, { 6400,14 }, { 6144,14 },    { 5888,14 }, { 5632,14 }, { 5376,14 }, { 5120,14 },    { 4864,14 }, { 4608,14 }, { 4352,14 }, { 4096,14 },    // 000000001xxxx...    {  522,13 }, {  521,13 }, {  773,13 }, { 1027,13 },    { 1282,13 }, { 1793,13 }, { 1537,13 }, { 3840,13 },    { 3584,13 }, { 3328,13 }, { 3072,13 }, {  282,13 },    {  281,13 }, {  280,13 }, {  279,13 }, {  278,13 },    // 00000001xxxx....    { 2816,12 }, {  520,12 }, {  772,12 }, { 2560,12 },    { 1026,12 }, {  519,12 }, {  277,12 }, {  276,12 },    { 2304,12 }, {  275,12 }, {  274,12 }, { 1281,12 },    {  771,12 }, { 2048,12 }, {  518,12 }, {  273,12 },    // 0000001xxx......    {  272,10 }, {  517,10 }, { 1792,10 }, {  770,10 },    { 1025,10 }, {  271,10 }, {  270,10 }, {  516,10 },    // 000xxxx.........    {	 0, 0 }, {  272,10 }, {  ESC, 6 }, {  ESC, 6 },    {  514, 7 }, {  265, 7 }, { 1024, 7 }, {  264, 7 },    {  263, 6 }, {  263, 6 }, {  262, 6 }, {  262, 6 },    {  513, 6 }, {  513, 6 }, {  261, 6 }, {  261, 6 },    // 00100xxx........    {  269, 8 }, { 1536, 8 }, {  268, 8 }, {  267, 8 },    {  515, 8 }, {  769, 8 }, { 1280, 8 }, {  266, 8 },    // xxxxx...........    {	0,  0 }, {  514, 7 }, {  263, 6 }, {  513, 6 },    {  269, 8 }, {  768, 5 }, {  260, 5 }, {  259, 5 },    {  512, 4 }, {  512, 4 }, {  258, 4 }, {  258, 4 },    {  257, 3 }, {  257, 3 }, {  257, 3 }, {  257, 3 },    {  EOB, 2 }, {  EOB, 2 }, {  EOB, 2 }, {  EOB, 2 },    {  EOB, 2 }, {  EOB, 2 }, {  EOB, 2 }, {  EOB, 2 },    {  256, 2 }, {  256, 2 }, {  256, 2 }, {  256, 2 },    {  256, 2 }, {  256, 2 }, {  256, 2 }, {  256, 2 }  };  /**   * Storage for RLE run and level of DCT block coefficients   */  private int data[];  /**   * Initializes the Huffman entropy decoder for MPEG-1 streams   */  public VLCInputStream(InputStream inputStream) {    super(inputStream);    data = new int[2];  }  /**   * Returns macroblock address increment codes   */  public int getMBACode() throws IOException {    int code, value = 0;    /* skip macroblock escape */    while ((code = showBits(11)) == 15) {      flushBits(11);    }    /* decode macroblock skip codes */    while ((code = showBits(11)) == 8) {      flushBits(11);      value += 33;    }    /* decode macroblock increment */    if (code >= 512)      code = (code >> 8) + 48;    else if (code >= 128)      code = (code >> 6) + 40;    else if (code >= 48)      code = (code >> 3) + 24;    else if (code >= 24)      code -= 24;    else      throw new IOException("Invalid macro block address increment");    flushBits(MBAtable[code][1]);    return value + MBAtable[code][0];  }  /**   * Returns I-picture macroblock type flags   */  public int getIMBCode() throws IOException {    int code = showBits(2);    if (code <= 0)      throw new IOException("Invalid I-picture macro block code");    flushBits(IMBtable[code][1]);    return IMBtable[code][0];  }  /**   * Returns P-picture macroblock type flags   */  public int getPMBCode() throws IOException {    int code = showBits(6);    if (code >= 8)      code = (code >> 3) + 8;    else if (code <= 0)      throw new IOException("Invalid P-picture macro block code");    flushBits(PMBtable[code][1]);    return PMBtable[code][0];  }  /**   * Returns B-picture macroblock type flags   */  public int getBMBCode() throws IOException {    int code = showBits(6);    if (code >= 16)      code = (code >> 3) + 16;    else if (code <= 0)      throw new IOException("Invalid B-picture macro block code");    flushBits(BMBtable[code][1]);    return BMBtable[code][0];  }  /**   * Returns coded block pattern flags   */  public int getCBPCode() throws IOException {    int code = showBits(9);    if (code >= 128)      code = (code >> 4) + 56;    else if (code >= 64)      code = (code >> 2) + 24;    else if (code >= 8)      code = (code >> 1) + 8;    else if (code <= 0)      throw new IOException("Invalid block pattern code");    flushBits(CBPtable[code][1]);    return CBPtable[code][0];  }  /**   * Returns motion vector codes   */  public int getMVCode() throws IOException {    int code = showBits(10);    if (code >= 128)      code = (code >> 7) + 28;    else if (code >= 24)      code = (code >> 3) + 12;    else if (code >= 12)      code -= 12;    else      throw new IOException("Invalid motion vector code");    flushBits(MVtable[code][1]);    code = MVtable[code][0];    return (getBits(1) == 0 ? code : -code);  }  /**   * Returns intra coded DC luminance coefficients   */  public int getIntraDCLumValue() throws IOException {    int code = showBits(9);    if (code >= 504)      code -= 488;    else if (code >= 448)      code = (code >> 3) - 48;    else      code >>= 6;    flushBits(DClumtable[code][1]);    int nbits = DClumtable[code][0];    if (nbits != 0) {      code = getBits(nbits);      if ((code & (1 << (nbits - 1))) == 0)	code -= (1 << nbits) - 1;      return code;    }    return 0;  }  /**   * Returns intra coded DC chrominance coefficients   */  public int getIntraDCChromValue() throws IOException {    int code = showBits(10);    if (code >= 1016)      code -= 992;    else if (code >= 960)      code = (code >> 3) - 104;    else      code >>= 6;    flushBits(DCchrtable[code][1]);    int nbits = DCchrtable[code][0];    if (nbits != 0) {      code = getBits(nbits);      if ((code & (1 << (nbits - 1))) == 0)	code -= (1 << nbits) - 1;      return code;    }    return 0;  }  /**   * Returns inter coded DC luminance or chrominance coefficients   */  public int[] getInterDCValue() throws IOException {    /* handle special variable length code */    if (showBits(1) != 0) {      data[0] = 0;      data[1] = getBits(2) == 2 ? 1 : -1;      return data;