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

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

Symbian

开发平台：

Visual C++

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