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

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

Symbian

开发平台：

C/C++

h261dec.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 "dllindex.h"
  38. #include "h261defs.h"
  39. #include "vldstate.h"
  40. #include "h261func.h"
  41. #include "hvscodes.h"        /* getImgParms can be called                    */
  42. #include "dec_blk.h"        /* set the proper pragmas for decode_block      */
  43. #include "vldecode.h"       /* set the proper pragmas for VLDecode          */
  44. #include "h263plus.h"
  46. //#define ANNOTATE_PICTURE    // Include diagnostic info in output picture
  47. #ifdef TESTING
  48. #include <stdio.h>
  49. #include <stdlib.h>
  50. #define BS_ERR_MSG(a)   a   // Generate messages on bitstream error (i.e., illegal 
  51.                             // bitstream syntax) to simplify debugging
  52. #define CHECKSYM(a)     a   // Check symbol types to verify decoder state tables
  54. #else
  55. #define BS_ERR_MSG(a)       // Suppress error messages 
  56. #define CHECKSYM(a)         // Don't check symbol types
  57. #endif
  60. // Declarations of local functions
  61. static int  findPSC( BS_PTR start[], int gn[], int num_sc, int *sc, H261Decoder *s );
  62. static void savePSCpointer( BS_PTR *bsPSC, H261Decoder *s );
  63. static void outputBsPointer( BS_PTR * start, BS_PTR * output, int codingMethod );
  64. static int decodeBitstream( H261Decoder *s,
  65.                             GOB_DESCR   *gob,
  66.                             BS_PTR      start[2],
  67.                             int         gn[2],
  68.                             int         *structStatus,
  69.                             int         *decStatus );
  70. static int  doGobStructures( H261Decoder *s, GOB_DESCR *gob, MACROBLOCK_DESCR mb[],
  71.                         BS_PTR start[2], int gn[2] );
  72. static int  doGobDecoding( H261Decoder *s, GOB_DESCR *gob, MACROBLOCK_DESCR mb[],
  73.                         BS_PTR start[2], SYMBOL sym[], int maxsym );
  74. static void gobConcealment( H261Decoder *s, GOB_DESCR *gob, MACROBLOCK_DESCR mb[] );
  75. static int build_gob_struct( S32 format, S32 gn, GOB_DESCR * gob);
  76. static int build263gob( S32 format, S32 gn, int next_gn, GOB_DESCR * gob,
  77.                         PICTURE_DESCR * pic );
  78. /*static void update_decMB( GOB_DESCR * gob, MACROBLOCK_DESCR mb[], int mb_per_row, 
  79.                         int codingMethod, MBMap * decMB, S32 * iFrame, int forcedUpdate );*/
  80. static int  initializePicture( H261Decoder * s );
  81. static int  decodePicLayer( BS_PTR * bs, int nbits, PICTURE_DESCR * pic,
  82.                             SYMBOL sym[], int maxsym, int codingMethod, GOB_DESCR * gob,
  83.                             int * ptype );
  84. static int  decode_pic261( BS_PTR * bs, int nbits, PICTURE_DESCR * pic,
  85.                             SYMBOL sym[], int maxsym);
  86. static int  decode261gob(  BS_PTR * bs, int nbits, GOB_DESCR * gob,
  87.                         MACROBLOCK_DESCR mb[], SYMBOL sym[], int maxsym);
  88. static int  decode_mb( SYMBOL insym[], int * nextsym, int * quant,
  89.                         GOB_DESCR * gob, MACROBLOCK_DESCR mb[], int mbnum,
  90.                         SYMBOL outsym[]);
  91. static int  decode_intra_block( SYMBOL insym[], int * nextsym,
  92.                             BLOCK_DESCR * block, SYMBOL outsym[]);
  93. static int  find_startcodes( BS_PTR * bs,   // Points to beginning of bitstream
  94.                             int numbits,    // length of bitstream in bits
  95.                             BS_PTR start[], // Returns positions for startcodes; size "max_start"
  96.                             int gobnum[],   // Returns 4 bits after startcode (5 bits for H.263); size "max_start"
  97.                             int max_start,  // Max number of start codes to be returned
  98.                             int codingMethod );  // Indicate H.261 or H.263 syntax
  99. static int  find_sc( BS_PTR * bs,       // Points to beginning of bitstream
  100.                      int numbits,       // length of bitstream in bits
  101.                      int startZeros,    // number of zeros in startcode
  102.                      BS_PTR * start );   // Returns position for bit after startcode
  103. #ifdef ANNOTATE_PICTURE
  104. // saveOrRestoreReconPicture
  105. static void saveOrRestoreReconPicture( PICTURE *pic,    // Picture to be saved or restored
  106.                                        int  restore     // Save if 0, otherwise restore
  107.                                      );
  108. // annotatePicture - Draw motion vectors etc.
  109. static void annotatePicture( PICTURE *pic, MACROBLOCK_DESCR mb[]);
  110. // annotateMacroblock
  111. static void annotateMacroblock( PIXEL data[], int xdim, MACROBLOCK_DESCR *mb,
  112.                                 int xMin, int xMax, int yMin, int yMax );
  113. static void drawMv( PIXEL data[], int xdim, int mvX, int mvY,
  114.                     int xMin, int xMax, int yMin, int yMax );
  115. static void plusMb( PIXEL data[], int xdim );
  116. static void crossMb( PIXEL data[], int xdim );
  117. static void fillMb( PIXEL data[], int xdim );
  118. static void markPixel( PIXEL *pixel );
  119. static int  DrawVector( unsigned char data[], int xdim, int x1, int y1, int x2, int y2 );
  120. static int  drawVec( unsigned char data[], int xdim, int x1, int y1 );
  121. #endif
  124. #define GN_END_OF_SEQUENCE  (31)    // GN=31 for EOS
  125. #define H263_START_ZEROS    (16)
  126. #define H263_GN_BITS        (5)
  127. #define H261_START_ZEROS    (15)
  128. #define H261_GN_BITS        (4)
  131. //
  132. //
  133. //  ****************************************************
  134. //  H261Decode - Decode one or several GOBs in a picture
  135. //  ****************************************************
  136. //
  137. //
  138. extern int  H261Decode( H261Decoder * s )
  139. #define NUM_SC      0
  140. #define NUMGOB      1
  141. #define ERRGOB      2
  142. #define IFRAME      3
  143. {
  144.     BS_PTR      *pStart;    // Position of startcodes ("start")
  145.     int         *pGn;       // GOB numbers following each startcode ("gn")
  146.     GOB_DESCR   *pGob;      // Can refer to several GOBs, if GOB headers are left out ("gob")
  147.     int         *pNum_sc;   // Points to number of startcodes found ("num_sc")
  148.     int         *pSc;       // Points to current startcode ("sc")
  149.     BS_PTR      bsPSC;
  150.     int         status, structStatus, decStatus;
  151.     BS_ERR_MSG(char msg[120];) /* Flawfinder: ignore */
  153.     s->state.actComp = 0;  // Init computation measure
  154.     pStart  =  s->state.bspStartCode;
  155.     pGn     =  s->state.gobNumber;
  156.     pGob    = &s->state.currentGob;
  157.     pNum_sc = &s->state.nStartCodes;
  158.     pSc     = &s->state.currentStartCode;
  160.     if (s->pic_layer.decodingInProgress) {
  161.         // Restore internal state; we interrupted reconstruction with status=OK
  162.         structStatus = decStatus = OK;
  163.         s->pic_layer.decodingInProgress = FALSE;    // Set only if we time out again
  165.     } else {    // We did not time out last time, so do the usual thing
  167.         s->state.i = 0;     // Tell ReconGob to reset its state
  169.         /* Find Picture and GOB Start Codes */
  170.         *pNum_sc = find_startcodes( &s->bsStart, BsDiff(s->bsEnd, s->bsStart),
  171.                                     pStart, pGn, SC_MAX, (int)s->codingMethod );
  172.         /*{   // Print startcode positions
  173.             int i;
  174.             for (i = 0; i < *pNum_sc; i++) {
  175.                 printf("Startcode %d: gn = %d starts in byte %d, bit %dn", i,
  176.                     pGn[i], pStart[i].byteptr - s->bsStart.byteptr, pStart[i].bitptr);
  177.             }
  178.             printf("Continue? ");
  179.             scanf("%d", &i);
  180.         }*/
  181.         s->status.dwStartcodes = *pNum_sc;
  182.         s->status.dwGobs = 0;       // # GOBs processed
  183.         s->status.dwBadgobs = 0;    // # erroneous GOBs
  184.         s->status.dwUpdateGobs = 0; // # GOBs for fast updating
  185.         s->status.dwFirstBadgob = 0; // First bad Gob
  186.         s->status.dwPsc = FALSE;    // indicates that a picture layer was successfully decoded
  187.         s->newBs = s->bsStart;      // Just in case...  (will be updated later)
  188.         if (*pNum_sc < 2) {
  189.             if (*pNum_sc == 1) {
  190.                 outputBsPointer( &pStart[0], &s->newBs, (int)s->codingMethod ); // If we exit, begin here next time
  191.             } else if ((s->bsEnd.byteptr - s->bsStart.byteptr) < 4) {
  192.                 // No startcode found and bitstream is less than 4 bytes long
  193.                 s->newBs = s->bsStart;
  194.             } else {
  195.                 // No startcode found; skip to end of bitstream
  196.                 s->newBs = s->bsEnd;
  197.                 s->newBs.byteptr -= 4;  // Back up 32 bits (22-bit PSC and one byte margin)
  198.             }
  199.             return( NO );
  200.         }
  201.         *pSc = 0;
  202.         if (s->next_gob == 0) {   // Decode Picture Layer info
  203.             do {
  204.                 if (findPSC( pStart, pGn, *pNum_sc, pSc, s ) != YES)   // Find Picture Start Code
  205.                     return( NO );
  206.                 // Try to decode Picture Layer
  207.                 outputBsPointer( &pStart[*pSc], &bsPSC, (int)s->codingMethod ); // Save possible picture start code pointer
  208.                 status = decodePicLayer( &pStart[*pSc], BsDiff(pStart[*pSc + 1], pStart[*pSc]),
  209.                                     &s->pic_layer, s->sym, s->maxSym, (int)s->codingMethod, pGob,
  210.                                     &s->ptype );
  211.                 // H.263: pStart[*pSc] gets bumped by decodePicLayer; now pointing to MB layer
  212.                 if (status != OK) {
  213.                     ++s->status.dwBadgobs;
  214.                     BS_ERR_MSG( H261ErrMsg( "Bitstream error when decoding Picture Layer" ); )
  215.                 } else {    // Decoded Picture Layer successfully
  216.                     savePSCpointer( &bsPSC, s );
  217.                     // Initialize image structures according to received image format: QCIF or CIF
  218.                     status = initializePicture ( s );   
  219.                     if (status != OK)  H261ErrMsg("Decoder: illegal picture format");
  220.                     s->status.dwIntraFrame = 1;  // Assume intraframe (set to zero if we encounter a non-INTRA MacroBlock)
  221. #ifdef ANNOTATE_PICTURE
  222.                     saveOrRestoreReconPicture( &s->oldOut, 1 ); // Restore prev. from local memory
  223. #endif
  224.                     if (s->codingMethod == H263_CODING  &&  status == OK) {
  225.                         s->next_gob = 0;    // First GOB is gn=0 for H.263
  226.                         break;  // Don't increment *pSc; decode GOB 0 first
  227.                     } else if (status == OK) {  // H.261 decoding
  228.                         s->next_gob = 1;    // Go on to decode first GOB (gn=1 for H.261)
  229.                     }
  230.                 }
  231.                 ++(*pSc);
  232.             } while (status != OK);
  233.         }
  234.     
  235.         // Decode GOBs until we reach next to last startcode or until picture complete
  236.         if (*pSc >= *pNum_sc - 1)  return NO;
  238.         // Decode bitstream for the first GOB
  239.         status = decodeBitstream( s, pGob, &pStart[*pSc], &pGn[*pSc], &structStatus, &decStatus );
  240.         if (status == H261_ERROR)  return NO;   // Exit to resync on next PSC
  242.     }   // end if !s->pic_layer.decodingInProgress
  244.     while (1) {     // Process until next to last startcode
  245.         // Reconstruct GOB
  246.         if (structStatus == OK) {
  247.             // decStatus!=OK means that we found bitstream errors
  248.             if (decStatus == OK) {
  249.                 //printf("Calling ReconGob n");
  250.                 ReconGob( pGob, s->mb, &s->oldOut, &s->newOut, &s->B_Out, 
  251.                            s->pic_layer.advancedPred, s->pic_layer.PBframeMode, 
  252.                            s->PBframeCap, s->pic_layer.reducedResUpdate, s->pic_layer.advancedIntraMode,
  253.                            &s->state, s->maxComp );
  254.                 // Time to exit?
  255.                 if (s->state.i > 0) {   // ReconGob timed out
  256.                     s->pic_layer.decodingInProgress = TRUE;
  257.                     return NO;
  258.                 }
  259. /*// Update macroblock map to control RGB conversion
  260. // This is not very useful anymore; skipped blocks might change when
  261. // we use overlapped MC or deblocking filter /SE 4/4/97
  262.                 update_decMB( pGob, pGob->mb, (int)(s->newOut.y.nhor >> 4), 
  263.                             (int)s->codingMethod, &s->decMB,
  264.                             &s->status.dwIntraFrame, NO );*/
  265.             } else {    //  Bitstream error
  266.                 gobConcealment( s, pGob, s->mb );
  267.             }
  268.             s->status.dwGobs += pGob->num_mb / max(1,pGob->mb_width);
  269.             s->next_gob = pGob->next_gn;
  270.         }
  271.         (*pSc)++;
  272.         outputBsPointer( &pStart[*pSc], &s->newBs, (int)s->codingMethod ); // If we exit, begin here next time
  273.         if (s->next_gob == 0) {    // Completed picture
  274. #ifdef DO_H263_PLUS
  275.             // Perform deblocking filtering
  276.             if(s->pic_layer.reducedResUpdate) {
  277.                 ReducedResDeblockingFilter( &s->newOut, s->mb );
  278.             } else if(s->pic_layer.deblockingFilterMode) {
  279.                 ApplyDeblockingFilter(&s->newOut, s->mb, FALSE);
  280.                 if(s->pic_layer.PBframeMode && s->PBframeCap) 
  281.                     ApplyDeblockingFilter(&s->B_Out, s->mb, TRUE);
  282.             }
  283. #endif
  284.             //checkPicture( s->newOut );  // Very useful when chasing subtle encoder bugs
  285. #ifdef ANNOTATE_PICTURE
  286.             saveOrRestoreReconPicture( &s->newOut, 0 ); // Save new picture to local memory
  287.             annotatePicture( &s->newOut, s->mb );  // Draw motion vectors etc.
  288.             annotatePicture( &s->B_Out, s->mb );
  289. #endif
  290.             return (YES);
  291.         }
  292.         if (*pSc >= *pNum_sc - 1)  return NO;
  294.         // Decode bitstream for the next GOB
  295.         status = decodeBitstream( s, pGob, &pStart[*pSc], &pGn[*pSc],
  296.                                   &structStatus, &decStatus );
  297.         if (status == H261_ERROR)  return NO;   // Exit to resync on next PSC
  298.     }
  299. }
  302. // findPSC - Search for Picture Start Code
  303. static int  findPSC( BS_PTR start[], int gn[], int num_sc, int *sc, H261Decoder *s )
  304. {
  305.     do {
  306.         if (*sc > num_sc - 2) { //  Reached last startcode?
  307.             return (NO);
  308.         }
  309.         (*sc)++;
  310.         outputBsPointer( &start[*sc], &s->newBs, (int)s->codingMethod ); // If we exit, begin here next time
  311.     } while (gn[*sc - 1] != 0); // GN=0 indicates PSC
  312.     *sc = *sc - 1;    // Back up to point at PSC
  313.     return( YES );
  314. }
  317. // savePSCpointer - Pass the pointer to the picture start code to caller
  318. static void savePSCpointer( BS_PTR *bsPSC, H261Decoder *s )
  319. {
  320.     s->status.dwPsc = TRUE; 
  321.     s->status.pscIndex.ww.byte = bsPSC->byteptr - s->bsAbs.byteptr; 
  322.     s->status.pscIndex.ww.bit =  bsPSC->bitptr & 0xff;
  323.     return;
  324. }
  326. // outputBsPointer - Copy "start" pointer and back up by length of startcode
  327. static void outputBsPointer( BS_PTR * start, BS_PTR * output, int codingMethod )
  328. {
  329.     int lenStartCode;
  330.     
  331.     if (codingMethod == H263_CODING) {
  332.         lenStartCode = H263_START_ZEROS + 1;
  333.     } else {
  334.         lenStartCode = H261_START_ZEROS + 1;
  335.     }
  336.     *output = *start;
  337.     IncBsPtr( output, -lenStartCode );
  338.     return;
  339. }
  342. // decodeBitstream - Decode bitstream for a GOB
  343. //  Returns H261_ERROR if we need to exit to resync on next PSC
  344. static int decodeBitstream( H261Decoder *s,
  345.                             GOB_DESCR   *gob,
  346.                             BS_PTR      start[2],
  347.                             int         gn[2],
  348.                             int         *structStatus,
  349.                             int         *decStatus )
  350. {
  351.     BS_ERR_MSG(char msg[120];) /* Flawfinder: ignore */
  352.     int nextStart;
  354.     *structStatus = doGobStructures( s, gob, s->mb, &start[0], &gn[0] );
  355.     if (*structStatus == OK  &&  gn[0] == s->next_gob) {
  356.         // GOB number is correct and structures in place
  357.         *decStatus = doGobDecoding( s, gob, s->mb, &start[0], s->sym, s->maxSym );
  358.     } else if (*structStatus == OK  &&  gn[0] == gob->next_gn) {     // GBSC was probably trashed
  359.         // This case will not occur for H.263
  360.         *structStatus = H261_ERROR;
  361.         //printf("Calling ConcealGob n");
  362.         ConcealGob( gob, s->mb, s->pic_layer.reducedResUpdate, &s->oldOut, &s->newOut);
  363.         ++s->status.dwBadgobs;
  364.         s->status.dwGobs += gob->num_mb / max(1,gob->mb_width);
  365.         s->next_gob = gob->next_gn;
  366.         s->status.dwIntraFrame=0;
  367.         BS_ERR_MSG(
  368.             sprintf( msg, "Bitstream error: did not find GOB %d", s->next_gob); /* Flawfinder: ignore */
  369.             H261ErrMsg( msg ); )
  370.     } else if (gn[0] == 0) {   // Unexpected PSC; exit so we can resync
  371.         *structStatus = H261_ERROR;
  372.         if (s->codingMethod == H263_CODING  &&  s->next_gob == 0) {
  373.             nextStart = 1;  // Try next startcode; this PSC did not work
  374.         } else {
  375.             nextStart = 0;  // Start with PSC next time
  376.         }
  377.         outputBsPointer( &start[nextStart], &s->newBs, (int)s->codingMethod );
  378.         BS_ERR_MSG( H261ErrMsg("Bitstream error: encountered PSC when expecting GBSC"); )
  379.         ++s->status.dwBadgobs;
  380.         s->status.dwIntraFrame=0;
  381.         s->next_gob = 0;
  382.         return H261_ERROR;  // This picture did not get done; start again
  383.     } else {    // Assume that GBSC was false; keep looking for GN = next_gob
  384.         *structStatus = H261_ERROR;
  385.     }
  386.     return OK;
  387. }
  390. // doGobStructures - Create gob and mb structures
  391. static int  doGobStructures( H261Decoder *s, GOB_DESCR *gob, MACROBLOCK_DESCR mb[],
  392.                         BS_PTR start[2], int gn[2] )
  393. {
  394.     int     maxbits, status;
  395.     
  396.     //printf("Entering doGobStructures:  gn[] = %d %dn", gn[0], gn[1]);
  397.     gob->mb = mb;
  398.     if (s->codingMethod == H263_CODING) {
  399.         if (s->next_gob > 0) {  // No GOB Layer for GOB 0
  400.             maxbits = BsDiff(start[1], start[0]);
  401.             status = DecGobLayer263( &start[0], maxbits, gob, &s->gfid );
  402.             // start[0] gets bumped by DecGobLayer263; now pointing to MB layer
  403.             if (status != OK) {
  404.                 BS_ERR_MSG( H261ErrMsg( "Bit error: DecGobLayer263 returned error" );)
  405.                 return( H261_ERROR );
  406.             }
  407.         }
  408.         status = build263gob( s->pic_layer.format, s->next_gob, gn[1], gob, &s->pic_layer );
  409.         if (status != OK) {
  410.             BS_ERR_MSG( H261ErrMsg( "Bit error: build263gob returned error" );)
  411.             return( H261_ERROR );
  412.         }
  413.     } else {    // H.261
  414.         status = build_gob_struct( s->pic_layer.format, s->next_gob, gob );
  415.         if (status != OK) {
  416.             H261ErrMsg( "Program error: build_gob_struct returned error" );
  417.             return( H261_ERROR );
  418.         }
  419.     }
  420.     return( status );
  421. }
  424. // doGobDecoding - Decode all information in a GOB
  425. static int  doGobDecoding( H261Decoder *s, GOB_DESCR *gob, MACROBLOCK_DESCR mb[],
  426.                         BS_PTR start[2], SYMBOL sym[], int maxsym )
  427. {
  428.     int     maxbits, status;
  429.     
  430.     //printf("Entering doGobDecoding:  num_mb = %dn", gob->num_mb);
  431.     maxbits = BsDiff(start[1], start[0]);
  432.     if (s->codingMethod == H263_CODING) {
  433.         mb += gob->first_col + gob->first_row * gob->mb_offset;
  434.         status = DecMbLayer263( &start[0], maxbits, gob, mb,
  435.                                     (int)s->pic_layer.interFrame,
  436.                                     (int)s->pic_layer.PBframeMode,
  437.                                     (int)s->pic_layer.unrestrictedMv,
  438.                                     (int)s->pic_layer.advancedIntraMode,
  439.                                     sym, maxsym);
  440.     } else {    // H.261
  441.         status = decode261gob( &start[0], maxbits, gob, mb, sym, maxsym);
  442.     }
  443.     if (status != OK) {
  444.         BS_ERR_MSG( H261ErrMsg( "Bitstream error in doGobDecoding" );)
  445.     }
  446.     return( status );
  447. }
  450. // gobConcealment - Conceal error and update error counters
  451. static void gobConcealment( H261Decoder *s, GOB_DESCR *gob, MACROBLOCK_DESCR mb[] )
  452. {
  453.     BS_ERR_MSG( char msg[120]; ) /* Flawfinder: ignore */
  454.     
  455.     //printf("Calling ConcealGob n");
  456.     ConcealGob( gob, mb, s->pic_layer.reducedResUpdate, &s->oldOut, &s->newOut );
  457.     if (s->pic_layer.PBframeMode && s->PBframeCap) {
  458.         // Conceal B-frame
  459.         ConcealGob( gob, mb, s->pic_layer.reducedResUpdate, &s->oldOut, &s->B_Out );
  460.     }
  461.     if (s->status.dwUpdateGobs == 0)   // If this is the first bad gob
  462.     {
  463.         s->status.dwFirstBadgob = s->next_gob;      // then save the number
  464.         s->status.dwUpdateGobs = gob->num_mb/max(1,gob->mb_width);
  465.     } else {
  466.         s->status.dwUpdateGobs = s->next_gob + gob->num_mb / max(1,gob->mb_width) -
  467.                                 s->status.dwFirstBadgob;
  468.     }
  469.     ++s->status.dwBadgobs;
  470.     s->status.dwIntraFrame=0;
  471.     BS_ERR_MSG(
  472.         sprintf( msg, "Bitstream error when decoding GOB %d", s->next_gob); /* Flawfinder: ignore */
  473.         H261ErrMsg( msg ); )
  474. }
  477. //  build_gob_struct - set up GOB descriptor and MB descriptors for GOB "gn"
  478. static int build_gob_struct( S32 format, S32 gn, GOB_DESCR * gob)
  479. #define MB_COLS_PER_GOB     11
  480. #define MB_ROWS_PER_GOB     3
  481. {
  482.     int mb_col, mb_row, row, col, index;
  484.     if (gn < 1  ||  gn > 12  ||     // CIF: GN=1,2,..,12
  485.         (format == 0  &&  gn != 1  &&  gn != 3  &&  gn != 5)) { // QCIF: 1,3,5
  486.         return (H261_ERROR);
  487.     }
  488.     // Fill in GOB descriptor
  489.     gob->num_mb = MB_COLS_PER_GOB * MB_ROWS_PER_GOB;
  490.     gob->first_col = 0;
  491.     gob->first_row = 0;
  492.     gob->mb_width = MB_COLS_PER_GOB;
  493.     gob->mb_offset = MB_COLS_PER_GOB;
  494.     // Determine next GOB number
  495.     if (format == 0  &&  gn < 5) {  // QCIF
  496.         gob->next_gn = gn + 2;
  497.     } else if (format != 0  &&  gn < 12) {  // CIF
  498.         gob->next_gn = gn + 1;
  499.     } else {    // This is last GOB in picture
  500.         gob->next_gn = 0;   // Look for PSC next time
  501.     }
  502.     // Fill in macroblock locations
  503.     if ((gn & 0x1)  ==  1) {
  504.         mb_col = 0;                 // Odd GOBs on left side
  505.     } else {
  506.         mb_col = MB_COLS_PER_GOB;   // Even GOBs on right side
  507.     }
  508.     mb_row = ((gn - 1) / 2) * MB_ROWS_PER_GOB;
  509.     for (row = 0; row < MB_ROWS_PER_GOB; row++) {
  510.         for (col = 0; col < MB_COLS_PER_GOB; col++) {
  511.             index = row * MB_COLS_PER_GOB + col;
  512.             (gob->mb + index)->x = col + mb_col;
  513.             (gob->mb + index)->y = row + mb_row;
  514.         }
  515.     }
  516.     return (OK);
  517. }
  520. // build263gob - set up GOB and MB descriptors for GOBS "gn" to "next_gn-1" (H.263)
  521. static int build263gob( S32 format, S32 gn, int next_gn, GOB_DESCR * gob,
  522.                         PICTURE_DESCR * pic )
  523. {
  524.     int mbhor, mbvert, num_gn, row, col, index, mbRowsPerGob;
  526.     switch (format) {
  527.     case SQCIF:
  528.         mbhor = 8;
  529.         num_gn = 6;
  530.         mbRowsPerGob = 1;
  531.         break;
  532.     case QCIF:
  533.         mbhor = 11;
  534.         num_gn = 9;
  535.         mbRowsPerGob = 1;
  536.         break;
  537.     case CIF:
  538.         mbhor = 22;
  539.         num_gn = 18;
  540.         mbRowsPerGob = 1;
  541.         break;
  542.     case CIF4:
  543.         mbhor = 44;
  544.         num_gn = 18;
  545.         mbRowsPerGob = 2;
  546.         break;
  547.     case CIF16:
  548.         mbhor = 88;
  549.         num_gn = 18;
  550.         mbRowsPerGob = 4;
  551.         break;
  552.     case ANYSIZE:
  553.         mbhor = (pic->cols + 15) >> 4;
  554.         num_gn = (pic->rows + 15) >> 4;
  555.         mbRowsPerGob = 1;
  556.         while (num_gn > GN_END_OF_SEQUENCE) {   // Max Group Number is 30
  557.             mbRowsPerGob *= 2;
  558.             num_gn = (num_gn + 1) >> 1;
  559.         }
  560.         break;
  561.     default:
  562.         return( H261_ERROR );
  563.         break;
  564.     }
  565. #ifdef DO_H263_PLUS
  566.     if (pic->reducedResUpdate) {
  567.         // Use 32x32 macroblocks
  568.         mbhor = ROUNDDIV2( mbhor );
  569.         if (mbRowsPerGob == 1) {
  570.             num_gn = ROUNDDIV2( num_gn );
  571.         } else {
  572.             mbRowsPerGob = ROUNDDIV2( mbRowsPerGob );
  573.         }
  574.     }
  575. #endif
  576.     if (gn < 0  ||  gn >= num_gn)  return( H261_ERROR );
  577.     // Fill in GOB descriptor
  578.     if (next_gn == 0  ||  next_gn == GN_END_OF_SEQUENCE) {
  579.         gob->next_gn = 0;   // Look for PSC next time
  580.         mbvert = num_gn - gn;
  581.     } else {
  582.         gob->next_gn = next_gn;
  583.         mbvert = next_gn - gn;
  584.     }
  585.     mbvert *= mbRowsPerGob;
  586.     if (mbvert <= 0)  return( H261_ERROR );
  587.     gob->num_mb = mbhor * mbvert;
  588.     gob->first_col = 0;
  589.     gob->first_row = gn * mbRowsPerGob; // Need previous row for advancedPred mode
  590.     gob->mb_width = mbhor;
  591.     gob->mb_offset = mbhor;
  592.     // Fill in macroblock locations
  593.     for (row = gn * mbRowsPerGob; row < gn * mbRowsPerGob + mbvert; row++) {
  594.         for (col = 0; col < mbhor; col++) {
  595.             index = row * mbhor + col;
  596.             gob->mb[index].x = col;
  597.             gob->mb[index].y = row;
  598.         }
  599.     }
  600.     return (OK);
  601. }
  603. /*********************
  604. //  update_decMB - Update macroblock map by ORing MTYPE for each MB
  605. static void update_decMB( GOB_DESCR * gob, MACROBLOCK_DESCR mb[], int mb_per_row, 
  606.                         int codingMethod, MBMap * decMB, S32 * iFrame, int forcedUpdate )
  607. {
  608.     int mbnum, i, row, col;
  609.     U8  mtype;
  610.     
  611.     if (codingMethod == H263_CODING) {
  612.         mbnum = gob->first_col + gob->first_row * gob->mb_offset;
  613.         for (i = mbnum; i < mbnum + gob->num_mb; ++i) {
  614.             mtype = mb[i].mtype;
  615.             decMB->data[i] |= mtype;
  616.             if ( mtype != MTYPE263_INTRA  &&  mtype != MTYPE263_INTRA_Q )  *iFrame = 0;
  617.         } 
  618.         if (forcedUpdate == YES) {  // Ensure that macroblock map is non-zero
  619.             for (i = mbnum; i < mbnum + gob->num_mb; ++i) {
  620.                 decMB->data[i] = 1;
  621.             } 
  622.         }
  623.     } else {    // H.261
  624.         mbnum = mb[0].x + mb[0].y * mb_per_row;
  625.         i = 0;
  626.         for (row = 0; row < MB_ROWS_PER_GOB; row++) {
  627.             for (col = 0; col < MB_COLS_PER_GOB; col++) {
  628.                 mtype = mb[i + col].mtype;
  629.                 decMB->data[mbnum + col] |= mtype;
  630.                 if ( mtype != MTYPE_INTRA  &&  mtype != MTYPE_INTRA_MQUANT )  *iFrame = 0;
  631.             }
  632.             mbnum += mb_per_row;
  633.             i += MB_COLS_PER_GOB;
  634.         } 
  635.         if (forcedUpdate == YES) {  // Ensure that macroblock map is non-zero
  636.             mbnum = mb[0].x + mb[0].y * mb_per_row;
  637.             for (row = 0; row < MB_ROWS_PER_GOB; row++) {
  638.                 for (col = 0; col < MB_COLS_PER_GOB; col++) {
  639.                     decMB->data[mbnum + col] = 1;
  640.                 }
  641.                 mbnum += mb_per_row;
  642.             } 
  643.         }
  644.     }
  645.     return;
  646. }
  647. *****************/
  649. /**************************************************************************
  650. * initializePicture ( H261Decoder *s) -
  651. *
  652. * this function initializes the picture structures according to the
  653. * format: QCIF or CIF
  654. *
  655. ***************************************************************************/
  656. #ifdef WATD
  657. extern void BreakPoint(void);
  658. #pragma aux BreakPoint = 0xcc;
  659. #endif
  660. static int  initializePicture( H261Decoder * s )
  661. {
  662.   S16   format;                     /* locals used for call to getImgParms  */
  663.   S16   numGOBs;                    /* this is done for consistency with    */
  664.   S16   numMBs;                     /* old init method                      */
  665.   S32   imgSize ;
  666.   S32   lumaSize;
  667.   S32   chromaLineLength;
  668.   S32   chromaRows;
  669.   S32   maxsym;  
  670.   int   status, mbHor, mbVert;
  672. #ifdef WATD
  673.    //BreakPoint();
  674. #endif
  675.   format = (S16)s->pic_layer.format;
  676.   s->decMB.format = format;
  677.   s->decMB.type = DECODER_MAP;
  678.     
  679.   if ( (s->formatCap == QCIF) && (format == CIF) )
  680.     H261ErrMsg("decoder not CIF capable");
  682.                     /* get the image parameters for the current format  */
  683.   if (format == ANYSIZE) {
  684.         mbHor = (s->pic_layer.cols + 15) >> 4;
  685.         mbVert = (s->pic_layer.rows + 15) >> 4;
  686.         //imgSize  = (long)384 * mbHor * mbVert;
  687.         lumaSize = (long)256 * mbHor * mbVert;
  688.         chromaLineLength = 8 * mbHor;
  689.         chromaRows = 8 * mbVert;
  690.         //numGOBs  = mbVert;
  691.         numMBs   = mbHor * mbVert;
  692.         //maxsym = 8 * lumaSize;
  693.         status = 0;
  694.         /////////if (numMBs > xxxxx)  status = UNKNOWN_PICTURE_FORMAT;
  695.   } else {
  696.     status = getImgParms (format, &numGOBs, &numMBs, &imgSize, &lumaSize, &chromaLineLength,
  697.                     &chromaRows, &maxsym);
  698.   }
  699.   if (status != 0) {
  700.     H261ErrMsg ("Decoder Error: initializePicture - UNKNOWN_PICTURE_FORMAT");
  701.     status = H261_ERROR;
  702.   } else if (numMBs > s->maxMbnum) {
  703.     H261ErrMsg ("Decoder Error: initializePicture - Too large picture");
  704.     status = H261_ERROR;
  705.   } else if (numMBs > s->maxMbnum) {
  706.     H261ErrMsg ("Decoder Error: initializePicture - Too large picture");
  707.     status = H261_ERROR;
  708.   } else {
  709.     status = OK;
  710.   }
  711.   // setup the image structures
  712.   //s->newOut.picLayout = s->B_Out.picLayout = VVS_LAYOUT_TEE;
  713.   //s->oldOut.picLayout   = VVS_LAYOUT_TEE;
  714.   s->newOut.picLayout = s->B_Out.picLayout = VVS_LAYOUT_YUV12;
  715.   
  716.   // Memory was already allocated when the decoder first opened.
  717.   // The luma pointers hold the address of the start of the memory for image buffers
  718.                                     
  719.   // Set up chroma pointers
  720.   // helix needs 420 out -gneel
  721.   // Layout_Tee also works.
  722.   if(s->newOut.picLayout == VVS_LAYOUT_YUV12)
  723.   {
  724. s->newOut.cb.ptr = s->newOut.y.ptr + lumaSize;
  725. s->B_Out.cb.ptr  = s->B_Out.y.ptr  + lumaSize;
  727. s->newOut.cr.ptr = s->newOut.cb.ptr + (lumaSize>>2);
  728. s->B_Out.cr.ptr  = s->B_Out.cb.ptr  + (lumaSize>>2);
  730. s->newOut.cb.ptrAlias = s->newOut.y.ptrAlias + lumaSize;
  731. s->B_Out.cb.ptrAlias  = s->B_Out.y.ptrAlias  + lumaSize;
  733. s->newOut.cr.ptrAlias = s->newOut.cb.ptrAlias + (lumaSize>>2);
  734. s->B_Out.cr.ptrAlias  = s->B_Out.cb.ptrAlias  + (lumaSize>>2);
  736. // Set up remainder of COMPONENT structs
  737. s->newOut.y.nhor    = s->B_Out.y.nhor    = chromaLineLength * 2;
  738. s->newOut.y.nvert   = s->B_Out.y.nvert   = chromaRows * 2;
  739. s->newOut.y.hoffset = s->B_Out.y.hoffset = chromaLineLength * 2;
  741. s->newOut.cb.nhor    = s->B_Out.cb.nhor    = chromaLineLength;
  742. s->newOut.cb.nvert   = s->B_Out.cb.nvert   = chromaRows;
  743. s->newOut.cb.hoffset = s->B_Out.cb.hoffset = chromaLineLength;
  745. s->newOut.cr.nhor    = s->B_Out.cr.nhor    = chromaLineLength;
  746. s->newOut.cr.nvert   = s->B_Out.cr.nvert   = chromaRows;
  747. s->newOut.cr.hoffset = s->B_Out.cr.hoffset = chromaLineLength;
  748.   } else {
  749. s->newOut.cb.ptr = s->newOut.y.ptr + lumaSize;
  750. s->B_Out.cb.ptr  = s->B_Out.y.ptr  + lumaSize;
  751. //s->oldOut.cb.ptr = s->oldOut.y.ptr + lumaSize;
  752.   
  753. s->newOut.cr.ptr = s->newOut.cb.ptr + chromaLineLength;
  755. s->B_Out.cr.ptr  = s->B_Out.cb.ptr  + chromaLineLength;
  756. //s->oldOut.cr.ptr = s->oldOut.cb.ptr + chromaLineLength;
  758. s->newOut.cb.ptrAlias = s->newOut.y.ptrAlias + lumaSize;
  759. s->B_Out.cb.ptrAlias  = s->B_Out.y.ptrAlias  + lumaSize;
  760. //s->oldOut.cb.ptrAlias = s->oldOut.y.ptrAlias + lumaSize;
  761. s->newOut.cr.ptrAlias = s->newOut.cb.ptrAlias + chromaLineLength;
  763. s->B_Out.cr.ptrAlias  = s->B_Out.cb.ptrAlias  + chromaLineLength;
  764. //s->oldOut.cr.ptrAlias = s->oldOut.cb.ptrAlias + chromaLineLength;
  766. // Set up remainder of COMPONENT structs
  767. s->newOut.y.nhor    = s->B_Out.y.nhor    = chromaLineLength * 2;
  768. s->newOut.y.nvert   = s->B_Out.y.nvert   = chromaRows * 2;
  769. s->newOut.y.hoffset = s->B_Out.y.hoffset = chromaLineLength * 2;
  771. s->newOut.cb.nhor    = s->B_Out.cb.nhor    = chromaLineLength;
  772. s->newOut.cb.nvert   = s->B_Out.cb.nvert   = chromaRows;
  773. s->newOut.cb.hoffset = s->B_Out.cb.hoffset = chromaLineLength * 2;
  775. s->newOut.cr.nhor    = s->B_Out.cr.nhor    = chromaLineLength;
  776. s->newOut.cr.nvert   = s->B_Out.cr.nvert   = chromaRows;
  777. s->newOut.cr.hoffset = s->B_Out.cr.hoffset = chromaLineLength * 2;
  778.   }
  779.   return (status);
  780. }
  783. //  decodePicLayer - Decode Picture Layer information
  784. static int  decodePicLayer( BS_PTR * bs, int nbits, PICTURE_DESCR * pic,
  785.                             SYMBOL sym[], int maxsym, int codingMethod, GOB_DESCR * gob,
  786.                             int * ptype )
  787. {
  788.     int     status;
  789.     
  790.     if (codingMethod == H263_CODING) {
  791.         status = DecPicLayer263( bs, nbits, pic, gob, ptype );
  792.     } else {
  793.         status = decode_pic261( bs, nbits, pic, sym, maxsym );
  794.     }
  795.     return( status );
  796. }
  799. //  decode_pic261 - Decode H.261 Picture Layer information
  800. //  This routine is very picky when determining whether bitstream is valid.
  801. //  It returns OK only if a startcode ends the bitstream; otherwise, it
  802. //  returns H261_ERROR.
  803. static int  decode_pic261( BS_PTR * bs, int nbits, PICTURE_DESCR * pic,
  804.                             SYMBOL sym[], int maxsym)
  805. {
  806.     int     state, status, parsed_bits, nsym, i;
  807.     BS_ERR_MSG( char msg[120] ); /* Flawfinder: ignore */
  809.     state = ST_AFTER_STARTCODE;
  810.     //printf( "DecodePic: Entering VLDecode with  State = %d  nbits = %dn",
  811.     //            state, nbits);
  812.     status = VLDECODE( *bs, nbits, &state, &parsed_bits, &nsym, sym, maxsym);
  813.     if (parsed_bits != nbits) {
  814.         BS_ERR_MSG( sprintf( msg, "decode_pic_layer: Tried to decode %d bits, exit after %d bits", /* Flawfinder: ignore */
  815.                 nbits, parsed_bits);
  816.                 H261ErrMsg( msg ); )
  817.         return (H261_ERROR);
  818.     }
  819.     if (state != ST_AFTER_STARTCODE) {
  820.         BS_ERR_MSG( sprintf( msg, "decode_pic_layer: Bitstream did not end with startcode"); /* Flawfinder: ignore */
  821.                 H261ErrMsg( msg); )
  822.         return (H261_ERROR);
  823.     }
  824. /*    {
  825.         int i;
  826.         printf( "DecodePic: Status = %d  State = %d  Decoded %d bits, %d symbolsn",
  827.                 status, state, parsed_bits, nsym);
  828.         // Print decoded symbols
  829.         printf("n");
  830.         for (i = 0; i < nsym; i++) {
  831.             printf("DecodePic: "); printsym( sym[i] ); printf("n");
  832.         }
  833.         printf("n");
  834.     }*/
  835.     CHECKSYM( if (checksym( sym[0], SYM_GN, "decode_pic_layer") != OK) exit(0); )
  836.     i = 1;  // Skip first symbol ("GN" = 0)
  837.     CHECKSYM( if (checksym( sym[i], SYM_QUANT_TR, "decode_pic_layer") != OK) exit(0); )
  838.     pic->tr = sym[i++].value;
  839.     CHECKSYM( if (checksym( sym[i], SYM_PTYPE, "decode_pic_layer") != OK) exit(0); )
  840.     pic->ptype = sym[i++].value;
  841.     pic->splitscreen = pic->ptype & FLAG_SPLITSCREEN;
  842.     pic->doccamera = pic->ptype & FLAG_DOCCAMERA;
  843.     pic->fp_release = pic->ptype & FLAG_FP_RELEASE;
  844.     if (pic->ptype & FLAG_CIF_FORMAT) {
  845.         pic->format = CIF;
  846.     } else {
  847.         pic->format = QCIF;
  848.     }
  849.     pic->hi_res = (pic->ptype & FLAG_HI_RES) ^ FLAG_HI_RES; // 1 = off, 0 = on
  850.     pic->advancedPred = 0;  // No overlapped MC for H.261
  851.     pic->PBframeMode = 0;   // No PB-frames for H.261
  852. #ifdef DO_H263_PLUS
  853.     pic->reducedResUpdate = 0;
  854. #endif
  855.     pic->peiCount = 0;                  // Loop 'til PEI=0
  856.     while (sym[i].type == SYM_SPARE) {
  857.         //char msg[100];
  858.         //sprintf(msg,"n Decode DLL: PEI=%x", sym[i].value);
  859.         //OutputDebugString(msg);
  860.         if (pic->peiCount < MAX_PEI_COUNT) {
  861.             //char msg[100];
  862.             //sprintf(msg,"n Decode DLL: pSpare: %2x", sym[i].value);
  863.             //OutputDebugString(msg);
  864.             pic->pSpare[pic->peiCount] = sym[i].value;
  865.         }
  866.         pic->peiCount++;                // Inc counter
  867.         i++;                            // Next Symbol  
  868.     }
  870.     CHECKSYM( if (checksym( sym[i], SYM_GEI_PEI, "decode_pic_layer") != OK) exit(0));    
  871.     i++;                                // Skip PEI Symbol
  872.     
  873.     if (sym[i].type != SYM_STARTCODE) {
  874.         BS_ERR_MSG( sprintf( msg, "decode_pic_layer: Did not find startcode after pic_layer"); /* Flawfinder: ignore */
  875.                 H261ErrMsg( msg ); )
  876.         return (H261_ERROR);
  877.     }
  878.     return (OK);
  879. }
  882. //  decode261gob - Decode all symbols for a Group Of Blocks
  883. //  This routine is very picky when determining whether bitstream is valid.
  884. //  It returns OK only if a startcode ends the bitstream; otherwise, it
  885. //  returns H261_ERROR.
  886. static int  decode261gob(  BS_PTR * bs, int nbits, GOB_DESCR * gob,
  887.                         MACROBLOCK_DESCR mb[], SYMBOL sym[], int maxsym)
  888. {
  889.     int     state, status, parsed_bits, mbnum, nextsym, quant, i, mba,
  890.             nsym,       // # symbols returned by VLDecode
  891.             isym;       // # symbols returned by this routine, i.e.,
  892.                         // after deletion of EOBs etc.
  893.     BS_ERR_MSG ( char msg[120] ); /* Flawfinder: ignore */
  895.     state = ST_AFTER_STARTCODE;
  896.     //printf( "DecodeGOB: Entering VLDecode with  State: ");
  897.     //printstate( state ); printf("  nbits = %dn", nbits);
  898.     status = VLDECODE( *bs, nbits, &state, &parsed_bits, &nsym, sym, maxsym);
  899.     if (parsed_bits != nbits) {
  900.         BS_ERR_MSG( sprintf( msg, "decode261gob: Tried to decode %d bits, exit after %d bits", /* Flawfinder: ignore */
  901.                 nbits, parsed_bits);
  902.                 H261ErrMsg( msg ); )
  903.         return (H261_ERROR);
  904.     }
  905.     if (state != ST_AFTER_STARTCODE) {
  906.         BS_ERR_MSG( sprintf( msg, "decode261gob: Bitstream did not end with startcode"); /* Flawfinder: ignore */
  907.                 H261ErrMsg( msg ); )
  908.         return (H261_ERROR);
  909.     }
  910. /*    {
  911.         int num;
  912.         printf( "DecodeGOB: Status = %d  State: ", status); printstate( state );
  913.         printf("  Decoded %d bits, %d symbolsn", parsed_bits, nsym);
  914.         // Print decoded symbols
  915.         printf("DecodeGOB: # symbols to print: ");
  916.         scanf("%d", &num);
  917.         for (i = 0; i < num; i++) {
  918.             printf("DecodeGOB: "); printsym( sym[i] ); printf("n");
  919.         }
  920.         printf("n");
  921.     }
  922.  */
  923.     nextsym = 0;
  924.     CHECKSYM( if (checksym( sym[nextsym], SYM_GN, "decode261gob") != OK) exit(0); )
  925.     gob->gn = sym[nextsym++].value;      // GOB number
  926.     CHECKSYM( if (checksym( sym[nextsym], SYM_QUANT_TR, "decode261gob") != OK) exit(0); )
  927.     quant = sym[nextsym++].value;
  928.     if (quant < QUANT_MIN  ||  quant > QUANT_MAX) {
  929.         BS_ERR_MSG( sprintf( msg, "decode261gob: quant = %d", quant); /* Flawfinder: ignore */
  930.                 H261ErrMsg( msg ); )
  931.         return (H261_ERROR);
  932.     }
  934.     gob->gquant = quant;
  935.     //CHECKSYM( if (checksym( sym[nextsym], SYM_GEI_PEI, "decode261gob") != OK) exit(0);  )
  936.     //gob->gei = sym[nextsym].value;
  937.     gob->num_gspare = 0;
  938.     while (sym[nextsym].type == SYM_SPARE) {   // Loop until GEI=0
  939.         CHECKSYM( if (checksym( sym[nextsym], SYM_SPARE, "decode261gob") != OK) exit(0); )
  940.         ++nextsym;  // Drop GSPARE on the floor
  941.         ++(gob->num_gspare);
  942.         
  943.     }
  944.     CHECKSYM( if (checksym( sym[nextsym], SYM_GEI_PEI, "decode261gob") != OK) exit(0); )
  945.     ++nextsym;      // Skip GEI
  946.     
  947.             
  948.     mbnum = 0;
  949.     isym = 0;
  950.     //  We expect MBA, MBA Stuffing, or Startcode
  951.     while (sym[nextsym].type == SYM_MBA_STUFFING) {
  952.         ++nextsym;      // Remove MBA stuffing
  953.     }
  954.     while (sym[nextsym].type != SYM_STARTCODE) {    // Keep going until next startcode
  955.         // We expect MBA
  956.         CHECKSYM( if (checksym( sym[nextsym], SYM_MBA, "decode261gob") != OK) exit(0); )
  957.         mba = sym[nextsym++].value;
  958.         //printf("MB #%d: ", mbnum+mba); printsym( sym[nextsym-1] ); // MBA
  959.         //printf("   "); printsym( sym[nextsym] ); printf("n"); // MTYPE
  960.         if (mbnum + mba  >  gob->num_mb) {
  961.             BS_ERR_MSG( sprintf( msg, "decode261gob: Bitstream error, mbnum=%d", mbnum + mba); /* Flawfinder: ignore */
  962.                     H261ErrMsg( msg ); )
  963.             return (H261_ERROR);
  964.         }
  965.         for (i = mbnum + 1; i < mbnum + mba; i++) {
  966.             mb[i-1].mtype = MTYPE_SKIP;
  967.         }
  968.         mbnum += mba;
  969.         status = decode_mb( sym, &nextsym, &quant, gob, mb, mbnum-1, &sym[isym] );
  970.         if (status == H261_ERROR) {
  971.             BS_ERR_MSG( sprintf( msg, "decode261gob: Bitstream error, MB #%d", mbnum); /* Flawfinder: ignore */
  972.                     H261ErrMsg( msg ); )
  973.             return (H261_ERROR);
  974.         }
  975.         isym += status;
  976.         //  We expect MBA, MBA Stuffing, or Startcode
  977.         while (sym[nextsym].type == SYM_MBA_STUFFING) {
  978.             ++nextsym;      // Remove MBA stuffing
  979.         }
  980.     }
  981.     for (i = mbnum + 1; i <= gob->num_mb; i++) {
  982.         mb[i-1].mtype = MTYPE_SKIP;
  983.     }
  984.     return (OK);
  985. }
  988. //  insym[*nextsym] contains MTYPE when we enter
  989. static int  decode_mb( SYMBOL insym[], int * nextsym, int * quant,
  990.                         GOB_DESCR * gob, MACROBLOCK_DESCR mb[], int mbnum,
  991.                         SYMBOL outsym[])
  992. {
  993.     int isym, blk, status, mask;
  994.     CHECKSYM ( char msg[120] ); /* Flawfinder: ignore */
  996.     //printf("decode_mb: "); printsym( insym[*nextsym] ); printf("n");
  997.     isym = 0;
  998.     CHECKSYM( if (checksym( insym[*nextsym], SYM_MTYPE, "decode_mb") != OK) exit(0); )
  999.     mb[mbnum].mtype = insym[(*nextsym)++].value;
  1000.     switch ( mb[mbnum].mtype ) {
  1001.     case MTYPE_INTER_MQUANT:
  1002.         CHECKSYM( if (checksym( insym[*nextsym], SYM_QUANT_TR, "decode_mb") != OK) exit(0); )
  1003.         *quant = insym[(*nextsym)++].value;
  1004.         if (*quant < QUANT_MIN  ||  *quant > QUANT_MAX) {
  1005.             BS_ERR_MSG( sprintf( msg, "decode_mb: quant = %d", *quant); /* Flawfinder: ignore */
  1006.                     H261ErrMsg( msg ); )
  1007.             return (H261_ERROR);
  1008.         }
  1009.         // FALLTHROUGH
  1010.     case MTYPE_INTER:
  1011.         CHECKSYM( if (checksym( insym[*nextsym], SYM_CBP, "decode_mb") != OK) exit(0); )
  1012.         mb[mbnum].cbp = insym[(*nextsym)++].value;
  1013.         mask = 0x20;    // Bitmask for first block
  1014.         for (blk = 0; blk < 6; blk++) {
  1015.             mb[mbnum].block[blk].nsym = 0;
  1016.             if ((mb[mbnum].cbp & mask) != 0) {
  1017.                 status = decode_block( insym, nextsym,
  1018.                                 &(mb[mbnum].block[blk]),
  1019.                                 &outsym[isym] );
  1020.                 if (status == H261_ERROR) {
  1021.                     BS_ERR_MSG( sprintf( msg, "decode_mb: Bitstream error, block #%d", blk); /* Flawfinder: ignore */
  1022.                             H261ErrMsg( msg ); )
  1023.                     return (H261_ERROR);
  1024.                 }
  1025.                 isym += status;
  1026.             }
  1027.             mask >>= 1;
  1028.         }
  1029.         break;
  1031.     case MTYPE_MCFILT_MQUANT:
  1032.     case MTYPE_MC_MQUANT:
  1033.         CHECKSYM( if (checksym( insym[*nextsym], SYM_QUANT_TR, "decode_mb") != OK) exit(0); )
  1034.         *quant = insym[(*nextsym)++].value;
  1035.         if (*quant < QUANT_MIN  ||  *quant > QUANT_MAX) {
  1036.             BS_ERR_MSG( sprintf( msg, "decode_mb: quant = %d", *quant); /* Flawfinder: ignore */
  1037.                     H261ErrMsg( msg ); )
  1038.             return (H261_ERROR);
  1039.         }
  1040.         // FALLTHROUGH
  1041.     case MTYPE_MCFILT_CBP:
  1042.     case MTYPE_MC_CBP:
  1043.         CHECKSYM( if (checksym( insym[*nextsym], SYM_MVD, "decode_mb") != OK) exit(0); )
  1044.         mb[mbnum].mvd_x = insym[(*nextsym)++].value;
  1045.         CHECKSYM( if (checksym( insym[*nextsym], SYM_MVD, "decode_mb") != OK) exit(0); )
  1046.         mb[mbnum].mvd_y = insym[(*nextsym)++].value;
  1047.         if (mbnum % gob->mb_width > 0  &&
  1048.                     mb[mbnum-1].mtype >= MTYPE_MC_NOCBP) {
  1049.              mb[mbnum].mv_x = mb[mbnum-1].mv_x + mb[mbnum].mvd_x;
  1050.              mb[mbnum].mv_y = mb[mbnum-1].mv_y + mb[mbnum].mvd_y;
  1051.         } else {
  1052.              mb[mbnum].mv_x = mb[mbnum].mvd_x;
  1053.              mb[mbnum].mv_y = mb[mbnum].mvd_y;
  1054.         }
  1055.         CHECKSYM( if (checksym( insym[*nextsym], SYM_CBP, "decode_mb") != OK) exit(0); )
  1056.         mb[mbnum].cbp = insym[(*nextsym)++].value;
  1057.         mask = 0x20;    // Bitmask for first block
  1058.         for (blk = 0; blk < 6; blk++) {
  1059.             mb[mbnum].block[blk].nsym = 0;
  1060.             if ((mb[mbnum].cbp & mask) != 0) {
  1061.                 status = decode_block( insym, nextsym,
  1062.                                 &(mb[mbnum].block[blk]),
  1063.                                 &outsym[isym] );
  1064.                 if (status == H261_ERROR) {
  1065.                     BS_ERR_MSG( sprintf( msg, "decode_mb: Bitstream error, block #%d", blk); /* Flawfinder: ignore */
  1066.                             H261ErrMsg( msg ); )
  1067.                     return (H261_ERROR);
  1068.                 }
  1069.                 isym += status;
  1070.             }
  1071.             mask >>= 1;
  1072.         }
  1073.         break;
  1075.     case MTYPE_MCFILT_NOCBP:
  1076.     case MTYPE_MC_NOCBP:
  1077.         CHECKSYM( if (checksym( insym[*nextsym], SYM_MVD, "decode_mb") != OK) exit(0); )
  1078.         mb[mbnum].mvd_x = insym[(*nextsym)++].value;
  1079.         CHECKSYM( if (checksym( insym[*nextsym], SYM_MVD, "decode_mb") != OK) exit(0); )
  1080.         mb[mbnum].mvd_y = insym[(*nextsym)++].value;
  1081.         if (mbnum % gob->mb_width > 0  &&
  1082.                     mb[mbnum-1].mtype >= MTYPE_MC_NOCBP) {
  1083.              mb[mbnum].mv_x = mb[mbnum-1].mv_x + mb[mbnum].mvd_x;
  1084.              mb[mbnum].mv_y = mb[mbnum-1].mv_y + mb[mbnum].mvd_y;
  1085.         } else {
  1086.              mb[mbnum].mv_x = mb[mbnum].mvd_x;
  1087.              mb[mbnum].mv_y = mb[mbnum].mvd_y;
  1088.         }
  1089.         break;
  1091.     case MTYPE_INTRA_MQUANT:
  1092.         CHECKSYM( if (checksym( insym[*nextsym], SYM_QUANT_TR, "decode_mb") != OK) exit(0); )
  1093.         *quant = insym[(*nextsym)++].value;
  1094.         if (*quant < QUANT_MIN  ||  *quant > QUANT_MAX) {
  1095.             BS_ERR_MSG( sprintf( msg, "decode_mb: quant = %d", *quant); /* Flawfinder: ignore */
  1096.                     H261ErrMsg( msg ); )
  1097.             return (H261_ERROR);
  1098.         }
  1099.         // FALLTHROUGH
  1100.     case MTYPE_INTRA:
  1101.         for (blk = 0; blk < 6; blk++) {
  1102.             status = decode_intra_block( insym, nextsym,
  1103.                                 &(mb[mbnum].block[blk]),
  1104.                                 &outsym[isym] );
  1105.             if (status == H261_ERROR) {
  1106.                 BS_ERR_MSG( sprintf( msg, "decode_mb: Bitstream error, block #%d", blk); /* Flawfinder: ignore */
  1107.                         H261ErrMsg( msg  ); )
  1108.                 return (H261_ERROR);
  1109.             }
  1110.             isym += status;
  1111.         }
  1112.         break;
  1114.     default:    // Illegal MTYPE is due to program error; not from bit errors
  1115.         CHECKSYM( sprintf( msg, "decode_mb: MTYPE = %d", mb[mbnum].mtype); /* Flawfinder: ignore */
  1116.             H261ErrMsg( msg ); )
  1117.         return (H261_ERROR);
  1118.         break;
  1119.     }
  1120.     mb[mbnum].quant = *quant;
  1121.     return (isym);
  1122. }
  1125. static int  decode_intra_block( SYMBOL insym[], int * nextsym,
  1126.                             BLOCK_DESCR * block, SYMBOL outsym[])
  1127. {
  1128.     int isym, zzpos, run;
  1129.     CHECKSYM ( char msg[120] ); /* Flawfinder: ignore */
  1131.     /* DC coefficient */
  1132.     //printf("decode_intra_block DC: "); printsym( insym[*nextsym] ); printf("n");
  1133.     CHECKSYM( if (checksym( insym[*nextsym], SYM_INTRA_DC, "decode_intra") != OK) exit(0); )
  1134.     outsym[0].type = 0;
  1135.     outsym[0].value = insym[(*nextsym)++].value;
  1136.     /* AC coefficients */
  1137.     isym = 1;
  1138.     zzpos = 1;
  1139.     //printf("decode_intra_block AC: "); printsym( insym[*nextsym] ); printf("n");
  1140.     while (insym[*nextsym].type != SYM_EOB) {
  1141.         if (insym[*nextsym].type == SYM_ESC_RUN) {
  1142.             run = insym[(*nextsym)++].value;
  1143.             outsym[isym].type = run;
  1144.             CHECKSYM( if (checksym( insym[*nextsym], SYM_ESC_LEVEL, "decode_intra") != OK) exit(0); )
  1145.             outsym[isym++].value = insym[(*nextsym)++].value;
  1146.         } else {
  1147.             run = insym[*nextsym].type;
  1148.             CHECKSYM( if (run < 0) {
  1149.                 sprintf( msg, "PROGRAM ERROR: run = %d in decode_intra", run); /* Flawfinder: ignore */
  1150.                 H261ErrMsg( msg );
  1151.                 return( H261_ERROR );
  1152.                 } )
  1153.             outsym[isym++] = insym[(*nextsym)++];
  1154.         }
  1155.         zzpos += run + 1;
  1156. //        printf("decode_intra_block AC: "); printsym( insym[*nextsym] );
  1157. //        printf("   zzpos = %dn", zzpos);
  1158.         if (zzpos > 64) {   // If we decoded coeff. 63, we will now have zzpos=64
  1159.             BS_ERR_MSG( sprintf( msg, "decode_intra_block: Bitstream error, zzpos=%d", zzpos); /* Flawfinder: ignore */
  1160.             H261ErrMsg( msg ); )
  1161.             return (H261_ERROR);
  1162.         }
  1163.     }
  1164.     (*nextsym)++;   /* Advance pointer to symbol after EOB */
  1165.     block->sym = outsym;
  1166.     block->nsym = isym;
  1167.     return (isym);
  1168. }
  1172. /* Compute # bits in segment bs1 - bs2 */
  1173. extern int BsDiff( BS_PTR bs1, BS_PTR bs2 )
  1174. {
  1175.     int bits;
  1177.     bits = 8 * (bs1.byteptr - bs2.byteptr) + bs1.bitptr - bs2.bitptr;
  1178.     return (bits);
  1179. }
  1182. static int  find_startcodes( BS_PTR * bs,   // Points to beginning of bitstream
  1183.                             int numbits,    // length of bitstream in bits
  1184.                             BS_PTR start[], // Returns positions for startcodes; size "max_start"
  1185.                             int gobnum[],   // Returns 4 bits after startcode (5 bits for H.263); size "max_start"
  1186.                             int max_start,  // Max number of start codes to be returned
  1187.                             int codingMethod )  // Indicate H.261 or H.263 syntax
  1188. {
  1189.     int i, bits_left, startZeros, gnBits;
  1190.     BS_PTR  bs_next;
  1192.     if (codingMethod == H263_CODING) {
  1193.         startZeros = H263_START_ZEROS;
  1194.         gnBits = H263_GN_BITS;
  1195.     } else {    // H.261
  1196.         startZeros = H261_START_ZEROS;
  1197.         gnBits = H261_GN_BITS;
  1198.     }
  1199.     i = 0;
  1200.     bs_next = *bs;
  1201.     while (i < max_start) {
  1202.         bits_left = numbits - BsDiff( bs_next, *bs);
  1203.         if (find_sc( &bs_next, bits_left, startZeros, &start[i] ) != YES) {
  1204.             return (i);
  1205.         }
  1206.         gobnum[i] = Get8Bits( start[i] ) >> (8 - gnBits);
  1207.         bs_next = start[i];
  1208.         i++;
  1209.     }
  1210.     return (max_start);
  1211. }
  1214. static  U8 leading[256];
  1215. static  U8 trailing[256];
  1217. extern void InitFindSC( void )
  1218. {
  1219.     int i, j, bitmask;
  1221.     for (i = 0; i < 256; i++) {
  1222.         leading[i] = 0;
  1223.         bitmask = 0x80;
  1224.         for (j = 0; j < 8; j++) {
  1225.             if ((i & bitmask) != 0) {
  1226.                 break;
  1227.             }
  1228.             bitmask >>= 1;
  1229.             ++leading[i];
  1230.         }
  1231.         trailing[i] = 0;
  1232.         bitmask = 0x1;
  1233.         for (j = 0; j < 8; j++) {
  1234.             if ((i & bitmask) != 0) {
  1235.                 break;
  1236.             }
  1237.             bitmask <<= 1;
  1238.             ++trailing[i];
  1239.         }
  1240.         //printf("%3x: Leading = %d  Trailing = %dn", i, leading[i], trailing[i]);
  1241.     }
  1242.     return;
  1243. }
  1246. //  find_sc - Find startcode consisting of startZeros zeros followed by 1
  1247. //  Returns YES if startcode found, otherwise NO
  1248. //  Operates on byte boundaries; might not look at last 8 bits in bitstream
  1249. static int  find_sc( BS_PTR * bs,       // Points to beginning of bitstream
  1250.                      int numbits,       // length of bitstream in bits
  1251.                      int startZeros,    // number of zeros in startcode
  1252.                      BS_PTR * start )   // Returns position for bit after startcode
  1253. {
  1254.     int     zeros, nbytes, i, validBitsInLastByte;
  1255.     U8   b;
  1257.     /* Read first byte from bitstream; set "irrelevant bits" to 1 */
  1258.     b = *bs->byteptr | (0xff & (0xff << (8 - bs->bitptr)));
  1259.     zeros = trailing[b];
  1260. //    nbytes = (numbits + bs->bitptr - 8 - max(H263_GN_BITS, H261_GN_BITS) ) >> 3;
  1261.     nbytes = (numbits + bs->bitptr - 1 ) >> 3;
  1262.     validBitsInLastByte = (numbits + bs->bitptr) &07;
  1263.     if (validBitsInLastByte == 0)
  1264.         validBitsInLastByte = 8;
  1265.     start->byteptr = bs->byteptr + 1;
  1266.     for (i = 0; i < nbytes; i++) {
  1267.         b = *start->byteptr;
  1268.         zeros += leading[b];
  1269.         if (zeros < startZeros  &&  b != 0) {
  1270.             zeros = trailing[b];
  1271.         } else if (b != 0) {    /* Found startcode */
  1272.             start->bitptr = leading[b] + 1;
  1273.             if (i == nbytes - 1 && 
  1274.                 start->bitptr + H263_GN_BITS > validBitsInLastByte
  1275.                 ||
  1276.                 i == nbytes - 2 &&
  1277.                 start->bitptr + H263_GN_BITS > 8 + validBitsInLastByte)
  1278.                 return(NO);
  1279.             if (start->bitptr > 7) {
  1280.                 ++(start->byteptr);
  1281.                 start->bitptr -= 8;
  1282.             }
  1283.             return (YES);
  1284.         }   /* else: b=0; continue until 1 is found */
  1285.         ++(start->byteptr);
  1286.     }
  1287.     return (NO);
  1288. }
  1290. #ifdef TESTING
  1291. ///////////  Routines for debugging  //////////////
  1292. extern int  checksym( SYMBOL sym, int type, char routine[] )
  1293. {
  1294.     char msg[120], csym[80], ctype[80]; /* Flawfinder: ignore */
  1295.     
  1296.     if (sym.type == type) {
  1297.         return (OK);
  1298.     } else {    // Not expected type
  1299.         sprintsym( sym , csym, 80);
  1300.         sprinttype( type, ctype, 80);
  1301.         SafeSprintf(msg, 120, "%s: Encountered %s  Expected %s", routine, csym, ctype);
  1302.         H261ErrMsg( msg );
  1303.         return (H261_ERROR);
  1304.     }
  1305. }
  1306. #endif // TESTING
  1308. #ifdef ANNOTATE_PICTURE
  1309. // saveOrRestoreReconPicture
  1310. static void saveOrRestoreReconPicture( PICTURE *pic,    // Picture to be saved or restored
  1311.                                        int  restore     // Save if 0, otherwise restore
  1312.                                      )
  1313. {
  1314. #define MAX_BYTES   ((176*144*3)/2)
  1315.     int             nBytes;
  1316.     static PIXEL    savePic[MAX_BYTES];
  1317.     
  1318.     nBytes = (pic->y.nhor * pic->y.nvert * 3) >> 1;
  1319.     // Packed format is assumed
  1320.     if (nBytes > MAX_BYTES) {
  1321.         H261ErrMsg("Error in saveOrRestoreReconPicturen");
  1322.         exit(0);
  1323.     } else if (restore) {   // Restore the saved picture
  1324.         memcpy( pic->y.ptr, savePic, nBytes ); /* Flawfinder: ignore */
  1325.     } else {                // Save picture for next decoding
  1326.         memcpy( savePic, pic->y.ptr, nBytes ); /* Flawfinder: ignore */
  1327.     }
  1328. }
  1331. // annotatePicture - Draw motion vectors etc.
  1332. static void annotatePicture( PICTURE *pic, MACROBLOCK_DESCR mb[])
  1333. {
  1334.     int     xSize, ySize, numMb, i, x, y;
  1335.     PIXEL   *upperLeft;
  1336.     
  1337.     xSize = pic->y.nhor;
  1338.     ySize = pic->y.nvert;
  1339.     numMb = (xSize * ySize) >> 8;
  1340.     for (i = 0; i < numMb; ++i) {
  1341.         x = 16 * mb[i].x;
  1342.         y = 16 * mb[i].y;
  1343.         upperLeft = pic->y.ptr + x + y * pic->y.hoffset;
  1344.         annotateMacroblock( upperLeft, pic->y.hoffset, &mb[i],
  1345.                             -x, xSize - 1 - x,
  1346.                             -y, ySize - 1 - y );
  1347.     }
  1348. }
  1350. #define WHITE   (255)
  1351. #define BLACK   (0)
  1352. #define BLACK_THRESHOLD (192)   // Paint with black if pixel is brighter than threshold
  1353. // Limit x to interval [low,high]
  1354. #define LIMIT( low, x, high )    max( low, min( x, high ))
  1356. // annotateMacroblock
  1357. static void annotateMacroblock( PIXEL data[], int xdim, MACROBLOCK_DESCR *mb,
  1358.                                 int xMin, int xMax, int yMin, int yMax )
  1359. {
  1361.     switch (mb->mtype)
  1362.     {
  1363.     case MTYPE_SKIP:
  1364.         // Do nothing
  1365.         break;
  1366.     case MTYPE263_INTER:
  1367.     case MTYPE263_INTER_Q:
  1368.         // Draw motion vector
  1369.         drawMv( &data[7 + 7 * xdim], xdim, mb->mv_x, mb->mv_y,
  1370.                 xMin-7, xMax-7, yMin-7, yMax-7 );
  1371.         break;
  1372.     case MTYPE263_INTER4V:
  1373.         // Draw a "plus"
  1374.         plusMb( data, xdim );
  1375.         // Draw 4 motion vectors
  1376.         drawMv( &data[3 + 3 * xdim], xdim, mb->blkMvX[0], mb->blkMvY[0],
  1377.                 xMin-3, xMax-3, yMin-3, yMax-3 );
  1378.         drawMv( &data[11 + 3 * xdim], xdim, mb->blkMvX[1], mb->blkMvY[1],
  1379.                 xMin-11, xMax-11, yMin-3, yMax-3 );
  1380.         drawMv( &data[3 + 11 * xdim], xdim, mb->blkMvX[2], mb->blkMvY[2],
  1381.                 xMin-3, xMax-3, yMin-11, yMax-11 );
  1382.         drawMv( &data[11 + 11 * xdim], xdim, mb->blkMvX[3], mb->blkMvY[3],
  1383.                 xMin-11, xMax-11, yMin-11, yMax-11 );
  1384.         break;
  1385.     case MTYPE263_INTRA:
  1386.     case MTYPE263_INTRA_Q:
  1387.         //  Draw motion vector and mark block with a cross
  1388.         drawMv( &data[7 + 7 * xdim], xdim, mb->mv_x, mb->mv_y,
  1389.                 xMin-7, xMax-7, yMin-7, yMax-7 );
  1390.         crossMb( data, xdim );
  1391.         break;
  1392.     default:
  1393.         // Fill block with white
  1394.         fillMb( data, xdim );
  1395.         break;
  1396.     }
  1397. }
  1400. // drawMv - Draw motion vector starting in (0,0)
  1401. static void drawMv( PIXEL data[], int xdim, int mvX, int mvY,
  1402.                     int xMin, int xMax, int yMin, int yMax )
  1403. {
  1404.     if (mvX == 0  &&  mvY == 0) {
  1405.         // Draw a circle
  1406.         markPixel( &data[-xdim] );
  1407.         markPixel( &data[-xdim + 1] );
  1408.         markPixel( &data[-1] );
  1409.         markPixel( &data[2] );
  1410.         markPixel( &data[xdim - 1] );
  1411.         markPixel( &data[xdim + 2] );
  1412.         markPixel( &data[2*xdim] );
  1413.         markPixel( &data[2*xdim+1] );
  1414.     } else {    // Draw motion vector
  1415.         // Divide by 2 (one frac. bit); round "away" from 0
  1416.         /*if (mvX > 0) ++mvX;
  1417.         mvX >>= 1;
  1418.         if (mvY > 0) ++mvY;
  1419.         mvY >>= 1;*/    // Leave mv's scaled up by factor of 2
  1420.         // Clip to picture rectangle
  1421.         mvX = LIMIT( xMin, mvX, xMax );
  1422.         mvY = LIMIT( yMin, mvY, yMax );
  1423.         DrawVector( data, xdim, 0, 0, mvX, mvY );
  1424.     }
  1425. }
  1428. // plusMb - Mark block with a "plus"
  1429. static void plusMb( PIXEL data[], int xdim )
  1430. {
  1431.     int col;
  1432.     
  1433.     // Horizontal line
  1434.     data += 7 * xdim;
  1435.     for (col = 5; col <= 9; ++col) {
  1436.         markPixel( &data[col] );
  1437.     }
  1438.     // Vertical line
  1439.     markPixel( &data[7 - 2 * xdim] );
  1440.     markPixel( &data[7 - 1 * xdim] );
  1441.     markPixel( &data[7 + 1 * xdim] );
  1442.     markPixel( &data[7 + 2 * xdim] );
  1443. }
  1446. // crossMb - Mark block with a cross
  1447. static void crossMb( PIXEL data[], int xdim )
  1448. {
  1449.     int row;
  1450.     
  1451.     for (row = 0; row < 16; ++row) {
  1452.         markPixel( &data[row] );
  1453.         markPixel( &data[15 - row] );
  1454.         data += xdim;
  1455.     }
  1456. }
  1459. // fillMb - Fill block with white
  1460. static void fillMb( PIXEL data[], int xdim )
  1461. {
  1462.     int row, col;
  1463.     
  1464.     for (row = 0; row < 16; ++row) {
  1465.         for (col = 0; col < 16; ++col) {
  1466.             markPixel( &data[col] );
  1467.         }
  1468.         data += xdim;
  1469.     }
  1470. }
  1473. // markPixel - Set pixel to white if < 192, otherwise set it to black
  1474. static void markPixel( PIXEL *pixel )
  1475. {
  1476.     if (*pixel < BLACK_THRESHOLD) {
  1477.         *pixel = WHITE;
  1478.     } else {
  1479.         *pixel = BLACK;
  1480.     }
  1481. }
  1483. ///////////// Graphics routines /////////////
  1485. #include <stdlib.h>
  1486. #include <math.h>
  1488. // Static function declarations
  1489. static int DrawVector( unsigned char data[], int xdim, int x1, int y1, int x2, int y2 );
  1490. static int drawVec( unsigned char data[], int xdim, int x1, int y1 );
  1492. // DrawVector - Draw vector from (x1,y1) to (x2,y2)
  1493. static int DrawVector( unsigned char data[], int xdim, int x1, int y1, int x2, int y2 )
  1494. {
  1495.     int x, y;
  1496.     
  1497.     if (y1 == y2) {         // Draw horizontal line
  1498.         data += y1 * xdim;
  1499.         for (x = min(x1,x2); x <= max(x1,x2); ++x)  markPixel( &data[x] );
  1500.     } else if (x1 == x2) {  // Draw vertical line
  1501.         data += min(y1,y2) * xdim;
  1502.         for (y = min(y1,y2); y <= max(y1,y2); ++y) {
  1503.             markPixel( &data[x1] );
  1504.             data += xdim;
  1505.         }
  1506.     } else if (x2 > x1) {   // Use (x1,y1) as origin
  1507.         data += x1 + y1 * xdim;
  1508.         drawVec( data, xdim, x2-x1, y2-y1 );
  1509.     } else {                // Use (x2,y2) as origin
  1510.         data += x2 + y2 * xdim;
  1511.         drawVec( data, xdim, x1-x2, y1-y2 );
  1512.     }
  1513.     return(1);
  1514. }
  1517. // drawVec - Draw vector from origin to (x1,y1)
  1518. //  Assumes that x1 > 0, and y1 != 0
  1519. //  Draw pixels that are within 0.5 units distance of vector
  1520. static int drawVec( unsigned char data[], int xdim, int x1, int y1 )
  1521. {
  1522.     int x, y, xLast, xNew;
  1523.     float   fX1, fY1, fNorm, fA, fB, fXstep, fX, fDist;
  1524.     
  1525.     if (y1 < 0) {
  1526.         y1 = -y1;
  1527.         xdim = -xdim;
  1528.     }
  1529.     // Now, both x1 and y1 are >0
  1530.     // Compute equation for line:  ax + by = 0, where (a,b) is normal vector of length 1
  1531.     // The distance between (x,y) and the line is the inner product: abs(ax + by)
  1532.     fX1 = (float)x1;
  1533.     fY1 = (float)y1;
  1534.     fNorm = (float) sqrt( fX1*fX1 + fY1*fY1);
  1535.     fA = -fY1 / fNorm;  // fA < 0
  1536.     fB = fX1 / fNorm;   // fB > 0
  1537.     fXstep = fX1 / fY1; // x increment per row
  1538.     // First row
  1539.     fX = (float)(0.5 * fXstep);  // Intersection with y=0.5
  1540.     xLast = (int)fX;    // Truncate (Note: fX > 0; int always truncates towards zero)
  1541.     for (x = 0; x <= xLast; ++x)  markPixel( &data[x] );
  1542.     // Intermediate rows
  1543.     for (y = 1; y < y1; ++y) {
  1544.         data += xdim;
  1545.         // Check distance to (xLast, y)
  1546.         fDist = fA * (float)xLast + fB * (float)y;  // fDist > 0
  1547.         if (fDist < 0.4999) {
  1548.             markPixel( &data[xLast] );
  1549.         } else if (fDist + fA - fB > -0.4999) {     // Check distance to (xLast+1, y-1)
  1550.             //fDist = fA * (float)(xLast+1) + fB * (float)(y-1);  // fDist < 0
  1551.             markPixel( &data[xLast+1 - xdim] );
  1552.         }
  1553.         fX += fXstep;   // Intersection with y+0.5
  1554.         xNew = (int)fX;
  1555.         for (x = xLast + 1; x <= xNew; ++x)  markPixel( &data[x] );
  1556.         xLast = xNew;
  1557.     }
  1558.     // Last row (y = y1)
  1559.     data += xdim;
  1560.     // Check distance to (xLast, y1)
  1561.     fDist = fA * (float)xLast + fB * (float)y1; // fDist > 0
  1562.     if (fDist < 0.4999) {
  1563.         markPixel( &data[xLast] );
  1564.     } else if (fDist + fA - fB > -0.4999) {     // Check distance to (xLast+1, y1-1)
  1565.         markPixel( &data[xLast+1 - xdim] );
  1566.     }
  1567.     for (x = xLast + 1; x <= x1; ++x)  markPixel( &data[x] );
  1568.     
  1569.     return(1);
  1570. }
  1572. #endif  /* ANNOTATE_PICTURE */
  1574. /*
  1575. // Compute checksums for picture (used for debugging only)
  1576. static int checkPicture( PICTURE pic );
  1577. static int checkComponent( COMPONENT comp );
  1579. static PIXEL encPic[176*144], decPic[176*144], diffPic[176*144];
  1581. extern int storePicture( PICTURE pic, int picNum )
  1582. {
  1583. int i, j;
  1584. PIXEL *in, *out;
  1586. in = pic.y.ptr;
  1587. if (picNum == 0)
  1588. out = encPic;
  1589. else
  1590. out = decPic;
  1591.     for (i = 0; i < pic.y.nvert; i++) {
  1592.         for (j = 0; j < pic.y.nhor; j++) {
  1593. out[j] = in[j];
  1594.         }
  1595. in += pic.y.hoffset;
  1596. out += pic.y.nhor;
  1597.     }
  1598. return( 1 );
  1599. }
  1601. static int checkPicture( PICTURE pic )
  1602. {
  1603. int         y, cb, cr, i;
  1604.     static int  sum = 0;
  1606. storePicture( pic, 1 );
  1607. y = checkComponent( pic.y );
  1608. cb = checkComponent( pic.cb );
  1609. cr = checkComponent( pic.cr );
  1610. sum += y + cb + cr;
  1611. for (i = 0; i < 176*144; ++i)
  1612. diffPic[i] = encPic[i] - decPic[i];
  1613. return( sum );
  1614. }
  1616. static int checkComponent( COMPONENT comp )
  1617. {
  1618.     int i, j, sum;
  1619.     PIXEL   *p;
  1621. sum = 0, p = comp.ptr;
  1622.     for (i = 0; i < comp.nvert; i++) {
  1623.         for (j = 0; j < comp.nhor; j++) {
  1624. sum += p[j];
  1625.         }
  1626. p += comp.hoffset;
  1627.     }
  1628. return( sum );
  1629. }
  1630. */