gdi.c

ct952 source code use for Digital Frame Photo

#ifdef TEST909S
    __dwVSYNC = 0;
    while(__dwVSYNC<2);
#else
    //UTL_DelayTime(COUNT_50_MSEC, FALSE);
    // OS_DelayTime(COUNT_50_MSEC); //Brian1.15, reduce code size
    DISP_DelayVSYNC(1);
#endif

#endif


}


//  *********************************************************************
//  Function    :   GDI_LoadPalette
//  Description :   This function loads the palette for the plane
//  Arguments   :   pPaletteInfo: point to Palette Info.
//
//  Return      :   none
//  Side Effect :
//  *********************************************************************

//void GDI_LoadPalette(BYTE bPaletteId)
// Brian, support GDI library
void GDI_LoadPalette(GDI_PALETTE_INFO *pPaletteInfo)
{

#ifndef NO_GDI

	DWORD i;

	for (i=0; i<pPaletteInfo->pdwPalette[0]; i++)
	{

        _dwGDIPalette[i+pPaletteInfo->bStartNumber] = pPaletteInfo->pdwPalette[1+i];
	}

#ifdef SUPPORT_CT909S
    DISP_SetPalette(_dwGDIPalette);
#else
    DISP_SetPalette(FALSE, _dwGDIPalette);
#endif


    // always keep the transparent color.
    GDI_ChangePALEntry(PAL_ENTRY_COLOR_TRANSPARENT, 0x5a000000, FALSE); //transparency

    GDI_WaitPaletteComplete(); // Brian0.95

	//UTL_DelayTime(COUNT_50_MSEC, FALSE);

#endif  //#ifndef NO_GDI

}


// Brian2.21, support fill rect by S/W
void _gdi_SetPixel(DWORD dwAddr, BYTE bPos, BYTE bColorMode, BYTE bColor)
{
    BYTE *pbPtr, bData;

    pbPtr = (BYTE *) dwAddr;

    bData = *pbPtr;

    switch(bColorMode)
    {
        case GDI_OSD_8B_MODE:
            bData = bColor;
            break;

        case GDI_OSD_4B_MODE:

            /*
            if (bPos)
            {
                bData = (bData & 0x0F) | (bColor << 4);
            }
            else
            {
                bData = (bData & 0xF0) | (bColor);
            }
            */

            // leon, Big endian
             if (bPos)
            {
                bData = (bData & 0xF0) | (bColor);
            }
            else
            {
                bData = (bData & 0x0F) | (bColor << 4);
            }
            break;
         case GDI_OSD_2B_MODE:
            /*
            switch (bPos)
            {
                case 0:
                    bData = (bData & 0x3F) | (bColor << 6);
                    break;
                case 1:
                    bData = (bData & 0xCF) | (bColor << 4);
                    break;
                case 2:
                    bData = (bData & 0xF3) | (bColor << 2);
                    break;
                case 3:
                    bData = (bData & 0xFC) | bColor;
                    break;
            }
            */

            // leon, Big endian
            switch (bPos)
            {
                case 3:
                    bData = (bData & 0x3F) | (bColor << 6);
                    break;
                case 2:
                    bData = (bData & 0xCF) | (bColor << 4);
                    break;
                case 1:
                    bData = (bData & 0xF3) | (bColor << 2);
                    break;
                case 0:
                    bData = (bData & 0xFC) | bColor;
                    break;
            }

            break;

    }

    *pbPtr = bData;

}

