frarray.c

魔兽2Linux版

	case 16:
        // Bit 7 clear
		if ( !(pbi->bit_pattern & 0x0080) )
		{
			ret_val = TRUE;
			*run_value += (pbi->bit_pattern & 0x007F) + 129;                             
		}
		break; 


    default:
    	ret_val = FALSE;
		break;
	}

    return ret_val;
}
/****************************************************************************
 * 
 *  ROUTINE       :     FrArrayCodeSBRun
 *
 *  INPUTS        :     UINT8 bit_value
 *
 *  OUTPUTS       :     UINT8 run_value
 *
 *  RETURNS       :     TRUE when a value has been fully decoded.
 *
 *  FUNCTION      :     Decodes a SB run value
 *
 *  SPECIAL NOTES :     None. 
 *
 *
 *  ERRORS        :     None.
 *
 ****************************************************************************/
BOOL FrArrayDeCodeSBRun(  PB_INSTANCE *pbi, UINT32 bit_value, INT32 * run_value )
{
    BOOL ret_val = FALSE;

    // Add in the new bit value.
    pbi->bits_so_far++;
    pbi->bit_pattern = (pbi->bit_pattern << 1) + (bit_value & 1);
        
    // Coding scheme:
	//	Codeword				RunLength
    //  0                       1
	//	10x					    2-3
	//	110x					4-5
	//	1110xx				    6-9
    //  11110xxx                10-17
    //  111110xxxx              18-33
    //  111111xxxxxxxxxxxx      34-4129
	switch ( pbi->bits_so_far )
	{
	case 1:  
		if ( pbi->bit_pattern == 0 )
		{
			ret_val = TRUE;
			*run_value = 1;                             
		}
		break; 

	case 3:
        // Bit 1 clear
		if ( !(pbi->bit_pattern & 0x0002) )
		{
			ret_val = TRUE;
			*run_value = (pbi->bit_pattern & 0x0001) + 2;                             
		}
		break; 
        
	case 4:
        // Bit 1 clear
		if ( !(pbi->bit_pattern & 0x0002) )
		{
			ret_val = TRUE;
			*run_value = (pbi->bit_pattern & 0x0001) + 4;                             
		}
		break; 
             
	case 6:
        // Bit 2 clear
		if ( !(pbi->bit_pattern & 0x0004) )
		{
			ret_val = TRUE;
			*run_value = (pbi->bit_pattern & 0x0003) + 6;                             
		}
		break; 
        
	case 8:
        // Bit 3 clear
		if ( !(pbi->bit_pattern & 0x0008) )
		{
			ret_val = TRUE;
			*run_value = (pbi->bit_pattern & 0x0007) + 10;                             
		}
		break; 
          
	case 10:
        // Bit 4 clear
		if ( !(pbi->bit_pattern & 0x0010) )
		{
			ret_val = TRUE;
			*run_value = (pbi->bit_pattern & 0x000F) + 18;                             
		}
		break; 

    case 18:
		ret_val = TRUE;
		*run_value = (pbi->bit_pattern & 0x0FFF) + 34;                             
		break; 

    default:
    	ret_val = FALSE;
		break;
	}

    return ret_val;
}

/****************************************************************************
 * 
 *  ROUTINE       :     FrArrayDeCodeBlockRun
 *
 *  INPUTS        :     UINT8 bit_value
 *
 *  OUTPUTS       :     UINT8 run_value
 *
 *  RETURNS       :     TRUE when a value has been fully decoded.
 *
 *  FUNCTION      :     Decodes a block run value
 *
 *  SPECIAL NOTES :     None. 
 *
 *
 *  ERRORS        :     None.
 *
 ****************************************************************************/
