autofunc.c

LCD OSD 程序用於8051 開發lcd

Bool mStar_AutoAdjustAdcGain(BYTE vsyncTime)
{ BYTE rGain, gGain, bGain;
  BYTE maxRGain, maxGGain, maxBGain;
  BYTE minRGain, minGGain, minBGain;
  BYTE retry=8;
  BYTE adcStatus;
  BYTE atgFlags=0;
  
  maxRGain=maxGGain=maxBGain=0xFF;
  minRGain=minGGain=minBGain=0;
  
  while (retry--)
    { rGain=((WORD)maxRGain+minRGain)/2;
      gGain=((WORD)maxGGain+minGGain)/2;
      bGain=((WORD)maxBGain+minBGain)/2;
      mStar_AdjustAdcGain(rGain, gGain, bGain);
      Delay1ms(vsyncTime);
      WaitAutoStatusReady(ATGCTRL, ATGR_B);
      adcStatus=mStar_ReadByte(ATGCTRL);      
      if (adcStatus&MAXR_B)
      	{
        rGain--;
      	atgFlags|=OverFlow;
      	}
      else
      	{
        rGain++;
      	atgFlags|=NoneOverFlow;
      	}
	  
      if (adcStatus&MAXG_B)
      	{
        gGain--;
      	atgFlags|=OverFlow;
      	}
      else
      	{
      	gGain++;
      	atgFlags|=NoneOverFlow;
      	}
	  
      if (adcStatus&MAXB_B)
      	{
        bGain--;
      	atgFlags|=OverFlow;
      	}
      else
      	{
      	bGain++;
      	atgFlags|=NoneOverFlow;
      	}
	  
//      if (adcStatus&(MAXR_B|MAXG_B|MAXB_B))
//      	atgFlags|=OverFlow;
//      else
//      	atgFlags|=NoneOverFlow;
      mStar_AdjustAdcGain(rGain, gGain, bGain);
      Delay1ms(vsyncTime);
      WaitAutoStatusReady(ATGCTRL, ATGR_B);
      adcStatus=mStar_ReadByte(ATGCTRL);
      if (adcStatus&MAXR_B)
      	{
        maxRGain=rGain+1;
      	atgFlags|=OverFlow;
      	}
      else
      	{
      	minRGain=rGain-1;
      	atgFlags|=NoneOverFlow;
      	}
	  
      if (adcStatus&MAXG_B)
      	{
        maxGGain=gGain+1;
      	atgFlags|=OverFlow;
      	}
      else
      	{
      	minGGain=gGain-1;
      	atgFlags|=NoneOverFlow;
      	}
	  
      if (adcStatus&MAXB_B)
      	{
        maxBGain=bGain+1;
      	atgFlags|=OverFlow;
      	}
      else
      	{
      	minBGain=bGain-1;
      	atgFlags|=NoneOverFlow;
      	}
	  
      if (CheckSyncLoss())
      	return FALSE;
//      if (adcStatus&(MAXR_B|MAXG_B|MAXB_B))
//      	atgFlags|=OverFlow;
//      else
//      	atgFlags|=NoneOverFlow;
    }
  
  if ((atgFlags&0xC0)!=0xC0)
    return FALSE;
  
  UserPrefAdcRedGain=rGain-1;
  UserPrefAdcGreenGain=gGain-1;
  UserPrefAdcBlueGain=bGain-1;
  mStar_AdjustAdcGain(UserPrefAdcRedGain, UserPrefAdcGreenGain, UserPrefAdcBlueGain);
  
  return TRUE;
}


