misc.asm

bf533平台图像采集程序

.global _ComputeVLI;
//.global _quantize;
.global _copy8to16;
//.global _WriteBitsStream;
//.global _get_nonzero_ac_index;
//.global _RLEComp;
.global _pre_fetch;
//.global _DCComp;
.global _ProcessDU;

.extern _stream;

.section L1_code;

/*
void ProcessDU(short* lpBuf,unsigned char* quantTab,HUFFCODE* dcHuffTab,HUFFCODE* acHuffTab,short* DC)
{
	#pragma align 4 
	short sigBuf[DCTBLOCKSIZE];                    //量化后信号缓冲
	
	_r8x8dct(lpBuf, coeff, temp);
	quantize(sigBuf, lpBuf, quantTab);
	DCComp(sigBuf, DC, dcHuffTab);	
	RLEComp(sigBuf, acHuffTab);
}
*/
_ProcessDU:
	link 132;

	[fp+8] = r0;
	[fp+12] = r1;
	[fp+16] = r2;
		
	r1.l = _coeff;
	r1.h = _coeff;
	r2.l = _temp;
	r2.h = _temp;
	call __r8x8dct;
	
	r0 = sp; //sigBuf
	r1 = [fp+8];
	r2 = [fp+12];
	call _quantize;
	
	[fp-4] = r0; //non_zero_ac_index
	
	r0 = sp;
	r1 = [fp+24];
	r2 = [fp+16];
	call _DCComp;	
	
	r0 = sp;
	r1 = [fp+20];
	r2 = [fp-4];
	call _RLEComp;	

	unlink;
	rts;
_ProcessDU.end:
	nop;

write_code:
	[--sp] = rets;
	//asume sizeof(HUFFCODE) = 6
	r2 = 6;
//	r0 = 0xF0(z);
	r2 = r2.l * r0.l(is);
	p2 = r2;
	
	p0.l = _stream;
	p0.h = _stream;
	
	p2 = p3 + p2; //p3: acdcHuffTab
	
	r0 = w[p2](z);
	r1 = b[p2+2](z);	
	
	
	call _WriteBitsStream;
	
	rets = [sp++];
	rts;
write_code.end:	
	nop;

//DCComp(sigBuf, DC, dcHuffTab);	
_DCComp:
	link 0;
	[--sp] = (r7:6);
		
	p0 = r0; //sigBuf
	p1 = r1; //DC
	
	p2.l = _pVLITAB;
	p2.h = _pVLITAB;
	p2 = [p2];
	
	p3 = r2; //dcHuffTab
	
	r0 = w[p0](x);
	r1 = w[p1](x);
	r0 = r0 - r1(ns) || w[p1] = r0;
	//r0 = diff
	
	cc = r0;
	if !cc jump DC_0;

	p1 = r0; //diffval
	p2 = p2 + p1;
	r2 = b[p2](z); //unsigned char* pVLITAB[diffVal]
	r1 = 6;
	r1 = r2.l * r1.l(is);
	p2 = r1;
	
	r6 = r0; //diffval
	
	p0.l = _stream;
	p0.h = _stream;
	
	p2 = p3 + p2; 
	
	r0 = w[p2](z);
	
	r1 = b[p2+2](z);	

	
	call _WriteBitsStream;
	
	//ComputeVLI
	r3 = abs r6;
	r7 = 2047(z);
	r2 = 15;	
	r3 = r3 & r7; //2048->0
	r7.l = signbits r3.l;
	r7.h = 0;
	r7 = r2 - r7; //codeLen = 16-(signbits+1); 

	r0 = r6;
	r2 = 1;
	r2 <<= r7;
	r2 += -1;
	r2 = r2 + r6;
	cc = r6 < 0;
	if cc r0 = r2; //r0 : Symbol.amplitude
	r1 = r7;

	call _WriteBitsStream;
	
DC_END:
	(r7:6) = [sp++];
	unlink;
	rts;
	
DC_0:
	r0 = 0;
	call write_code;
	jump DC_END;
		
_DCComp.end:
	nop;
/*		
	diffVal = sigBuf[0] - *DC;
	*DC = sigBuf[0];

	//搜索Huffman表，写入相应的码字
	if (diffVal == 0)
	{  
		huff = &dcHuffTab[0];
		WriteBitsStream(huff->code, huff->length);                      //{0，2，0},写进零长度
	}
	else
	{   
		huff = &dcHuffTab[pVLITAB[diffVal]];
		sym2 = BuildSym2(diffVal);
		WriteBitsStream(huff->code, huff->length);       //写进长度 
		WriteBitsStream(sym2.amplitude, sym2.codeLen);                //写进幅度  
	}
*/
	
