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

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

Symbian

开发平台：

Visual C++

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