BOOL FrArrayDeCodeBlockRun(  PB_INSTANCE *pbi, UINT32 bit_value, INT32 * run_value )
{
    BOOL ret_val = FALSE;

    // Add in the new bit value.
    pbi->bits_so_far++;
    pbi->bit_pattern = (pbi->bit_pattern << 1) + (bit_value & 1);
        
    // Coding scheme:
	//	Codeword				RunLength
	//	0x						1-2
	//	10x						3-4
	//	110x					5-6
	//	1110xx					7-10
	//	11110xx					11-14
	//	11111xxxx				15-30 	

	switch ( pbi->bits_so_far )
	{
	case 2: 
        // If bit 1 is clear
		if ( !(pbi->bit_pattern & 0x0002) )
		{
			ret_val = TRUE;
			*run_value = (pbi->bit_pattern & 0x0001) + 1;
		}           
		break;      

	case 3:  
        // If bit 1 is clear
		if ( !(pbi->bit_pattern & 0x0002) )
		{
			ret_val = TRUE;
			*run_value = (pbi->bit_pattern & 0x0001) + 3;
		}           
		break;      
            
	case 4:
        // If bit 1 is clear
		if ( !(pbi->bit_pattern & 0x0002) )
		{
			ret_val = TRUE;
			*run_value = (pbi->bit_pattern & 0x0001) + 5;
		}           
		break;      
             
	case 6:
        // If bit 2 is clear
		if ( !(pbi->bit_pattern & 0x0004) )
		{
			ret_val = TRUE;
			*run_value = (pbi->bit_pattern & 0x0003) + 7;
		}           
		break;      
        
	case 7:
        // If bit 2 is clear
		if ( !(pbi->bit_pattern & 0x0004) )
		{
			ret_val = TRUE;
			*run_value = (pbi->bit_pattern & 0x0003) + 11;
		}           
		break;      
           
	case 9:
		ret_val = TRUE;
		*run_value = (pbi->bit_pattern & 0x000F) + 15;
		break;      
	}

    return ret_val;
}

/****************************************************************************
 * 
 *  ROUTINE       :     FrArrayUnpackMode
 *
 *  INPUTS        :     None
 *
 *  OUTPUTS       :     None
 *
 *  RETURNS       :     A decoded mode token
 *
 *  FUNCTION      :     Unpacks a mode token
 *
 *  SPECIAL NOTES :     None. 
 *
 *
 *  ERRORS        :     None.
 *
 ****************************************************************************/
CODING_MODE FrArrayUnpackMode(PB_INSTANCE *pbi)
{
    // Coding scheme:
	//	Token                       Codeword	    Bits
	//	Entry   0 (most frequent)   0               1
	//	Entry   1       	        10 			    2
	//	Entry   2       	        110 		    3
	//	Entry   3       	        1110 		    4
	//	Entry   4       	        11110 		    5
	//	Entry   5       	        111110 	        6
	//	Entry   6       	        1111110 	    7
	//	Entry   7       	        1111111 	    7

    // Initialise the decoding.
    pbi->bit_pattern = 0;
    pbi->bits_so_far = 0; 

	pbi->bit_pattern = bitread1(&pbi->br);

    // Do we have a match 
    if ( pbi->bit_pattern == 0 )
		return (CODING_MODE)0;

    // Get the next bit
	pbi->bit_pattern = (pbi->bit_pattern << 1) | bitread1(&pbi->br);

    // Do we have a match 
    if ( pbi->bit_pattern == 0x0002 )
		return (CODING_MODE)1;

	pbi->bit_pattern = (pbi->bit_pattern << 1) | bitread1(&pbi->br);

    // Do we have a match 
    if ( pbi->bit_pattern == 0x0006 )
		return (CODING_MODE)2;

	pbi->bit_pattern = (pbi->bit_pattern << 1) | bitread1(&pbi->br);

    // Do we have a match 
    if ( pbi->bit_pattern == 0x000E )
		return (CODING_MODE)3;

	pbi->bit_pattern = (pbi->bit_pattern << 1) | bitread1(&pbi->br);

    // Do we have a match 
    if ( pbi->bit_pattern == 0x001E )
		return (CODING_MODE)4;

	pbi->bit_pattern = (pbi->bit_pattern << 1) | bitread1(&pbi->br);

    // Do we have a match 
    if ( pbi->bit_pattern == 0x003E )
		return (CODING_MODE)5;

	pbi->bit_pattern = (pbi->bit_pattern << 1) | bitread1(&pbi->br);

    // Do we have a match 
    if ( pbi->bit_pattern == 0x007E )
		return (CODING_MODE)6;
    else
		return (CODING_MODE)7;
}

/****************************************************************************
 * 
 *  ROUTINE       :     GetNextBInitSb
 *
 *  INPUTS        :     None. 
 *                      
 *  OUTPUTS       :     None.
 *
 *  RETURNS       :     None
 *
 *  FUNCTION      :     Initialises decode process for a Block RLC stream.
 *
 *  SPECIAL NOTES :     None. 
 *
 *
 *  ERRORS        :     None.
 *
 ****************************************************************************/
void GetNextBInit(PB_INSTANCE *pbi)
{
	pbi->NextBit = bitread1(&pbi->br);

	// Read run length
	FrArrayDeCodeInit(pbi);               
	while ( FrArrayDeCodeBlockRun( pbi, bitread1(&pbi->br), &pbi->BitsLeft ) == FALSE );
}

/****************************************************************************
 * 
 *  ROUTINE       :     GetNextSbBit
 *
 *  INPUTS        :     None. 
 *                      
 *  OUTPUTS       :     None.
 *
 *  RETURNS       :     Value of next bit in stream.
 *
 *  FUNCTION      :     Returns next available bit value from  a Block RLC stream.
 *
 *  SPECIAL NOTES :     None. 
 *
 *
 *  ERRORS        :     None.
 *
 ****************************************************************************/
UINT8 GetNextBBit (PB_INSTANCE *pbi)
{
	if ( !pbi->BitsLeft )
	{
		// Toggle the value.  
		pbi->NextBit = ( pbi->NextBit == 1 ) ? 0 : 1;

        // Read next run
		FrArrayDeCodeInit(pbi);
    	while ( FrArrayDeCodeBlockRun( pbi,bitread1(&pbi->br), &pbi->BitsLeft ) == FALSE );
	}

	// Have  read a bit
	pbi->BitsLeft--;
	
	// Return next bit value
	return pbi->NextBit;
}

/****************************************************************************
 * 
 *  ROUTINE       :     GetNextSbInitSb
 *
 *  INPUTS        :     None. 
 *                      
 *  OUTPUTS       :     None.
 *
 *  RETURNS       :     None
 *
 *  FUNCTION      :     Initialises decode process for an SB RLC stream.
 *
 *  SPECIAL NOTES :     None. 
 *
 *
 *  ERRORS        :     None.
 *
 ****************************************************************************/
void GetNextSbInit(PB_INSTANCE *pbi)
{
	pbi->NextBit = bitread1(&pbi->br);

	// Read run length
	FrArrayDeCodeInit(pbi);               
	while ( FrArrayDeCodeSBRun( pbi,bitread1(&pbi->br), &pbi->BitsLeft ) == FALSE );
}

/****************************************************************************
 * 
 *  ROUTINE       :     GetNextSbBit
 *
 *  INPUTS        :     None. 
 *                      
 *  OUTPUTS       :     None.
 *
 *  RETURNS       :     Value of next bit in stream.
 *
 *  FUNCTION      :     Returns next available bit value from an SB RLC stream.
 *
 *  SPECIAL NOTES :     None. 
 *
 *
 *  ERRORS        :     None.
 *
 ****************************************************************************/
UINT8 GetNextSbBit (PB_INSTANCE *pbi)
{
	if ( !pbi->BitsLeft )
	{
		// Toggle the value.  
		pbi->NextBit = ( pbi->NextBit == 1 ) ? 0 : 1;

        // Read next run
		FrArrayDeCodeInit(pbi);               
    	while ( FrArrayDeCodeSBRun( pbi, bitread1(&pbi->br), &pbi->BitsLeft ) == FALSE );
	}

	// Have  read a bit
	pbi->BitsLeft--;
	
	// Return next bit value
	return pbi->NextBit;
}