_RLEComp:
	link 0;
	[--sp] = (r7:4, p5:3);

	p5 = r0; ////sigBuf
	p3 = r1; //acHuffTab
	
//	call _get_nonzero_ac_index;
//	cc = r0;
//	if !cc jump ALL_AC_0;
	
//	p4 = r0; //nonzero_ac_index	

	cc = r2; //nonzero_ac_index
	if !cc jump ALL_AC_0;
	
	p4 = r2; //nonzero_ac_index	

	p5 += 2; //lpbuf+1	
	r6 = 0; //r6.h <- 0
	r5 = 0; //zeroNum
	r4 = 15;
	
	lsetup(lrles, lrlee) lc0 = p4;
	lrles:
		r6 = w[p5++](x);
		cc = r6;
		if cc jump WRITE_BITS;
		cc = r5 < r4;
		if !cc jump WRITE_BITS; 
	lrlee: r5 += 1;
	
	r0 = p4;
	r1 = 63;
	cc = r0 == r1;
	if cc jump END;
	
	r0 = 0;
	call write_code;
	
	END:
	(r7:4, p5:3) = [sp++];
	unlink;
	rts;

ALL_AC_0:
	r0 = 0;
	call write_code;
	jump END;	

WRITE_BITS:
	//r6: lpBuf[i], amplitude
	//ComputeVLI
	r3 = abs r6;
	r7 = 2047(z);
	r2 = 15;	
	r3 = r3 & r7; //2048->0
	r7.l = signbits r3.l;
	r7.h = 0;
	r3 = r2 - r7; //codeLen = 16-(signbits+1); 
	
	cc = r3;
	if !cc jump CODELEN_0;

	r0 = r5 << 4;	
	r0 = r0 + r3;
	r1 = 6;
	r0 = r0.l * r1.l(is);
	p2 = r0;
	p2 = p3 + p2;

	r7 = r3;
		
	r0 = w[p2](z);
	r1 = b[p2+2](z);	

	p0.l = _stream;
	p0.h = _stream;
	
	call _WriteBitsStream;

	r0 = r6;
	r2 = 1;
	r2 <<= r7;
	r2 += -1;
	r2 = r2 + r6;
	cc = r6 < 0;
	if cc r0 = r2; //r0 : Symbol.amplitude
	r1 = r7;

	call _WriteBitsStream;
	
//Symbol.codeLen r3; value r6;		
//	Symbol.codeLen = ComputeVLI(value);
//	if (value >= 0)
//		Symbol.amplitude = value;
//	else
//		Symbol.amplitude = (2 << Symbol.codeLen) - 1 + value; 
  
	
	r5 = -1;
	jump lrlee;
	
CODELEN_0:
	r0 = 0xF0(z);
	call write_code;
	r5 = -1;
	jump lrlee;

_RLEComp.end:
	nop;
	
//	if (i == 0)                                    //如果ac信号全为0
//	{
//		huff = &acHuffTab[0x00];
//		WriteBitsStream(huff->code, huff->length);                   //写入块结束标记  
//	}
//	else
//	{ 
//		RLEComp(sigBuf, acHuffTab, i);              //对AC进行长度编码 
/*		for (j = 0; j < acLen; j++)                   //依次对AC中间符号Huffman编码
		{   
			if (acSym[j].codeLen == 0)                   //是否有连续16个0
			{   
				huff = &acHuffTab[0xF0];
				WriteBitsStream(huff->code, huff->length);                   //写入块结束标记  
			}
			else
			{
				huff = &acHuffTab[acSym[j].zeroLen * 16 + acSym[j].codeLen];
				WriteBitsStream(huff->code, huff->length);                   //写入块结束标记  
				sym2 = BuildSym2(acSym[j].amplitude);
				WriteBitsStream(sym2.amplitude, sym2.codeLen);                //写进幅度  
			}   
		}
*/
//	if (i != 63)                                  //如果最后位以0结束就写入EOB
//		{
//			huff = &acHuffTab[0x00];
//			WriteBitsStream(huff->code, huff->length);                   //写入块结束标记  
//		}
//	}