Bool mStar_AutoAdjustAdcOffset(BYTE vsyncTime)
{ BYTE rOffset, gOffset, bOffset;
  BYTE maxROffset, maxGOffset, maxBOffset;
  BYTE minROffset, minGOffset, minBOffset;
  BYTE retry=8;
  BYTE adcStatus;
  BYTE atgFlags=0;
  
  maxROffset=maxGOffset=maxBOffset=0xFF;
  minROffset=minGOffset=minBOffset=0;
  
  while (retry--)
    { rOffset=((WORD)maxROffset+minROffset)/2;
      gOffset=((WORD)maxGOffset+minGOffset)/2;
      bOffset=((WORD)maxBOffset+minBOffset)/2;
      mStar_AdjustAdcOffset(rOffset, gOffset, bOffset);
      Delay1ms(vsyncTime);
      WaitAutoStatusReady(ATGCTRL, ATGR_B);
      adcStatus=mStar_ReadByte(ATGST);
      if (adcStatus&MINR_B)
      	{
        rOffset++;
      	atgFlags|=UnderFlow;
      	}
      else
      	{
        rOffset--;
      	atgFlags|=NoneUnderFlow;
      	}
	  
      if (adcStatus&MING_B)
      	{
        gOffset++;
      	atgFlags|=UnderFlow;
      	}
      else
      	{
      	gOffset--;
      	atgFlags|=NoneUnderFlow;
      	}
      if (adcStatus&MINB_B)
      	{
        bOffset++;
      	atgFlags|=UnderFlow;
      	}
      else
      	{
      	bOffset--;      
      	atgFlags|=NoneUnderFlow;
      	}
	  
//      if (adcStatus&(MINR_B|MING_B|MINB_B))
//      	atgFlags|=UnderFlow;
//      else
//      	atgFlags|=NoneUnderFlow;
      mStar_AdjustAdcOffset(rOffset, gOffset, bOffset);
      Delay1ms(vsyncTime);
      WaitAutoStatusReady(ATGCTRL, ATGR_B);
      adcStatus=mStar_ReadByte(ATGST);
      if (adcStatus&MINR_B)
      	{
        minROffset=rOffset-1;
      	atgFlags|=UnderFlow;
      	}
      else
      	{
      	maxROffset=rOffset+1;
      	atgFlags|=NoneUnderFlow;
      	}
	  
      if (adcStatus&MING_B)
      	{
        minGOffset=gOffset-1;
      	atgFlags|=UnderFlow;
      	}
      else
      	{
      	maxGOffset=gOffset+1;
      	atgFlags|=NoneUnderFlow;
      	}
	  
      if (adcStatus&MINB_B)
      	{
        minBOffset=bOffset-1;
      	atgFlags|=UnderFlow;
      	}
      else
      	{
      	maxBOffset=bOffset+1;
      	atgFlags|=NoneUnderFlow;
      	}
	  
      if (CheckSyncLoss())
      	return FALSE;
//      if (adcStatus&(MINR_B|MING_B|MINB_B))
//      	atgFlags|=UnderFlow;
//      else
//      	atgFlags|=NoneUnderFlow;
//   	 printData("retry %d", retry);
//   	 printData("r-offset %d", rOffset+1);
//  	 printData("g-offset %d", gOffset+1);
// 	 printData("b-offset %d", bOffset+1);
   }
  
  if ((atgFlags&0xC0)!=0xC0)
  	{
//  	 printData("atgFlags %x", atgFlags);
//  	 printData("r-offset %d", rOffset+1);
//  	 printData("g-offset %d", gOffset+1);
//  	 printData("b-offset %d", bOffset+1);
    return FALSE;
  	}

  UserPrefAdcRedOffset=rOffset+1;
  UserPrefAdcGreenOffset=gOffset+1;
  UserPrefAdcBlueOffset=bOffset+1;//+5; //for greyscle in Blue chanel dark level is hard to differentiate
  mStar_AdjustAdcOffset(UserPrefAdcRedOffset, UserPrefAdcGreenOffset, UserPrefAdcBlueOffset);
  
  return TRUE;
}