/****************************************************************************
 * 
 *  ROUTINE       :     GetNextMbInitSb
 *
 *  INPUTS        :     None. 
 *                      
 *  OUTPUTS       :     None.
 *
 *  RETURNS       :     None
 *
 *  FUNCTION      :     Initialises decode process for a MB RLC stream.
 *
 *  SPECIAL NOTES :     None. 
 *
 *
 *  ERRORS        :     None.
 *
 ****************************************************************************/
void GetNextMbInit(PB_INSTANCE *pbi)
{
	pbi->NextBit = bitread1(&pbi->br);
	pbi->BitsLeft = 0;

	// Read run length
	FrArrayDeCodeInit(pbi);               
	while ( FrArrayDeCodeMBRun( pbi,bitread1(&pbi->br), &pbi->BitsLeft ) == FALSE );
}

/****************************************************************************
 * 
 *  ROUTINE       :     GetNextSbBit
 *
 *  INPUTS        :     None. 
 *                      
 *  OUTPUTS       :     None.
 *
 *  RETURNS       :     Value of next bit in stream.
 *
 *  FUNCTION      :     Returns next available bit value from a MB RLC stream.
 *
 *  SPECIAL NOTES :     None. 
 *
 *
 *  ERRORS        :     None.
 *
 ****************************************************************************/
UINT8 GetNextMbBit (PB_INSTANCE *pbi)
{
	if ( !pbi->BitsLeft )
	{
		// Toggle the value.  
		pbi->NextBit = ( pbi->NextBit == 1 ) ? 0 : 1;

        // Read next run
		FrArrayDeCodeInit(pbi);       
    	while ( FrArrayDeCodeMBRun( pbi, bitread1(&pbi->br), &pbi->BitsLeft ) == FALSE );
	}

	// Decrement bits left in run counter
	pbi->BitsLeft--;
	
	// Return next bit value
	return pbi->NextBit;
}


/****************************************************************************
 * 
 *  ROUTINE       :     ReadBlockPatternInit
 *
 *  INPUTS        :     None. 
 *                      
 *  OUTPUTS       :     None.
 *
 *  RETURNS       :     None
 *
 *  FUNCTION      :     Initialises the block pattern reader
 *
 *  SPECIAL NOTES :     None. 
 *
 *
 *  ERRORS        :     None.
 *
 ****************************************************************************/
void ReadBlockPatternInit (PB_INSTANCE *pbi)
{
	pbi->BlockPatternPredictor = 0;
}

/****************************************************************************
 * 
 *  ROUTINE       :     ReadNextBlockPattern
 *
 *  INPUTS        :     None. 
 *                      
 *  OUTPUTS       :     None.
 *
 *  RETURNS       :     A pattern of coded or uncoded blocks for a macro block.
 *
 *  FUNCTION      :     Returns the block pattern for the next macro block.
 *
 *  SPECIAL NOTES :     None. 
 *
 *
 *  ERRORS        :     None.
 *
 ****************************************************************************/
UINT8 ReadNextBlockPattern (PB_INSTANCE *pbi)
{
	UINT8 BlockPattern = 0;
	UINT8 Bitpattern = 0;
	UINT32 BitCount = 3;

	// Read three bits and test to see if we have a valid token.
	Bitpattern = bitread(&pbi->br, 3);

	// Test pattern to see if is a valid token.
	BlockPattern = BlockDecode1[pbi->BlockPatternPredictor][Bitpattern];

	// if pattern was not a valid token
	if ( !BlockPattern )
	{
		BitCount++;
		Bitpattern = (Bitpattern << 1) + bitread1(&pbi->br);

		// Test pattern to see if is a valid token.
		BlockPattern = BlockDecode2[pbi->BlockPatternPredictor][Bitpattern];

		if ( !BlockPattern )
		{
			BitCount++;
			Bitpattern = (Bitpattern << 1) + bitread1(&pbi->br);
			BlockPattern = BlockDecode3[pbi->BlockPatternPredictor][Bitpattern];
		}
	}

	// Update the entropy predictor for next time.
	pbi->BlockPatternPredictor = BPPredictor[BlockPattern];

	return BlockPattern;
}