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

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

Symbian

开发平台：

C/C++

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