hpel_8x8_16.asm

adi bf533视频编码程序

/*******************************************************************************
Copyright(c) 2000 - 2002 Analog Devices. All Rights Reserved.
Developed by Joint Development Software Application Team, IPDC, Bangalore, India
for Blackfin DSPs  ( Micro Signal Architecture 1.0 specification).

By using this module you agree to the terms of the Analog Devices License
Agreement for DSP Software. 
********************************************************************************
Module Name     : hpel.asm
Label Name      : __hpel
Version         :   1.0
Change History  :

                Version     Date          Author            Comments
                1.0         04/12/2001    Vijay             Original 

Description     : This routine does the half pixel computation for the motion 
                  estimation.

Assumption      : The routine assumes that WINWIDTH is a multiple of 4.

Prototype       : int _hpel(unsigned char *best_match, int min_SAD, 
                            unsigned char *target, int WINWIDTH);

                    best_match -> Address of the best matching reference block
                    min_SAD    -> The minimum SAD corresponding to the best 
                                  matching block.
                    target     -> Address of the target macro block (16x16)
                    WINWIDTH   -> Width of the reference window (WINWIDTH)

                    The output is the half pel positions which are returned to 
                    the calling routine

Registers used  : A0, A1, R0-R7, I0-I3, M0, M1, M3, L0-L3, P0, P2-P5, LC0.

Performance:
            Code size                       :  768 bytes
            Cycle count for half pixelation : 1695 cycles
*******************************************************************************/

// Half pixel computation
///////////////////////////////ROUNDING TYPE ==0 //////////////////////////////////
.section L1_code;
.align 8;
.global __hpel_8x8_16_RND;

__hpel_8x8_16_RND:

    [--SP] = (R7:4, P5:3);
    [--SP] = RETS;
    L0 = 0;
    L1 = 0;
    L2 = 0;
    L3 = 0;
    P5 = R0;                // Address of the best matching block
    R5 = R1;                // SAD corresponding to the best match
    P4 = R2;                // Address of the target block
    P3 = [SP + 44];         // Width of the reference window
    
    
/********************store the best matching block**********************/

    I0 = R0;                 // Address of best match   
    I1 = R0;                 // Address of best match
    P0 = [SP + 64];          //address of MBy_match
    I3 = P0;                 //address of MBy_match 
    M3 = 12(Z);
    P2 = 8 (Z);              //16
    R1 = P3;                 // WINWIDTH
    R1 += -8;               //-20
    M1 = R1;                //M1的值再定一下

    LSETUP(STORE_BEST_ST,STORE_BEST_END) LC0 = P2;
    DISALGNEXCPT || R0 = [I0++] || R2 = [I1++];
STORE_BEST_ST:
        DISALGNEXCPT || R1 = [I0++] || R3  =[I1++]; 
        R6 = BYTEOP1P(R1:0,R3:2) || R0 = [I0++M1] || R2  =[I1++M1]; 
        R6 = BYTEOP1P(R1:0,R3:2)(R) || [I3++] = R6 || R0 = [I0++];
STORE_BEST_END:       
		DISALGNEXCPT  || [I3++M3] = R6 || R2  =[I1++]; 
                                      
/************************************************************************/
    
    
    P0 = 344;
    SP -= P0;
    I3 = SP;                // Temporary buffer in stack
    R4 = 0;
/******************** INTERPOLATE DIAGONAL BLOCKS ********************/
    M0 = 7;
    M3 = -3 (X);
    R0 = P5;                // Address of the best match
    R0 += -1;
    I0 = R0;
    I1 = R0;
    R2 = P3;                // WINWIDTH
    R1 = R0 - R2 (S);
    I2 = R1;                // Address of best match - (WINWIDTH+1)
    R2 += -9;        //-17
    M1 = R2;
    P2 = 9;   //17

    LSETUP(AVG4_ST, AVG4_END) LC0 = P2;
    DISALGNEXCPT || R0 = [I1++] || R2 = [I2++];
    DISALGNEXCPT || R1 = [I1++M3] || R3 = [I2++M3];
    R7 = BYTEOP2P(R1:0,R3:2) (RNDL) || R0 = [I1++M0];
