h261dec.c

linux下的一款播放器

/* ***** BEGIN LICENSE BLOCK *****
 * Source last modified: $Id: h261dec.c,v 1.3.34.1 2004/07/09 01:56:22 hubbe Exp $
 * 
 * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
 * 
 * The contents of this file, and the files included with this file,
 * are subject to the current version of the RealNetworks Public
 * Source License (the "RPSL") available at
 * http://www.helixcommunity.org/content/rpsl unless you have licensed
 * the file under the current version of the RealNetworks Community
 * Source License (the "RCSL") available at
 * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
 * will apply. You may also obtain the license terms directly from
 * RealNetworks.  You may not use this file except in compliance with
 * the RPSL or, if you have a valid RCSL with RealNetworks applicable
 * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
 * the rights, obligations and limitations governing use of the
 * contents of the file.
 * 
 * Alternatively, the contents of this file may be used under the
 * terms of the GNU General Public License Version 2 or later (the
 * "GPL") in which case the provisions of the GPL are applicable
 * instead of those above. If you wish to allow use of your version of
 * this file only under the terms of the GPL, and not to allow others
 * to use your version of this file under the terms of either the RPSL
 * or RCSL, indicate your decision by deleting the provisions above
 * and replace them with the notice and other provisions required by
 * the GPL. If you do not delete the provisions above, a recipient may
 * use your version of this file under the terms of any one of the
 * RPSL, the RCSL or the GPL.
 * 
 * This file is part of the Helix DNA Technology. RealNetworks is the
 * developer of the Original Code and owns the copyrights in the
 * portions it created.
 * 
 * This file, and the files included with this file, is distributed
 * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
 * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
 * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
 * ENJOYMENT OR NON-INFRINGEMENT.
 * 
 * Technology Compatibility Kit Test Suite(s) Location:
 *    http://www.helixcommunity.org/content/tck
 * 
 * Contributor(s):
 * 
 * ***** END LICENSE BLOCK ***** */

#include "hxtypes.h"
#include "dllindex.h"
#include "h261defs.h"
#include "vldstate.h"
#include "h261func.h"
#include "hvscodes.h"        /* getImgParms can be called                    */
#include "dec_blk.h"        /* set the proper pragmas for decode_block      */
#include "vldecode.h"       /* set the proper pragmas for VLDecode          */
#include "h263plus.h"

//#define ANNOTATE_PICTURE    // Include diagnostic info in output picture
#ifdef TESTING
#include <stdio.h>
#include <stdlib.h>
#define BS_ERR_MSG(a)   a   // Generate messages on bitstream error (i.e., illegal 
                            // bitstream syntax) to simplify debugging
#define CHECKSYM(a)     a   // Check symbol types to verify decoder state tables

#else
#define BS_ERR_MSG(a)       // Suppress error messages 
#define CHECKSYM(a)         // Don't check symbol types
#endif


// Declarations of local functions
static int  findPSC( BS_PTR start[], int gn[], int num_sc, int *sc, H261Decoder *s );
static void savePSCpointer( BS_PTR *bsPSC, H261Decoder *s );
static void outputBsPointer( BS_PTR * start, BS_PTR * output, int codingMethod );
static int decodeBitstream( H261Decoder *s,
                            GOB_DESCR   *gob,
                            BS_PTR      start[2],
                            int         gn[2],
                            int         *structStatus,
                            int         *decStatus );
static int  doGobStructures( H261Decoder *s, GOB_DESCR *gob, MACROBLOCK_DESCR mb[],
                        BS_PTR start[2], int gn[2] );
static int  doGobDecoding( H261Decoder *s, GOB_DESCR *gob, MACROBLOCK_DESCR mb[],
                        BS_PTR start[2], SYMBOL sym[], int maxsym );
static void gobConcealment( H261Decoder *s, GOB_DESCR *gob, MACROBLOCK_DESCR mb[] );
static int build_gob_struct( S32 format, S32 gn, GOB_DESCR * gob);
static int build263gob( S32 format, S32 gn, int next_gn, GOB_DESCR * gob,
                        PICTURE_DESCR * pic );
