ave2koverlay.c

driver wdk

	ULONG dcgx;
	ULONG cxyuv;
	ULONG hpsc;
	if (nop != 0)
	{
	  if(nop>nip){
	    xpsc=0;
	    xsci=1024l*nip/nop;
	    dcgx = 0;
	  }
	  else{
		xpsc = nip / nop;
		if(xpsc>64) xpsc = 64;

		xsci = 1024l * nip / (nop * xpsc--);
		if(xsci>4095) xsci = 4095;
		dcgx = Dcgx(xpsc);
	  }
	}

    	cxyuv = HpsH[xpsc] >> 16;

	hpsc = (xpsc<<18) + cxyuv + (cxyuv<<8) + (dcgx<<27);
  if(nop>nip)
    hpsc=hpsc+(1l<<17);
		*HPreScale=hpsc;
		*HScale=(xsci<<12) + hxo;

}	

static void Setup_VScale(PDEVICE_EXTENSION pDE, int nil, int nol, ULONG hyo)
{
	ULONG VScale,VGain;
	GetVScaleParas(nil, nol, hyo, &VScale, &VGain);
	Ave2kWriteRegister(pDE, HPS_V_SCALE, VScale);
	Ave2kWriteRegister(pDE, HPS_V_GAIN, VGain);
}
static void GetVScaleParas(int nil, int nol, ULONG hyo, ULONG *VScale, ULONG *VGain)
{
  ULONG yacl;
  ULONG ysci;
  ULONG ypo;
  ULONG ype;
  ULONG yacm;
  ULONG factor;
  ULONG dcgy;
  ULONG hpsv;
  ULONG cya;
  ULONG cyb;
  ULONG pfy;
  ULONG pfuv;
  ULONG weight;
  int index;
  if(nol!=0){
    if(nol>nil){
      nol++;
      nol/=2;
    }
    if(nol*2==nil || nol*3== nil || nol*4==nil)
      nol++;
    if(nol*3<=nil*2){		//nol/nil < 2/3
       index=nil/nol;
       hpsv=HpsV[index-1];
       cya=(hpsv>>24)&0xff;
       cyb=(hpsv>>16)&0xff;
       //Output(cya+" "+cyb+"\n");
       //weight=hpsv&0xff;
       dcgy=index/2;
       //if(index>=2)
	 //dcgy=1;
       //else
	 //dcgy=0;
	yacm=1;
	yacl=nil/nol-1;
	ysci=1020-1024l*nol/nil;
	ype=ysci/16;
	ypo=ype;
    }
    else{
       dcgy=0;
       cya=0;
       cyb=255;
	yacm=0;
	factor=1000l*nil/nol;
	yacl=nil/nol-1;
	ysci=factor-factor*nol/nil;
	ype=ysci/16;
	ypo=ype;
    }
/*    if(nol*3<=nil*2){		//nol/nil < 2/3
       index=nil/nol;
       hpsv=HpsV[index-1];
       cya=(hpsv>>24)&0xff;
       cyb=(hpsv>>16)&0xff;
       dcgy=index/2;
    } 
    else{
       dcgy=0;
       cya=0;
       cyb=255;
    }
    if(nol>nil){
        yacm=0;
	factor=1000l*nil/(nol/2);
	yacl=nil/(nol/2)-1;
	ysci=factor-factor*(nol/2)/nil;
	ype=ysci/16;
	ypo=(ype*12)/10;
    }
    else{
      if(nol*3<=nil*2){
        yacm=1;
        yacl=nil/nol-1;
	ysci=1020-1024l*nol/nil;
	ype=ysci/16;
	ypo=ype;
      }
      else{
	yacm=0;
	factor=1000l*nil/nol;
	yacl=nil/nol-1;
	ysci=factor-factor*nol/nil;
	ype=ysci/16;
	ypo=ype;
      }
    }
	*/
	*VScale=(yacm<<31)+(ysci<<21)+(yacl<<15)+(ypo<<8)+(ype<<1);
    pfy=0;
    pfuv=1;
	*VGain=(pfuv<<24)+(dcgy<<16)+(cya<<8)+cyb;
  }
}

