hpel_16x16.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_16x16_16_RND;

__hpel_16x16_16_RND:

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

    I0 = R0;                // Address of pRef match   
    I1 = R0;                // Address of pRef match
    P0 = [SP + 64];         //address of MBy_match
    I3 = P0;                //address of MBy_match 
    P2 = 16 (Z);
    R1 = P3;                 // WINWIDTH
    R1 += -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++] || R2  =[I1++]; 
        R6 = BYTEOP1P(R1:0,R3:2)(R) || [I3++] = R6 || R1 = [I0++];
        DISALGNEXCPT  || [I3++] = R6 || 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];               
STORE_BEST_END:
        DISALGNEXCPT || R0 = [I0++]|| 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 += -17;
    M1 = R2;
    P2 = 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++M0];
        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;
    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;                 //add by BXD
    CALL _compute_sad;
    CC = R0 < R5;
    IF CC R5 = R0;
    IF CC R4 = R7;
    R1 = 1(Z);
    IF CC R6 = R1;
    
    R7.H = 1;               // (V,H) -> R7.H = 1, R7.L = 1
    R0 = P4;
    R1 = SP;
    R1 += 21;               //add by BXD
    CALL _compute_sad;
    CC = R0 < R5;
    IF CC R5 = R0;
    IF CC R4 = R7;
    R1 = 21(Z);
    IF CC R6 = R1;
    
    R7.L = -1;              // (V,H) -> R7.H = 1, R7.L = -1
    R0 = P4;
    R1 = SP;
    R1 += 20;
    CALL _compute_sad;
    CC = R0 < R5;
    IF CC R5 = R0;
    IF CC R4 = R7;
    R1 = 20(Z);
    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 MBy_match 
    P2 = 16 (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 || R1 = [I0++];
        DISALGNEXCPT  || [I3++] = R6 || 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++] = 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 = 16 (Z);
    R1 = P3;                // WINWIDTH
    R1 += -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++];
        DISALGNEXCPT  || [I3++] = R6 || 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;//add by BXD
    CALL _compute_sad;
    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;
    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 = 16 (Z);
    CC = R4==R7;
    
    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++];
    [I3++]=R0||R0 = [I0++];
    [I3++]=R0||R0 = [I0 ++ M1];
STORE_BEST_END1_ALIGN:    
	[I3++]=R0||R0 = [I0++];
	
	JUMP STORE_BYPASS1;
/*
STORE_DISALIGN:	   // (V,H)=(0,1)
    I0+=2;
    LSETUP(STORE_BEST_ST1,STORE_BEST_END1) LC0 = P2;
    DISALGNEXCPT || R0 = [I0++];
    DISALGNEXCPT || R1 = [I0++];
STORE_BEST_ST1:
		R6 = ALIGN8(R1,R0) || R0 = [I0++];
		R6 = ALIGN8(R0,R1) || [I3++] = R6 || R1 = [I0++];		
        R6 = ALIGN8(R1,R0) || [I3++] = R6 || R0  =[I0++]; 
        R6 = ALIGN8(R0,R1) || [I3++] = R6 || R0 = [I0++];                
		
STORE_BEST_END1:		
		DISALGNEXCPT || [I3++] = R6 || R1 = [I0++];
		*/
		
	
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 MBy_match 
    P2 = 16 (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 || R1 = [I0++];
        DISALGNEXCPT  || [I3++] = R6 || 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++] = 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 = 17;
    R1 += -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++] || R2  =[I1++]; 
        R6 = BYTEOP1P(R1:0,R3:2)(R) || [I3++] = R6 || R1 = [I0++];
        DISALGNEXCPT  || [I3++] = R6 || 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;
    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 += 16;               //modify by BXD
    CALL _compute_sad_aligned;
    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 = 16(Z);      //modify by BXD
    CC = R4==R7; 
    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 = 16 (Z);    
    
    LSETUP(STORE_BEST_ST2,STORE_BEST_END2) LC0 = P2;
    R0 = [I0++];
STORE_BEST_ST2:
    [I3++]=R0||R0 = [I0++];
    [I3++]=R0||R0 = [I0++];
    [I3++]=R0||R0 = [I0++];
STORE_BEST_END2:    
	[I3++]=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_16x16_16_RND.end: