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

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

Symbian

开发平台：

C/C++

h263dec.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 "dllindex.h"
  37. #include "h261defs.h"
  38. #include "vldstate.h"
  39. #include "vldtabs.h"
  40. #include "h261func.h"
  41. #include "vldecode.h"       /* set the proper pragmas for VLDecode          */
  42. #include "h263plus.h"
  44. //#include <stdio.h>
  45. //#include <stdlib.h>
  46. //#define BS_ERR_MSG(a)   a   // Generate messages on bitstream error (i.e., illegal 
  47.                             // bitstream syntax) to simplify debugging
  48. #define BS_ERR_MSG(a)       // Suppress error messages 
  50. //#define CHECKSYM(a)     a     // Check symbol types to verify decoder state tables
  51. #define CHECKSYM(a)             // Don't check symbol types
  53. ////////////  Static function declarations  ////////////
  54. //  initPBtabs - Initialize tables for Bquant and mvB/mvF
  55. static void initPBtabs( PICTURE_DESCR * pic );
  56. //  decMvd - Decode "num" motion vectors
  57. static int  decMvd( BS_PTR * bs,    // Bitstream pointer; updated by this routine
  58.                     int * maxBits,  // max bits to decode; updated by this routine
  59.                     int num,        // number of motion vectors to decode
  60.                     S8  x[],        // hor. components decoded by this routine
  61.                     S8  y[]         // vert. components decoded by this routine
  62.                     );
  63. // getMvComp - Compute mv component in H.263 decoder
  64. static int getMvComp( int pred, S8 diff, int unrestrictedMv );
  65. //  dec263blocks - Decode block layer for a macroblock
  66. static int  dec263blocks(   BS_PTR * bs,    // Bitstream pointer; updated by this routine
  67.                             int * maxBits,  // max bits to decode; updated by this routine
  68.                             int cbp,        // Coded Block Pattern
  69.                             int intraFlag,  // 0: INTER block, otherwise INTRA
  70.                             int advancedIntraMode, // 0: off else on
  71.                             BLOCK_DESCR block[6],   // block descriptors generated by this routine
  72.                             SYMBOL sym[],   // array for symbols generated by this routine
  73.                             int maxsym      // size of sym[] array
  74.                             );
  75. //  parseSymbols - Create block descriptor and merge ESC-RUN and ESC-LEVEL symbols
  76. //  Return number of symbols
  77. static int parseSymbols( SYMBOL insym[],        // Input symbols
  78.                         int nsym,               // # input symbols
  79.                         SYMBOL outsym[]         // output symbols
  80.                         );
  84. //  DecPicLayer263 - Decode H.263 Picture Layer information
  85. extern int  DecPicLayer263( BS_PTR * bs, int nbits, PICTURE_DESCR * pic,
  86.                             GOB_DESCR * gob, int * decPtype )
  87. {
  88.     int     gn, tr, ptype, quant, pei, pspare, cpm;
  89. #ifdef DO_H263_PLUS
  90.     int eptype=0;
  91. #endif
  92.     // Decode GN
  93.     if (FLDecSymbol( bs, 5, &nbits, &gn )  !=  OK)  return( OUT_OF_BITS );
  94.     if (gn != 0)  return( H261_ERROR );     // GN=0 for Picture Start Code
  95.     // Decode TR
  96.     if (FLDecSymbol( bs, 8, &nbits, &tr )  !=  OK)  return( OUT_OF_BITS );
  97.     pic->tr = tr;
  98.     // Decode PTYPE
  99.     if (FLDecSymbol( bs, 13, &nbits, &ptype )  !=  OK)  return( OUT_OF_BITS );
  101. #ifdef DO_H263_PLUS
  102.     if ((ptype & 0xe0) == PTYPE263_EPTYPE) {
  103.         if(FLDecSymbol( bs, 14, &nbits, &eptype )  !=  OK)  return( OUT_OF_BITS );
  104.         // the picture type is in bits 1-3 of EPTYPE, put those bits into bits 6-8 of PTYPE
  105.         ptype &= 0xFFFFFF1F; // clear bits 6-8
  106.         ptype |= (0x3800 & eptype) >> 6; 
  107.     }
  108. #endif
  110.     pic->ptype = ptype;
  111.     *decPtype = ptype;
  112.     pic->splitscreen = ptype & PTYPE263_SPLITSCREEN;
  113.     pic->doccamera = ptype & PTYPE263_DOCCAMERA;
  114.     pic->fp_release = ptype & PTYPE263_FP_RELEASE;
  115.     switch (ptype & 0xe0)
  116.     {
  117.     case PTYPE263_SQCIF:
  118.         pic->format = SQCIF;
  119.         break;
  120.     case PTYPE263_QCIF:
  121.         pic->format = QCIF;
  122.         break;
  123.     case PTYPE263_CIF:
  124.         pic->format = CIF;
  125.         break;
  126.     case PTYPE263_4CIF:
  127.         pic->format = CIF4;
  128.         break;
  129.     case PTYPE263_16CIF:
  130.         pic->format = CIF16;
  131.         break;
  132.     case PTYPE263_RESERVED:
  133.         pic->format = ANYSIZE;
  134.         break;
  135.     default:
  136.         return( H261_ERROR );
  137.         break;
  138.     }
  139.     if ((ptype & 0x800) != 0  || (ptype & 0x1000) == 0) return( H261_ERROR );
  140.     pic->interFrame = ptype & PTYPE263_INTER;
  141.     pic->unrestrictedMv = ptype & PTYPE263_UNRESTRICTED_MV;
  142.     pic->advancedPred = ptype & PTYPE263_ADVANCED_PRED;
  143.     pic->syntax_basedAC = ptype & PTYPE263_SYNTAX_BASED_AC;
  144.     if (pic->syntax_basedAC) {
  145.         BS_ERR_MSG( H261ErrMsg("Syntax-based AC not yet supported"); )
  146.         return( H261_ERROR );
  147.     }
  148.     pic->PBframeMode = (ptype & PTYPE263_PB_FRAME) != 0;
  150. #ifdef DO_H263_PLUS
  151.     // Do PB frame - either orignal or improved mode
  152.     pic->PBframeMode = (ptype & PTYPE263_PB_FRAME) ? 1 : 0;
  153.     if(pic->PBframeMode) {
  154.         if( eptype & EPTYPE263PLUS_IMPROVED_PBFRAME_MODE) {
  155.             pic->PBframeMode = H263PLUS_IMPROVED_PBFRAME_MODE;
  156.         }
  157.     } else {
  158.         if( eptype & EPTYPE263PLUS_IMPROVED_PBFRAME_MODE) {
  159.             return ( H261_ERROR );
  160.         }
  161.     }
  162.     // Are deblocking filters on?
  163.     pic->deblockingFilterMode = eptype & EPTYPE263PLUS_DEBLOCKING_FILTER_MODE;
  164.     // Use advanced intra mode?
  165.     pic->advancedIntraMode = eptype & EPTYPE263PLUS_ADVANCED_INTRA_MODE;
  166.     // Using Reduced-resolution Update mode?
  167.     pic->reducedResUpdate = eptype & EPTYPE263PLUS_REDUCED_RES_UPDATE;
  168.     //if (pic->reducedResUpdate && (!pic->interFrame || pic->PBframeMode)) return( H261_ERROR );
  169. #else
  170.     pic->reducedResUpdate = 0;
  171. #endif
  173.     if(pic->interFrame == 0 && pic->PBframeMode != 0) return( H261_ERROR );
  174.     // Decode PQUANT
  175.     if (FLDecSymbol( bs, 5, &nbits, &quant )  !=  OK)  return( OUT_OF_BITS );
  176.     if (quant < QUANT_MIN  ||  quant > QUANT_MAX)  return( H261_ERROR );
  177.     gob->gquant = quant;
  178.      // Decode CPM (continuous presence multipoint). For now, flag error if not zero.
  179.     if (FLDecSymbol( bs, 1, &nbits, &cpm )  !=  OK)  return( OUT_OF_BITS );
  180.     // if (cpm != 0)  return( H261_ERROR );
  181.     pic->cpm = cpm;     // Save (we may need it?)
  182.     if (pic->PBframeMode) {
  183.         // Decode TRB
  184.         if (FLDecSymbol( bs, 3, &nbits, &tr )  !=  OK)  return( OUT_OF_BITS );
  185.         pic->tempRefBframe = tr;
  186.         // Decode DBQUANT
  187.         if (FLDecSymbol( bs, 2, &nbits, &quant )  !=  OK)  return( OUT_OF_BITS );
  188.         pic->dbQuant = quant;
  189.         initPBtabs( pic );  // Generate lookup tables for Bquant and mvB/mvF
  190.     }
  191.     pic->trPrev = pic->tr;  // Hold on to TR for decoding of next picture
  192.     // Decode PEI
  193.     if (FLDecSymbol( bs, 1, &nbits, &pei )  !=  OK)  return( OUT_OF_BITS );
  194.     pic->peiCount = 0;
  195.     // Decode PSPARE
  196.     while (pei) {   // Loop until PEI=0
  197.         if (pic->peiCount < MAX_PEI_COUNT) {
  198.             FLDecSymbol( bs, 8, &nbits, &pspare );
  199.             pic->pSpare[pic->peiCount] = pspare;
  200.         } else {
  201.             ++bs->byteptr;  // Drop PSPARE on the floor
  202.         }
  203.         ++pic->peiCount;
  204.         if (FLDecSymbol( bs, 1, &nbits, &pei )  !=  OK)  return( OUT_OF_BITS );
  205.     }
  206.     // Indicate that GOB header has no "spares"
  207.     gob->gei = 0;
  208.     gob->num_gspare = 0;
  209.     return( OK );
  210. }
  213. //  InitMvTabs - Initialize tables for mvB/mvF
  214. extern void InitMvTabs( int trD, int trB,
  215.                         int tabMvF[], int tabMvB[]  // [UMV_MIN:UMV_MAX]
  216.                         )
  217. {
  218.     int i;
  220.     // Generate tables for B-picture motion vectors
  221.     trD &= H263_TR_MASK;
  222.     if (trD == 0)  trD = 2; // Avoid divide by 0
  223.     if (trB >= trD)  trB = 0;   // Ensure trB < trD
  224.     for (i = UMV_MIN; i <= UMV_MAX; ++i) {
  225.         tabMvF[i] = (trB * i) / trD;          // Mv using prev. picture
  226.         tabMvB[i] = ((trB - trD) * i) / trD;  // Mv using new P-picture
  227.     }
  228. }
  231. // Tables for B-picture: Bquant and mvF/mvB
  232. static U8   tabBquant[QUANT_MAX-QUANT_MIN+1];
  233. static int  decMvF[UMV_MAX-UMV_MIN+1],  // Mv using prev. picture
  234.             decMvB[UMV_MAX-UMV_MIN+1];  // Mv using new P-picture
  236. //  initPBtabs - Initialize tables for Bquant and mvB/mvF
  237. static void initPBtabs( PICTURE_DESCR * pic )
  238. {
  239.     int i, n;
  241.     // Generate tables for B-picture motion vectors
  242.     InitMvTabs( (pic->tr - pic->trPrev) & H263_TR_MASK, 
  243.                 pic->tempRefBframe,
  244.                 &decMvF[-UMV_MIN], &decMvB[-UMV_MIN] );
  245.     // Generate table for Bquant
  246.     n = pic->dbQuant + 5;
  247.     for (i = QUANT_MIN; i <= QUANT_MAX; ++i) {
  248.         tabBquant[i - QUANT_MIN] = min( (n*i) >> 2, QUANT_MAX );
  249.     }
  250. }
  253. //  DecGobLayer263 - Decode H.263 GOB Layer information
  254. extern int  DecGobLayer263( BS_PTR * bs, int nbits, GOB_DESCR * gob, int * gfid )
  255. {
  256.     int     gn, quant;
  258.     // Decode GN
  259.     if (FLDecSymbol( bs, 5, &nbits, &gn )  !=  OK)  return( OUT_OF_BITS );
  260.     // Decode GFID
  261.     if (FLDecSymbol( bs, 2, &nbits, gfid )  !=  OK)  return( OUT_OF_BITS );
  262.     // Decode GQUANT
  263.     if (FLDecSymbol( bs, 5, &nbits, &quant )  !=  OK)  return( OUT_OF_BITS );
  264.     if (quant < QUANT_MIN  ||  quant > QUANT_MAX)  return( H261_ERROR );
  265.     gob->gquant = quant;
  266.     // Indicate that GOB header has no "spares"
  267.     gob->gei = 0;
  268.     gob->num_gspare = 0;
  269.     return( OK );
  270. }
  272. //#define DB_DUMP_BLOCK_SYMBOLS
  273. #ifdef DB_DUMP_BLOCK_SYMBOLS
  274. FILE * pDecFile=0;
  275. int bDecOpen=0;
  276. int bDecClose=0;
  277. #endif
  279. //  DecMbLayer263 - Decode macroblock layer and block layer for a Group Of Blocks
  280. //  This routine is very picky when determining whether bitstream is valid.
  281. //  It returns OK only if a startcode ends the bitstream; otherwise, it
  282. //  returns H261_ERROR.
  283. extern int  DecMbLayer263(  BS_PTR * bs,    // Bitstream pointer
  284.                             int nbits,      // Bits to decode (incl. trailing startcode)
  285.                             GOB_DESCR * gob,        // GOB descriptor
  286.                             MACROBLOCK_DESCR mb[],  // Packed array of "gob->num_mb" MB descr.
  287.                             int interFrame, // 0: ptype=INTRA, otherwise ptype=INTER
  288.                             int PBframe,    // 0: not PB frame, otherwise PB frame
  289.                             int unrestrictedMv, // 0: -16/+15.5 motion, otherwise +/- 31.5
  290.                             int advancedIntraMode, // 0: off else on
  291.                             SYMBOL sym[],   // symbol array
  292.                             int maxsym      // size of symbol array
  293.                             )
  294. {
  295.     int     quant, isym, mcbpcTab, i, j, status, cbpyTab, intraFlag, horPredOnly, mvX, mvY;
  296.     SYMBOL  s;
  297.     int     mcbpc, modB, cbpB;
  298.     BS_ERR_MSG ( char msg[120] ); /* Flawfinder: ignore */
  299.     
  300.     isym = 0;
  301.     quant = gob->gquant;
  302.     if (interFrame) {
  303.         mcbpcTab = TAB263_MCBPC_INTER;
  304.     } else {
  305.         mcbpcTab = TAB263_MCBPC_INTRA;
  306.     }
  307.     for (i = 0; i < gob->num_mb; ++i) {
  308.         // Decode MCBPC
  309.         do {
  310.             status = VLDecSymbol( bs, mcbpcTab, &nbits, &s );
  311. if (status != OK)  
  312.                 if (s.type != SYM_STARTCODE) {
  313. status = BITSTREAM_ERROR;
  314. goto error_exit;
  315. } else {
  316. return(OK);
  317. }
  318.         } while( s.type == SYM_MCBPC_STUFFING );
  319.         mcbpc = s.value;
  320.         mb[i].mtype = mcbpc & 0xfc; // Mask off cbpC (two LSBs)
  322. #ifdef DO_H263_PLUS
  323.         if(advancedIntraMode && 
  324.             (mb[i].mtype == MTYPE263_INTRA || mb[i].mtype == MTYPE263_INTRA_Q)) {
  325.             // Decode INTRA_MODE
  326.             status = VLDecSymbol( bs, TAB263PLUS_INTRA_MODE, &nbits, &s );
  327. if (status != OK)  goto error_exit;
  328.             mb[i].intra_mode = s.value;
  329.         } else {
  330.             mb[i].intra_mode = ADV_INTRA_PRED_NONE;
  331.         }
  332. #endif
  333.         //printf("DecMbLayer:  x = %d   y = %d   type = %dn", mb[i].x, mb[i].y, mb[i].mtype );
  334.         if (mb[i].mtype == MTYPE_SKIP) {
  335.             mb[i].mv_x = 0;
  336.             mb[i].mv_y = 0;
  337.         } else {
  338.             if (PBframe) {
  339.                 // Decode MODB
  340. #ifdef DO_H263_PLUS
  341. if(PBframe==H263PLUS_IMPROVED_PBFRAME_MODE) {
  342. status = VLDecSymbol( bs, TAB263PLUS_MODB, &nbits, &s );
  343. } else {
  344. status = VLDecSymbol( bs, TAB263_MODB, &nbits, &s );
  345. }
  346. #else
  347. status = VLDecSymbol( bs, TAB263_MODB, &nbits, &s );
  348. #endif
  349. if (status != OK)  
  350. goto error_exit;
  351.                 modB = s.value;
  352.                 mb[i].modB = modB;
  353.                 if (BFRAME_HAS_CBP(&mb[i])) {    // Decode cbpB
  354.                     status = FLDecSymbol( bs, 6, &nbits, &cbpB );
  355.                     if (status != OK)  goto error_exit;
  356.                     mb[i].cbpB = cbpB;
  357.                 } else {
  358.                     mb[i].cbpB = 0;
  359.                 }
  360.             } else {
  361.                 mb[i].modB = modB = 0;
  362.             }
  363.             // Decode cbpY
  364.             if (mb[i].mtype == MTYPE263_INTRA  ||  mb[i].mtype == MTYPE263_INTRA_Q) {
  365.                 cbpyTab = TAB263_CBPY_INTRA;
  366.             } else {
  367.                 cbpyTab = TAB263_CBPY;
  368.             }
  369.             status = VLDecSymbol( bs, cbpyTab, &nbits, &s );
  370.             if (status != OK)  goto error_exit;
  371.             mb[i].cbp = (s.value << 2) | (mcbpc & 0x3);
  372.             // Decode DQUANT
  373.             if (mb[i].mtype == MTYPE263_INTER_Q  ||  mb[i].mtype == MTYPE263_INTRA_Q) {
  374.                 status = VLDecSymbol( bs, TAB263_DQUANT, &nbits, &s );
  375.                 if (status != OK)  goto error_exit;
  376.                 mb[i].dquant = s.value;
  377.                 quant += mb[i].dquant;
  378.                 if (quant < QUANT_MIN)
  379.                     quant = QUANT_MIN;
  380.                 if (quant > QUANT_MAX)
  381.                     quant = QUANT_MAX;
  382.             }
  383.             mb[i].quant = quant;
  384.             // Decode motion vectors and block layer
  385.             if (i < gob->mb_width) {
  386.                 horPredOnly = YES;  // First row of macroblocks; don't use prev. row
  387.             } else {
  388.                 horPredOnly = NO;
  389.             }
  390.             switch( mb[i].mtype ) {
  391.                 
  392.             case MTYPE263_INTRA:
  393.             case MTYPE263_INTRA_Q:
  394.                 if (PBframe) {  // Decode MVD
  395.                     status = decMvd( bs, &nbits, 1, &mb[i].mvd_x, &mb[i].mvd_y );
  396.                     if (status != OK)  goto error_exit;
  397.                     MvPred( &mb[i], WHOLE_MACROBLOCK, gob->mb_offset, horPredOnly, &mvX, &mvY );
  398.                     mb[i].mv_x = getMvComp( mvX, mb[i].mvd_x, unrestrictedMv );
  399.                     mb[i].mv_y = getMvComp( mvY, mb[i].mvd_y, unrestrictedMv );
  400.                     if (BFRAME_HAS_MOTION_VECTOR(&mb[i])) {  // Decode MVDB
  401.                         status = decMvd( bs, &nbits, 1, &mb[i].mvdB_x, &mb[i].mvdB_y );
  402.                         if (status != OK)  goto error_exit;
  403.                     }
  404.                 } else {
  405.                     mb[i].mv_x = 0;
  406.                     mb[i].mv_y = 0;
  407.                 }
  409.                 intraFlag = YES;
  410. #ifdef DO_H263_PLUS
  411.                 status = dec263blocks( bs, &nbits, mb[i].cbp, intraFlag, advancedIntraMode,
  412.                                         mb[i].block, &sym[isym], maxsym - isym );
  413. #else
  414.                 status = dec263blocks( bs, &nbits, mb[i].cbp, intraFlag, 0,
  415.                                         mb[i].block, &sym[isym], maxsym - isym );
  416. #endif
  419. #ifdef DB_DUMP_BLOCK_SYMBOLS
  420.                 if(bDecClose) {
  421.                     fclose(pDecFile);
  422.                     pDecFile = NULL;
  423.                 }
  424.                 if(bDecOpen) {
  425.                     pDecFile = fopen("C:\temp\dec_out.dmp", "wt");
  426.                 }
  428.                 if(pDecFile) {
  429.                     int b,s;
  430.                     fprintf(pDecFile, "n n Macroblock %d n n", i);
  431.                     for(b=0; b<6; b++) {
  432.                         fprintf(pDecFile, "n Block %d n", b);
  433.                         for(s=0; s<mb[i].block[b].nsym; s++) {
  434.                             fprintf(pDecFile, "lev = %d  run = %dn", mb[i].block[b].sym[s].value, mb[i].block[b].sym[s].type);
  435.                         }
  436.                     }
  437.                 }
  438. #endif
  440.                 if (status == H261_ERROR) {
  441.                     status = BITSTREAM_ERROR;
  442.                     goto error_exit;
  443.                 }
  444.                 isym += status;
  445.                 break;
  446.                 
  447.             case MTYPE263_INTER:
  448.             case MTYPE263_INTER_Q:
  449.                 // Decode MVD
  450.                 status = decMvd( bs, &nbits, 1, &mb[i].mvd_x, &mb[i].mvd_y );
  451.                 if (status != OK)  goto error_exit;
  452.                 MvPred( &mb[i], WHOLE_MACROBLOCK, gob->mb_offset, horPredOnly, &mvX, &mvY );
  453.                 mb[i].mv_x = getMvComp( mvX, mb[i].mvd_x, unrestrictedMv );
  454.                 mb[i].mv_y = getMvComp( mvY, mb[i].mvd_y, unrestrictedMv );
  455.                 if (BFRAME_HAS_MOTION_VECTOR(&mb[i])) {  // Decode MVDB
  456.                     status = decMvd( bs, &nbits, 1, &mb[i].mvdB_x, &mb[i].mvdB_y );
  457.                     if (status != OK)  goto error_exit;
  458.                 }
  459.                 intraFlag = 0;
  460.                 status = dec263blocks( bs, &nbits, mb[i].cbp, intraFlag, 0,
  461.                                         mb[i].block, &sym[isym], maxsym - isym );
  462.                 if (status == H261_ERROR) {
  463.                     status = BITSTREAM_ERROR;
  464.                     goto error_exit;
  465.                 }
  466.                 isym += status;
  467.                 break;
  468.                 
  469.             case MTYPE263_INTER4V:
  470.                 // Decode MVD1-4
  471.                 status = decMvd( bs, &nbits, 4, mb[i].blkDiffX, mb[i].blkDiffY );
  472.                 if (status != OK)  goto error_exit;
  473.                 for (j = 0; j < 4; ++j) {
  474.                     MvPred( &mb[i], j, gob->mb_offset, horPredOnly, &mvX, &mvY );
  475.                     mb[i].blkMvX[j] = getMvComp( mvX, mb[i].blkDiffX[j], unrestrictedMv );
  476.                     mb[i].blkMvY[j] = getMvComp( mvY, mb[i].blkDiffY[j], unrestrictedMv );
  477.                 }
  478.                 if (BFRAME_HAS_MOTION_VECTOR(&mb[i])) {  // Decode MVDB
  479.                     status = decMvd( bs, &nbits, 1, &mb[i].mvdB_x, &mb[i].mvdB_y );
  480.                     if (status != OK)  goto error_exit;
  481.                 }
  482.                 intraFlag = 0;
  483.                 status = dec263blocks( bs, &nbits, mb[i].cbp, intraFlag, 0,
  484.                                         mb[i].block, &sym[isym], maxsym - isym );
  485.                 if (status == H261_ERROR) {
  486.                     status = BITSTREAM_ERROR;
  487.                     goto error_exit;
  488.                 }
  489.                 isym += status;
  490.                 break;
  491.                 
  492.             default:
  493.                 status = UNKNOWN_MTYPE;
  494.                 goto error_exit;
  495.                 break;
  496.             }
  497.             
  498.             if (PBframe) {
  499.                 // Reconstruct forward and backward mv for B-frame
  500.                 GetMvBframe( &mb[i], unrestrictedMv, &decMvF[-UMV_MIN], &decMvB[-UMV_MIN] );
  501.                 mb[i].Bquant = tabBquant[quant - QUANT_MIN];
  502.                 if (BFRAME_HAS_CBP(&mb[i])) {    // Decode B blocks
  503.                     intraFlag = 0;
  504.                     status = dec263blocks( bs, &nbits, mb[i].cbpB, intraFlag, 0,
  505.                                             mb[i].Bblock, &sym[isym], maxsym - isym );
  506.                     if (status == H261_ERROR) {
  507.                         status = BITSTREAM_ERROR;
  508.                         goto error_exit;
  509.                     }
  510.                     isym += status;
  511.                 }
  512.             }
  513.         }
  514.     }
  515.     //printf("DecMbLayer:  Remove stuffing, then find startcode; nbits = %dn", nbits);
  516.     
  517. do {
  518.         status = VLDecSymbol( bs, mcbpcTab, &nbits, &s );
  519.         if (status != OK)  
  520. return(OK);
  521. // goto error_exit;
  522. // sometimes the end of stream is not that clean.. -gneel
  523.     } while( s.type == SYM_MCBPC_STUFFING);
  524. //    if (s.type != SYM_STARTCODE  ||  nbits != 0) {
  525. //        status = BITSTREAM_ERROR;
  526. //        goto error_exit;
  527. //    }
  528. // After all the mbs are over there may not be a start code.
  530.     return( OK );
  532. error_exit:
  533.     BS_ERR_MSG( sprintf( msg, "DecMbLayer263: error %d occurred in block #%d", status, i); /* Flawfinder: ignore */
  534.                                 H261ErrMsg( msg ); )
  535.     return( H261_ERROR );
  536. }
  539. //  decMvd - Decode "num" motion vectors
  540. static int  decMvd( BS_PTR * bs,    // Bitstream pointer; updated by this routine
  541.                     int * maxBits,  // max bits to decode; updated by this routine
  542.                     int num,        // number of motion vectors to decode
  543.                     S8  x[],        // hor. components decoded by this routine
  544.                     S8  y[]         // vert. components decoded by this routine
  545.                     )
  546. {
  547.     int     i, status;
  548.     SYMBOL  s;
  549.     
  550.     for (i = 0; i < num; ++i) {
  551.         // Decode horizontal component
  552.         status = VLDecSymbol( bs, TAB263_MVD, maxBits, &s );
  553.         if (status != OK)  return( status );
  554.         x[i] = s.value;
  555.         // Decode vertical component
  556.         status = VLDecSymbol( bs, TAB263_MVD, maxBits, &s );
  557.         if (status != OK)  return( status );
  558.         y[i] = s.value;
  559.     }
  560.     return( OK );
  561. }
  564. // getMvComp - Compute mv component in H.263 decoder
  565. static int getMvComp( int pred, S8 diff, int unrestrictedMv )
  566. {
  567.     int output;
  568.     
  569.     output = pred + diff;
  570.     if (unrestrictedMv == 0) {
  571.         while (output < MVD263_MIN) {
  572.             output += MV263_WRAP;
  573.         }
  574.         while (output > MVD263_MAX) {
  575.             output -= MV263_WRAP;
  576.         }
  577.     } else if (pred < UMV_NEG_THRESH) {
  578.         // UMV pred < -15.5: -31.5 <= output <= 0
  579.         if (output < UMV_MIN) {
  580.             output += MV263_WRAP;   // Need only check negative limit, since diff <= 15.5
  581.         }
  582.     } else if (pred > UMV_POS_THRESH  &&  output > UMV_MAX) {
  583.         // UMV pred > 16: 0 <= output <= 31.5
  584.         output -= MV263_WRAP;       // Need only check positive limit, since diff >= -16
  585.     }   // else: Don't need to check for -15.5 <= pred <= 16
  586.     return( output );
  587. }
  590. //  GetMvBframe - Reconstruct forward and backward motion vectors for B-frame
  591. extern void GetMvBframe( MACROBLOCK_DESCR *mb, int unrestrictedMv,
  592.                          int tabMvF[], int tabMvB[]  // [UMV_MIN:UMV_MAX]
  593.                          )
  594. {
  595.     int j;
  597.     if (mb->mtype == MTYPE263_INTER4V) {
  598.         for (j = 0; j < 4; ++j) {
  599.             // Forward prediction (using prev. frame)
  600.             mb->blkMvFx[j] = tabMvF[ mb->blkMvX[j] ];
  601.             mb->blkMvFy[j] = tabMvF[ mb->blkMvY[j] ];
  602.             if (BFRAME_HAS_MOTION_VECTOR(mb)) {
  603.                 mb->blkMvFx[j] = getMvComp( mb->blkMvFx[j], mb->mvdB_x, unrestrictedMv );
  604.                 mb->blkMvFy[j] = getMvComp( mb->blkMvFy[j], mb->mvdB_y, unrestrictedMv );
  605.                 // Backward prediction (using next P-frame)
  606.                 mb->blkMvBx[j] = mb->blkMvFx[j] - mb->blkMvX[j];
  607.                 mb->blkMvBy[j] = mb->blkMvFy[j] - mb->blkMvY[j];
  608.             } else {
  609.                 mb->blkMvBx[j] = tabMvB[ mb->blkMvX[j] ];
  610.                 mb->blkMvBy[j] = tabMvB[ mb->blkMvY[j] ];
  611.             }
  612.         }
  613.     } else {    // Same motion vector for the whole macroblock
  614.         // Forward prediction (using prev. frame)
  615.         mb->blkMvFx[0] = tabMvF[ mb->mv_x ];
  616.         mb->blkMvFy[0] = tabMvF[ mb->mv_y ];
  617.         if (BFRAME_HAS_MOTION_VECTOR(mb)) {
  618.             mb->blkMvFx[0] = getMvComp( mb->blkMvFx[0], mb->mvdB_x, unrestrictedMv );
  619.             mb->blkMvFy[0] = getMvComp( mb->blkMvFy[0], mb->mvdB_y, unrestrictedMv );
  620.             // Backward prediction (using next P-frame)
  621.             mb->blkMvBx[0] = mb->blkMvFx[0] - mb->mv_x;
  622.             mb->blkMvBy[0] = mb->blkMvFy[0] - mb->mv_y;
  623.         } else {
  624.             mb->blkMvBx[0] = tabMvB[ mb->mv_x ];
  625.             mb->blkMvBy[0] = tabMvB[ mb->mv_y ];
  626.         }
  627.     }
  628. }
  631. //  dec263blocks - Decode block layer for a macroblock
  632. static int  dec263blocks(   BS_PTR * bs,    // Bitstream pointer; updated by this routine
  633.                             int * maxBits,  // max bits to decode; updated by this routine
  634.                             int cbp,        // Coded Block Pattern
  635.                             int intraFlag,  // 0: INTER block, otherwise INTRA
  636.                             int advancedIntraMode, // 0: off else on
  637.                             BLOCK_DESCR block[6],   // block descriptors generated by this routine
  638.                             SYMBOL sym[],   // array for symbols generated by this routine
  639.                             int maxsym      // size of sym[] array
  640.                             )
  641. {
  642.     int startState, isym, mask, blk, state, status, parsed_bits, nsym;
  643.     
  644.     if (intraFlag) {
  645. #ifdef DO_H263_PLUS
  646.         if(advancedIntraMode) {
  647.             startState = ST263PLUS_BLK_6;
  648.         } else {
  649.             startState = ST263_INTRA_DC_AC;
  650.         }
  651. #else
  652.         startState = ST263_INTRA_DC_AC; // Decode DC and AC coeffs
  653. #endif
  654.     } else {
  655.         startState = ST263_BLK_6;       // Decode one INTER block
  656.     }
  657.     isym = 0;
  658.     mask = 0x20;    // Bit 5 indicates whether first block is coded
  659.     for (blk = 0; blk < 6; ++blk) {
  660.         if (cbp & mask) {
  661.             state = startState;
  662.             status = VLDECODE( *bs, *maxBits, &state, &parsed_bits, 
  663.                                 &nsym, &sym[isym], maxsym - isym );
  664.             if (status != FINISHED_LAST_BLOCK)  return( H261_ERROR );
  665.             IncBsPtr( bs, parsed_bits );
  666.             *maxBits -= parsed_bits;
  667.             status = parseSymbols( &sym[isym], nsym, &sym[isym] );
  668.             if (status == H261_ERROR)  return( H261_ERROR );
  669.             block[blk].sym = &sym[isym];
  670.             block[blk].nsym = status;
  671.             isym += status;
  672.         } else if (intraFlag && !advancedIntraMode) { // Decode INTRA-DC
  673.             if (VLDecSymbol( bs, TAB263_INTRA_DC, maxBits, &sym[isym] )  !=  OK) {
  674.                 return( H261_ERROR );
  675.             }
  676.             block[blk].sym = &sym[isym];
  677.             block[blk].nsym = 1;
  678.             ++isym;
  679.         } else {    // No coeffs
  680.             block[blk].nsym = 0;
  681.         }
  682.         mask >>= 1; // Check next block
  683.     }
  684.     return( isym );
  685. }
  688. //  parseSymbols - Merge ESC-RUN and ESC-LEVEL symbols
  689. //  Return number of symbols
  690. static int parseSymbols( SYMBOL insym[],        // Input symbols
  691.                         int nsym,               // # input symbols
  692.                         SYMBOL outsym[]         // output symbols
  693.                         )
  694. {
  695.     int iIn, iOut, zzpos, last, run;
  696.     BS_ERR_MSG ( char msg[120] ); /* Flawfinder: ignore */
  697.     
  698.     iIn = 0, iOut = 0, zzpos = 0;
  699.     while (iIn < nsym) {
  700.         if (insym[iIn].type == SYM_ESC_RUN) {   // Encountered ESCAPE-LAST-RUN-LEVEL symbol
  701.             last = insym[iIn].value & 0x40;     // LAST is found in bit 6
  702.             run = insym[iIn++].value & 0x3f;    // RUN in bits 0-5
  703.             outsym[iOut].type = run;
  704.             CHECKSYM( if (checksym( insym[iIn], SYM_ESC_LEVEL, "parseSymbols") != OK) return(H261_ERROR);)
  705.             outsym[iOut++].value = insym[iIn++].value;
  706.         } else {
  707.             last = insym[iIn].type & 0x40;      // LAST is found in bit 6
  708.             run = insym[iIn].type & 0x3f;     // RUN in bits 0-5
  709.             outsym[iOut].type = run;
  710.             outsym[iOut++].value = insym[iIn++].value;
  711.         }
  712.         zzpos += run + 1;
  713.         //printf("parseSymbols: "); printsym(outsym[iOut-1 ); printf("   zzpos = %dn", zzpos);
  714.         if (zzpos > 64) {   // If we decoded coeff. 63, we will now have zzpos=64
  715.             BS_ERR_MSG( sprintf( msg, "parseSymbols: Bitstream error, zzpos=%d", zzpos); /* Flawfinder: ignore */
  716.             H261ErrMsg( msg ); )
  717.             return (H261_ERROR);
  718.         }
  719.         if (last != 0  &&  iIn < nsym) {
  720.             H261ErrMsg( "parseSymbols: Encountered LAST=1 prematurely" );
  721.             return (H261_ERROR);
  722.         }
  723.     }
  724.     /*{
  725.         int i;
  726.         static int iprint = YES;
  727.         if (iprint) {
  728.             printf("parseSymbols: Found %d symbolsn", iOut);
  729.             for (i = 0; i < iOut; ++i) {
  730.                 printf("Symbol %d:  ", i);
  731.                 printsym( outsym[i] );
  732.                 printf("n");
  733.             }
  734.             printf("parseSymbols: Continue printouts? [0/1]: ");
  735.             scanf("%d", &iprint);
  736.         }
  737.     }*/
  738.     if (last != LAST263_RUNVAL  ||  iIn != nsym) {
  739.         H261ErrMsg( "parseSymbols: Did not find LAST=1" );
  740.         return (H261_ERROR);
  741.     }
  742.     return (iOut);
  743. }