#ifdef SUPPORT_GDI_FILL_RECT_BY_SW
void _gdi_FillRectBySW(BYTE bRegionId, PARM_RECT *pParm)
{
    DWORD i, j,  dwStartAddress, dwByteOffset, dwAddressCount; // the byte address
    DWORD dwRegionWidthInByte;
    BYTE bPositionStart, bPosition;

    /*
     if (bRegionId & GDI_SHADING_OPERATION)
    {
        bRegionId = bRegionId - GDI_SHADING_OPERATION;
    }

     if (bRegionId >= NUMBER_OF_REGION)
        return;

     if (pParm->rect.wLeft >= __RegionList[bRegionId].wWidth ||
        pParm->rect.wTop >= __RegionList[bRegionId].wHeight ||
        pParm->rect.wLeft > pParm->rect.wRight ||
        pParm->rect.wTop > pParm->rect.wBottom)
        return; // the position is not in the area

     if (pParm->rect.wRight == pParm->rect.wLeft) // Brian1.22, width need to be 2n, doesn't support 1-pixel width
     {
        return;
     }

    if (pParm->rect.wBottom >= __RegionList[bRegionId].wHeight)
		pParm->rect.wBottom = __RegionList[bRegionId].wHeight-1;

    if (pParm->rect.wRight >= __RegionList[bRegionId].wWidth)
        pParm->rect.wRight = __RegionList[bRegionId].wWidth-1;

    */


     dwRegionWidthInByte = __RegionList[bRegionId].wWidth >> __RegionList[bRegionId].bColorMode;

    dwByteOffset = ((DWORD)pParm->rect.wTop*__RegionList[bRegionId].wWidth +  pParm->rect.wLeft) >> __RegionList[bRegionId].bColorMode;
    bPositionStart = ((DWORD)pParm->rect.wTop*__RegionList[bRegionId].wWidth +  pParm->rect.wLeft) % (1<< __RegionList[bRegionId].bColorMode);

    dwStartAddress = __RegionList[bRegionId].dwTAddr + dwByteOffset;

    //printf("base = %lx, dwByteOffset = %lx, dwStartAddress = %lx", __RegionList[bRegionId].dwTAddr, dwByteOffset, dwStartAddress);
    //printf("Width = %lx, Height = %lx", __RegionList[bRegionId].wWidth, __RegionList[bRegionId].wHeight);



    for (i = 0 ; i<= pParm->rect.wBottom - pParm->rect.wTop; i++)
    {
        dwAddressCount = dwStartAddress + dwRegionWidthInByte*i;
        bPosition = bPositionStart;

        for (j = 0 ; j<= pParm->rect.wRight- pParm->rect.wLeft; j++)
        {
                _gdi_SetPixel(dwAddressCount, bPosition, __RegionList[bRegionId].bColorMode, pParm->bColor);

                switch(__RegionList[bRegionId].bColorMode)
                {
                    case GDI_OSD_8B_MODE:
                        dwAddressCount++;
                        break;

                    case GDI_OSD_4B_MODE:
                        bPosition++;
                        if (bPosition == 2)
                        {
                            bPosition = 0;
                            dwAddressCount++;
                        }
                        break;
                     case GDI_OSD_2B_MODE:
                        bPosition++;
                        if (bPosition == 4)
                        {
                            bPosition = 0;
                            dwAddressCount++;
                        }
                        break;

                }


        }


    }


}
#endif  // SUPPORT_GDI_FILL_RECT_BY_SW




void GDI_FillRect(BYTE bRegionId, PARM_RECT *pParm)
{
    DWORD i, dwIndex;
    PARM_RECT rect;

    if (bRegionId & GDI_SHADING_OPERATION)
    {
        bRegionId = bRegionId - GDI_SHADING_OPERATION;

        rect.rect.wLeft = pParm->rect.wLeft;
        rect.rect.wRight = pParm->rect.wRight;

        dwIndex = 0;
        for (i=pParm->rect.wTop; i<=pParm->rect.wBottom; i++)
        {
            rect.rect.wTop = i;
            rect.rect.wBottom = i;
            rect.bColor = pParm->bShadePtr[dwIndex];
            _gdi_FillRect(bRegionId, &rect);

            if (dwIndex <  pParm->bColor-1)
            {
                dwIndex++;
            }

        }

    }
    else
    {
        _gdi_FillRect(bRegionId, pParm);

    }

}


