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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
vld.h
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：58k
源码类别：

Symbian

开发平台：

Visual C++

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