AVG4_ST:    
        DISALGNEXCPT || I0 += M3 || R2 = [I2++M0];
        R6 = BYTEOP2P(R1:0,R3:2) (RNDH) || R0 = [I1++M3] || R2 = [I2++M3];
        R7 = R6 + R7 (NS) || I0 -= M3;
    
        R7 = BYTEOP2P(R1:0,R3:2) (RNDL, R) || [I3++] = R7 || R1 = [I1++M0];
        DISALGNEXCPT || I0 += M3 || R3 = [I2++M0];
        R6 = BYTEOP2P(R1:0,R3:2) (RNDH, R) || R1 = [I1++M3] || R3 = [I2++M3];
        R7 = R6 + R7 (NS) || I0 -= M3;
    
        R7 = BYTEOP2P(R1:0,R3:2) (RNDL) || [I3++] = R7 || R0 = [I1++M1];
        DISALGNEXCPT || I0 += M3 || R2 = [I2++M1];
        R6 = BYTEOP2P(R1:0,R3:2) (RNDH) || R0 = [I1++] || R2 = [I2++];
        R7 = R6 + R7 (NS) || I0 -= M3;
                   
        DISALGNEXCPT || R1 = [I1++M3] || R3 = [I2++M3];
AVG4_END:
        R7 = BYTEOP2P(R1:0,R3:2) (RNDL) || [I3++] = R7 || R0 = [I1++M0];       
    
/**************** CALCULATE SAD FOR DIAGONAL BLOCKS *******************/
	R6=0(Z);                   //the offset from SP
    R7 = -1;                // (V,H) -> R7.H = -1, R7.L = -1
    R0 = P4;
    R1 = SP;
    CALL _compute_sad_8x8_16;
    CC = R0 < R5;
    IF CC R5 = R0;
    IF CC R4 = R7;
    
    R7.L = 1;               // (V,H) -> R7.H = -1, R7.L = 1
    R0 = P4;
    R1 = SP;
    R1 += 1;             //modify by BXD
    CALL _compute_sad_8x8_16;
    CC = R0 < R5;
    IF CC R5 = R0;
    IF CC R4 = R7;
    R1 = 1(Z);        //modify by BXD
    IF CC R6 = R1;
    
    R7.H = 1;               // (V,H) -> R7.H = 1, R7.L = 1
    R0 = P4;
    R1 = SP;
    R1 += 13;           ///modify by BXD
    CALL _compute_sad_8x8_16;
    CC = R0 < R5;
    IF CC R5 = R0;
    IF CC R4 = R7;
    R1 = 13(Z);         //13
    IF CC R6 = R1;
    
    R7.L = -1;              // (V,H) -> R7.H = 1, R7.L = -1
    R0 = P4;
    R1 = SP;
    R1 += 12;           //20
    CALL _compute_sad_8x8_16;
    CC = R0 < R5;
    IF CC R5 = R0;
    IF CC R4 = R7;
    R1 = 12(Z);         //12
    IF CC R6 = R1;
    
    CC = R4==0;
    IF CC JUMP STORE_BYPASS0; 
    //if half pel match better, store the interpolated block
 /********************store the best matching block**********************/
	R0 = SP;
	R0 = R0 + R6;
    I0 = R0;                // Address of half pel best match   
    I1 = R0;                
    P0 = [SP + 408];         //address of MBy_match :SP + 344 + 64
    I3 = P0;                 //address of the 8x8 block in MBy_match 
    P2 = 8 (Z);      //16
    M3 = 12(Z);
    
    LSETUP(STORE_BEST_ST0,STORE_BEST_END0) LC0 = P2;
    DISALGNEXCPT || R0 = [I0++] || R2 = [I1++];