//==================================================================
Bool mStar_AutoAdcColor(BYTE vsyncTime)
{ BYTE result;

  if (SrcInputType==Input_Digital)
    return FALSE;

  mStar_WriteByte(ATGCTRL, 0x11); // enable auto Gain
  mStar_WriteByte(REGBK, REGBANKADC);
  mStar_WriteByte(DBFC, 0);
  mStar_WriteByte(REGBK, REGBANKSCALER);

//  vsyncTime=GetVSyncTime();

  result=mStar_AutoAdjustAdcOffset(vsyncTime);
  if (!result)

  mStar_AdjustAdcOffset(UserPrefAdcRedOffset, UserPrefAdcGreenOffset, UserPrefAdcBlueOffset);

  result=mStar_AutoAdjustAdcGain(vsyncTime);
  if (!result)
    mStar_AdjustAdcGain(UserPrefAdcRedGain, UserPrefAdcGreenGain, UserPrefAdcBlueGain);

#if 0
  printData("adc gain red %d", UserPrefAdcRedGain);
  printData("adc gain green %d", UserPrefAdcGreenGain);
  printData("adc gain blue %d", UserPrefAdcBlueGain);
  printData("adc offset red %d", UserPrefAdcRedOffset);
  printData("adc offset green %d", UserPrefAdcGreenOffset);
  printData("adc offset blue %d", UserPrefAdcBlueOffset);
#endif

  mStar_WriteByte(REGBK, REGBANKADC);
  mStar_WriteByte(DBFC, 1);
  mStar_WriteByte(REGBK, REGBANKSCALER);
  mStar_WriteByte(ATGCTRL, 0); // enable auto Gain

  return result;
}

//==================================================================
Bool mStar_AutoGeomtry(void)
{ Bool result=TRUE;
  BYTE vsyncTime;

  vsyncTime=GetVSyncTime();
#if 0
  if (FactoryModeFlag)
    { mStar_AutoAdcColor(vsyncTime);
      if (InputTimingChangeFlag)
      	return FALSE;
    }
#endif
  mStar_WriteByte(DBFC, 0);
  if (SrcInputType!=Input_Digital)
    { // Automatically adjusting Data threshold
      mStar_AdjustAdcGain(0x80, 0x80, 0x80);
      mStar_AdjustAdcOffset(0x90, 0x90, 0x90);
      // auto adjust threshold
    #if QuickAuto
      mStar_WriteByte(AOVDV, 0x40);
    #else
      AutoSetDataThreshold(vsyncTime+3);
    #endif
      if (InputTimingChangeFlag)
      	{ result=FALSE;
          goto AutoGeomtryFailed;
      	}
      // auto adjust htotal
      result=mStar_AutoHTotal(vsyncTime*2);
      if (!result)
        goto AutoGeomtryFailed;

      if (InputTimingChangeFlag)
      	{ result=FALSE;
          goto AutoGeomtryFailed;
      	}
      // auto adjust phase
      if (result)
        { mStar_AdjustAdcGain(UserPrefAdcRedGain, UserPrefAdcGreenGain, UserPrefAdcBlueGain);
	   mStar_AdjustAdcOffset(UserPrefAdcRedOffset, UserPrefAdcGreenOffset, UserPrefAdcBlueOffset);
          mStar_AutoPhase(vsyncTime+3);
      	}
      if (InputTimingChangeFlag)
      	{ result=FALSE;
          goto AutoGeomtryFailed;
      	}
      Delay1ms(vsyncTime*2);
      mStar_AutoPosition();

    }
AutoGeomtryFailed:
	//jon add
  #if Giotto       
  CheckLineBuffer();   //ASW 0721 solve dos-mode line-buffer over
#endif

  mStar_WriteByte(AOVDV, 0x40);
  mStar_WriteByte(DBFC, 5);
  mStar_AdjustAdcGain(UserPrefAdcRedGain, UserPrefAdcGreenGain, UserPrefAdcBlueGain);
  mStar_AdjustAdcOffset(UserPrefAdcRedOffset, UserPrefAdcGreenOffset, UserPrefAdcBlueOffset);

  return result;
}

Bool mStar_AutoColor(void)
{ Bool result;
  BYTE vsyncTime;

  vsyncTime=GetVSyncTime();
  result=mStar_AutoAdcColor(vsyncTime*2+3);
  if (InputTimingChangeFlag)
    return FALSE;
  return result;
}