//  *********************************************************************
//  Function    :   GDI_FillRect
//  Description :   This function fills the rectangle
//  Arguments   :   pParm points to the PARM_RECT
//  Return      :   none
//  Side Effect :
//  Note        :
//  *********************************************************************
void _gdi_FillRect(BYTE bRegionId, PARM_RECT *pParm)
{
    DWORD dwAddress;
    WORD wOp_width, wOp_height;
    WORD wAg_width, wAg_offset;
	WORD wOSDWidth, wOSDHeight;
	DWORD dwOSDBase;
	BYTE b4bitMode;


    if (bRegionId & GDI_SHADING_OPERATION)
    {
        bRegionId = bRegionId - GDI_SHADING_OPERATION;
    }


    if (bRegionId >= NUMBER_OF_REGION)
        return;


	wOSDWidth = __RegionList[bRegionId].wWidth;
	wOSDHeight = __RegionList[bRegionId].wHeight;
	dwOSDBase = __RegionList[bRegionId].dwTAddr;
	b4bitMode = __RegionList[bRegionId].bColorMode;


	// do boundary check
    if (pParm->rect.wLeft >= wOSDWidth ||
        pParm->rect.wTop >= wOSDHeight ||
        pParm->rect.wLeft > pParm->rect.wRight ||
        pParm->rect.wTop > pParm->rect.wBottom)
        return; // the position is not in the area

	if (pParm->rect.wBottom >= wOSDHeight)
		pParm->rect.wBottom = wOSDHeight-1;

    // brian2.21, also protect width range
    if (pParm->rect.wRight >= wOSDWidth)
		pParm->rect.wRight = wOSDWidth-1;


	if (pParm->rect.wRight == pParm->rect.wLeft) // Brian1.22, width need to be 2n, doesn't support 1-pixel width
        return;


#ifdef SUPPORT_GDI_FILL_RECT_BY_SW
    // brian2.21, 4-bit OSD mode fill DRAM directly
    if (__RegionList[bRegionId].bColorMode == GDI_OSD_4B_MODE)
    {
        _gdi_FillRectBySW(bRegionId, pParm);
        return;
    }
#endif



#ifndef GDI_WITHOUT_OS
    OS_LockMutex(&__mutexGDIIdle);
#endif

    // Reset VPU
     _gdi_ResetVPU();

#ifdef SUPPORT_CT909S
    REG_GPU_CTL0 |= GPU_OP; // enable gpu_op
#endif


    if (pParm->rect.wRight >= wOSDWidth)
        pParm->rect.wRight = wOSDWidth-1;

#ifdef SUPPORT_CT909S
    if (b4bitMode == GDI_OSD_2B_MODE)
    {
        wOSDWidth = ((wOSDWidth+15)>>4)*16;
    }
#endif


    dwAddress = dwOSDBase + (((DWORD)pParm->rect.wTop*wOSDWidth + pParm->rect.wLeft)>>b4bitMode);


#ifdef SUPPORT_CT909S
    wOp_width = ((pParm->rect.wRight - pParm->rect.wLeft + 1) & 0x3ff)>>b4bitMode;   // use 10 bit
    wOp_height = ((pParm->rect.wBottom - pParm->rect.wTop + 1) &0x3ff);   // use 10 bit
    wAg_width = (wOp_width + (dwAddress & 0x3) + 3) >> 2;                       // 4-byte alignment
    wAg_offset = (((wOSDWidth>>b4bitMode) + 3)>>2) - wAg_width + 1;     // 4-byte alignment
#else
    wOp_width = ((pParm->rect.wRight - pParm->rect.wLeft + 1) & 0xfff)>>b4bitMode;   // use 12 bit
    wOp_height = ((pParm->rect.wBottom - pParm->rect.wTop + 1) &0x7ff);   // use 11 bit
    wAg_width = (wOp_width + (dwAddress & 0x7) + 7) >> 3;
    wAg_offset = (((wOSDWidth>>b4bitMode) + 7)>>3) - wAg_width + 1;
#endif




    if (b4bitMode == GDI_OSD_4B_MODE)
    {
        pParm->bColor = (pParm->bColor << 4) | pParm->bColor;
    }
#ifdef SUPPORT_CT909S
    else if (b4bitMode == GDI_OSD_2B_MODE)
    {
        pParm->bColor = (pParm->bColor << 6) | (pParm->bColor << 4) | (pParm->bColor << 2) | pParm->bColor;
    }
#endif



    REG_GPU_CTL1 = (pParm->bColor << 24);
    REG_GPU_OP_SIZE = (wOp_height << 16) + wOp_width;

#ifdef SUPPORT_CT909S
    REG_GPU_AG_OFF = (wAg_offset) << 16; // ag_width is not used in CT909S

#else
    REG_GPU_AG_OFF = ((wAg_width << 8) + wAg_offset) << 16;
#endif

    REG_GPU_SRC_ADDR = 0;
    REG_GPU_DEST_ADDR = dwAddress;

    // Brian1.02
#ifdef GDI_CHECK_DISP_MEM_LINE
{
    DWORD dwStartTick;

    dwStartTick = OS_GetSysTimer();

    while (OS_GetSysTimer() -dwStartTick <30) // check for 30 msec
    {

#ifdef SUPPORT_CT909S
        if ( (REG_DISP_MEM_LINE & 0x3FF) < (pParm->rect.wTop) || // + REGION_Y_NTSC -10) ||
              (REG_DISP_MEM_LINE & 0x3FF) > (pParm->rect.wBottom + REGION_Y_PAL))  //REGION_Y_NTSC))
#else
        if ( (REG_DISP_MEM_LINE & 0x7FF) < (pParm->rect.wTop) || // + REGION_Y_NTSC -10) ||
              (REG_DISP_MEM_LINE & 0x7FF) > (pParm->rect.wBottom + REGION_Y_PAL))  //REGION_Y_NTSC))
#endif
        {

            break;
        }
        MACRO_IDLE();
        MACRO_IDLE();
    }
}

#endif

    asm volatile ( "" : : : "memory" );  //HAL_REORDER_BARRIER();

#ifdef SUPPORT_CT909S

#ifdef GDI_CHECK_DISP_MEM_LINE_BY_HW
    REG_GPU_OP_THRE = (pParm->rect.wTop << 16) | (pParm->rect.wBottom + REGION_Y_PAL);

    REG_GPU_CTL0 = GPU_INT_EN |GPU_OP | (4 << 16)  | (4 << 20) | (GPU_FILLRECTANGLE << 2) | GPU_START | GPU_OP_JUDGE_EN;

#else
    REG_GPU_CTL0 = GPU_INT_EN |GPU_OP | (4 << 16)  | (4 << 20) | (GPU_FILLRECTANGLE << 2) | GPU_START;
#endif



#else
    REG_GPU_CTL0 = GPU_INT_EN | GPU_REQ_EN | GPU_W_REL_EN | (0x10 << 16) | (GPU_FILLRECTANGLE << 2) | GPU_START;
#endif

/*
	// wait command complete
	while (REG_GPU_CTL0 & GPU_STATUS)
	{
		// need time out check here
	}
*/
    _gdi_CheckCmdComplete();

#ifndef GDI_WITHOUT_OS
    OS_UnlockMutex(&__mutexGDIIdle);
#endif

}