STORE_BEST_ST0:
        DISALGNEXCPT || R1 = [I0++] || R3  =[I1++]; 
        R6 = BYTEOP1P(R1:0,R3:2) || R0 = [I0++] || R2  =[I1++]; 
        R6 = BYTEOP1P(R1:0,R3:2)(R) || [I3++] = R6 || R0 = [I0++];
       
STORE_BEST_END0:       
		DISALGNEXCPT || [I3++M3] = R6 || R2  =[I1++];               

/************************************************************************/
   
STORE_BYPASS0:    
/******************** INTERPOLATE LEFT/RIGHT BLOCKS ********************/
    R0 = P5;                // Address of the best match
    I0 = R0;                // Address of best match
    R0 += -1;
    I1 = R0;                // Address of best match - 1
    I3 = SP;                // Output buffer
    P2 = 8 (Z);             //16
    R1 = P3;                // WINWIDTH
    R1 += -12;                //20
    M1 = R1;
    MNOP;

    LSETUP(AVG2_LR_ST, AVG2_LR_END) LC0 = P2;
    DISALGNEXCPT || R0 = [I0++] || R2 = [I1++];
AVG2_LR_ST:
        DISALGNEXCPT || R1 = [I0++] || R3  =[I1++]; 
        R6 = BYTEOP1P(R1:0,R3:2) || R0 = [I0++] || R2  =[I1++]; 
        R6 = BYTEOP1P(R1:0,R3:2)(R) || [I3++] = R6 || R1 = [I0++M1];
        DISALGNEXCPT  || [I3++] = R6 || R3  =[I1++M1];                          
        R6 = BYTEOP1P(R1:0,R3:2) || R0 = [I0++];
AVG2_LR_END:
        DISALGNEXCPT || [I3++] = R6 || R2  =[I1++];
    
/**************** CALCULATE SAD FOR LEFT/RIGHT BLOCKS *******************/
    P2 = R4;                //backup R4
	R7 = 1;                 // (V,H) -> R7.H = 0, R7.L = 1
    R0 = P4;
    R1 = SP;
    R1 += 1;
    CALL _compute_sad_8x8_16;
    CC = R0 < R5;
    IF CC R5 = R0;
    IF CC R4 = R7;
    
    R7.L = -1;              // (V,H) -> R7.H = 0, R7.L = -1
    R0 = P4;
    R1 = SP;
    CALL _compute_sad_8x8_16;
    CC = R0 < R5;
    IF CC R5 = R0;
    IF CC R4 = R7;
    
    R3 = P2;
    CC = R4==R3;         //R4 has been modified?
    IF CC JUMP STORE_BYPASS1;
 
    //if half pel match better, store the 
/********************store the best matching block**********************/
	R0 = SP;
    I0 = R0;                // Address of half pel interpolated block                
    P0 = [SP + 408];         //address of MBy_match :SP + 344 + 64
    I3 = P0;                //address of MBy_match 
    P2 = 8 (Z);            //16
    CC = R4==R7;
    M3 = 12(Z);
    
    IF !CC JUMP STORE_DISALIGN;

    LSETUP(STORE_BEST_ST1_ALIGN,STORE_BEST_END1_ALIGN) LC0 = P2;
    M1 = 8(Z);
    R0 = [I0++];
STORE_BEST_ST1_ALIGN: // (V,H)=(0,-1)
    
    [I3++]=R0||R0 = [I0 ++ M1];
STORE_BEST_END1_ALIGN:    
	[I3++M3]=R0||R0 = [I0++];
	
	JUMP STORE_BYPASS1;
/////////////////////////////////////////////////////	
STORE_DISALIGN:	   // (V,H)=(0,1)

    R0 = SP;
	R0 += 1; 
    I0 = R0;                // Address of half pel best match   
    I1 = R0;                
    P0 = [SP + 408];         //address of MBy_match :SP + 344 + 64
    I3 = P0;                 //address of the 8x8 block in MBy_match 
    P2 = 8 (Z);              //16
    M3 = 12(Z);
    
    LSETUP(STORE_BEST_ST1,STORE_BEST_END1) LC0 = P2;
    DISALGNEXCPT || R0 = [I0++] || R2 = [I1++];
STORE_BEST_ST1:
        DISALGNEXCPT || R1 = [I0++] || R3  =[I1++]; 
        R6 = BYTEOP1P(R1:0,R3:2) || R0 = [I0++] || R2  =[I1++]; 
        R6 = BYTEOP1P(R1:0,R3:2)(R) || [I3++] = R6 || R0 = [I0++];
     
STORE_BEST_END1:       
		DISALGNEXCPT || [I3++M3] = R6 || R2  =[I1++];
		
		
		
				
							
    
STORE_BYPASS1:   
/******************** INTERPOLATE TOP/BOTTOM BLOCKS ********************/
    R1 = P3;                // WINWIDTH
    R0 = P5;                // Address of the best match
    I0 = R0;                // Address of best match
    R0 = R0 - R1(S) || NOP;
    I1 = R0;                // Address of best match - WINWIDTH
    I3 = SP;                // Output buffer
    P2 = 9;                 //17
    R1 += -8;               //16
    M1 = R1;

    LSETUP(AVG2_TB_ST, AVG2_TB_END) LC0 = P2;
    DISALGNEXCPT || R0 = [I0++] || R2 = [I1++];
AVG2_TB_ST:
        DISALGNEXCPT || R1 = [I0++] || R3  =[I1++]; 
        R6 = BYTEOP1P(R1:0,R3:2) || R0 = [I0++M1] || R2  =[I1++M1]; 
        R6 = BYTEOP1P(R1:0,R3:2)(R) || [I3++] = R6 || R0 = [I0++];
      
AVG2_TB_END:
        DISALGNEXCPT || [I3++] = R6 || R2  = [I1++];             
    
/**************** CALCULATE SAD FOR TOP/BOTTOM BLOCKS *******************/
    
	P2 = R4;                //backup R4
	R7.H = -1;              // (V,H) -> R7.H = -1, R7.L = 0
    R7.L = 0;
    R0 = P4;
    R1 = SP;
    CALL _compute_sad_aligned_8x8_16;
    CC = R0 < R5;
    IF CC R5 = R0;
    IF CC R4 = R7;
    
    R7.H = 1;               // (V,H) -> R7.H = 1, R7.L = 0
    R0 = P4;
    R1 = SP;
    R1 += 8;      //16
    CALL _compute_sad_aligned_8x8_16;
    CC = R0 < R5;
    IF CC R5 = R0;
    IF CC R4 = R7;
 
/********************store the best matching block**********************/   
    R3 = P2;
    CC = R4==R3;
    IF CC JUMP STORE_BYPASS2;
    
    R0 = 0(Z);
    R1 = 8(Z);          //16
    CC = R4==R7; //modify by BXD
    IF !CC R1=R0;
    R0 = SP;
    R0 = R0+R1;          // Address of half pel best match
    I0 = R0;
    P0 = [SP + 408];         //address of MBy_match :SP + 344 + 64
    I3 = P0;                //address of MBy_match     
    P2 = 8(Z);       //16 
    M3 = 12(Z);
    
    LSETUP(STORE_BEST_ST2,STORE_BEST_END2) LC0 = P2;
    R0 = [I0++];
STORE_BEST_ST2:
    [I3++]=R0||R0 = [I0++];
    
STORE_BEST_END2:    
	[I3++M3]=R0||R0 = [I0++];
		 
    
STORE_BYPASS2:    
/********************************************************************/
    R0 = R4;                // Return horizontal and vertical half pel
    P0 = 344;
    SP = SP + P0;
    [SP + 48] = R5;        //store SAD corresponding to the best match
    RETS = [SP++];
    (R7:4, P5:3) = [SP++];
__hpel_8x8_16_RND.end:
    RTS;
    

//////////////////////ROUND TYPE ==1 /////////////////////////////////////

/*
.section L1_code;
.align 8;
.global __hpel_8x8_16_T;

__hpel_8x8_16_T:

    [--SP] = (R7:4, P5:3);