/*static void update_decMB( GOB_DESCR * gob, MACROBLOCK_DESCR mb[], int mb_per_row, 
                        int codingMethod, MBMap * decMB, S32 * iFrame, int forcedUpdate );*/
static int  initializePicture( H261Decoder * s );
static int  decodePicLayer( BS_PTR * bs, int nbits, PICTURE_DESCR * pic,
                            SYMBOL sym[], int maxsym, int codingMethod, GOB_DESCR * gob,
                            int * ptype );
static int  decode_pic261( BS_PTR * bs, int nbits, PICTURE_DESCR * pic,
                            SYMBOL sym[], int maxsym);
static int  decode261gob(  BS_PTR * bs, int nbits, GOB_DESCR * gob,
                        MACROBLOCK_DESCR mb[], SYMBOL sym[], int maxsym);
static int  decode_mb( SYMBOL insym[], int * nextsym, int * quant,
                        GOB_DESCR * gob, MACROBLOCK_DESCR mb[], int mbnum,
                        SYMBOL outsym[]);
static int  decode_intra_block( SYMBOL insym[], int * nextsym,
                            BLOCK_DESCR * block, SYMBOL outsym[]);
static int  find_startcodes( BS_PTR * bs,   // Points to beginning of bitstream
                            int numbits,    // length of bitstream in bits
                            BS_PTR start[], // Returns positions for startcodes; size "max_start"
                            int gobnum[],   // Returns 4 bits after startcode (5 bits for H.263); size "max_start"
                            int max_start,  // Max number of start codes to be returned
                            int codingMethod );  // Indicate H.261 or H.263 syntax
static int  find_sc( BS_PTR * bs,       // Points to beginning of bitstream
                     int numbits,       // length of bitstream in bits
                     int startZeros,    // number of zeros in startcode
                     BS_PTR * start );   // Returns position for bit after startcode
#ifdef ANNOTATE_PICTURE
// saveOrRestoreReconPicture
static void saveOrRestoreReconPicture( PICTURE *pic,    // Picture to be saved or restored
                                       int  restore     // Save if 0, otherwise restore
                                     );
// annotatePicture - Draw motion vectors etc.
static void annotatePicture( PICTURE *pic, MACROBLOCK_DESCR mb[]);
// annotateMacroblock
static void annotateMacroblock( PIXEL data[], int xdim, MACROBLOCK_DESCR *mb,
                                int xMin, int xMax, int yMin, int yMax );
static void drawMv( PIXEL data[], int xdim, int mvX, int mvY,
                    int xMin, int xMax, int yMin, int yMax );
static void plusMb( PIXEL data[], int xdim );
static void crossMb( PIXEL data[], int xdim );
static void fillMb( PIXEL data[], int xdim );
static void markPixel( PIXEL *pixel );
static int  DrawVector( unsigned char data[], int xdim, int x1, int y1, int x2, int y2 );
static int  drawVec( unsigned char data[], int xdim, int x1, int y1 );
#endif


#define GN_END_OF_SEQUENCE  (31)    // GN=31 for EOS
#define H263_START_ZEROS    (16)
#define H263_GN_BITS        (5)
#define H261_START_ZEROS    (15)
#define H261_GN_BITS        (4)


