dequantz.s

关于DVD的MPEG2用的DSP代码,在DSP的实现MPEG的压缩,解压算法.

;************************************************************************
; (c)1996-1997 Copyright M-Pact, Inc. All rights reserved
;
; Revision 1.0
;
;	
;
;	Module: SUB_I_dequantize_sample
;		SUB_II_dequantize_sample
;
;	Initial version:Jinshi Huang 2/19/97
;
;	Calling	:     	none
;	Called by:	Main
;	Return:		r26, fraction
;	Param in:     	sample, bit_alloc
;	Temp reg:	
;	AGR  reg:	
;	Local buffer:
;************************************************************************
	.nolist
#include "regdef.h"
#include "memory.h"
#include "constant.h"
#include "user.h"
	.list

	
	.text
	
 	.global	SUB_I_dequantize_sample
	.global	SUB_II_dequantize_sample

;***********************************************************************

SUB_I_dequantize_sample:

	.if	DB_DEQ_SAMP

	movi	r10,local_sample_byte
	rswi	r10,0x500	// begining of dump addr
	movi	r10,local_sample_byte+(2*3*32)*4
	rswi	r10,0x504	// end of dump addr
	movi	r10,1
	rswi	r10,0x508	// start dumping
	
	.endif

	.if	DB_DEQ_BIT

	movi	r10,local_bit_alloc_byte
	rswi	r10,0x500	// begining of dump addr
	movi	r10,local_bit_alloc_byte+(2*32)*4
	rswi	r10,0x504	// end of dump addr
	movi	r10,1
	rswi	r10,0x508	// start dumping
	
	.endif
	
	.if	DB_SCALE_INDEX

	movi	r10,local_scale_index_byte
	rswi	r10,0x500	// begining of dump addr
	movi	r10,local_scale_index_byte+(2*3*32)*4
	rswi	r10,0x504	// end of dump addr
	movi	r10,1
	rswi	r10,0x508	// start dumping
	
	.endif

	movi	AGRMod0, 0		
	movi	AGRSiz0, 0xffff		;linear addressing

	movb	r10,  LBfr_ps_stereo 
	movb	r11,  LBfr_ps_sblimit

	mupi	r20, 0xffff
	ori	r20, 0xffff		;-1.0	