/*	
typedef struct tagHUFFCODE        //Huffman码结构
{
 unsigned short code;                       // huffman 码字
 unsigned char length;                     // 码字长度
 unsigned short val;                        // 码字对应的值
}HUFFCODE;
*/	
/*
 void RLEComp(short* lpbuf, HUFFCODE* acHuffTab, int EOBPos)
 {  
  unsigned char zeroNum     = 0;                //0行程计数器
  const unsigned char MAXZEROLEN = 15;          //最大0行程
  unsigned int i        = 0;     

  HUFFCODE * huff;
  SYM2 sym2;

  for (i = 1; i <= EOBPos; i++)         //从第二个信号，即AC信号开始编码
  {
	   if (lpbuf[i] == 0 && zeroNum < MAXZEROLEN)  
	   {
			++zeroNum;   
	   }
	   else
	   {  
			unsigned char codeLen = ComputeVLI(lpbuf[i]);                    //幅度编码占用长度
			short amplitude = lpbuf[i];                 //幅度
			
		    
			if (codeLen == 0)                   //是否有连续16个0
			{   
				huff = &acHuffTab[0xF0];
				WriteBitsStream(huff->code, huff->length);                   //写入块结束标记  
			}
			else
			{
				huff = &acHuffTab[zeroNum * 16 + codeLen];
				WriteBitsStream(huff->code, huff->length);                   //写入块结束标记  
				sym2 = BuildSym2(amplitude);
				WriteBitsStream(sym2.amplitude, sym2.codeLen);                //写进幅度  
			}  
			 
			zeroNum = 0;           //0计数器复位
		}
	} 
}
*/

//i = get_nonzero_ac_index(sigBuf);
_get_nonzero_ac_index:
	
	p1 = r0;
	
	p0 = 62;
	
	p1 = p1 + (p0 << 1);
	
	p0 = 32; //32
	
	lsetup(lindexs, lindexe) lc0 = p0;
	lindexs:
		r3 = [p1--];
		cc = r3;
	lindexe: if cc jump NONZERO;
	
	NONZERO:
	r2 = p1;
	r3 >>= 16;
	cc = r3;
	r3 = 0;
	r1 = 1;
	if cc r3 = r1;
	r2 += 4;
	r2 = r2 - r0;
	r2 >>= 1;
	
	r0 = r2 + r3;
	
	rts;
_get_nonzero_ac_index.end:
	nop;
/*
	for (i = 63; (i > 0) && (sigBuf[i] == 0); i--) //判断ac信号是否为0
	{
												 //注意，空循环
	}
*/

/*
typedef struct
{
	unsigned char* h;
	unsigned char* t;
	unsigned int bytenew;
	unsigned int bytepos;
}bitstream_t;
*/

//void WriteBitsStream(unsigned short value,unsigned char codeLen)
_WriteBitsStream:
	//total_len = 7-stream.bytepos+codeLen;
	r3 = [p0+12];
	r3 = r1 - r3;
	r3 += 7; //total_len
	
	r2 = 8;
	
	cc = r2 <= r3;
	if cc jump LEN_ABOVE8_0;

	LEN_BELOW8:
	
	r1 = [p0+8]; //stream.newbyte
	
	r2 = r2 - r3; //8-total_len
	r0 <<= r2;

	r1 = r1 | r0;
	[p0+8] = r1;
	
	r2 += -1;
	[p0+12] = r2;
	
	rts;
	
LEN_ABOVE8_0:
	[--sp] = (r7:4);
	r6 = [p0+8]; //stream.newbyte
	
LEN_ABOVE8:
	p1 = [p0+4];
	r4 = r2 - r3; //8-total_len
	r5 = lshift r0 by r4.l;
	r6 = r6 | r5;
	
	r5 = 0xff;
	r6 = r6 & r5;
	cc = r5 == r6;
	if cc jump IS_FF;
	
	b[p1++] = r6;
	[p0+4] = p1;
	
FINISH_A_BYTE:
	r3 = abs r4;
	cc = r2 <= r3;

	r6 = 0;
	r1 = r3;//codeLen
	
	//trim value by codeLen
	r7 = 1;
	r7 <<= r1;
	r7 += -1;
	r0 = r0 & r7;//value &= (1<<codeLen)-1;

	if cc jump LEN_ABOVE8;	
	
//	jump LEN_BELOW8;
	r2 = r2 - r3; //8-total_len
	r0 <<= r2;

	r6 = r6 | r0;
	[p0+8] = r6;
	
	r2 += -1;
	[p0+12] = r2;
	
	(r7:4) = [sp++];
	rts;
	
IS_FF:	
	b[p1++]	= r6;
	r6 = 0;
	b[p1++] = r6;
	[p0+4] = p1;
	jump FINISH_A_BYTE;

		
_WriteBitsStream.end:
	nop;
	

/*
_BitstreamPutBits:	
	[--sp] = r5;
	p0 = r0;
	p0 += 12; //p0
	r0 = [p0--]; //r0 bs->pos p0 point to buf
	r3 = r0 + r2;		
	r5 = 32;
	cc = r5 < r3;
	if cc jump SHIFTABOVE32;