//
//
//  ****************************************************
//  H261Decode - Decode one or several GOBs in a picture
//  ****************************************************
//
//
extern int  H261Decode( H261Decoder * s )
#define NUM_SC      0
#define NUMGOB      1
#define ERRGOB      2
#define IFRAME      3
{
    BS_PTR      *pStart;    // Position of startcodes ("start")
    int         *pGn;       // GOB numbers following each startcode ("gn")
    GOB_DESCR   *pGob;      // Can refer to several GOBs, if GOB headers are left out ("gob")
    int         *pNum_sc;   // Points to number of startcodes found ("num_sc")
    int         *pSc;       // Points to current startcode ("sc")
    BS_PTR      bsPSC;
    int         status, structStatus, decStatus;
    BS_ERR_MSG(char msg[120];) /* Flawfinder: ignore */

    s->state.actComp = 0;  // Init computation measure
    pStart  =  s->state.bspStartCode;
    pGn     =  s->state.gobNumber;
    pGob    = &s->state.currentGob;
    pNum_sc = &s->state.nStartCodes;
    pSc     = &s->state.currentStartCode;

    if (s->pic_layer.decodingInProgress) {
        // Restore internal state; we interrupted reconstruction with status=OK
        structStatus = decStatus = OK;
        s->pic_layer.decodingInProgress = FALSE;    // Set only if we time out again

    } else {    // We did not time out last time, so do the usual thing

        s->state.i = 0;     // Tell ReconGob to reset its state

        /* Find Picture and GOB Start Codes */
        *pNum_sc = find_startcodes( &s->bsStart, BsDiff(s->bsEnd, s->bsStart),
                                    pStart, pGn, SC_MAX, (int)s->codingMethod );
        /*{   // Print startcode positions
            int i;
            for (i = 0; i < *pNum_sc; i++) {
                printf("Startcode %d: gn = %d starts in byte %d, bit %d\n", i,
                    pGn[i], pStart[i].byteptr - s->bsStart.byteptr, pStart[i].bitptr);
            }
            printf("Continue? ");
            scanf("%d", &i);
        }*/
        s->status.dwStartcodes = *pNum_sc;
        s->status.dwGobs = 0;       // # GOBs processed
        s->status.dwBadgobs = 0;    // # erroneous GOBs
        s->status.dwUpdateGobs = 0; // # GOBs for fast updating
        s->status.dwFirstBadgob = 0; // First bad Gob
        s->status.dwPsc = FALSE;    // indicates that a picture layer was successfully decoded
        s->newBs = s->bsStart;      // Just in case...  (will be updated later)
        if (*pNum_sc < 2) {
            if (*pNum_sc == 1) {
                outputBsPointer( &pStart[0], &s->newBs, (int)s->codingMethod ); // If we exit, begin here next time
            } else if ((s->bsEnd.byteptr - s->bsStart.byteptr) < 4) {
                // No startcode found and bitstream is less than 4 bytes long
                s->newBs = s->bsStart;
            } else {
                // No startcode found; skip to end of bitstream
                s->newBs = s->bsEnd;
                s->newBs.byteptr -= 4;  // Back up 32 bits (22-bit PSC and one byte margin)
            }
            return( NO );
        }
        *pSc = 0;
        if (s->next_gob == 0) {   // Decode Picture Layer info
            do {
                if (findPSC( pStart, pGn, *pNum_sc, pSc, s ) != YES)   // Find Picture Start Code
                    return( NO );
                // Try to decode Picture Layer
                outputBsPointer( &pStart[*pSc], &bsPSC, (int)s->codingMethod ); // Save possible picture start code pointer
                status = decodePicLayer( &pStart[*pSc], BsDiff(pStart[*pSc + 1], pStart[*pSc]),
                                    &s->pic_layer, s->sym, s->maxSym, (int)s->codingMethod, pGob,
                                    &s->ptype );
                // H.263: pStart[*pSc] gets bumped by decodePicLayer; now pointing to MB layer
                if (status != OK) {
                    ++s->status.dwBadgobs;
                    BS_ERR_MSG( H261ErrMsg( "Bitstream error when decoding Picture Layer" ); )
                } else {    // Decoded Picture Layer successfully
                    savePSCpointer( &bsPSC, s );
                    // Initialize image structures according to received image format: QCIF or CIF
                    status = initializePicture ( s );   
                    if (status != OK)  H261ErrMsg("Decoder: illegal picture format");
                    s->status.dwIntraFrame = 1;  // Assume intraframe (set to zero if we encounter a non-INTRA MacroBlock)
#ifdef ANNOTATE_PICTURE
                    saveOrRestoreReconPicture( &s->oldOut, 1 ); // Restore prev. from local memory
#endif
                    if (s->codingMethod == H263_CODING  &&  status == OK) {
                        s->next_gob = 0;    // First GOB is gn=0 for H.263
                        break;  // Don't increment *pSc; decode GOB 0 first
                    } else if (status == OK) {  // H.261 decoding
                        s->next_gob = 1;    // Go on to decode first GOB (gn=1 for H.261)
                    }
                }
                ++(*pSc);
            } while (status != OK);
        }
    
        // Decode GOBs until we reach next to last startcode or until picture complete
        if (*pSc >= *pNum_sc - 1)  return NO;

        // Decode bitstream for the first GOB
        status = decodeBitstream( s, pGob, &pStart[*pSc], &pGn[*pSc], &structStatus, &decStatus );
        if (status == H261_ERROR)  return NO;   // Exit to resync on next PSC

    }   // end if !s->pic_layer.decodingInProgress

    while (1) {     // Process until next to last startcode
        // Reconstruct GOB
        if (structStatus == OK) {
            // decStatus!=OK means that we found bitstream errors
            if (decStatus == OK) {
                //printf("Calling ReconGob \n");
                ReconGob( pGob, s->mb, &s->oldOut, &s->newOut, &s->B_Out, 
                           s->pic_layer.advancedPred, s->pic_layer.PBframeMode, 
                           s->PBframeCap, s->pic_layer.reducedResUpdate, s->pic_layer.advancedIntraMode,
                           &s->state, s->maxComp );
                // Time to exit?
                if (s->state.i > 0) {   // ReconGob timed out
                    s->pic_layer.decodingInProgress = TRUE;
                    return NO;
                }
				/*// Update macroblock map to control RGB conversion
				// This is not very useful anymore; skipped blocks might change when
				// we use overlapped MC or deblocking filter /SE 4/4/97
                update_decMB( pGob, pGob->mb, (int)(s->newOut.y.nhor >> 4), 
                            (int)s->codingMethod, &s->decMB,
                            &s->status.dwIntraFrame, NO );*/
            } else {    //  Bitstream error
                gobConcealment( s, pGob, s->mb );
            }
            s->status.dwGobs += pGob->num_mb / max(1,pGob->mb_width);
            s->next_gob = pGob->next_gn;
        }
        (*pSc)++;
        outputBsPointer( &pStart[*pSc], &s->newBs, (int)s->codingMethod ); // If we exit, begin here next time
        if (s->next_gob == 0) {    // Completed picture
#ifdef DO_H263_PLUS
            // Perform deblocking filtering
            if(s->pic_layer.reducedResUpdate) {
                ReducedResDeblockingFilter( &s->newOut, s->mb );
            } else if(s->pic_layer.deblockingFilterMode) {
                ApplyDeblockingFilter(&s->newOut, s->mb, FALSE);
                if(s->pic_layer.PBframeMode && s->PBframeCap) 
                    ApplyDeblockingFilter(&s->B_Out, s->mb, TRUE);
            }
#endif
            //checkPicture( s->newOut );  // Very useful when chasing subtle encoder bugs
#ifdef ANNOTATE_PICTURE
            saveOrRestoreReconPicture( &s->newOut, 0 ); // Save new picture to local memory
            annotatePicture( &s->newOut, s->mb );  // Draw motion vectors etc.
            annotatePicture( &s->B_Out, s->mb );
#endif
            return (YES);
        }
        if (*pSc >= *pNum_sc - 1)  return NO;

        // Decode bitstream for the next GOB
        status = decodeBitstream( s, pGob, &pStart[*pSc], &pGn[*pSc],
                                  &structStatus, &decStatus );
        if (status == H261_ERROR)  return NO;   // Exit to resync on next PSC
    }
}


// findPSC - Search for Picture Start Code
static int  findPSC( BS_PTR start[], int gn[], int num_sc, int *sc, H261Decoder *s )
{
    do {
        if (*sc > num_sc - 2) { //  Reached last startcode?
            return (NO);
        }
        (*sc)++;
        outputBsPointer( &start[*sc], &s->newBs, (int)s->codingMethod ); // If we exit, begin here next time
    } while (gn[*sc - 1] != 0); // GN=0 indicates PSC
    *sc = *sc - 1;    // Back up to point at PSC
    return( YES );
}