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

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

Symbian

开发平台：

Visual C++

vld.c：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: vld.c,v 1.3.34.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. #include "hxtypes.h"
  51. //#include <stdio.h>
  52. //#include <stdlib.h>
  53. //#include <string.h>
  54. //#include <ctype.h>
  55. #include "dllindex.h"
  56. #include "h261defs.h"
  57. #include "h261func.h"
  58. #include "vldstate.h"
  59. #include "vldtabs.h"
  60. #include "vld.h"
  61. #include "machine.h"
  62. #include "hvutils.h"
  63. #include "h263plus.h"
  65. #if defined(_WINDOWS)
  66. #include "hxstrutl.h"
  67. #endif /* _WINDOWS */
  69. static int buildtable( int minBits, struct vlc_entry input[], DECTABENTRY output[DECTABSIZE]);
  70. static int parse_bits(  char vlc[],     /* String with bit pattern */
  71.                         int strmax,     /* Max characters in "vlc" excluding terminating null */
  72.                         int maxbits,    /* Max # bits in codeword */
  73.                         int * bits,     /* Returns # bits; 0 < bits < maxbits+1 */
  74.                         int * codeword, /* Returns codeword */
  75.                         int minBits     // Min # bits in codeword
  76. );
  79. //  Get8Bits - return next 8 bits from bitstream
  80. extern U8 Get8Bits( BS_PTR bs)
  81. {
  82.     int k;
  84.     k = (*bs.byteptr << 8) | *(bs.byteptr + 1);
  85.     return (k >> (8 - bs.bitptr));
  86. }
  88. //  IncBsPtr - Increment (or decrement) bitstream pointer
  89. extern void IncBsPtr( BS_PTR * bs, int incr)
  90. {
  91.     bs->bitptr += incr;
  92.     while (bs->bitptr > 7) {
  93.        ++(bs->byteptr);
  94.         bs->bitptr -= 8;
  95.     }
  96.     while (bs->bitptr < 0) {
  97.         --(bs->byteptr);
  98.         bs->bitptr += 8;
  99.     }
  100.     return;
  101. }
  104. // FLDecSymbol - Decode fixed length symbol of length "bits"
  105. // Return values:   1   OK: successful decoding; symbol returned in "value"
  106. //                  0   OUT_OF_BITS: consumed more than "numBits"; returning numBits < 0
  107. extern int FLDecSymbol( BS_PTR * bs,        // Bitstream pointer; incremented by this routine
  108.                         int bits,           // Symbol length
  109.                         int * numBits,      // Max # bits to decode; decremented by this routine
  110.                         int * value         // Returns decoded symbol
  111.                         )
  112. {
  113.     *value = 0;
  114.     while (bits > 8) {
  115.         *value |= Get8Bits( *bs ) << (bits - 8);
  116.         bits -= 8;
  117.         *numBits -= 8;
  118.         ++bs->byteptr;
  119.     }
  120.     *value |= Get8Bits( *bs ) >> (8 - bits);
  121.     *numBits -= bits;       // Subtract parsed bits
  122.     IncBsPtr( bs, bits);    // Advance bitpointer
  123.     //printf("FLDecSymbol: value = %2xn", *value );
  124.     if (*numBits < 0) {
  125.         return (OUT_OF_BITS);
  126.     }
  127.     return( OK );
  128. }
  131. // VLDecSymbol - Decode variable length symbol using dectable[tabNum]
  132. // Return values:   1   OK: successful decoding; symbol returned in sym
  133. //                  0   OUT_OF_BITS: consumed more than "numBits"; returning numBits < 0
  134. //                  -1  ILLEGAL_SYMBOL: bitstream error
  135. //                  -2  ILLEGAL_STATE: internal program error
  136. //                  -3  FINISHED_LAST_BLOCK: reached state ST263_FINISHED (program
  137. //                      error for this routine)
  138. extern int VLDecSymbol( BS_PTR * bs,        // Bitstream pointer; incremented by this routine
  139.                         int tabNum,         // Use dectable[tabNum] for decoding
  140.                         int * numBits,      // Max # bits to decode; decremented by this routine
  141.                         SYMBOL * sym        // Returns decoded symbol
  142.                         )
  143. {
  144.     DECTABENTRY * entry;
  146.     /*printf( "Entered VLDecSymbol: bitstream = %2x %2x %2x %2x  bitptr = %dn",
  147.             *bs->byteptr, *(bs->byteptr + 1), *(bs->byteptr + 2),
  148.             *(bs->byteptr + 3), bs->bitptr);*/
  149.             
  150.     entry = &dectable [tabNum] [Get8Bits( *bs )];
  151.     while (entry->bits < 0) {   // Long codeword; sym.value indicates table */
  152.         *numBits += entry->bits;        // Subtract parsed bits
  153.         IncBsPtr( bs, -entry->bits);    // Advance bitpointer
  154.         //printf("VLDecSymbol - long symbol: "); printsym( entry->sym ); printf("n");
  155.         entry = &dectable [ entry->sym.value ] [Get8Bits( *bs )];
  156.     }
  157.     *numBits -= entry->bits;        // Subtract parsed bits
  158.     IncBsPtr( bs, entry->bits);     // Advance bitpointer
  159.     /*{
  160.         //int input;
  161.         printf("VLDecSymbol: "); printsym( entry->sym ); printf("n");
  162.         printf("  Cont? (<0 to exit): ");
  163.         scanf("%d", &input);
  164.         if (input < 0) exit(0);
  165.     }*/
  166.     if (entry->sym.type  ==  SYM_EXIT) {    // Premature exit
  167.         if (*numBits < 0) {
  168.             return (OUT_OF_BITS);
  169.         } else {
  170.             return (entry->sym.value);
  171.         }
  172.     }
  173.     *sym = entry->sym;
  174.     if (*numBits < 0) {
  175.         return (OUT_OF_BITS);
  176.     }
  177.     return( OK );
  178. }
  181. //  InitDecodeTable - Generate decoding tables
  182. extern void InitDecodeTable( void )
  183. {
  184.     int minBits;
  185.     
  186.     minBits = 1;    // Codeword strings need to be non-empty
  187.     buildtable( minBits, dct_next, dectable[TAB_DCT_NEXT]);
  188.     buildtable( minBits, dct_first, dectable[TAB_DCT_FIRST]);
  189.     buildtable( minBits, dct_00100, dectable[TAB_DCT_00100]);
  190.     buildtable( minBits, dct_000000, dectable[TAB_DCT_000000]);
  191.     buildtable( minBits, escape_run, dectable[TAB_ESCAPE_RUN]);
  192.     buildtable( minBits, escape_level, dectable[TAB_ESCAPE_LEVEL]);
  194.     buildtable( minBits, intra_dc, dectable[TAB_INTRA_DC]);
  195.     buildtable( minBits, last_intra_dc, dectable[TAB_LAST_INTRA_DC]);
  197.     buildtable( minBits, mba_startcode, dectable[TAB_MBA_STARTCODE]);
  198.     buildtable( minBits, long_mba, dectable[TAB_LONG_MBA]);
  199.     buildtable( minBits, long_startcode, dectable[TAB_LONG_STARTCODE]);
  201.     buildtable( minBits, mtype, dectable[TAB_MTYPE]);
  202.     buildtable( minBits, long_mtype, dectable[TAB_LONG_MTYPE]);
  204.     buildtable( minBits, mvd, dectable[TAB_MVD]);
  205.     buildtable( minBits, long_mvd, dectable[TAB_LONG_MVD]);
  207.     buildtable( minBits, cbp, dectable[TAB_CBP]);
  208.     buildtable( minBits, long_cbp, dectable[TAB_LONG_CBP]);
  210.     buildtable( minBits, quant_tr, dectable[TAB_QUANT_TR]);  //Don't parse strings
  212.     buildtable( minBits, gei_pei, dectable[TAB_GEI_PEI]);
  213.     buildtable( minBits, long_spare, dectable[TAB_LONG_SPARE]);  //Don't parse strings
  215.     buildtable( minBits, gn, dectable[TAB_GN]);
  216.     buildtable( minBits, ptype, dectable[TAB_PTYPE]);    //Don't parse strings
  218.     buildtable( minBits, illegal_state, dectable[TAB_ILLEGAL_STATE]);
  219.     
  220.     // Generate H.263 decoding tables
  221.     buildtable( minBits, mcbpc263,               dectable[TAB263_MCBPC_INTER] );
  222.     buildtable( minBits, long_mcbpc263,          dectable[TAB263_LONG_MCBPC_INTER] );
  223.     buildtable( minBits, long_startcode263,      dectable[TAB263_LONG_STARTCODE] );
  224.     buildtable( minBits, zeros_and_start263,     dectable[TAB263_ZEROS_AND_START] );
  225.     buildtable( minBits, intra_mcbpc263,         dectable[TAB263_MCBPC_INTRA] );
  226.     buildtable( minBits, long_intra_mcbpc263,    dectable[TAB263_LONG_MCBPC_INTRA] );
  227.     buildtable( minBits, modb263,                dectable[TAB263_MODB] );
  228.     buildtable( minBits, cbpy263,                dectable[TAB263_CBPY] );
  229.     buildtable( minBits, intra_cbpy263,          dectable[TAB263_CBPY_INTRA] );
  230.     buildtable( minBits, dquant263,              dectable[TAB263_DQUANT] );
  231.     buildtable( minBits, mvd263,                 dectable[TAB263_MVD] );
  232.     buildtable( minBits, long_mvd263,            dectable[TAB263_LONG_MVD] );
  233.     buildtable( minBits, tcoef,                  dectable[TAB263_TCOEF] );
  234.     buildtable( minBits, tcoef_0001,             dectable[TAB263_TCOEF_0001] );
  235.     buildtable( minBits, tcoef_0000_1,           dectable[TAB263_TCOEF_0000_1] );
  236.     buildtable( minBits, tcoef_0000_0,           dectable[TAB263_TCOEF_0000_0] );
  237.     buildtable( minBits, esc263_run,             dectable[TAB263_ESC_RUN] );
  238.     buildtable( minBits, esc263_level,           dectable[TAB263_ESCAPE_LEVEL] );
  239.     buildtable( minBits, intra263_dc,            dectable[TAB263_INTRA_DC] );
  240. #ifdef DO_H263_PLUS
  241.     buildtable( minBits, modb263plus,            dectable[TAB263PLUS_MODB] );
  242.     buildtable( minBits, intra_mode263plus,      dectable[TAB263PLUS_INTRA_MODE] );
  243.     buildtable( minBits, tcoef_plus,             dectable[TAB263PLUS_TCOEF] );
  244.     buildtable( minBits, tcoef_0001_plus,        dectable[TAB263PLUS_TCOEF_0001] );
  245.     buildtable( minBits, tcoef_0000_1_plus,      dectable[TAB263PLUS_TCOEF_0000_1] );
  246.     buildtable( minBits, tcoef_0000_0_plus,      dectable[TAB263PLUS_TCOEF_0000_0] );
  247. #endif
  248.     minBits = 0;    // Accept empty codeword string (length 0) to produce SYM_EXIT
  249.     buildtable( minBits, finished_263blk,        dectable[TAB263_FINISHED] );
  250.     
  251.     /*{
  252.         int i, ntab;
  254.         printf("nDiagnostic print of table #: ");
  255.         scanf("%d", &ntab);
  256.         while (ntab >= 0) {
  257.             printf( "Entry    Type  Value  Length  Statechangen");
  258.             for (i = 0; i < 256; i++) {
  259.                 printf( " %3d     %3d    %3d    %3d        %3dn", i,
  260.                 dectable[ntab][i].sym.type, dectable[ntab][i].sym.value,
  261.                 dectable[ntab][i].bits, dectable[ntab][i].statechange);
  262.             }
  263.             printf("nDiagnostic print of table #: ");
  264.             scanf("%d", &ntab);
  265.         }
  266.         
  267.         printf("nselectdectab:n");
  268.         for (i = 0; i < NUMSTATES; ++i)
  269.         {
  270.             if (i % 10  ==  0)  printf("n%3d   ", i);
  271.             if (i % 10  ==  5)  printf("  ");
  272.             printf("%3d", selectdectab[i] );
  273.         }
  274.         printf("n");
  275.     }*/
  276.     return;
  277. }
  280. //  buildtable - Generate 8-bit (DECTABBITS) decode table;
  281. //  Contains 256 (DECTABSIZE) entries
  282. static int buildtable( int minBits, struct vlc_entry input[], DECTABENTRY output[DECTABSIZE])
  283. {
  284.     int i, j, bits, codeword, flc, value, status;
  285.     char msg[120]; /* Flawfinder: ignore */
  287.     for (i = 0; i < DECTABSIZE; i++) {
  288.         output[i].sym.type = SYM_EXIT;
  289.         output[i].sym.value = ILLEGAL_SYMBOL;
  290.     }
  291.     if (strcmpi( input[0].vlc, "FLC")) {    /* VLC is default */
  292.         flc = 0;
  293.         //printf("Variable lengthn");
  294.         i = 0;
  295.     } else {
  296.         flc = 1;
  297.         //printf("Fixed lengthn");
  298.         i = 1;
  299.     }
  300.     //printf( "                   Hex   Type   Value   Statechangen");
  301.     while (strcmpi( input[i].vlc, "End")) {  /* Process until "End" */
  302.         status = parse_bits( input[i].vlc, MAX_STRING_VLD-1, DECTABBITS,
  303.                                 &bits, &codeword, minBits);
  304.         if (status != OK) {
  305.             sprintf( msg, "Error in parse_bits from buildtable"); /* Flawfinder: ignore */
  306.             H261ErrMsg( msg );
  307.             return( H261_ERROR );
  308.         }
  309.         codeword <<= DECTABBITS - bits;
  310.         value = input[i].value;
  311.         if (flc == 0) { /* Do one codeword if VLC code */
  312.             input[i].last_value = value;
  313.         }
  314.         while (value <= input[i].last_value) {
  315.             //strpad( input[i].vlc, ' ', MAX_STRING_VLD-1);
  316.             //printf( "%3d: %s    %2x  %4d   %4d      %4d    Bits = %dn",
  317.             //    i, input[i].vlc, codeword, input[i].type, value,
  318.             //    input[i].statechange, bits);
  319.             /* Build decode table */
  320.             for (j = codeword; j < codeword + (1 << (DECTABBITS - bits)); j++) {
  321.                 if (output[j].sym.type != SYM_EXIT  ||
  322.                         output[j].sym.value != ILLEGAL_SYMBOL) {
  323.                     sprintf( msg, "String %d: Entry %d done previously", i, j); /* Flawfinder: ignore */
  324.                     H261ErrMsg( msg );
  325.                     return( H261_ERROR );
  326.                 }
  327.                 output[j].sym.type = input[i].type;
  328.                 output[j].sym.value = value;
  329.                 output[j].statechange = input[i].statechange;
  330.                 /* Signal long codeword by inverting "bits" */
  331.                 if (input[i].type == SYM_ESCAPE) {
  332.                     output[j].bits = -bits;
  333.                 } else {
  334.                     output[j].bits = bits;
  335.                 }
  336.             }
  337.             ++value;
  338.             codeword += (1 << (DECTABBITS - bits));
  339.         }
  340.         if (++i > DECTABSIZE) {
  341.             goto no_end;
  342.         }
  343.     }
  344. /*    if (flc == 0) {
  345.         printf("Reached End after finding %d variable length codesn", i);
  346.     } else {
  347.         printf("Reached End after finding %d fixed length entriesn", i-1);
  348.     }
  349.  */
  350.     return (OK);
  351.     
  352. no_end:
  353.     sprintf( msg, "No End mark"); /* Flawfinder: ignore */
  354.     H261ErrMsg( msg );
  355.     return( H261_ERROR );
  356. }
  359. //  Parse bitstring "vlc", return length in "bits" and value in "codeword"
  360. static int parse_bits(  char vlc[],     /* String with bit pattern */
  361.                         int strmax,     /* Max characters in "vlc" excluding terminating null */
  362.                         int maxbits,    /* Max # bits in codeword */
  363.                         int * bits,     /* Returns # bits; 0 < bits < maxbits+1 */
  364.                         int * codeword, /* Returns codeword */
  365.                         int minBits     // Min # bits in codeword
  366. )
  367. {
  368.     int j, c;
  369.     char msg[120]; /* Flawfinder: ignore */
  370.     
  371.     *bits = 0, j = 0, *codeword = 0;
  372.     c = vlc[j];
  373.     while (c != 0) {
  374.         if (c == '0'  ||  c == '1') {
  375.             *codeword <<= 1;
  376.             ++(*bits);
  377.             if (c == '1') {
  378.                 ++(*codeword);
  379.             }
  380.         } else if (isspace(c) == 0) {   /* Found illegal character */
  381.             SafeSprintf(msg, 120, "parse_bits - Illegal string: %s", vlc);
  382.             H261ErrMsg( msg );
  383.             return( H261_ERROR );
  384.         }
  385.         c = vlc[++j];
  386.     }
  387.     if (j > strmax) {
  388.         SafeSprintf(msg, 120, "Too long string: %s", vlc);
  389.         H261ErrMsg( msg );
  390.         return( H261_ERROR );
  391.     }
  392.     if (*bits > maxbits  ||  *bits < minBits) {
  393.         SafeSprintf(msg, 120, "Illegal string: %s", vlc);
  394.         H261ErrMsg( msg );
  395.         return( H261_ERROR );
  396.     }
  397.     return (OK);
  398. }
  401. ///////////  Routines for debugging  //////////////
  403. //  strpad - Pad str to length len; return number of appended chars
  404. /*static int strpad( char str[], int pad, int len)
  405. {
  406.     int i, numpad;
  408.     numpad = 0;
  409.     for (i = strlen(str); i < len; i++) {
  410.         str[i] = pad;
  411.         ++numpad;
  412.     }
  413.     if (numpad > 0) {
  414.         str[len] = NULL;
  415.     }
  416.     return (numpad);
  417. }*/
  419. extern void printsym( SYMBOL sym )
  420. {
  421.     char ctype[80]; /* Flawfinder: ignore */
  422.     
  423.     sprinttype( sym.type, ctype, 80);
  424.     printf("%s =%4d", ctype, sym.value);
  425.     return;
  426. }
  428. extern void sprintsym( SYMBOL sym, char s[], int sBufLen)
  429. {
  430.     char ctype[80]; /* Flawfinder: ignore */
  431.     
  432.     sprinttype( sym.type, ctype, 80);
  433.     SafeSprintf(s, sBufLen, "%s =%4d", ctype, sym.value);
  434.     return;
  435. }
  437. extern void sprinttype( int symtype, char s[], int sBufLen)
  438. {
  439.     switch (symtype) {
  440.     case SYM_EXIT:
  441.         SafeSprintf(s, sBufLen, "EXIT");
  442.         break;
  443.     case SYM_ESCAPE:
  444.         SafeSprintf(s, sBufLen, "ESCAPE  Table");
  445.         break;
  446.     case SYM_EOB:
  447.         SafeSprintf(s, sBufLen, "End Of Block");
  448.         break;
  449.     case SYM_INTRA_DC:
  450.         SafeSprintf(s, sBufLen, "Intra DC");
  451.         break;
  452.     case SYM_MBA:
  453.         SafeSprintf(s, sBufLen, "MBA");
  454.         break;
  455.     case SYM_STARTCODE:
  456.         SafeSprintf(s, sBufLen, "StartCode");
  457.         break;
  458.     case SYM_MBA_STUFFING:
  459.         SafeSprintf(s, sBufLen, "MBA Stuffing");
  460.         break;
  461.     case SYM_MTYPE:
  462.         SafeSprintf(s, sBufLen, "MB Type");
  463.         break;
  464.     case SYM_MVD:
  465.         SafeSprintf(s, sBufLen, "MVDiff");
  466.         break;
  467.     case SYM_CBP:
  468.         SafeSprintf(s, sBufLen, "CBP");
  469.         break;
  470.     case SYM_QUANT_TR:
  471.         SafeSprintf(s, sBufLen, "Quant/TR");
  472.         break;
  473.     case SYM_GEI_PEI:
  474.         SafeSprintf(s, sBufLen, "ExtraInsert");
  475.         break;
  476.     case SYM_SPARE:
  477.         SafeSprintf(s, sBufLen, "Spare");
  478.         break;
  479.     case SYM_GN:
  480.         SafeSprintf(s, sBufLen, "GOB Number");
  481.         break;
  482.     case SYM_PTYPE:
  483.         SafeSprintf(s, sBufLen, "Picture Type");
  484.         break;
  485.     case SYM_ESC_RUN:
  486.         SafeSprintf(s, sBufLen, "ESC Run");
  487.         break;
  488.     case SYM_ESC_LEVEL:
  489.         SafeSprintf(s, sBufLen, "ESC Level");
  490.         break;
  491.     case SYM_MCBPC:
  492.         SafeSprintf(s, sBufLen, "MCBPC");
  493.         break;
  494.     case SYM_MCBPC_STUFFING:
  495.         SafeSprintf(s, sBufLen, "MCBPC Stuffing");
  496.         break;
  497.     case SYM_MODB:
  498.         SafeSprintf(s, sBufLen, "MODB");
  499.         break;
  500.     case SYM_CBPY:
  501.         SafeSprintf(s, sBufLen, "CBPY");
  502.         break;
  503.     case SYM_DQUANT:
  504.         SafeSprintf(s, sBufLen, "DQUANT");
  505.         break;
  506.     default:
  507.         SafeSprintf(s, sBufLen, "Run = %d   Level", symtype);
  508.         break;
  509.     }
  510.     return;
  511. }
  513. extern void printstate( int state )
  514. {
  515.     switch (state) {
  516.     case ST_MC_NOCBP_MVDX:
  517.         printf("MC No coeffs MVDx");
  518.         break;
  519.     case ST_MC_NOCBP_MVDY:
  520.         printf("MC No coeffs MVDy");
  521.         break;
  522.     case ST_MBA_STARTCODE:
  523.         printf("MBA or Startcode");
  524.         break;
  525.     case ST_NEXT_BLK_6:
  526.         printf("One block to go, AC coeff");
  527.         break;
  528.     case ST_FIRST_BLK_6:
  529.         printf("One block to go, first coeff");
  530.         break;
  531.     case ST_NEXT_BLK_5:
  532.         printf("Two blocks to go, AC coeff");
  533.         break;
  534.     case ST_FIRST_BLK_5:
  535.         printf("Two blocks to go, first coeff");
  536.         break;
  537.     case ST_NEXT_BLK_4:
  538.         printf("Three blocks to go, AC coeff");
  539.         break;
  540.     case ST_FIRST_BLK_4:
  541.         printf("Three blocks to go, first coeff");
  542.         break;
  543.     case ST_NEXT_BLK_3:
  544.         printf("Four blocks to go, AC coeff");
  545.         break;
  546.     case ST_FIRST_BLK_3:
  547.         printf("Four blocks to go, first coeff");
  548.         break;
  549.     case ST_NEXT_BLK_2:
  550.         printf("Five blocks to go, AC coeff");
  551.         break;
  552.     case ST_FIRST_BLK_2:
  553.         printf("Five blocks to go, first coeff");
  554.         break;
  555.     case ST_NEXT_BLK_1:
  556.         printf("Six blocks to go, AC coeff");
  557.         break;
  558.     case ST_FIRST_BLK_1:
  559.         printf("Six blocks to go, first coeff");
  560.         break;
  561.     case ST_INTRA_DC_BLK_6:
  562.         printf("Last INTRA block, DC coeff");
  563.         break;
  564.     case ST_INTRA_AC_BLK_5:
  565.         printf("Two INTRA blocks to go, AC coeff");
  566.         break;
  567.     case ST_INTRA_DC_BLK_5:
  568.         printf("Two INTRA blocks to go, DC coeff");
  569.         break;
  570.     case ST_INTRA_AC_BLK_4:
  571.         printf("Three INTRA blocks to go, AC coeff");
  572.         break;
  573.     case ST_INTRA_DC_BLK_4:
  574.         printf("Three INTRA blocks to go, DC coeff");
  575.         break;
  576.     case ST_INTRA_AC_BLK_3:
  577.         printf("Four INTRA blocks to go, AC coeff");
  578.         break;
  579.     case ST_INTRA_DC_BLK_3:
  580.         printf("Four INTRA blocks to go, DC coeff");
  581.         break;
  582.     case ST_INTRA_AC_BLK_2:
  583.         printf("Five INTRA blocks to go, AC coeff");
  584.         break;
  585.     case ST_INTRA_DC_BLK_2:
  586.         printf("Five INTRA blocks to go, DC coeff");
  587.         break;
  588.     case ST_INTRA_AC_BLK_1:
  589.         printf("Six INTRA blocks to go, AC coeff");
  590.         break;
  591.     case ST_INTRA_DC_BLK_1:
  592.         printf("Six INTRA blocks to go, DC coeff");
  593.         break;
  594.     case ST_MC_CBP_MVDX:
  595.         printf("MVDx");
  596.         break;
  597.     case ST_MC_CBP_MVDY:
  598.         printf("MVDy");
  599.         break;
  600.     case ST_CBP:
  601.         printf("CBP");
  602.         break;
  603.     case ST_INTRA_MQUANT:
  604.         printf("INTRA MQUANT");
  605.         break;
  606.     case ST_MC_CBP_MQUANT:
  607.         printf("MC MQUANT");
  608.         break;
  609.     case ST_ESC_BLK_6:
  610.         printf("ESCAPE, one block to go");
  611.         break;
  612.     case ST_INTER_MQUANT:
  613.         printf("INTER MQUANT");
  614.         break;
  615.     case ST_ESC_BLK_5:
  616.         printf("ESCAPE, two blocks to go");
  617.         break;
  618.     case ST_MTYPE:
  619.         printf("MTYPE");
  620.         break;
  621.     case ST_ESC_BLK_4:
  622.         printf("ESCAPE, three blocks to go");
  623.         break;
  624.     case ST_GEI_PEI:
  625.         printf("PEI/GEI");
  626.         break;
  627.     case ST_ESC_BLK_3:
  628.         printf("ESCAPE, four blocks to go");
  629.         break;
  630.     case ST_PTYPE:
  631.         printf("PictureType");
  632.         break;
  633.     case ST_ESC_BLK_2:
  634.         printf("ESCAPE, five blocks to go");
  635.         break;
  636.     case ST_GQUANT:
  637.         printf("GQUANT");
  638.         break;
  639.     case ST_ESC_BLK_1:
  640.         printf("ESCAPE, six blocks to go");
  641.         break;
  642.     case ST_TR:
  643.         printf("TempRef");
  644.         break;
  645.     case ST_AFTER_STARTCODE:
  646.         printf("After Startcode");
  647.         break;
  648.     case ST_ESC_INTRA_5:
  649.         printf("ESCAPE, two INTRA blocks to go");
  650.         break;
  651.     case ST_ESC_INTRA_4:
  652.         printf("ESCAPE, three INTRA blocks to go");
  653.         break;
  654.     case ST_ESC_INTRA_3:
  655.         printf("ESCAPE, four INTRA blocks to go");
  656.         break;
  657.     case ST_ESC_INTRA_2:
  658.         printf("ESCAPE, five INTRA blocks to go");
  659.         break;
  660.     case ST_ESC_INTRA_1:
  661.         printf("ESCAPE, six INTRA blocks to go");
  662.         break;
  664.     // H.263 states
  665.     case ST263_FINISHED:
  666.         printf("Finished H.263 block decoding");
  667.         break;
  668.     case ST263_ESC_FINISHED:
  669.         printf("Decode ESC-LEVEL, then done");
  670.         break;
  671.     case ST263_BLK_6:
  672.         printf("Decoding last block (block 6)");
  673.         break;
  674.     case ST263_ESC_BLK6:
  675.         printf("Decode ESC-LEVEL, then continue with block 6");
  676.         break;
  677.     case ST263_BLK_5:
  678.         printf("Decoding block 5");
  679.         break;
  680.     case ST263_ESC_BLK5:
  681.         printf("Decode ESC-LEVEL, then continue with block 5");
  682.         break;
  683.     case ST263_BLK_4:
  684.         printf("Decoding block 4");
  685.         break;
  686.     case ST263_ESC_BLK4:
  687.         printf("Decode ESC-LEVEL, then continue with block 4");
  688.         break;
  689.     case ST263_BLK_3:
  690.         printf("Decoding block 3");
  691.         break;
  692.     case ST263_ESC_BLK3:
  693.         printf("Decode ESC-LEVEL, then continue with block 3");
  694.         break;
  695.     case ST263_BLK_2:
  696.         printf("Decoding block 2");
  697.         break;
  698.     case ST263_ESC_BLK2:
  699.         printf("Decode ESC-LEVEL, then continue with block 2");
  700.         break;
  701.     case ST263_BLK_1:
  702.         printf("Decoding block 1");
  703.         break;
  704.     case ST263_ESC_BLK1:
  705.         printf("Decode ESC-LEVEL, then continue with block 1");
  706.         break;
  707.     case ST263_INTRA_DC_ONLY:
  708.         printf("Decode INTRA-DC only, then exit");
  709.         break;
  710.     case ST263_INTRA_DC_AC:
  711.         printf("Decode INTRA-DC and AC coeffs, then exit");
  712.         break;
  714.     default:
  715.         printf("Unknown state = %d", state);
  716.         break;
  717.     }
  718.     return;
  719. }