void StopVideo(PDEVICE_EXTENSION pDE)
{
	Ave2kWriteRegister(pDE, MC1, 0x20000000); //Disable EPS1
	Ave2kWriteRegister(pDE, MC1, TR_E_1<<16);
}
static void StartVideo(PDEVICE_EXTENSION pDE)
{
	int rpsIndex=0;
	int nOdd, nEven;
	//Ave2kWriteRegister(pDE, MC1, (TR_E_1<<16)|TR_E_1);
	//return;
	if(pDE->OverlayWindow.OpenClose){
		nOdd=0x0800;
		nEven=0x1000;
	}
	else{
		nOdd=0x2000;
		nEven=0x4000;
	}
	pDE->RPS[1].PhysicalAddress=MmGetPhysicalAddress(&pDE->RPS[1].RPSBuffer[0]).u.LowPart;
	Ave2kWriteRegister(pDE, RPS_ADDR1, pDE->RPS[1].PhysicalAddress);
	//Fill the RPS sequence
	{//wait for blank
	pDE->RPS[1].RPSBuffer[rpsIndex++]=CMD_JUMP|nOdd;
	pDE->RPS[1].RPSBuffer[rpsIndex]=pDE->RPS[1].PhysicalAddress+(rpsIndex+4)*sizeof(ULONG);
	rpsIndex++;
	pDE->RPS[1].RPSBuffer[rpsIndex++]=CMD_PAUSE|nOdd;
	pDE->RPS[1].RPSBuffer[rpsIndex++]=CMD_JUMP;
	pDE->RPS[1].RPSBuffer[rpsIndex]=pDE->RPS[1].PhysicalAddress+(rpsIndex+2)*sizeof(ULONG);
	rpsIndex++;
	//EVEN:
	pDE->RPS[1].RPSBuffer[rpsIndex++]=CMD_PAUSE|nEven;
	}
	//COMM:
	{//start DMA1
	pDE->RPS[1].RPSBuffer[rpsIndex++]=CMD_WR_REG|(1<<8)|(MC1/4);
	pDE->RPS[1].RPSBuffer[rpsIndex++] =	(TR_E_1<<16)|TR_E_1;
	}
	pDE->RPS[1].RPSBuffer[rpsIndex++]=CMD_STOP;
	Ave2kWriteRegister(pDE, MC1, 0x20002000); //Enable EPS1

	//Ave2kWriteRegister(pDE, MC1, (TR_E_1<<16)|TR_E_1);
}

static void Shift(PDEVICE_EXTENSION pDE, int nChannel)
{
	ULONG nX;
	ULONG nY;
	ULONG dFrame;
	ULONG pitch;
	ULONG nol;
	ULONG nil;
	if(nChannel==0){
		nX=pDE->OverlayWindow.Left;
		nY=pDE->OverlayWindow.Top;
	}
	else{
		nX=pDE->OverlayWindow.Left2;
		nY=pDE->OverlayWindow.Top2;
	}
	dFrame=pDE->DisplayParameter.PhysicalAddress + 
	     nY*pDE->DisplayParameter.Pitch + 
		 nX*pDE->DisplayParameter.Depth;
	pitch =	pDE->DisplayParameter.Pitch;
	if(nChannel==0){
		nol = pDE->OverlayWindow.Bottom - pDE->OverlayWindow.Top;
		nil = pDE->NIL;
	}
	else{
		nol = pDE->OverlayWindow.Bottom2 - pDE->OverlayWindow.Top2;
		nil = pDE->NIL2;
	}
	if(nol>nil){
		Ave2kWriteRegister(pDE, BASE_ODD1, dFrame+pitch);
		Ave2kWriteRegister(pDE, BASE_EVEN1, dFrame);
		Ave2kWriteRegister(pDE, PROT_ADDR1, dFrame + pitch * nol);
		Ave2kWriteRegister(pDE, PITCH1, pitch*2);
	}
	else{
		Ave2kWriteRegister(pDE, BASE_ODD1, dFrame);
		Ave2kWriteRegister(pDE, BASE_EVEN1, dFrame + pitch * nol +4);
		Ave2kWriteRegister(pDE, PROT_ADDR1,  dFrame + pitch * nol);
		Ave2kWriteRegister(pDE, PITCH1, pitch);
	}
	if(pDE->DisplayParameter.BitCount==0x8000000f)
		Ave2kWriteRegister(pDE, BASE_PAGE1, 0x00000001);
	else
		Ave2kWriteRegister(pDE, BASE_PAGE1, 0x00000000);
	Ave2kWriteRegister(pDE, NUM_LINE_BYTE1, (nil << 16) + pDE->NIP);
	Ave2kWriteRegister(pDE, MC2, (UPLD_DMA1<<16)|UPLD_DMA1);
}

void Ave2kMaskClip(PDEVICE_EXTENSION pDE, PVOID pMask)
{
	ULONG nop, nol, nTotal, nLineByte;
	ULONG ClipDmaPhyAddr;
	if(pMask==NULL){
		DisableAllClip(pDE);
		return ;
	}

	nop=pDE->OverlayWindow.Right - pDE->OverlayWindow.Left;
	nol=pDE->OverlayWindow.Bottom - pDE->OverlayWindow.Top;
	nTotal=((nop+8)/8)*nol;
	Ave2kWriteRegister(pDE, MC1, ((TR_E_2<<16)));
	//for(i=0; i<64; i++)
	//	pDE->ClipDmaBuffer[i]=0x55555555;
	//pDE->ClipDmaBuffer[0]=0xF0f05555;
	//pDE->ClipDmaBuffer[63]=0xcccccccc;
	ClipDmaPhyAddr=MmGetPhysicalAddress(pMask).u.LowPart;
	Ave2kWriteRegister(pDE,BASE_ODD2, ClipDmaPhyAddr);
	Ave2kWriteRegister(pDE,BASE_EVEN2, ClipDmaPhyAddr);
	Ave2kWriteRegister(pDE,PROT_ADDR2, ClipDmaPhyAddr + nTotal);
	Ave2kWriteRegister(pDE,PITCH2,(nop+8)/8);
	Ave2kWriteRegister(pDE,BASE_PAGE2,0x00000004); //read from memory
	nLineByte=(nol<<16)+nop/4;
	Ave2kWriteRegister(pDE,NUM_LINE_BYTE2, nLineByte);//64*sizeof(ULONG));
	
	//Upload video DMA 2
	Ave2kWriteRegister(pDE, MC2,(UPLD_DMA2<<16)|UPLD_DMA2); 
	//Enable video channel 2
	Ave2kWriteRegister(pDE, MC1, ((TR_E_2<<16)|TR_E_2)); 
	pDE->outformat= (pDE->outformat & 0xffff0000)|0x70;
	Ave2kWriteRegister(pDE, CLIP_FORMAT_CTRL, pDE->outformat);

	//Upload format register
	Ave2kWriteRegister(pDE,MC2,(UPLD_HPS_V<<16)|UPLD_HPS_V); //bit 5: U
//	UploadVideo(pDE);
}
 
BOOLEAN SetClipRect(PDEVICE_EXTENSION pDE, PAVE2KCLIPLIST pClipList)
{
	int nChannel=pClipList->nChannel;
	pDE->lNumOfRect[nChannel]=pClipList->lNumOfRect;
	if((0 == pDE->OverlayWindow.OpenClose || pDE->lNumOfRect[0] == 0L) &&
		(0 == pDE->OverlayWindow.OpenClose2 || pDE->lNumOfRect[1] == 0L)){
		DisableAllClip(pDE);
		return TRUE;
	}
	//disable DMA 2 first
	Ave2kWriteRegister(pDE, MC1, ((TR_E_2<<16)));
	BuildClipInfo(pDE->Clips[nChannel].ClipDmaBuffer, pClipList);
#if 0
	//Send clipping to the chip
	ClipDmaPhyAddr=MmGetPhysicalAddress(&pDE->Clips[nChannel].ClipDmaBuffer[0]).u.LowPart;
	Ave2kWriteRegister(pDE,BASE_ODD2, ClipDmaPhyAddr);
	Ave2kWriteRegister(pDE,BASE_EVEN2, ClipDmaPhyAddr);
	Ave2kWriteRegister(pDE,PROT_ADDR2, ClipDmaPhyAddr + 64*sizeof(ULONG));
	Ave2kWriteRegister(pDE,PITCH2,0x00000000);
	Ave2kWriteRegister(pDE,BASE_PAGE2,0x00000004);
	Ave2kWriteRegister(pDE,NUM_LINE_BYTE2,0x4040);
	//Upload video DMA 2
	Ave2kWriteRegister(pDE, MC2,(UPLD_DMA2<<16)|UPLD_DMA2); 
#endif
	//Enable video channel 2
	Ave2kWriteRegister(pDE, MC1, ((TR_E_2<<16)|TR_E_2)); 

	//Enable clipping
	pDE->outformat= (pDE->outformat&0xffff0000) | 0x40; //not inverted clipping
	if(JudgeInterlace(pDE))
		pDE->outformat |= 0x08;
	Ave2kWriteRegister(pDE,CLIP_FORMAT_CTRL,pDE->outformat);
	//Upload format register
	Ave2kWriteRegister(pDE,MC2,(UPLD_HPS_V<<16)|UPLD_HPS_V); //bit 5: U
	return TRUE;
}
static BOOLEAN JudgeInterlace(PDEVICE_EXTENSION pDE)
{
    if(1 == pDE->OverlayWindow.OpenClose && 1 == pDE->OverlayWindow.OpenClose2)
		return FALSE;
	else{
		if(1 == pDE->OverlayWindow.OpenClose){
			if(pDE->OverlayWindow.Bottom - pDE->OverlayWindow.Top > pDE->NIL)
				return TRUE;
			else
				return FALSE;
		}
		else{
			if(pDE->OverlayWindow.Bottom2 - pDE->OverlayWindow.Top2 > pDE->NIL2)
				return TRUE;
			else
				return FALSE;
		}
	}
}
static void DisableAllClip(PDEVICE_EXTENSION pDE)
{
	//disable clipping rectangle
	pDE->outformat= pDE->outformat&0xffff0000;
	Ave2kWriteRegister(pDE,CLIP_FORMAT_CTRL,pDE->outformat);
	//Upload format register
	Ave2kWriteRegister(pDE,MC2,(UPLD_HPS_V<<16)|UPLD_HPS_V); //bit 5: U
	//disable DMA 2
	Ave2kWriteRegister(pDE, MC1, ((TR_E_2<<16)));
}                               
static void BuildClipInfo(ULONG ClipDmaBuffer[], PAVE2KCLIPLIST pClipList)
{
	int i,j;
	ULONG nPos[32];
	USHORT bMask;
	int nTotalPos;
	int nRects=pClipList->lNumOfRect;
	for(i=0; i<32; i++){
		ULONG nTemp;
		ULONG nMin;
		if(i==0)
			nTemp=0;
		else
			nTemp=nPos[i-1];
		nMin=65535;//a value never be used
		for(j=0; j<nRects; j++){
			ULONG nTop=pClipList->ClippingRect[j].top;
			ULONG nBottom=pClipList->ClippingRect[j].bottom;
			if(nTop>nTemp && nTop<nMin)
				nMin=nTop;
			if(nBottom>nTemp && nBottom<nMin)
				nMin=nBottom;
		}
		if(nMin==65535){// no more line
			i++;
			break;
		}
		nPos[i]=nMin;
	}
	nTotalPos=i-1;
	for(i=0; i<nTotalPos; i++)
		ClipDmaBuffer[i*2+1]=nPos[i]<<16;
	if(nTotalPos!=31)
		ClipDmaBuffer[i*2+1]=0;
	bMask=0x0001;
	for(i=0; i<nRects; i++){
		for(j=0; j<nTotalPos; j++){
			if(nPos[j]>=pClipList->ClippingRect[i].top && 
					nPos[j]<pClipList->ClippingRect[i].bottom)
				ClipDmaBuffer[j*2+1] |= bMask;
		}
		bMask<<=1;
	}

	for(i=0; i<32; i++){
		ULONG nTemp;
		ULONG nMin;
		if(i==0)
			nTemp=0;
		else
			nTemp=nPos[i-1];
		nMin=65535;
		if(nTemp<pClipList->ClippingRect[0].left)
			nMin=pClipList->ClippingRect[0].left;
		for(j=0; j<nRects; j++){
			ULONG nLeft=pClipList->ClippingRect[j].left;
			ULONG nRight=pClipList->ClippingRect[j].right;
			if(nLeft>nTemp && nLeft<nMin)
				nMin=nLeft;
			if(nRight>nTemp && nRight<nMin)
				nMin=nRight;
		}
		if(nMin==65535){// no more pixel
			i++;
			break;
		}
		nPos[i]=nMin;
	}
	nTotalPos=i-1;
	for(i=0; i<nTotalPos; i++)
		ClipDmaBuffer[i*2]=nPos[i]<<16;
	if(nTotalPos!=31)
		ClipDmaBuffer[i*2]=0;
	bMask=0x0001;
	for(i=0; i<nRects; i++){
		for(j=0; j<nTotalPos; j++){
			if(nPos[j]>=pClipList->ClippingRect[i].left && 
					nPos[j]<pClipList->ClippingRect[i].right)
				ClipDmaBuffer[j*2] |= bMask;
		}
		bMask<<=1;
	}
#if 0
	ClipDmaBuffer[0]=0x30001;
	ClipDmaBuffer[1]=0x50001;
	ClipDmaBuffer[2]=0x290000;
	ClipDmaBuffer[3]=0x140000;
	//ClipDmaBuffer[4]=0x390002;
	//ClipDmaBuffer[5]=0x240002;
	ClipDmaBuffer[4]=0x0;
	ClipDmaBuffer[5]=0x0;
#endif
}