//	movi	AGRAdr0, local_fraction_byte
	movi	r13, 0			;loop count
	
        CLR_TrapReg
	loop	r10, loop_I_dequantize	;for (k=0, ...
 
	multi	r15, r13, SBLIMIT*3*4	;sample[2][3][SBLIMIT] (word) 
	multi	r16, r13, SBLIMIT*3*4	;scale_index[2][3][SBLIMIT] (word) 
	multi	r14, r13, SBLIMIT*4	;bit_alloc[2][SBLIMIT] (word)

	addi	r1, r15, local_fraction_byte
	mov	AGRAdr0, r1
	
	loop	SBLIMIT, inner_loop_I_dequantize	; for (i=0, ...
	addi	r2, r14, local_bit_alloc_byte
	nop				;pipeline
	movb	r9, l2			;r9=bit_alloc[k][i]=nb-1
	tsti	r9, 0
	beq	set_fraction_to_zero
	
	addi	r2, r15, local_sample_byte	
	movi	r6, 0			;pipeline. init fraction=0.0
	movh	r8, l2			;r8=sample[k][0][i]
	shrv	r1, r8, r9		;sample[k][0][i]>>nb-1
        andi    r1, 1                   //(sample[k][0][i] >> nb-1) & 1
	tsti	r1, 1
	bnz	init_fraction_done
	mov	r6, r20			;init fraction=-1.0
init_fraction_done:
	shlv	r1, r6, r9		;fraction*(1<<nb-1)
	movi	r2, 1
	shlv	r2, r9
	subi	r2, 1			;(1<<nb-1)-1
	and	r2, r8			;sample & ..
	subi	r3, r9, 1		;nb-2
	shl	r3, 3			;word to byte addr. 2 words each
	addi	r3, local_FAnb_table_byte	;table starts with nb=2
	add	r2, r1			;pipeline
	movw	r1, l3			//MSW of table
	addi	r2, 1			;pipeline
	mulf	r4, r2, r1		;int*float. result in LSW
	addi	r3, 1*4			//pipeline
	movw	r1, l3			//LSW of table
        nop
	shl	r4, 23			//MSBs
	or	r0, r4, r5		//prefix to 23 LSBs
	mulf	r4, r2, r1
	nop	
	nop
        nop                        //pipeline
//	shl	r4, 1		//compensate for the *1/2 in LSW coeff
	add	r5, r4, r0	//append to MSW	
	j	save_fraction	

set_fraction_to_zero:
	movi	r5, 0
save_fraction:
	addi	r2, r16, local_scale_index_byte
	nop				//pipeline
	movb	r3, l2
//	nop
	shl	r2, r3, 2			//word to byte
	addi	r2, local_multiple_byte
	mov	AGRAdr1, r2
//	movw	r3, l2
	nop
//	mulf	r0, r5, r3
//	nop	
//	nop				//pipeline
//	shl	r0, 1			//compensate for 1/2 scale in table
//	nop				//pipeline
//	nop
	mulf	r0, r5, a1(0)
	madd	r0, r5, a1(0)		//compensate for 1/2 scale in table
	nop
	rnd	a0(1*4), r0		//saturate if any
inc_inner_loop_count:
	addi	r14, 4			//inc 1 word
	addi	r15, 4			//inc 1 word
	addi	r16, 4			//inc 1 word
inner_loop_I_dequantize:
	addi	r13, 1
loop_I_dequantize:		
        SET_TrapReg


	.if	DB_DEQ_OUT

	movi	r10,local_fraction_byte
	rswi	r10,0x500	// begining of dump addr
	movi	r10,local_fraction_byte+(2*3*32)*4
	rswi	r10,0x504	// end of dump addr
	movi	r10,1
	rswi	r10,0x508	// start dumping
	
	.endif
	
	j	r26
	


;***********************************************************************
// r22=x=i>>2
	
SUB_II_dequantize_sample:

	.if	DB_DEQ_SAMP

	movi	r10,local_sample_byte
	rswi	r10,0x500	// begining of dump addr
	movi	r10,local_sample_byte+(2*3*32)*4
	rswi	r10,0x504	// end of dump addr
	movi	r10,1
	rswi	r10,0x508	// start dumping
	
	.endif

	.if	DB_DEQ_BIT

	movi	r10,local_bit_alloc_byte
	rswi	r10,0x500	// begining of dump addr
	movi	r10,local_bit_alloc_byte+(2*32)*4
	rswi	r10,0x504	// end of dump addr
	movi	r10,1
	rswi	r10,0x508	// start dumping
	
	.endif
	
	.if	DB_SCALE_INDEX

	movi	r10,local_scale_index_byte
	rswi	r10,0x500	// begining of dump addr
	movi	r10,local_scale_index_byte+(2*3*32)*4
	rswi	r10,0x504	// end of dump addr
	movi	r10,1
	rswi	r10,0x508	// start dumping
	
	.endif

	movi	AGRMod0, 0		
	movi	AGRSiz0, 0xffff		;linear addressing
	movi	AGRSiz1, 0xffff		;linear addressing

	movb	r10, LBfr_ps_stereo
	movb	r11, LBfr_ps_sblimit
	
	mupi	r20, 0xff80
	ori	r20, 0x0000		;-1.0
	movi	r21, SBLIMIT
	
	movi	r13, 0			;loop count (outer)
//	movi	r14, local_bit_alloc_byte
	movi	r15, local_sample_byte
//	movi	r16, local_scale_index_byte
	movi	AGRAdr0, local_fraction_byte
	
        CLR_TrapReg
	loop	r10, loop_II_dequantize	;for (k=0, ...
	
	
	loop	3, middle_loop_II_dequantize	;for (j=0, ... 

	multi	r0, r13, SBLIMIT*4
	multi	r2, r13, SBLIMIT*3*4
	multi	r4, r22, SBLIMIT*4
	movi	r17, local_ITaloc_idx_byte	//pipeline
	addi	r14, r0, local_bit_alloc_byte
        nop
	add	r2, r4
	addi	r16, r2, local_scale_index_byte
	
	loop	r11, inner_loop_II_dequantize	; for (i=0, ...

	movb	r9, l14			;r9=bit_alloc[k][i]=nb-1
	movb	r7, l17			;pipeline. r7=offset
	tsti	r9, 0
	beq	set_fraction_to_zero_2

	add	r7, r9			//[i][bit_alloc[k][i]]
	shl	r1, r7, 1		//shorts to bytes
	addi	r1, local_I2Asteps	
	nop
	movh	r0, l1			//r0=alloc[i][bit_alloc[k][i]].steps
	movi	r18, 0			//x=0
	movi	r1, 1
local_MSB:
	shlv	r2, r1, r18
//	sub	r2, r0
	tst	r2, r0
	bgte	MSB_found		//MSB found if
					//(1<<x)>=(*alloc)[i][bit_alloc[k][i]].steps
	addi	r18, 1			//x++
	j	local_MSB
MSB_found:

	subi	r18, 1			//x-1
	
// MSB inversion

	movi	r6, 0			//init fraction =0.0
	movh	r8, l15			//r8=sample[k][j][i]
	shrv	r1, r8, r18		;sample[k][0][i]>>x-1
	tsti	r1, 1
	bnz	init_fraction_done_2
	mov	r6, r20			;init fraction=-1.0
init_fraction_done_2: 

// form a 2s complement sample

	subi	r2, r18, 23
	abs	r2			//r2=23-x
	movi	r1, 1
	shlv	r1, r18
	subi	r1, 1			//r1=(1<<x-1)-1
	and	r0, r8, r1		//sample[k][j][i] & ...
	shlv	r0, r2			//integer to fractional
	add	r6, r0			//fraction[k][j][i] += ...

// dequantize the sample

	addi	r1, r7, local_B2Aquant	
	nop
	movb	r0, l1			//r0=alloc[i][bit_alloc[k][i]].quant
	shl	r0, 2			//word to byte addr
	addi	r1, r0, local_d_tbl_byte
	addi	r2, r0, local_c_tbl_byte
	movw	r3, l1			//r3=d[(*alloc[i][bit_alloc[k][i]].quant]
//	movw	r1, l2			//r1=c[(*alloc[i][bit_alloc[k][i]].quant]
	mov	AGRAdr1, r2
	
	add	r6, r3			//fraction[k][j][i] += d[...
//	mulf	r4, r6, r1		//fraction[k][j][i] *= c[...
//	nop	
//	nop				//pipeline
//	shl	r4, 1			//compensate for 1/2 scale in table
	mulf	r4, r6, a1(0)
	madd	r4, r6, a1(0)		//compensate for 1/2 scale in table
	j	save_fraction_2

set_fraction_to_zero_2:
//	movi	r4, 0
	movi	r6, 0
	mulf	r4, r6, a1(0)
	nop
	
save_fraction_2:

	.if	0
	rnd	a0(1*4), r4
	addi	r14, 4			//inc 1 word
	addi	r15, 4			//inc 1 word
	addi	r16, 4			//inc 1 word
	addi	r17, 1			//inc 1 byte
	.endif
	
	rnd	r4			//saturate if any
	movb	r1, l16			//r1=scale_index[j][x][i]
	shl	r1, 2			//word to byte addr
	addi	r1, local_multiple_byte
//	rnd	r4			//saturate if any
//	movw	r0, l1			//r0=multiple[scale_index[j][x][i]]
	mov	AGRAdr1, r1
//	mulf	r2, r4, r0
	addi	r14, 4			//inc 1 word pipeline
	addi	r15, 4			//inc 1 word pipeline
//	shl	r2, 1			//*2 to compensate for scale in table
	mulf	r2, r4, a1(0)
	madd	r2, r4, a1(0)		//*2 to compensate for scale in table
	addi	r16, 4			//inc 1 word
	rnd	a0(1*4), r2		//saturate if any
	addi	r17, 1			//inc 1 byte
//	nop
//	rnd	a0(1*4), r2		//saturate if any

	
inner_loop_II_dequantize:

	sub	r1, r21, r11
	beq	no_more_fraction
	movi	r4, 0
	loop	r1, remaining_loop
	mov	a0(1*4), r4
	addi	r14, 4			//inc 1 word
	addi	r15, 4			//inc 1 word
	addi	r16, 4			//inc 1 word
	addi	r17, 1			//inc 1 byte
remaining_loop:

no_more_fraction:
	nop

middle_loop_II_dequantize:	
	addi	r13, 1
loop_II_dequantize:		
        SET_TrapReg


	.if	DB_DEQ_OUT

	movi	r10,local_fraction_byte
	rswi	r10,0x500	// begining of dump addr
	movi	r10,local_fraction_byte+(2*3*32)*4
	rswi	r10,0x504	// end of dump addr
	movi	r10,1
	rswi	r10,0x508	// start dumping
	
	.endif
		
	j	r26