开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
vld.h
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：58k
源码类别：

Symbian

开发平台：

C/C++

vld.h：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #ifndef _INC_VLD
  37. #define _INC_VLD 1
  38.  
  39. /*  DECTABENTRY - Description of each entry in the decode tables
  40.  *  An entry in the decode table contains the following information:
  41.  *  sym  -      a)  If bits > 0, sym contains decoded symbol
  42.  *              If sym.type = SYM_EXIT, we find the reason in sym.value
  43.  *              b)  bits < 0 indicates that long codeword was encountered.
  44.  *              We continue decoding using table indicated by sym.value.
  45.  *              sym.type is not defined.
  46.  *  statechange Add to state to get the new state
  47.  *  bits  -     abs(bits) is # of parsed bits.  bits < 0 indicates code > 8 bits
  48.  */
  50. typedef struct {
  51.     SYMBOL sym;
  52.     S8 statechange;
  53.     S8 bits;
  54. } DECTABENTRY;
  56. #define DECTABBITS          8       /* Look up DECTABBITS bits at a time */
  57. #define DECTABSIZE          256     /* 2 ** DECTABBITS */
  59. DECTABENTRY dectable[NUMTABS][DECTABSIZE];
  61. U8 selectdectab[NUMSTATES] = {
  62.     TAB_ILLEGAL_STATE,                      /* State 0 is not used */
  63.     TAB_MVD,                TAB_MVD,        /* ST_MC_NOCBP_MVD */
  64.     TAB_MBA_STARTCODE,
  65.     TAB_DCT_NEXT,           TAB_DCT_FIRST,  /* Block 6 */
  66.     TAB_DCT_NEXT,           TAB_DCT_FIRST,  /* Block 5 */
  67.     TAB_DCT_NEXT,           TAB_DCT_FIRST,  /* Block 4 */
  68.     TAB_DCT_NEXT,           TAB_DCT_FIRST,  /* Block 3 */
  69.     TAB_DCT_NEXT,           TAB_DCT_FIRST,  /* Block 2 */
  70.     TAB_DCT_NEXT,           TAB_DCT_FIRST,  /* Block 1 */
  71.     TAB_LAST_INTRA_DC,                      /* INTRA Block 6 */
  72.     TAB_DCT_NEXT,           TAB_INTRA_DC,   /* INTRA Block 5 */
  73.     TAB_DCT_NEXT,           TAB_INTRA_DC,   /* INTRA Block 4 */
  74.     TAB_DCT_NEXT,           TAB_INTRA_DC,   /* INTRA Block 3 */
  75.     TAB_DCT_NEXT,           TAB_INTRA_DC,   /* INTRA Block 2 */
  76.     TAB_DCT_NEXT,           TAB_INTRA_DC,   /* INTRA Block 1 */
  77.     TAB_MVD,                TAB_MVD,        /* ST_MC_CBP_MVD */
  78.     TAB_CBP,
  79.     TAB_QUANT_TR,                           /* ST_INTRA_MQUANT */
  80.     TAB_QUANT_TR,                           /* ST_MC_CBP_MQUANT */
  81.     TAB_ESCAPE_LEVEL,
  82.     TAB_QUANT_TR,                           /* ST_INTER_MQUANT */
  83.     TAB_ESCAPE_LEVEL,
  84.     TAB_MTYPE,
  85.     TAB_ESCAPE_LEVEL,
  86.     TAB_GEI_PEI,
  87.     TAB_ESCAPE_LEVEL,
  88.     TAB_PTYPE,
  89.     TAB_ESCAPE_LEVEL,
  90.     TAB_QUANT_TR,                           /* ST_GQUANT */
  91.     TAB_ESCAPE_LEVEL,
  92.     TAB_QUANT_TR,                           /* ST_TR */
  93.     TAB_GN,                                 /* ST_AFTER_STARTCODE */
  94.     TAB_ESCAPE_LEVEL,
  95.     TAB_ILLEGAL_STATE,                      /* State 46 is not used */
  96.     TAB_ESCAPE_LEVEL,
  97.     TAB_ILLEGAL_STATE,                      /* State 48 is not used */
  98.     TAB_ESCAPE_LEVEL,
  99.     TAB_ILLEGAL_STATE,                      /* State 50 is not used */
  100.     TAB_ESCAPE_LEVEL,
  101.     TAB_ILLEGAL_STATE,                      /* State 52 is not used */
  102.     TAB_ESCAPE_LEVEL,
  103.     
  104.     // H.263 states start at item 54
  105.     TAB263_FINISHED,                        // Done with last block
  106.     TAB263_ESCAPE_LEVEL,                    // ESCAPE-RUN-LEVEL as last TCOEF of last block
  107.     TAB263_TCOEF,   TAB263_ESCAPE_LEVEL,    // Block 6
  108.     TAB263_TCOEF,   TAB263_ESCAPE_LEVEL,    // Block 5
  109.     TAB263_TCOEF,   TAB263_ESCAPE_LEVEL,    // Block 4
  110.     TAB263_TCOEF,   TAB263_ESCAPE_LEVEL,    // Block 3
  111.     TAB263_TCOEF,   TAB263_ESCAPE_LEVEL,    // Block 2
  112.     TAB263_TCOEF,   TAB263_ESCAPE_LEVEL,    // Block 1
  113.     TAB263_INTRA_DC,                        // INTRA-DC only
  114.     TAB_ILLEGAL_STATE,                      // State 69 is not used
  115.     TAB263_INTRA_DC                         // INTRA-DC followed by AC coefficients
  117. #ifdef DO_H263_PLUS
  118.     ,
  119.     TAB263_FINISHED,                            // Done with last block
  120.     TAB263_ESCAPE_LEVEL,                        // ESCAPE-RUN-LEVEL as last TCOEF of last block
  121.     TAB263PLUS_TCOEF, TAB263_ESCAPE_LEVEL,  // Block 6
  122.     TAB263PLUS_TCOEF, TAB263_ESCAPE_LEVEL,  // Block 5
  123.     TAB263PLUS_TCOEF, TAB263_ESCAPE_LEVEL,  // Block 4
  124.     TAB263PLUS_TCOEF, TAB263_ESCAPE_LEVEL,  // Block 3
  125.     TAB263PLUS_TCOEF, TAB263_ESCAPE_LEVEL,  // Block 2
  126.     TAB263PLUS_TCOEF, TAB263_ESCAPE_LEVEL   // Block 1
  127. #endif
  128. };
  130. #define MAX_STRING_VLD          (DECTABBITS + 4)
  132. struct vlc_entry {
  133.     char    vlc[MAX_STRING_VLD]; /* Flawfinder: ignore */
  134.     int     type;
  135.     int     value;
  136.     int     statechange;
  137.     int     last_value; /* Only used for fixed-length codes */
  138. };
  141. ////////////////  Tables for H.261  //////////////////
  143. static  struct vlc_entry dct_next[] = {
  144.     {"0000 01",     SYM_ESCAPE, TAB_ESCAPE_RUN,    0},
  145.     {"0010 0",      SYM_ESCAPE, TAB_DCT_00100,     0},
  146.     {"0000 00",     SYM_ESCAPE, TAB_DCT_000000,    0},
  147.     {"10",          SYM_EOB,    0,      (ST_FIRST_BLK_2 - ST_NEXT_BLK_1)},
  149.     {"110",         0,      1,      0},
  150.     {"111",         0,      -1,     0},
  152.     {"0110",        1,      1,      0},
  153.     {"0111",        1,      -1,     0},
  155.     {"0100 0",      0,      2,      0},
  156.     {"0100 1",      0,      -2,     0},
  157.     {"0101 0",      2,      1,      0},
  158.     {"0101 1",      2,      -1,     0},
  160.     {"0010 10",     0,      3,      0},
  161.     {"0010 11",     0,      -3,     0},
  162.     {"0011 10",     3,      1,      0},
  163.     {"0011 11",     3,      -1,     0},
  164.     {"0011 00",     4,      1,      0},
  165.     {"0011 01",     4,      -1,     0},
  167.     {"0001 100",    1,      2,      0},
  168.     {"0001 101",    1,      -2,     0},
  169.     {"0001 110",    5,      1,      0},
  170.     {"0001 111",    5,      -1,     0},
  171.     {"0001 010",    6,      1,      0},
  172.     {"0001 011",    6,      -1,     0},
  173.     {"0001 000",    7,      1,      0},
  174.     {"0001 001",    7,      -1,     0},
  176.     {"0000 1100",   0,      4,      0},
  177.     {"0000 1101",   0,      -4,     0},
  178.     {"0000 1000",   2,      2,      0},
  179.     {"0000 1001",   2,      -2,     0},
  180.     {"0000 1110",   8,      1,      0},
  181.     {"0000 1111",   8,      -1,     0},
  182.     {"0000 1010",   9,      1,      0},
  183.     {"0000 1011",   9,      -1,     0},
  184.     {"End"}
  185. };
  187. static  struct vlc_entry dct_first[] = {
  188.     {"0000 01",     SYM_ESCAPE, TAB_ESCAPE_RUN, (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  189.     {"0010 0",      SYM_ESCAPE, TAB_DCT_00100,  (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  190.     {"0000 00",     SYM_ESCAPE, TAB_DCT_000000, (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  192.     {"10",          0,      1,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  193.     {"11",          0,      -1,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  195.     {"0110",        1,      1,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  196.     {"0111",        1,      -1,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  198.     {"0100 0",      0,      2,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  199.     {"0100 1",      0,      -2,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  200.     {"0101 0",      2,      1,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  201.     {"0101 1",      2,      -1,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  203.     {"0010 10",     0,      3,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  204.     {"0010 11",     0,      -3,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  205.     {"0011 10",     3,      1,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  206.     {"0011 11",     3,      -1,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  207.     {"0011 00",     4,      1,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  208.     {"0011 01",     4,      -1,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  210.     {"0001 100",    1,      2,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  211.     {"0001 101",    1,      -2,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  212.     {"0001 110",    5,      1,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  213.     {"0001 111",    5,      -1,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  214.     {"0001 010",    6,      1,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  215.     {"0001 011",    6,      -1,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  216.     {"0001 000",    7,      1,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  217.     {"0001 001",    7,      -1,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  219.     {"0000 1100",   0,      4,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  220.     {"0000 1101",   0,      -4,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  221.     {"0000 1000",   2,      2,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  222.     {"0000 1001",   2,      -2,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  223.     {"0000 1110",   8,      1,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  224.     {"0000 1111",   8,      -1,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  225.     {"0000 1010",   9,      1,      (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  226.     {"0000 1011",   9,      -1,     (ST_NEXT_BLK_1 - ST_FIRST_BLK_1)},
  227.     {"End"}
  228. };
  230. static  struct vlc_entry dct_00100[] = {
  231.     {"110 0",       0,      5,      0},
  232.     {"110 1",       0,      -5,     0},
  233.     {"001 0",       0,      6,      0},
  234.     {"001 1",       0,      -6,     0},
  235.     {"101 0",       1,      3,      0},
  236.     {"101 1",       1,      -3,     0},
  237.     {"100 0",       3,      2,      0},
  238.     {"100 1",       3,      -2,     0},
  239.     {"111 0",       10,     1,      0},
  240.     {"111 1",       10,     -1,     0},
  241.     {"011 0",       11,     1,      0},
  242.     {"011 1",       11,     -1,     0},
  243.     {"010 0",       12,     1,      0},
  244.     {"010 1",       12,     -1,     0},
  245.     {"000 0",       13,     1,      0},
  246.     {"000 1",       13,     -1,     0},
  247.     {"End"}
  248. };
  250. static  struct vlc_entry dct_000000[] = {
  251.     {"10 100",      0,      7,      0},
  252.     {"10 101",      0,      -7,     0},
  253.     {"11 000",      1,      4,      0},
  254.     {"11 001",      1,      -4,     0},
  255.     {"10 110",      2,      3,      0},
  256.     {"10 111",      2,      -3,     0},
  257.     {"11 110",      4,      2,      0},
  258.     {"11 111",      4,      -2,     0},
  259.     {"10 010",      5,      2,      0},
  260.     {"10 011",      5,      -2,     0},
  261.     {"11 100",      14,     1,      0},
  262.     {"11 101",      14,     -1,     0},
  263.     {"11 010",      15,     1,      0},
  264.     {"11 011",      15,     -1,     0},
  265.     {"10 000",      16,     1,      0},
  266.     {"10 001",      16,     -1,     0},
  268.     {"01 1101 0",   0,      8,      0},
  269.     {"01 1101 1",   0,      -8,     0},
  270.     {"01 1000 0",   0,      9,      0},
  271.     {"01 1000 1",   0,      -9,     0},
  272.     {"01 0011 0",   0,      10,     0},
  273.     {"01 0011 1",   0,      -10,    0},
  274.     {"01 0000 0",   0,      11,     0},
  275.     {"01 0000 1",   0,      -11,    0},
  276.     {"01 1011 0",   1,      5,      0},
  277.     {"01 1011 1",   1,      -5,     0},
  278.     {"01 0100 0",   2,      4,      0},
  279.     {"01 0100 1",   2,      -4,     0},
  280.     {"01 1100 0",   3,      3,      0},
  281.     {"01 1100 1",   3,      -3,     0},
  282.     {"01 0010 0",   4,      3,      0},
  283.     {"01 0010 1",   4,      -3,     0},
  284.     {"01 1110 0",   6,      2,      0},
  285.     {"01 1110 1",   6,      -2,     0},
  286.     {"01 0101 0",   7,      2,      0},
  287.     {"01 0101 1",   7,      -2,     0},
  288.     {"01 0001 0",   8,      2,      0},
  289.     {"01 0001 1",   8,      -2,     0},
  290.     {"01 1111 0",   17,     1,      0},
  291.     {"01 1111 1",   17,     -1,     0},
  292.     {"01 1010 0",   18,     1,      0},
  293.     {"01 1010 1",   18,     -1,     0},
  294.     {"01 1001 0",   19,     1,      0},
  295.     {"01 1001 1",   19,     -1,     0},
  296.     {"01 0111 0",   20,     1,      0},
  297.     {"01 0111 1",   20,     -1,     0},
  298.     {"01 0110 0",   21,     1,      0},
  299.     {"01 0110 1",   21,     -1,     0},
  301.     {"00 1101 00",  0,      12,     0},
  302.     {"00 1101 01",  0,      -12,    0},
  303.     {"00 1100 10",  0,      13,     0},
  304.     {"00 1100 11",  0,      -13,    0},
  305.     {"00 1100 00",  0,      14,     0},
  306.     {"00 1100 01",  0,      -14,    0},
  307.     {"00 1011 10",  0,      15,     0},
  308.     {"00 1011 11",  0,      -15,    0},
  309.     {"00 1011 00",  1,      6,      0},
  310.     {"00 1011 01",  1,      -6,     0},
  311.     {"00 1010 10",  1,      7,      0},
  312.     {"00 1010 11",  1,      -7,     0},
  313.     {"00 1010 00",  2,      5,      0},
  314.     {"00 1010 01",  2,      -5,     0},
  315.     {"00 1001 10",  3,      4,      0},
  316.     {"00 1001 11",  3,      -4,     0},
  317.     {"00 1001 00",  5,      3,      0},
  318.     {"00 1001 01",  5,      -3,     0},
  319.     {"00 1000 10",  9,      2,      0},
  320.     {"00 1000 11",  9,      -2,     0},
  321.     {"00 1000 00",  10,     2,      0},
  322.     {"00 1000 01",  10,     -2,     0},
  323.     {"00 1111 10",  22,     1,      0},
  324.     {"00 1111 11",  22,     -1,     0},
  325.     {"00 1111 00",  23,     1,      0},
  326.     {"00 1111 01",  23,     -1,     0},
  327.     {"00 1110 10",  24,     1,      0},
  328.     {"00 1110 11",  24,     -1,     0},
  329.     {"00 1110 00",  25,     1,      0},
  330.     {"00 1110 01",  25,     -1,     0},
  331.     {"00 1101 10",  26,     1,      0},
  332.     {"00 1101 11",  26,     -1,     0},
  333.     {"End"}
  334. };
  336. static  struct vlc_entry escape_run[] = {
  337.     {"FLC"},
  338.     {"00 0000",     SYM_ESC_RUN,    0,  -ST_DIFF_ESC_LEVEL,     63},
  339.     {"End"}
  340. };
  342. /* ESC_LEVEL: Levels 0 and -128 are not allowed */
  343. static  struct vlc_entry escape_level[] = {
  344.     {"FLC"},
  345.     {"0000 0001",   SYM_ESC_LEVEL,      1,  ST_DIFF_ESC_LEVEL,  127},
  346.     {"1000 0001",   SYM_ESC_LEVEL,   -127,  ST_DIFF_ESC_LEVEL,  -1},
  347.     {"End"}
  348. };
  350. /* INTRA DC coeff:  Levels 0 and 255 not allowed; level 128 repr. by 255 */
  351. static  struct vlc_entry intra_dc[] = {
  352.     {"FLC"},
  353.     {"0000 0001", SYM_INTRA_DC,   1,    -1,     127},
  354.     {"1111 1111", SYM_INTRA_DC, 128,    -1,     128},
  355.     {"1000 0001", SYM_INTRA_DC, 129,    -1,     254},
  356.     {"End"}
  357. };
  359. /* INTRA DC coeff:  Levels 0 and 255 not allowed; level 128 repr. by 255 */
  360. static  struct vlc_entry last_intra_dc[] = {
  361.     {"FLC"},
  362.     {"0000 0001", SYM_INTRA_DC,   1, (ST_NEXT_BLK_6 - ST_INTRA_DC_BLK_6), 127},
  363.     {"1111 1111", SYM_INTRA_DC, 128, (ST_NEXT_BLK_6 - ST_INTRA_DC_BLK_6), 128},
  364.     {"1000 0001", SYM_INTRA_DC, 129, (ST_NEXT_BLK_6 - ST_INTRA_DC_BLK_6), 254},
  365.     {"End"}
  366. };
  368. static  struct vlc_entry mba_startcode[] = {
  369.     {"1",           SYM_MBA,        1,  (ST_MTYPE - ST_MBA_STARTCODE)},
  370.     {"011",         SYM_MBA,        2,  (ST_MTYPE - ST_MBA_STARTCODE)},
  371.     {"010",         SYM_MBA,        3,  (ST_MTYPE - ST_MBA_STARTCODE)},
  372.     {"0011",        SYM_MBA,        4,  (ST_MTYPE - ST_MBA_STARTCODE)},
  373.     {"0010",        SYM_MBA,        5,  (ST_MTYPE - ST_MBA_STARTCODE)},
  374.     {"0001 1",      SYM_MBA,        6,  (ST_MTYPE - ST_MBA_STARTCODE)},
  375.     {"0001 0",      SYM_MBA,        7,  (ST_MTYPE - ST_MBA_STARTCODE)},
  376.     {"0000 111",    SYM_MBA,        8,  (ST_MTYPE - ST_MBA_STARTCODE)},
  377.     {"0000 110",    SYM_MBA,        9,  (ST_MTYPE - ST_MBA_STARTCODE)},
  378.     {"0000 1011",   SYM_MBA,       10,  (ST_MTYPE - ST_MBA_STARTCODE)},
  379.     {"0000 1010",   SYM_MBA,       11,  (ST_MTYPE - ST_MBA_STARTCODE)},
  380.     {"0000 1001",   SYM_MBA,       12,  (ST_MTYPE - ST_MBA_STARTCODE)},
  381.     {"0000 1000",   SYM_MBA,       13,  (ST_MTYPE - ST_MBA_STARTCODE)},
  383.     {"0000 0",      SYM_ESCAPE, TAB_LONG_MBA,   0},
  384.     {"End"}
  385. };
  387. static  struct vlc_entry long_mba[] = {
  388.     {"111",         SYM_MBA,       14,  (ST_MTYPE - ST_MBA_STARTCODE)},
  389.     {"110",         SYM_MBA,       15,  (ST_MTYPE - ST_MBA_STARTCODE)},
  390.     
  391.     {"101 11",      SYM_MBA,       16,  (ST_MTYPE - ST_MBA_STARTCODE)},
  392.     {"101 10",      SYM_MBA,       17,  (ST_MTYPE - ST_MBA_STARTCODE)},
  393.     {"101 01",      SYM_MBA,       18,  (ST_MTYPE - ST_MBA_STARTCODE)},
  394.     {"101 00",      SYM_MBA,       19,  (ST_MTYPE - ST_MBA_STARTCODE)},
  395.     {"100 11",      SYM_MBA,       20,  (ST_MTYPE - ST_MBA_STARTCODE)},
  396.     {"100 10",      SYM_MBA,       21,  (ST_MTYPE - ST_MBA_STARTCODE)},
  398.     {"100 011",     SYM_MBA,       22,  (ST_MTYPE - ST_MBA_STARTCODE)},
  399.     {"100 010",     SYM_MBA,       23,  (ST_MTYPE - ST_MBA_STARTCODE)},
  400.     {"100 001",     SYM_MBA,       24,  (ST_MTYPE - ST_MBA_STARTCODE)},
  401.     {"100 000",     SYM_MBA,       25,  (ST_MTYPE - ST_MBA_STARTCODE)},
  402.     {"011 111",     SYM_MBA,       26,  (ST_MTYPE - ST_MBA_STARTCODE)},
  403.     {"011 110",     SYM_MBA,       27,  (ST_MTYPE - ST_MBA_STARTCODE)},
  404.     {"011 101",     SYM_MBA,       28,  (ST_MTYPE - ST_MBA_STARTCODE)},
  405.     {"011 100",     SYM_MBA,       29,  (ST_MTYPE - ST_MBA_STARTCODE)},
  406.     {"011 011",     SYM_MBA,       30,  (ST_MTYPE - ST_MBA_STARTCODE)},
  407.     {"011 010",     SYM_MBA,       31,  (ST_MTYPE - ST_MBA_STARTCODE)},
  408.     {"011 001",     SYM_MBA,       32,  (ST_MTYPE - ST_MBA_STARTCODE)},
  409.     {"011 000",     SYM_MBA,       33,  (ST_MTYPE - ST_MBA_STARTCODE)},
  411.     {"001 111",     SYM_MBA_STUFFING,   0,  0},
  412.     {"000 0000 0",  SYM_ESCAPE, TAB_LONG_STARTCODE, 0},
  413.     {"End"}
  414. };
  416. static  struct vlc_entry long_startcode[] = {
  417.     {"001",     SYM_STARTCODE, 0, (ST_AFTER_STARTCODE - ST_MBA_STARTCODE)},
  418.     {"End"}
  419. };
  421. static  struct vlc_entry mtype[] = {
  422.     {"0001",    SYM_MTYPE,  MTYPE_INTRA,        (ST_INTRA_DC_BLK_1 - ST_MTYPE)},
  423.     {"0000 001",SYM_MTYPE,  MTYPE_INTRA_MQUANT, (ST_INTRA_MQUANT - ST_MTYPE)},
  424.     {"1",       SYM_MTYPE,  MTYPE_INTER,        (ST_CBP - ST_MTYPE)},
  425.     {"0000 1",  SYM_MTYPE,  MTYPE_INTER_MQUANT, (ST_INTER_MQUANT - ST_MTYPE)},
  426.     {"0000 0001",SYM_MTYPE, MTYPE_MC_CBP,       (ST_MC_CBP_MVDX - ST_MTYPE)},
  427.     {"001",     SYM_MTYPE,  MTYPE_MCFILT_NOCBP, (ST_MC_NOCBP_MVDX - ST_MTYPE)},
  428.     {"01",      SYM_MTYPE,  MTYPE_MCFILT_CBP,   (ST_MC_CBP_MVDX - ST_MTYPE)},
  429.     {"0000 01", SYM_MTYPE,  MTYPE_MCFILT_MQUANT,(ST_MC_CBP_MQUANT - ST_MTYPE)},
  430.     {"0000 0000", SYM_ESCAPE,   TAB_LONG_MTYPE, 0},
  431.     {"End"}
  432. };
  434. static  struct vlc_entry long_mtype[] = {
  435.     {"1",       SYM_MTYPE,  MTYPE_MC_NOCBP,     (ST_MC_NOCBP_MVDX - ST_MTYPE)},
  436.     {"01",      SYM_MTYPE,  MTYPE_MC_MQUANT,    (ST_MC_CBP_MQUANT - ST_MTYPE)},
  437.     {"End"}
  438. };
  440. static  struct vlc_entry mvd[] = {
  441.     {"1",           SYM_MVD,    0,      1},
  442.     {"010",         SYM_MVD,    1,      1},
  443.     {"011",         SYM_MVD,    -1,     1},
  444.     {"0010",        SYM_MVD,    2,      1},
  445.     {"0011",        SYM_MVD,    -2,     1},
  446.     {"0001 0",      SYM_MVD,    3,      1},
  447.     {"0001 1",      SYM_MVD,    -3,     1},
  448.     {"0000 110",    SYM_MVD,    4,      1},
  449.     {"0000 111",    SYM_MVD,    -4,     1},
  450.     {"0000 1010",   SYM_MVD,    5,      1},
  451.     {"0000 1011",   SYM_MVD,    -5,     1},
  452.     {"0000 1000",   SYM_MVD,    6,      1},
  453.     {"0000 1001",   SYM_MVD,    -6,     1},
  454.     {"0000 0",      SYM_ESCAPE, TAB_LONG_MVD,   1},
  455.     {"End"}
  456. };
  458. static  struct vlc_entry long_mvd[] = {
  459.     {"110",         SYM_MVD,    7,      0},
  460.     {"111",         SYM_MVD,    -7,     0},
  461.     {"101 10",      SYM_MVD,    8,      0},
  462.     {"101 11",      SYM_MVD,    -8,     0},
  463.     {"101 00",      SYM_MVD,    9,      0},
  464.     {"101 01",      SYM_MVD,    -9,     0},
  465.     {"100 10",      SYM_MVD,    10,     0},
  466.     {"100 11",      SYM_MVD,    -10,    0},
  467.     {"100 010",     SYM_MVD,    11,     0},
  468.     {"100 011",     SYM_MVD,    -11,    0},
  469.     {"100 000",     SYM_MVD,    12,     0},
  470.     {"100 001",     SYM_MVD,    -12,    0},
  471.     {"011 110",     SYM_MVD,    13,     0},
  472.     {"011 111",     SYM_MVD,    -13,    0},
  473.     {"011 100",     SYM_MVD,    14,     0},
  474.     {"011 101",     SYM_MVD,    -14,    0},
  475.     {"011 010",     SYM_MVD,    15,     0},
  476.     {"011 011",     SYM_MVD,    -15,    0},
  477.     {"011 001",     SYM_MVD,    -16,    0},
  478.     {"End"}
  479. };
  481. static  struct vlc_entry cbp[] = {
  482.     {"111",         SYM_CBP,    0x3c,   (ST_FIRST_BLK_3 - ST_CBP)},
  483.     {"1101",        SYM_CBP,    0x4,    (ST_FIRST_BLK_6 - ST_CBP)},
  484.     {"1100",        SYM_CBP,    0x8,    (ST_FIRST_BLK_6 - ST_CBP)},
  485.     {"1011",        SYM_CBP,    0x10,   (ST_FIRST_BLK_6 - ST_CBP)},
  486.     {"1010",        SYM_CBP,    0x20,   (ST_FIRST_BLK_6 - ST_CBP)},
  488.     {"1001 1",      SYM_CBP,    0xc,    (ST_FIRST_BLK_5 - ST_CBP)},
  489.     {"1001 0",      SYM_CBP,    0x30,   (ST_FIRST_BLK_5 - ST_CBP)},
  490.     {"1000 1",      SYM_CBP,    0x14,   (ST_FIRST_BLK_5 - ST_CBP)},
  491.     {"1000 0",      SYM_CBP,    0x28,   (ST_FIRST_BLK_5 - ST_CBP)},
  492.     {"0111 1",      SYM_CBP,    0x1c,   (ST_FIRST_BLK_4 - ST_CBP)},
  493.     {"0111 0",      SYM_CBP,    0x2c,   (ST_FIRST_BLK_4 - ST_CBP)},
  494.     {"0110 1",      SYM_CBP,    0x34,   (ST_FIRST_BLK_4 - ST_CBP)},
  495.     {"0110 0",      SYM_CBP,    0x38,   (ST_FIRST_BLK_4 - ST_CBP)},
  496.     {"0101 1",      SYM_CBP,    0x1,    (ST_FIRST_BLK_6 - ST_CBP)},
  497.     {"0101 0",      SYM_CBP,    0x3d,   (ST_FIRST_BLK_2 - ST_CBP)},
  498.     {"0100 1",      SYM_CBP,    0x2,    (ST_FIRST_BLK_6 - ST_CBP)},
  499.     {"0100 0",      SYM_CBP,    0x3e,   (ST_FIRST_BLK_2 - ST_CBP)},
  501.     {"0011 11",     SYM_CBP,    0x18,   (ST_FIRST_BLK_5 - ST_CBP)},
  502.     {"0011 10",     SYM_CBP,    0x24,   (ST_FIRST_BLK_5 - ST_CBP)},
  503.     {"0011 01",     SYM_CBP,    0x3,    (ST_FIRST_BLK_5 - ST_CBP)},
  504.     {"0011 00",     SYM_CBP,    0x3f,   (ST_FIRST_BLK_1 - ST_CBP)},
  506.     {"0010 111",    SYM_CBP,    0x5,    (ST_FIRST_BLK_5 - ST_CBP)},
  507.     {"0010 110",    SYM_CBP,    0x9,    (ST_FIRST_BLK_5 - ST_CBP)},
  508.     {"0010 101",    SYM_CBP,    0x11,   (ST_FIRST_BLK_5 - ST_CBP)},
  509.     {"0010 100",    SYM_CBP,    0x21,   (ST_FIRST_BLK_5 - ST_CBP)},
  510.     {"0010 011",    SYM_CBP,    0x6,    (ST_FIRST_BLK_5 - ST_CBP)},
  511.     {"0010 010",    SYM_CBP,    0xa,    (ST_FIRST_BLK_5 - ST_CBP)},
  512.     {"0010 001",    SYM_CBP,    0x12,   (ST_FIRST_BLK_5 - ST_CBP)},
  513.     {"0010 000",    SYM_CBP,    0x22,   (ST_FIRST_BLK_5 - ST_CBP)},
  515.     {"0001 1111",   SYM_CBP,    0x7,    (ST_FIRST_BLK_4 - ST_CBP)},
  516.     {"0001 1110",   SYM_CBP,    0xb,    (ST_FIRST_BLK_4 - ST_CBP)},
  517.     {"0001 1101",   SYM_CBP,    0x13,   (ST_FIRST_BLK_4 - ST_CBP)},
  518.     {"0001 1100",   SYM_CBP,    0x23,   (ST_FIRST_BLK_4 - ST_CBP)},
  519.     {"0001 1011",   SYM_CBP,    0xd,    (ST_FIRST_BLK_4 - ST_CBP)},
  520.     {"0001 1010",   SYM_CBP,    0x31,   (ST_FIRST_BLK_4 - ST_CBP)},
  521.     {"0001 1001",   SYM_CBP,    0x15,   (ST_FIRST_BLK_4 - ST_CBP)},
  522.     {"0001 1000",   SYM_CBP,    0x29,   (ST_FIRST_BLK_4 - ST_CBP)},
  523.     {"0001 0111",   SYM_CBP,    0xe,    (ST_FIRST_BLK_4 - ST_CBP)},
  524.     {"0001 0110",   SYM_CBP,    0x32,   (ST_FIRST_BLK_4 - ST_CBP)},
  525.     {"0001 0101",   SYM_CBP,    0x16,   (ST_FIRST_BLK_4 - ST_CBP)},
  526.     {"0001 0100",   SYM_CBP,    0x2a,   (ST_FIRST_BLK_4 - ST_CBP)},
  527.     {"0001 0011",   SYM_CBP,    0xf,    (ST_FIRST_BLK_3 - ST_CBP)},
  528.     {"0001 0010",   SYM_CBP,    0x33,   (ST_FIRST_BLK_3 - ST_CBP)},
  529.     {"0001 0001",   SYM_CBP,    0x17,   (ST_FIRST_BLK_3 - ST_CBP)},
  530.     {"0001 0000",   SYM_CBP,    0x2b,   (ST_FIRST_BLK_3 - ST_CBP)},
  532.     {"0000 1111",   SYM_CBP,    0x19,   (ST_FIRST_BLK_4 - ST_CBP)},
  533.     {"0000 1110",   SYM_CBP,    0x25,   (ST_FIRST_BLK_4 - ST_CBP)},
  534.     {"0000 1101",   SYM_CBP,    0x1a,   (ST_FIRST_BLK_4 - ST_CBP)},
  535.     {"0000 1100",   SYM_CBP,    0x26,   (ST_FIRST_BLK_4 - ST_CBP)},
  536.     {"0000 1011",   SYM_CBP,    0x1d,   (ST_FIRST_BLK_3 - ST_CBP)},
  537.     {"0000 1010",   SYM_CBP,    0x2d,   (ST_FIRST_BLK_3 - ST_CBP)},
  538.     {"0000 1001",   SYM_CBP,    0x35,   (ST_FIRST_BLK_3 - ST_CBP)},
  539.     {"0000 1000",   SYM_CBP,    0x39,   (ST_FIRST_BLK_3 - ST_CBP)},
  540.     {"0000 0111",   SYM_CBP,    0x1e,   (ST_FIRST_BLK_3 - ST_CBP)},
  541.     {"0000 0110",   SYM_CBP,    0x2e,   (ST_FIRST_BLK_3 - ST_CBP)},
  542.     {"0000 0101",   SYM_CBP,    0x36,   (ST_FIRST_BLK_3 - ST_CBP)},
  543.     {"0000 0100",   SYM_CBP,    0x3a,   (ST_FIRST_BLK_3 - ST_CBP)},
  545.     {"0000 00",     SYM_ESCAPE, TAB_LONG_CBP,   0},
  546.     {"End"}
  547. };
  549. static  struct vlc_entry long_cbp[] = {
  550.     {"11 1",        SYM_CBP,    0x1f,   (ST_FIRST_BLK_2 - ST_CBP)},
  551.     {"11 0",        SYM_CBP,    0x2f,   (ST_FIRST_BLK_2 - ST_CBP)},
  552.     {"10 1",        SYM_CBP,    0x37,   (ST_FIRST_BLK_2 - ST_CBP)},
  553.     {"10 0",        SYM_CBP,    0x3b,   (ST_FIRST_BLK_2 - ST_CBP)},
  554.     {"01 1",        SYM_CBP,    0x1b,   (ST_FIRST_BLK_3 - ST_CBP)},
  555.     {"01 0",        SYM_CBP,    0x27,   (ST_FIRST_BLK_3 - ST_CBP)},
  556.     {"End"}
  557. };
  559. static  struct vlc_entry quant_tr[] = {
  560.     {"FLC"},
  561.     {"00000",   SYM_QUANT_TR,   0,      ST_DIFF_QUANT,      31},
  562.     {"End"}
  563. };
  565. static  struct vlc_entry gei_pei[] = {
  566.     {"0",       SYM_GEI_PEI,    0,      (ST_MBA_STARTCODE - ST_GEI_PEI)},
  567.     {"1",       SYM_ESCAPE, TAB_LONG_SPARE,     0},
  568.     {"End"}
  569. };
  571. static  struct vlc_entry long_spare[] = {
  572.     {"FLC"},
  573.     {"0000 0000",   SYM_SPARE,  0,      0,      255},
  574.     {"End"}
  575. };
  577. static  struct vlc_entry gn[] = {
  578.     {"FLC"},
  579.     {"0000",    SYM_GN,     0,  (ST_TR - ST_AFTER_STARTCODE),       0},
  580.     {"0001",    SYM_GN,     1,  (ST_GQUANT - ST_AFTER_STARTCODE),   15},
  581.     {"End"}
  582. };
  584. static  struct vlc_entry ptype[] = {
  585.     {"FLC"},
  586.     {"0000 00", SYM_PTYPE,  0,  (ST_GEI_PEI - ST_PTYPE),    63},
  587.     {"End"}
  588. };
  590. static  struct vlc_entry illegal_state[] = {
  591.     {"0",       SYM_EXIT,   ILLEGAL_STATE,      0},
  592.     {"1",       SYM_EXIT,   ILLEGAL_STATE,      0},
  593.     {"End"}
  594. };
  597. ////////////////  Tables for H.263  //////////////////
  599. // Starts with COD=0 for coded block; COD=1 for skipped block
  600. static  struct vlc_entry mcbpc263[] = {
  601.     {"0 0000 0",    SYM_ESCAPE, TAB263_LONG_MCBPC_INTER},
  602.     
  603.     {"1",           SYM_MCBPC,  MTYPE_SKIP},
  604.     
  605.     {"0 1",         SYM_MCBPC,  MTYPE263_INTER + 0},
  606.     {"0 0011",      SYM_MCBPC,  MTYPE263_INTER + 1},
  607.     {"0 0010",      SYM_MCBPC,  MTYPE263_INTER + 2},
  608.     {"0 0001 01",   SYM_MCBPC,  MTYPE263_INTER + 3},
  609.     {"0 011",       SYM_MCBPC,  MTYPE263_INTER_Q + 0},
  610.     {"0 0000 111",  SYM_MCBPC,  MTYPE263_INTER_Q + 1},
  611.     {"0 0000 110",  SYM_MCBPC,  MTYPE263_INTER_Q + 2},
  612.     {"0 010",       SYM_MCBPC,  MTYPE263_INTER4V + 0},
  613.     {"0 0000 101",  SYM_MCBPC,  MTYPE263_INTER4V + 1},
  614.     {"0 0000 100",  SYM_MCBPC,  MTYPE263_INTER4V + 2},
  615.     {"0 0001 1",    SYM_MCBPC,  MTYPE263_INTRA + 0},
  616.     {"0 0001 00",   SYM_MCBPC,  MTYPE263_INTRA_Q + 0},
  617.     {"End"}
  618. };
  620. static  struct vlc_entry long_mcbpc263[] = {        // Starts with "0 0000 0"
  621.     {"00 0000 0",  SYM_ESCAPE, TAB263_LONG_STARTCODE},  // Note: no COD=0 preceeds startcode
  622.     
  623.     {"000 1",       SYM_MCBPC_STUFFING,  MTYPE263_STUFFING},
  625.     {"010 1",       SYM_MCBPC,  MTYPE263_INTER_Q + 3},
  626.     {"101",         SYM_MCBPC,  MTYPE263_INTER4V + 3},
  627.     {"100",         SYM_MCBPC,  MTYPE263_INTRA + 1},
  628.     {"011",         SYM_MCBPC,  MTYPE263_INTRA + 2},
  629.     {"11",          SYM_MCBPC,  MTYPE263_INTRA + 3},
  630.     {"010 0",       SYM_MCBPC,  MTYPE263_INTRA_Q + 1},
  631.     {"001 1",       SYM_MCBPC,  MTYPE263_INTRA_Q + 2},
  632.     {"001 0",       SYM_MCBPC,  MTYPE263_INTRA_Q + 3},
  633.     {"End"}
  634. };
  636. static  struct vlc_entry long_startcode263[] = {    // Starts with "0000 0000 0000 0"
  637.     {"000 0",       SYM_ESCAPE,     TAB263_ZEROS_AND_START},
  638.     {"000 1",       SYM_STARTCODE,  MTYPE263_STARTCODE},
  639.     {"End"}
  640. };
  642. // Handle startcodes preceded by 1 to 7 zeros
  643. // Starts with 17 zeros
  644. // CJG 8.13.96: added line containing "0000 0001"
  645. //   Deals with Intel's padding more than 7 bits of zeros (8) after last macroblock in row.
  646. //    This does not conform to H.263, and we may want to remove it after(if) Intel fixes
  647. //    their video coder.  This change was interop tested in San Jose with all other vendors.
  648. static  struct vlc_entry zeros_and_start263[] = {
  649.     {"1",           SYM_STARTCODE,  MTYPE263_STARTCODE},
  650.     {"01",          SYM_STARTCODE,  MTYPE263_STARTCODE},
  651.     {"001",         SYM_STARTCODE,  MTYPE263_STARTCODE},
  652.     {"0001",        SYM_STARTCODE,  MTYPE263_STARTCODE},
  653.     {"0000 1",      SYM_STARTCODE,  MTYPE263_STARTCODE},
  654.     {"0000 01",     SYM_STARTCODE,  MTYPE263_STARTCODE},
  655.     {"0000 001",    SYM_STARTCODE,  MTYPE263_STARTCODE},
  656.     {"0000 0001",   SYM_STARTCODE,  MTYPE263_STARTCODE},
  657.     {"End"}
  658. };
  660. static  struct vlc_entry intra_mcbpc263[] = {
  661.     {"0000 0000",   SYM_ESCAPE, TAB263_LONG_MCBPC_INTRA},
  662.     
  663.     {"1",           SYM_MCBPC,  MTYPE263_INTRA + 0},
  664.     {"001",         SYM_MCBPC,  MTYPE263_INTRA + 1},
  665.     {"010",         SYM_MCBPC,  MTYPE263_INTRA + 2},
  666.     {"011",         SYM_MCBPC,  MTYPE263_INTRA + 3},
  667.     
  668.     {"0001",        SYM_MCBPC,  MTYPE263_INTRA_Q + 0},
  669.     {"0000 01",     SYM_MCBPC,  MTYPE263_INTRA_Q + 1},
  670.     {"0000 10",     SYM_MCBPC,  MTYPE263_INTRA_Q + 2},
  671.     {"0000 11",     SYM_MCBPC,  MTYPE263_INTRA_Q + 3},
  672.     {"End"}
  673. };
  675. static  struct vlc_entry long_intra_mcbpc263[] = {  // Starts with "0000 0000"
  676.     {" 0000 0",    SYM_ESCAPE,  TAB263_LONG_STARTCODE},
  677.     
  678.     {" 1",          SYM_MCBPC_STUFFING,  MTYPE263_STUFFING},
  679.     {"End"}
  680. };
  682. static  struct vlc_entry modb263[] = {
  683.     {"0",   SYM_MODB,   0},
  684.     {"10",  SYM_MODB,   1},
  685.     {"11",  SYM_MODB,   2},
  686.     {"End"}
  687. };
  689. static  struct vlc_entry cbpy263[] = {
  690.     {"0011",    SYM_CBPY,   0xf },
  691.     {"0010 1",  SYM_CBPY,   0xe },
  692.     {"0010 0",  SYM_CBPY,   0xd },
  693.     {"1001",    SYM_CBPY,   0xc },
  694.     
  695.     {"0001 1",  SYM_CBPY,   0xb },
  696.     {"0111",    SYM_CBPY,   0xa },
  697.     {"0000 10", SYM_CBPY,   0x9 },
  698.     {"1011",    SYM_CBPY,   0x8 },
  699.     
  700.     {"0001 0",  SYM_CBPY,   0x7 },
  701.     {"0000 11", SYM_CBPY,   0x6 },
  702.     {"0101",    SYM_CBPY,   0x5 },
  703.     {"1010",    SYM_CBPY,   0x4 },
  704.     
  705.     {"0100",    SYM_CBPY,   0x3 },
  706.     {"1000",    SYM_CBPY,   0x2 },
  707.     {"0110",    SYM_CBPY,   0x1 },
  708.     {"11",      SYM_CBPY,   0x0 },
  709.     {"End"}
  710. };
  712. static  struct vlc_entry intra_cbpy263[] = {
  713.     {"0011",    SYM_CBPY,   0x0 },
  714.     {"0010 1",  SYM_CBPY,   0x1 },
  715.     {"0010 0",  SYM_CBPY,   0x2 },
  716.     {"1001",    SYM_CBPY,   0x3 },
  717.     
  718.     {"0001 1",  SYM_CBPY,   0x4 },
  719.     {"0111",    SYM_CBPY,   0x5 },
  720.     {"0000 10", SYM_CBPY,   0x6 },
  721.     {"1011",    SYM_CBPY,   0x7 },
  722.     
  723.     {"0001 0",  SYM_CBPY,   0x8 },
  724.     {"0000 11", SYM_CBPY,   0x9 },
  725.     {"0101",    SYM_CBPY,   0xa },
  726.     {"1010",    SYM_CBPY,   0xb },
  727.     
  728.     {"0100",    SYM_CBPY,   0xc },
  729.     {"1000",    SYM_CBPY,   0xd },
  730.     {"0110",    SYM_CBPY,   0xe },
  731.     {"11",      SYM_CBPY,   0xf },
  732.     {"End"}
  733. };
  735. static  struct vlc_entry dquant263[] = {
  736.     {"00",      SYM_DQUANT, -1},
  737.     {"01",      SYM_DQUANT, -2},
  738.     {"10",      SYM_DQUANT, 1},
  739.     {"11",      SYM_DQUANT, 2},
  740.     {"End"}
  741. };
  743. static  struct vlc_entry mvd263[] = {
  744.     {"0000 0",      SYM_ESCAPE, TAB263_LONG_MVD},
  745.     
  746.     {"0000 1001",   SYM_MVD,    -6},
  747.     {"0000 1011",   SYM_MVD,    -5},
  748.     
  749.     {"0000 111",    SYM_MVD,    -4},
  750.     {"0001 1",      SYM_MVD,    -3},
  751.     {"0011",        SYM_MVD,    -2},
  752.     {"011",         SYM_MVD,    -1},
  753.     
  754.     {"1",           SYM_MVD,    0},
  755.     {"010",         SYM_MVD,    1},
  756.     {"0010",        SYM_MVD,    2},
  757.     {"0001 0",      SYM_MVD,    3},
  758.     
  759.     {"0000 110",    SYM_MVD,    4},
  760.     {"0000 1010",   SYM_MVD,    5},
  761.     {"0000 1000",   SYM_MVD,    6},
  762.     {"End"}
  763. };
  765. static  struct vlc_entry long_mvd263[] = {  // Starts with "0000 0"
  766.     {"000 0010 1",    SYM_MVD,    -32},
  767.     {"000 0011 1",    SYM_MVD,    -31},
  768.     {"000 0101",      SYM_MVD,    -30},
  769.     {"000 0111",      SYM_MVD,    -29},
  770.     
  771.     {"000 1001",      SYM_MVD,    -28},
  772.     {"000 1011",      SYM_MVD,    -27},
  773.     {"000 1101",      SYM_MVD,    -26},
  774.     {"000 1111",      SYM_MVD,    -25},
  775.     
  776.     {"001 001",       SYM_MVD,    -24},
  777.     {"001 011",       SYM_MVD,    -23},
  778.     {"001 101",       SYM_MVD,    -22},
  779.     {"001 111",       SYM_MVD,    -21},
  780.     
  781.     {"010 001",       SYM_MVD,    -20},
  782.     {"010 011",       SYM_MVD,    -19},
  783.     {"010 101",       SYM_MVD,    -18},
  784.     {"010 111",       SYM_MVD,    -17},
  785.     
  786.     {"011 001",       SYM_MVD,    -16},
  787.     {"011 011",       SYM_MVD,    -15},
  788.     {"011 101",       SYM_MVD,    -14},
  789.     {"011 111",       SYM_MVD,    -13},
  790.     
  791.     {"100 001",       SYM_MVD,    -12},
  792.     {"100 011",       SYM_MVD,    -11},
  793.     {"100 11",        SYM_MVD,    -10},
  794.     {"101 01",        SYM_MVD,    -9},
  795.     
  796.     {"101 11",        SYM_MVD,    -8},
  797.     {"111",           SYM_MVD,    -7},
  799.     {"110",           SYM_MVD,    7},
  800.     
  801.     {"101 10",        SYM_MVD,    8},
  802.     {"101 00",        SYM_MVD,    9},
  803.     {"100 10",        SYM_MVD,    10},
  804.     {"100 010",       SYM_MVD,    11},
  805.     
  806.     {"100 000",       SYM_MVD,    12},
  807.     {"011 110",       SYM_MVD,    13},
  808.     {"011 100",       SYM_MVD,    14},
  809.     {"011 010",       SYM_MVD,    15},
  810.     
  811.     {"011 000",       SYM_MVD,    16},
  812.     {"010 110",       SYM_MVD,    17},
  813.     {"010 100",       SYM_MVD,    18},
  814.     {"010 010",       SYM_MVD,    19},
  815.     
  816.     {"010 000",       SYM_MVD,    20},
  817.     {"001 110",       SYM_MVD,    21},
  818.     {"001 100",       SYM_MVD,    22},
  819.     {"001 010",       SYM_MVD,    23},
  820.     
  821.     {"001 000",       SYM_MVD,    24},
  822.     {"000 1110",      SYM_MVD,    25},
  823.     {"000 1100",      SYM_MVD,    26},
  824.     {"000 1010",      SYM_MVD,    27},
  825.     
  826.     {"000 1000",      SYM_MVD,    28},
  827.     {"000 0110",      SYM_MVD,    29},
  828.     {"000 0100",      SYM_MVD,    30},
  829.     {"000 0011 0",    SYM_MVD,    31},
  830.     {"End"}
  831. };
  833. static  struct vlc_entry finished_263blk[] = {
  834.     {" ",       SYM_EXIT,   FINISHED_LAST_BLOCK,    0},
  835.     {"End"}
  836. };
  838. static  struct vlc_entry tcoef[] = {
  839.     {"0001",        SYM_ESCAPE, TAB263_TCOEF_0001,      0},
  840.     {"0000 1",      SYM_ESCAPE, TAB263_TCOEF_0000_1,    0},
  841.     {"0000 0",      SYM_ESCAPE, TAB263_TCOEF_0000_0,    0},
  843.     {"100",         0,      1,      0},
  844.     {"101",         0,      -1,     0},
  845.     {"1111 0",      0,      2,      0},
  846.     {"1111 1",      0,      -2,     0},
  847.     {"0101 010",    0,      3,      0},
  848.     {"0101 011",    0,      -3,     0},
  849.     {"0010 1110",   0,      4,      0},
  850.     {"0010 1111",   0,      -4,     0},
  851.     {"1100",        1,      1,      0},
  852.     {"1101",        1,      -1,     0},
  853.     {"0101 000",    1,      2,      0},
  854.     {"0101 001",    1,      -2,     0},
  855.     {"1110 0",      2,      1,      0},
  856.     {"1110 1",      2,      -1,     0},
  857.     {"0110 10",     3,      1,      0},
  858.     {"0110 11",     3,      -1,     0},
  859.     {"0110 00",     4,      1,      0},
  860.     {"0110 01",     4,      -1,     0},
  861.     {"0101 10",     5,      1,      0},
  862.     {"0101 11",     5,      -1,     0},
  863.     {"0100 110",    6,      1,      0},
  864.     {"0100 111",    6,      -1,     0},
  865.     {"0100 100",    7,      1,      0},
  866.     {"0100 101",    7,      -1,     0},
  867.     {"0100 010",    8,      1,      0},
  868.     {"0100 011",    8,      -1,     0},
  869.     {"0100 000",    9,      1,      0},
  870.     {"0100 001",    9,      -1,     0},
  871.     {"0010 1100",   10,     1,      0},
  872.     {"0010 1101",   10,     -1,     0},
  873.     {"0010 1010",   11,     1,      0},
  874.     {"0010 1011",   11,     -1,     0},
  875.     {"0010 1000",   12,     1,      0},
  876.     {"0010 1001",   12,     -1,     0},
  878.     {"0111 0",      0 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  879.     {"0111 1",      0 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  880.     {"0011 110",    1 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  881.     {"0011 111",    1 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  882.     {"0011 100",    2 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  883.     {"0011 101",    2 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  884.     {"0011 010",    3 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  885.     {"0011 011",    3 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  886.     {"0011 000",    4 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  887.     {"0011 001",    4 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  888.     {"0010 0110",   5 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  889.     {"0010 0111",   5 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  890.     {"0010 0100",   6 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  891.     {"0010 0101",   6 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  892.     {"0010 0010",   7 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  893.     {"0010 0011",   7 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  894.     {"0010 0000",   8 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  895.     {"0010 0001",   8 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  896.     {"End"}
  897. };
  899. static  struct vlc_entry tcoef_0001[] = {
  900.     {" 1111 0",     0,      5,      0},
  901.     {" 1111 1",     0,      -5,     0},
  902.     {" 0010 10",    0,      6,      0},
  903.     {" 0010 11",    0,      -6,     0},
  904.     {" 0010 00",    0,      7,      0},
  905.     {" 0010 01",    0,      -7,     0},
  906.     {" 1110 0",     1,      3,      0},
  907.     {" 1110 1",     1,      -3,     0},
  908.     {" 1101 0",     2,      2,      0},
  909.     {" 1101 1",     2,      -2,     0},
  910.     {" 0001 10",    3,      2,      0},
  911.     {" 0001 11",    3,      -2,     0},
  912.     {" 0001 00",    4,      2,      0},
  913.     {" 0001 01",    4,      -2,     0},
  914.     {" 1100 0",     13,     1,      0},
  915.     {" 1100 1",     13,     -1,     0},
  916.     {" 1011 0",     14,     1,      0},
  917.     {" 1011 1",     14,     -1,     0},
  918.     {" 0000 10",    15,     1,      0},
  919.     {" 0000 11",    15,     -1,     0},
  920.     {" 0000 00",    16,     1,      0},
  921.     {" 0000 01",    16,     -1,     0},
  923.     {" 1010 0",     9 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  924.     {" 1010 1",     9 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  925.     {" 1001 0",     10 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  926.     {" 1001 1",     10 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  927.     {" 1000 0",     11 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  928.     {" 1000 1",     11 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  929.     {" 0111 0",     12 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  930.     {" 0111 1",     12 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  931.     {" 0110 0",     13 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  932.     {" 0110 1",     13 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  933.     {" 0101 0",     14 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  934.     {" 0101 1",     14 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  935.     {" 0100 0",     15 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  936.     {" 0100 1",     15 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  937.     {" 0011 0",     16 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  938.     {" 0011 1",     16 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  939.     {"End"}
  940. };
  942. static  struct vlc_entry tcoef_0000_1[] = {
  943.     {"000 010",     0,      8,      0},
  944.     {"000 011",     0,      -8,     0},
  945.     {"000 000",     0,      9,      0},
  946.     {"000 001",     0,      -9,     0},
  947.     {"111 10",      17,     1,      0},
  948.     {"111 11",      17,     -1,     0},
  949.     {"111 00",      18,     1,      0},
  950.     {"111 01",      18,     -1,     0},
  951.     {"110 10",      19,     1,      0},
  952.     {"110 11",      19,     -1,     0},
  953.     {"110 00",      20,     1,      0},
  954.     {"110 01",      20,     -1,     0},
  955.     {"101 10",      21,     1,      0},
  956.     {"101 11",      21,     -1,     0},
  957.     {"101 00",      22,     1,      0},
  958.     {"101 01",      22,     -1,     0},
  960.     {"100 10",      0 + LAST263_RUNVAL,     2,      ST263_DIFF_LAST},
  961.     {"100 11",      0 + LAST263_RUNVAL,     -2,     ST263_DIFF_LAST},
  962.     {"100 00",      17 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  963.     {"100 01",      17 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  964.     {"011 10",      18 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  965.     {"011 11",      18 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  966.     {"011 00",      19 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  967.     {"011 01",      19 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  968.     {"010 10",      20 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  969.     {"010 11",      20 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  970.     {"010 00",      21 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  971.     {"010 01",      21 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  972.     {"001 10",      22 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  973.     {"001 11",      22 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  974.     {"001 00",      23 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  975.     {"001 01",      23 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  976.     {"000 10",      24 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  977.     {"000 11",      24 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  978.     {"End"}
  979. };
  981. static  struct vlc_entry tcoef_0000_0[] = {
  982.     {"11",          SYM_ESCAPE, TAB263_ESC_RUN,     0},
  983.     
  984.     {"000 1110",    0,      10,     0},
  985.     {"000 1111",    0,      -10,    0},
  986.     {"000 1100",    0,      11,     0},
  987.     {"000 1101",    0,      -11,    0},
  988.     {"100 0000",    0,      12,     0},
  989.     {"100 0001",    0,      -12,    0},
  990.     {"011 110",     1,      4,      0},
  991.     {"011 111",     1,      -4,     0},
  992.     {"100 0010",    1,      5,      0},
  993.     {"100 0011",    1,      -5,     0},
  994.     {"101 0000 0",  1,      6,      0},
  995.     {"101 0000 1",  1,      -6,     0},
  996.     {"011 100",     2,      3,      0},
  997.     {"011 101",     2,      -3,     0},
  998.     {"101 0001 0",  2,      4,      0},
  999.     {"101 0001 1",  2,      -4,     0},
  1000.     {"011 010",     3,      3,      0},
  1001.     {"011 011",     3,      -3,     0},
  1002.     {"101 0010 0",  4,      3,      0},
  1003.     {"101 0010 1",  4,      -3,     0},
  1004.     {"011 000",     5,      2,      0},
  1005.     {"011 001",     5,      -2,     0},
  1006.     {"101 0011 0",  5,      3,      0},
  1007.     {"101 0011 1",  5,      -3,     0},
  1008.     {"010 110",     6,      2,      0},
  1009.     {"010 111",     6,      -2,     0},
  1010.     {"101 0100 0",  6,      3,      0},
  1011.     {"101 0100 1",  6,      -3,     0},
  1012.     {"010 100",     7,      2,      0},
  1013.     {"010 101",     7,      -2,     0},
  1014.     {"010 010",     8,      2,      0},
  1015.     {"010 011",     8,      -2,     0},
  1016.     {"010 000",     9,      2,      0},
  1017.     {"010 001",     9,      -2,     0},
  1018.     {"101 0101 0",  10,     2,      0},
  1019.     {"101 0101 1",  10,     -2,     0},
  1020.     {"100 0100",    23,     1,      0},
  1021.     {"100 0101",    23,     -1,     0},
  1022.     {"100 0110",    24,     1,      0},
  1023.     {"100 0111",    24,     -1,     0},
  1024.     {"101 0110 0",  25,     1,      0},
  1025.     {"101 0110 1",  25,     -1,     0},
  1026.     {"101 0111 0",  26,     1,      0},
  1027.     {"101 0111 1",  26,     -1,     0},
  1029.     {"000 1010",    0 + LAST263_RUNVAL,     3,      ST263_DIFF_LAST},
  1030.     {"000 1011",    0 + LAST263_RUNVAL,     -3,     ST263_DIFF_LAST},
  1031.     {"000 1000",    1 + LAST263_RUNVAL,     2,      ST263_DIFF_LAST},
  1032.     {"000 1001",    1 + LAST263_RUNVAL,     -2,     ST263_DIFF_LAST},
  1033.     {"001 110",     25 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1034.     {"001 111",     25 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1035.     {"001 100",     26 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1036.     {"001 101",     26 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1037.     {"001 010",     27 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1038.     {"001 011",     27 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1039.     {"001 000",     28 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1040.     {"001 001",     28 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1041.     {"100 1000",    29 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1042.     {"100 1001",    29 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1043.     {"100 1010",    30 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1044.     {"100 1011",    30 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1045.     {"100 1100",    31 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1046.     {"100 1101",    31 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1047.     {"100 1110",    32 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1048.     {"100 1111",    32 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1049.     {"101 1000 0",  33 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1050.     {"101 1000 1",  33 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1051.     {"101 1001 0",  34 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1052.     {"101 1001 1",  34 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1053.     {"101 1010 0",  35 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1054.     {"101 1010 1",  35 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1055.     {"101 1011 0",  36 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1056.     {"101 1011 1",  36 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1057.     {"101 1100 0",  37 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1058.     {"101 1100 1",  37 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1059.     {"101 1101 0",  38 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1060.     {"101 1101 1",  38 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1061.     {"101 1110 0",  39 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1062.     {"101 1110 1",  39 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1063.     {"101 1111 0",  40 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1064.     {"101 1111 1",  40 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1065.     {"End"}
  1066. };
  1068. static  struct vlc_entry esc263_run[] = {
  1069.     {"FLC"},
  1070.     {"0 00 0000",   SYM_ESC_RUN,    0,  -ST263_DIFF_ESC_LEVEL,  63},
  1071.     {"1 00 0000",   SYM_ESC_RUN,
  1072.                     0 + LAST263_RUNVAL,
  1073.                     ST263_DIFF_LAST - ST263_DIFF_ESC_LEVEL,
  1074.                     63 + LAST263_RUNVAL},
  1075.     {"End"}
  1076. };
  1078. /* ESC_LEVEL: Levels 0 and -128 are not allowed */
  1079. static  struct vlc_entry esc263_level[] = {
  1080.     {"FLC"},
  1081.     {"0000 0001",   SYM_ESC_LEVEL,      1,  ST263_DIFF_ESC_LEVEL,   127},
  1082.     {"1000 0001",   SYM_ESC_LEVEL,   -127,  ST263_DIFF_ESC_LEVEL,   -1},
  1083.     {"End"}
  1084. };
  1086. // INTRA DC coeff:  Levels 0 and 255 not allowed; level 128 repr. by 255
  1087. // Indicate run=0 by setting type=0
  1088. static  struct vlc_entry intra263_dc[] = {
  1089.     {"FLC"},
  1090.     {"0000 0001",   0,      1,      ST263_DIFF_INTRA_DC,    127},
  1091.     {"1111 1111",   0,      128,    ST263_DIFF_INTRA_DC,    128},
  1092.     {"1000 0001",   0,      129,    ST263_DIFF_INTRA_DC,    254},
  1093.     {"End"}
  1094. };
  1097. ////////////////  Tables for H.263+  //////////////////
  1099. static  struct vlc_entry modb263plus[] = {
  1100.     {"0",   SYM_MODB,   0},
  1101.     {"10",  SYM_MODB,   1},
  1102.     {"110", SYM_MODB,   2},
  1103.     {"111", SYM_MODB,   3},
  1104.     {"End"}
  1105. };
  1107. static  struct vlc_entry intra_mode263plus[] = {
  1108.     {"0",   SYM_INTRA_MODE,   0},
  1109.     {"10",  SYM_INTRA_MODE,   1},
  1110.     {"11",  SYM_INTRA_MODE,   2},
  1111.     {"End"}
  1112. };
  1115. static  struct vlc_entry tcoef_plus[] = {
  1116.     {"0001",        SYM_ESCAPE, TAB263PLUS_TCOEF_0001,      0},
  1117.     {"0000 1",      SYM_ESCAPE, TAB263PLUS_TCOEF_0000_1,    0},
  1118.     {"0000 0",      SYM_ESCAPE, TAB263PLUS_TCOEF_0000_0,    0},
  1120.     {"100",         0,      1,      0},
  1121.     {"101",         0,      -1,     0},
  1122.     {"1111 0",      1,      1,      0},
  1123.     {"1111 1",      1,      -1,     0},
  1124.     {"0101 010",    3,      1,      0},
  1125.     {"0101 011",    3,      -1,     0},
  1126.     {"0010 1110",   5,      1,      0},
  1127.     {"0010 1111",   5,      -1,     0},
  1128.     {"1100",        0,      2,      0},
  1129.     {"1101",        0,      -2,     0},
  1130.     {"0101 000",    1,      2,      0},
  1131.     {"0101 001",    1,      -2,     0},
  1132.     {"1110 0",      0,      3,      0},
  1133.     {"1110 1",      0,      -3,     0},
  1134.     {"0110 10",     0,      5,      0},
  1135.     {"0110 11",     0,      -5,     0},
  1136.     {"0110 00",     0,      4,      0},
  1137.     {"0110 01",     0,      -4,     0},
  1138.     {"0101 10",     2,      1,      0},
  1139.     {"0101 11",     2,      -1,     0},
  1140.     {"0100 110",    4,      1,      0},
  1141.     {"0100 111",    4,      -1,     0},
  1142.     {"0100 100",    0,      8,      0},
  1143.     {"0100 101",    0,      -8,     0},
  1144.     {"0100 010",    0,      7,      0},
  1145.     {"0100 011",    0,      -7,     0},
  1146.     {"0100 000",    0,      6,      0},
  1147.     {"0100 001",    0,      -6,     0},
  1148.     {"0010 1100",   0,      9,      0},
  1149.     {"0010 1101",   0,      -9,     0},
  1150.     {"0010 1010",   2,      2,      0},
  1151.     {"0010 1011",   2,      -2,     0},
  1152.     {"0010 1000",   1,      3,      0},
  1153.     {"0010 1001",   1,      -3,     0},
  1155.     {"0111 0",      0 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  1156.     {"0111 1",      0 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  1157.     {"0011 110",    1 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  1158.     {"0011 111",    1 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  1159.     {"0011 100",    2 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  1160.     {"0011 101",    2 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  1161.     {"0011 010",    3 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  1162.     {"0011 011",    3 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  1163.     {"0011 000",    0 + LAST263_RUNVAL,     2,      ST263_DIFF_LAST},
  1164.     {"0011 001",    0 + LAST263_RUNVAL,     -2,     ST263_DIFF_LAST},
  1165.     {"0010 0110",   5 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  1166.     {"0010 0111",   5 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  1167.     {"0010 0100",   6 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  1168.     {"0010 0101",   6 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  1169.     {"0010 0010",   4 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  1170.     {"0010 0011",   4 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  1171.     {"0010 0000",   0 + LAST263_RUNVAL,     3,      ST263_DIFF_LAST},
  1172.     {"0010 0001",   0 + LAST263_RUNVAL,     -3,     ST263_DIFF_LAST},
  1173.     {"End"}
  1174. };
  1176. static  struct vlc_entry tcoef_0001_plus[] = {
  1177.     {" 1111 0",     7,      1,      0},
  1178.     {" 1111 1",     7,      -1,     0},
  1179.     {" 0010 10",    8,      1,      0},
  1180.     {" 0010 11",    8,      -1,     0},
  1181.     {" 0010 00",    9,      1,      0},
  1182.     {" 0010 01",    9,      -1,     0},
  1183.     {" 1110 0",     1,      4,      0},
  1184.     {" 1110 1",     1,      -4,     0},
  1185.     {" 1101 0",     3,      2,      0},
  1186.     {" 1101 1",     3,      -2,     0},
  1187.     {" 0001 10",    4,      2,      0},
  1188.     {" 0001 11",    4,      -2,     0},
  1189.     {" 0001 00",    5,      2,      0},
  1190.     {" 0001 01",    5,      -2,     0},
  1191.     {" 1100 0",     6,      1,      0},
  1192.     {" 1100 1",     6,      -1,     0},
  1193.     {" 1011 0",     0,      10,     0},
  1194.     {" 1011 1",     0,      -10,    0},
  1195.     {" 0000 10",    0,      12,     0},
  1196.     {" 0000 11",    0,      -12,    0},
  1197.     {" 0000 00",    0,      11,     0},
  1198.     {" 0000 01",    0,      -11,    0},
  1200.     {" 1010 0",     9 + LAST263_RUNVAL,     1,      ST263_DIFF_LAST},
  1201.     {" 1010 1",     9 + LAST263_RUNVAL,     -1,     ST263_DIFF_LAST},
  1202.     {" 1001 0",     10 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1203.     {" 1001 1",     10 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1204.     {" 1000 0",     11 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1205.     {" 1000 1",     11 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1206.     {" 0111 0",     12 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1207.     {" 0111 1",     12 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1208.     {" 0110 0",     13 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1209.     {" 0110 1",     13 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1210.     {" 0101 0",      8 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1211.     {" 0101 1",      8 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1212.     {" 0100 0",      7 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1213.     {" 0100 1",      7 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1214.     {" 0011 0",      0 + LAST263_RUNVAL,    4,      ST263_DIFF_LAST},
  1215.     {" 0011 1",      0 + LAST263_RUNVAL,    -4,     ST263_DIFF_LAST},
  1216.     {"End"}
  1217. };
  1219. static  struct vlc_entry tcoef_0000_1_plus[] = {
  1220.     {"000 010",     10,     1,      0},
  1221.     {"000 011",     10,     -1,     0},
  1222.     {"000 000",     11,     1,      0},
  1223.     {"000 001",     11,     -1,     0},
  1224.     {"111 10",       0,     18,     0},
  1225.     {"111 11",       0,     -18,    0},
  1226.     {"111 00",       0,     17,     0},
  1227.     {"111 01",       0,     -17,    0},
  1228.     {"110 10",       0,     16,     0},
  1229.     {"110 11",       0,     -16,    0},
  1230.     {"110 00",       0,     15,     0},
  1231.     {"110 01",       0,     -15,    0},
  1232.     {"101 10",       0,     14,     0},
  1233.     {"101 11",       0,     -14,    0},
  1234.     {"101 00",       0,     13,     0},
  1235.     {"101 01",       0,     -13,    0},
  1237.     {"100 10",      14 + LAST263_RUNVAL,     1,     ST263_DIFF_LAST},
  1238.     {"100 11",      14 + LAST263_RUNVAL,     -1,    ST263_DIFF_LAST},
  1239.     {"100 00",      17 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1240.     {"100 01",      17 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1241.     {"011 10",      18 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1242.     {"011 11",      18 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1243.     {"011 00",      16 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1244.     {"011 01",      16 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1245.     {"010 10",      15 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1246.     {"010 11",      15 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1247.     {"010 00",       2 + LAST263_RUNVAL,    2,      ST263_DIFF_LAST},
  1248.     {"010 01",       2 + LAST263_RUNVAL,    -2,     ST263_DIFF_LAST},
  1249.     {"001 10",       1 + LAST263_RUNVAL,    2,      ST263_DIFF_LAST},
  1250.     {"001 11",       1 + LAST263_RUNVAL,    -2,     ST263_DIFF_LAST},
  1251.     {"001 00",       0 + LAST263_RUNVAL,    6,      ST263_DIFF_LAST},
  1252.     {"001 01",       0 + LAST263_RUNVAL,    -6,     ST263_DIFF_LAST},
  1253.     {"000 10",       0 + LAST263_RUNVAL,    5,      ST263_DIFF_LAST},
  1254.     {"000 11",       0 + LAST263_RUNVAL,    -5,     ST263_DIFF_LAST},
  1255.     {"End"}
  1256. };
  1258. static  struct vlc_entry tcoef_0000_0_plus[] = {
  1259.     {"11",          SYM_ESCAPE, TAB263_ESC_RUN,     0},
  1260.     
  1261.     {"000 1110",    4,       3,    0},
  1262.     {"000 1111",    4,       -3,   0},
  1263.     {"000 1100",    9,      2,     0},
  1264.     {"000 1101",    9,      -2,    0},
  1265.     {"100 0000",   13,      1,     0},
  1266.     {"100 0001",   13,      -1,    0},
  1267.     {"011 110",     1,      5,      0},
  1268.     {"011 111",     1,      -5,     0},
  1269.     {"100 0010",    1,      6,      0},
  1270.     {"100 0011",    1,      -6,     0},
  1271.     {"101 0000 0",  1,      7,      0},
  1272.     {"101 0000 1",  1,      -7,     0},
  1273.     {"011 100",     2,      3,      0},
  1274.     {"011 101",     2,      -3,     0},
  1275.     {"101 0001 0",  3,      4,      0},
  1276.     {"101 0001 1",  3,      -4,     0},
  1277.     {"011 010",     3,      3,      0},
  1278.     {"011 011",     3,      -3,     0},
  1279.     {"101 0010 0",  5,      3,      0},
  1280.     {"101 0010 1",  5,      -3,     0},
  1281.     {"011 000",     6,      2,      0},
  1282.     {"011 001",     6,      -2,     0},
  1283.     {"101 0011 0",  0,      25,      0},
  1284.     {"101 0011 1",  0,      -25,     0},
  1285.     {"010 110",     7,      2,      0},
  1286.     {"010 111",     7,      -2,     0},
  1287.     {"101 0100 0",  0,      24,      0},
  1288.     {"101 0100 1",  0,      -24,     0},
  1289.     {"010 100",     8,      2,      0},
  1290.     {"010 101",     8,      -2,     0},
  1291.     {"010 010",     2,      4,      0},
  1292.     {"010 011",     2,      -4,     0},
  1293.     {"010 000",    12,      1,      0},
  1294.     {"010 001",    12,      -1,     0},
  1295.     {"101 0101 0",  0,     23,      0},
  1296.     {"101 0101 1",  0,     -23,     0},
  1297.     {"100 0100",    0,     20,      0},
  1298.     {"100 0101",    0,     -20,     0},
  1299.     {"100 0110",    0,     19,      0},
  1300.     {"100 0111",    0,     -19,     0},
  1301.     {"101 0110 0",  0,     22,      0},
  1302.     {"101 0110 1",  0,     -22,     0},
  1303.     {"101 0111 0",  0,     21,      0},
  1304.     {"101 0111 1",  0,     -21,     0},
  1306.     {"000 1010",    20 + LAST263_RUNVAL,     1,     ST263_DIFF_LAST},
  1307.     {"000 1011",    20 + LAST263_RUNVAL,     -1,    ST263_DIFF_LAST},
  1308.     {"000 1000",    19 + LAST263_RUNVAL,     1,     ST263_DIFF_LAST},
  1309.     {"000 1001",    19 + LAST263_RUNVAL,     -1,    ST263_DIFF_LAST},
  1310.     {"001 110",      4 + LAST263_RUNVAL,    2,      ST263_DIFF_LAST},
  1311.     {"001 111",      4 + LAST263_RUNVAL,    -2,     ST263_DIFF_LAST},
  1312.     {"001 100",      3 + LAST263_RUNVAL,    2,      ST263_DIFF_LAST},
  1313.     {"001 101",      3 + LAST263_RUNVAL,    -2,     ST263_DIFF_LAST},
  1314.     {"001 010",      1 + LAST263_RUNVAL,    3,      ST263_DIFF_LAST},
  1315.     {"001 011",      1 + LAST263_RUNVAL,    -3,     ST263_DIFF_LAST},
  1316.     {"001 000",      0 + LAST263_RUNVAL,    7,      ST263_DIFF_LAST},
  1317.     {"001 001",      0 + LAST263_RUNVAL,    -7,     ST263_DIFF_LAST},
  1318.     {"100 1000",     2 + LAST263_RUNVAL,    3,      ST263_DIFF_LAST},
  1319.     {"100 1001",     2 + LAST263_RUNVAL,    -3,     ST263_DIFF_LAST},
  1320.     {"100 1010",     1 + LAST263_RUNVAL,    4,      ST263_DIFF_LAST},
  1321.     {"100 1011",     1 + LAST263_RUNVAL,    -4,     ST263_DIFF_LAST},
  1322.     {"100 1100",     0 + LAST263_RUNVAL,    9,      ST263_DIFF_LAST},
  1323.     {"100 1101",     0 + LAST263_RUNVAL,    -9,     ST263_DIFF_LAST},
  1324.     {"100 1110",     0 + LAST263_RUNVAL,    8,      ST263_DIFF_LAST},
  1325.     {"100 1111",     0 + LAST263_RUNVAL,    -8,     ST263_DIFF_LAST},
  1326.     {"101 1000 0",  21 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1327.     {"101 1000 1",  21 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1328.     {"101 1001 0",  22 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1329.     {"101 1001 1",  22 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1330.     {"101 1010 0",  23 + LAST263_RUNVAL,    1,      ST263_DIFF_LAST},
  1331.     {"101 1010 1",  23 + LAST263_RUNVAL,    -1,     ST263_DIFF_LAST},
  1332.     {"101 1011 0",   7 + LAST263_RUNVAL,    2,      ST263_DIFF_LAST},
  1333.     {"101 1011 1",   7 + LAST263_RUNVAL,    -2,     ST263_DIFF_LAST},
  1334.     {"101 1100 0",   6 + LAST263_RUNVAL,    2,      ST263_DIFF_LAST},
  1335.     {"101 1100 1",   6 + LAST263_RUNVAL,    -2,     ST263_DIFF_LAST},
  1336.     {"101 1101 0",   5 + LAST263_RUNVAL,    2,      ST263_DIFF_LAST},
  1337.     {"101 1101 1",   5 + LAST263_RUNVAL,    -2,     ST263_DIFF_LAST},
  1338.     {"101 1110 0",   3 + LAST263_RUNVAL,    3,      ST263_DIFF_LAST},
  1339.     {"101 1110 1",   3 + LAST263_RUNVAL,    -3,     ST263_DIFF_LAST},
  1340.     {"101 1111 0",   0 + LAST263_RUNVAL,    10,     ST263_DIFF_LAST},
  1341.     {"101 1111 1",   0 + LAST263_RUNVAL,    -10,    ST263_DIFF_LAST},
  1342.     {"End"}
  1343. };
  1346. #endif