📄 post_test.c
字号:
if (OutRGBFormat) {
UART_Printf ("%3d %3d %3d\n", r>>2, g>>2, b>>2);
}
else {
//fprintf ( output_F, "%3d %3d %3d\n", (r&0x3e0>>2), (g&0x3f0>>2), (b&0x3e0>>2));
UART_Printf ("%3d %3d %3d\n", (r&0x3e0)>>2, (g&0x3f0)>>2, (b&0x3e0)>>2);
}
}
#if (POST_IMAGE_SORCE == POST_IMAGE_HEADER)
static void POSTT_GetImageFromHeader(u32 uFbAddr, u32 uHSize, u32 uVSize, CSPACE eBpp)
{
u32 i;
u16 *pBufAddr16;
u32 *pBufAddr32;
pBufAddr16 = (u16 *)uFbAddr;
pBufAddr32 = (u32 *)uFbAddr;
switch(eBpp)
{
case RGB16 : for(i=0 ; i<uHSize*uVSize ; i++)
{
//*pBufAddr16++ = pGuitar240320_16rgb[i];
//*pBufAddr16++ = pRacingGirl320240[i];
*pBufAddr16++ = sun320240_16bpp[i];
}
break;
case RGB24 : for(i=0 ; i<uHSize*uVSize ; i++)
{
//*pBufAddr32++ = pGuitar240320_24rgb[i];
*pBufAddr32++ = pYepp320x240[i];
}
break;
case YC420 : for(i=0 ; i<uHSize*uVSize ; i++)
{
*pBufAddr16++ = pGuitar240320_YCbYCr420[i];
}
break;
case YCBYCR : for(i=0 ; i<uHSize*uVSize ; i++)
{
*pBufAddr16++ = pGuitar240320_YCbYCr422[i];
}
break;
case YCRYCB : for(i=0 ; i<uHSize*uVSize ; i++)
{
*pBufAddr16++ = pGuitar240320_YCrYCb422[i];
}
break;
case CBYCRY : for(i=0 ; i<uHSize*uVSize ; i++)
{
*pBufAddr16++ = pGuitar240320_CbYCrY422[i];
}
break;
case CRYCBY : for(i=0 ; i<uHSize*uVSize ; i++)
{
*pBufAddr16++ = pGuitar240320_CrYCbY422[i];
}
break;
default : break;
}
}
#endif
static void POSTT_GetImageFromBMP(u32 uFbAddr, u32 uHSize, u32 uVSize, u32 NumOfImage, CSPACE eBpp)
{
u32 ImageNum;
u16 *pBufAddr16;
u32 *pBufAddr32;
u32 *uBuffer_Temp;
uBuffer_Temp = (u32 *)malloc(300000); //bmp file
pBufAddr16 = (u16 *)uFbAddr;
pBufAddr32 = (u32 *)uFbAddr;
ImageNum = NumOfImage%(sizeof(Image_Entertain)/4);
switch(eBpp)
{
case RGB16 : LoadFromFile((const char*)Image_Entertain[ImageNum], (u32)uBuffer_Temp);
ConvertBmpToRgb16bpp((u32)uBuffer_Temp, (u32)pBufAddr16, uHSize, uVSize);
break;
case RGB24 : LoadFromFile((const char*)Image_Entertain[ImageNum], (u32)uBuffer_Temp);
ConvertBmpToRgb24bpp((u32)uBuffer_Temp, (u32)pBufAddr32, uHSize, uVSize);
break;
default : break;
}
free(uBuffer_Temp);
}
////////////////////////////////////////////////////////////////////////////
////////////////// RGB to RGB ///////////////////
////////////////////////////////////////////////////////////////////////////
static void POSTT_SetCscTypeDmaToDma_R2R(void)
{
u32 uSelDmaCscType_R2R;
while(1)
{
UART_Printf("\n");
UART_Printf("[1] From RGB16 To RGB16\n");
UART_Printf("[2] From RGB16 To RGB24\n");
UART_Printf("[3] From RGB24 To RGB16\n");
UART_Printf("[4] From RGB24 To RGB24\n");
UART_Printf("\n");
UART_Printf(">>Select The Color Space Conversion Type: ");
uSelDmaCscType_R2R = UART_GetIntNum();
if (uSelDmaCscType_R2R == 1 || uSelDmaCscType_R2R == 2 || uSelDmaCscType_R2R == 3 || uSelDmaCscType_R2R == 4)
{
eSrcDataFmt = (uSelDmaCscType_R2R == 1 || uSelDmaCscType_R2R == 2) ? RGB16 : RGB24;
eDstDataFmt = (uSelDmaCscType_R2R == 1 || uSelDmaCscType_R2R == 3) ? RGB16 : RGB24;
break;
}
else
UART_Printf("Invalid Input! Retry It!!\n");
}
if (eSrcDataFmt == RGB16 && eDstDataFmt == RGB16)
{
// Scale up(width, height)
uImgHSz = 120, uImgVSz = 160;
uSrcStartX = 20, uSrcStartY = 30;
uSrcCroppedHSz = 88, uSrcCroppedVSz = 100;
uDstStartX = 40, uDstStartY = 80;
uDstScaledHSz = 160, uDstScaledVSz = 160;
}
else if (eSrcDataFmt == RGB16 && eDstDataFmt == RGB24)
{
// Scale up(width), scale down(height)
uImgHSz = 240, uImgVSz = 320;
uSrcStartX = 80, uSrcStartY = 160;
uSrcCroppedHSz = 120, uSrcCroppedVSz = 160;
uDstStartX = 20, uDstStartY = 40;
uDstScaledHSz = 200, uDstScaledVSz = 120;
}
else if (eSrcDataFmt == RGB24 && eDstDataFmt == RGB16)
{
// scale down(width), scale up(height)
uImgHSz = 360, uImgVSz = 480;
uSrcStartX = 30, uSrcStartY = 40;
uSrcCroppedHSz = 160, uSrcCroppedVSz = 100;
uDstStartX = 10, uDstStartY = 50;
uDstScaledHSz = 120, uDstScaledVSz = 190;
}
else if (eSrcDataFmt == RGB24 && eDstDataFmt == RGB24)
{
// scale down(widht, height)
uImgHSz = 360, uImgVSz = 480;
uSrcStartX = 80, uSrcStartY = 20;
uSrcCroppedHSz = 168, uSrcCroppedVSz = 240;
uDstStartX = 100, uDstStartY = 100;
uDstScaledHSz = 128, uDstScaledVSz = 140;
}
else
{
UART_Printf("Error! Unsupported Data Format!\n");
return;
}
UART_Printf("\n");
if(uSimpleTest == 0)
{
UART_Printf("========= Complex_Test Image Size =========\n");
UART_Printf("SrcImgHSz = %d, SrcImgVSz = %d\n",uImgHSz,uImgVSz);
UART_Printf("SrcStartX = %d, SrcStartY = %d\n",uSrcStartX,uSrcStartY);
UART_Printf("SrcCroppedHSz = %d, SrcCroppedVSz = %d\n",uSrcCroppedHSz,uSrcCroppedVSz);
UART_Printf("DstStartX = %d, DstStartY = %d\n",uDstStartX,uDstStartY);
UART_Printf("DstScaledHSz = %d, DstScaledVSz = %d\n",uDstScaledHSz,uDstScaledVSz);
UART_Printf("=================================================\n");
UART_Printf("\n");
}
}
static void POSTT_SimpleDmaToDma_R2R(void)
{
u32 uLcdHSz, uLcdVSz;
u32 uGlibStAddr;
u32 uBytesPerPixel;
UART_Printf("[POSTT_SimpleDmaToDma_R2R(No Scaling)]\n");
uSimpleTest = 1;
POSTT_SetCscTypeDmaToDma_R2R();
LCD_InitDISPC(eDstDataFmt, uLcdStAddr, WIN0, false);
LCD_Start();
LCD_SetWinOnOff(1, WIN0);
LCD_GetFrmSz(&uLcdHSz, &uLcdVSz, WIN0);
// To Clear the LCD Display
GLIB_Init(uLcdStAddr, uLcdHSz, uLcdVSz, eDstDataFmt);
GLIB_ClearFrame(C_BLACK);
uBytesPerPixel = (eDstDataFmt == RGB16) ? 2: 4;
uGlibStAddr = uLcdStAddr + uLcdHSz*uLcdVSz*uBytesPerPixel;
#if (POST_IMAGE_SORCE == POST_IMAGE_PATTERN)
GLIB_Init(uGlibStAddr, uLcdHSz, uLcdVSz, eSrcDataFmt);
GLIB_DrawPattern(uLcdHSz, uLcdVSz);
#elif (POST_IMAGE_SORCE == POST_IMAGE_HEADER)
POSTT_GetImageFromHeader(uGlibStAddr, uLcdHSz, uLcdVSz, eSrcDataFmt);
#endif
POST_InitIpForDmaInDmaOut( uLcdHSz, uLcdVSz, uGlibStAddr, eSrcDataFmt,
uLcdHSz, uLcdVSz, uLcdStAddr, eDstDataFmt,
1, false, ONE_SHOT, &oPost );
POST_StartProcessing(&oPost);
while (!POST_IsProcessingDone(&oPost));
#if (POST_IMAGE_BMP_SLIDE)
{
u32 uImageNum;
UART_Printf("Input the any key to display the other image ('q' : quit)\n");
uImageNum = 0;
while(UART_Getc() != 'q')
{
POSTT_GetImageFromBMP(uGlibStAddr, uLcdHSz, uLcdVSz, uImageNum, eSrcDataFmt);
// Only CSC operation, not Scaling
POST_InitIpForDmaInDmaOut( uLcdHSz, uLcdVSz, uGlibStAddr, eSrcDataFmt,
uLcdHSz, uLcdVSz, uLcdStAddr, eDstDataFmt,
1, false, ONE_SHOT, &oPost );
POST_StartProcessing(&oPost);
while (!POST_IsProcessingDone(&oPost));
uImageNum++;
}
}
#endif
}
static void POSTT_ComplexIDmaToDma_R2R(void)
{
u32 uGlibStAddr=0;
u32 uBytesPerPixel=0;
u32 uSrcStAddr;
UART_Printf("[POSTT_ComplexIDmaToDma_R2R]\n");
uSimpleTest = 0;
POSTT_SetCscTypeDmaToDma_R2R();
//bIsR2Y2RFlag = false;
ePostRunMode = ONE_SHOT;
//LCD_InitLDI(MAIN);
#ifdef LCD_INIT_TEST
LCD_InitBase();
LCD_Start();
LCD_InitWin(eDstDataFmt, uImgHSz, uImgVSz, 0, 0, uImgHSz, uImgVSz, 0, 0, uLcdStAddr, WIN0, false);
#else
LCD_InitDISPC(eDstDataFmt, uLcdStAddr, WIN0, false);
LCD_Start();
#endif
LCD_SetWinOnOff(1, WIN0);
LCD_GetFrmSz(&uLcdHSz, &uLcdVSz, WIN0);
// To Clear the LCD Display
GLIB_Init(uLcdStAddr, uLcdHSz, uLcdVSz, eDstDataFmt);
GLIB_ClearFrame(C_BLACK);
uBytesPerPixel = (eDstDataFmt == RGB16) ? 2: 4;
uGlibStAddr = uLcdStAddr + uLcdHSz*uLcdVSz*uBytesPerPixel;
uSrcStAddr=0;
// CSC & Scaling the DrawPattern 1
#if (POST_IMAGE_SORCE == POST_IMAGE_PATTERN)
GLIB_Init(uGlibStAddr, uImgHSz, uImgVSz, eSrcDataFmt);
GLIB_DrawPattern(uImgHSz, uImgVSz);
#elif (POST_IMAGE_SORCE == POST_IMAGE_HEADER)
POSTT_GetImageFromHeader(uGlibStAddr, uLcdHSz, uLcdVSz, eSrcDataFmt);
#endif
POST_InitIp1( uImgHSz, uImgVSz, uSrcStartX, uSrcStartY, uSrcCroppedHSz, uSrcCroppedVSz, uGlibStAddr, eSrcDataFmt,
uLcdHSz, uLcdVSz, uDstStartX, uDstStartY, uDstScaledHSz, uDstScaledVSz, uLcdStAddr, eDstDataFmt,
2, false, ePostRunMode, POST_DMA, POST_DMA, &oPost);
UART_Printf("Draw Pattern 1(Frame 0)\n");
POST_StartProcessing1(0, 0, &oPost);
while (!POST_IsProcessingDone(&oPost));
UART_Printf("Enter Any Key\n");
UART_Getc();
// CSC & Scaling the DrawPattern 2
POST_GetSrcStAddr(1, &uSrcStAddr, &oPost);
GLIB_Init(uSrcStAddr, uImgHSz, uImgVSz, eSrcDataFmt);
GLIB_DrawPattern2(uImgHSz, uImgVSz);
UART_Printf("Draw Pattern 2(Frame 1)\n");
POST_StartProcessing1(1, 0, &oPost);
while (!POST_IsProcessingDone(&oPost));
}
static void POSTT_SimpleFreeRunDmaToDma_R2R_Polling(void)
{
u32 uGlibStAddr=0, uGlibStAddr2=0;
u32 uBytesPerPixel=0;
u32 uFrmCnt = 0;
UART_Printf("[POSTT_SimpleFreeRunDmaToDma_R2R_Polling]\n");
uSimpleTest = 1;
POSTT_SetCscTypeDmaToDma_R2R();
bIsPollingOrInt = TRUE; // Polling
//LCD_InitLDI(MAIN);
#ifdef LCD_INIT_TEST
LCD_InitBase();
LCD_Start();
LCD_InitWin(eDstDataFmt, uImgHSz, uImgVSz, 0, 0, uImgHSz, uImgVSz, 0, 0, uLcdStAddr, WIN0, false);
#else
LCD_InitDISPC(eDstDataFmt, uLcdStAddr, WIN0, false);
LCD_Start();
#endif
LCD_SetWinOnOff(1, WIN0);
LCD_GetFrmSz(&uLcdHSz, &uLcdVSz, WIN0);
//uBytesPerPixel = (eDstDataFmt == RGB16) ? 2: 4;
uBytesPerPixel = 4;
uGlibStAddr = uLcdStAddr + uLcdHSz*uLcdVSz*uBytesPerPixel;
uGlibStAddr2 = uGlibStAddr + uLcdHSz*uLcdVSz*uBytesPerPixel;
GLIB_Init(uGlibStAddr, uLcdHSz, uLcdVSz, eSrcDataFmt);
GLIB_DrawPattern(uLcdHSz, uLcdVSz);
GLIB_Init(uGlibStAddr2, uLcdHSz, uLcdVSz, eSrcDataFmt);
GLIB_DrawPattern2(uLcdHSz, uLcdVSz);
POST_InitIpForDmaInDmaOut( uLcdHSz, uLcdVSz, uGlibStAddr, eSrcDataFmt,
uLcdHSz, uLcdVSz, uLcdStAddr, eDstDataFmt,
1, false, FREE_RUN, &oPost);
POST_SetNextFrameStAddr(uGlibStAddr, uLcdStAddr, &oPost);
uFrmCnt = 0;
POST_StartProcessing(&oPost);
while(uFrmCnt<uMaxFrameCnt)
{
while (!POST_IsProcessingDone(&oPost));
if (uFrmCnt%2)
POST_SetNextFrameStAddr(uGlibStAddr2, uLcdStAddr, &oPost);
else
POST_SetNextFrameStAddr(uGlibStAddr, uLcdStAddr, &oPost);
POST_ClearPending(&oPost);
DelayfrTimer(milli, 1000);
uFrmCnt++;
}
POST_StopProcessingOfFreeRun(&oPost);
while (!POST_IsProcessingDone(&oPost));
POST_ClearPending(&oPost);
#if (POST_IMAGE_BMP_SLIDE)
POSTT_GetImageFromBMP(uGlibStAddr, uLcdHSz, uLcdVSz, 8, eSrcDataFmt);
POSTT_GetImageFromBMP(uGlibStAddr2, uLcdHSz, uLcdVSz, 9, eSrcDataFmt);
POST_InitIpForDmaInDmaOut( uLcdHSz, uLcdVSz, uGlibStAddr, eSrcDataFmt,
uLcdHSz, uLcdVSz, uLcdStAddr, eDstDataFmt,
1, false, FREE_RUN, &oPost);
POST_SetNextFrameStAddr(uGlibStAddr, uLcdStAddr, &oPost);
uFrmCnt = 0;
POST_StartProcessing(&oPost);
while(uFrmCnt<uMaxFrameCnt)
{
while (!POST_IsProcessingDone(&oPost));
if (uFrmCnt%2)
POST_SetNextFrameStAddr(uGlibStAddr2, uLcdStAddr, &oPost);
else
POST_SetNextFrameStAddr(uGlibStAddr, uLcdStAddr, &oPost);
POST_ClearPending(&oPost);
DelayfrTimer(milli, 1000);
uFrmCnt++;
}
POST_StopProcessingOfFreeRun(&oPost);
while (!POST_IsProcessingDone(&oPost));
POST_ClearPending(&oPost);
#endif
}
void POSTT_SimpleFreeRunDmaToDma_R2R_Int(void)
{
u32 uBytesPerPixel=0;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -