wince 2416 应用程序更改屏参

最新推荐文章于 2016-07-21 15:44:51 发布
最新推荐文章于 2016-07-21 15:44:51 发布
阅读量840 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SVS4414/article/details/46357721
版权
1，首先需要设置注册表值
[HKEY_LOCAL_MACHINE\System\GDI\Lcd]
"ScreenWidth" =dword:320
"ScreenHeight"=dword:1e0
"HBP" =dword:a
"HFP"=dword:14
"HSW" =dword:24
"PPL"=dword:1e0
"VBP" =dword:10
"VFP"=dword:d
"VSW" =dword:7
"LPP"=dword:0
"CLKDIV" =dword:40
"CPL"=dword:20
"IOE" =dword:0
"IPC"=dword:0
"IHS" =dword:0
"IVS"=dword:10
"RGB" =dword:3c

"LIGHT"=dword:0

2，更改底层

s3c2416_ldi.c

DWORD   svsbuf[18];


int
GetLcdValueFromReg()
{
    HKEY hKey;
    int nRet = DMDO_0;
DWORD   dwSize, dwAngle, dwType = REG_DWORD;
DWORD   ScreenWidth=320;
DWORD ScreenHeight=240;
DWORD HBP=38;
DWORD HFP=2;
DWORD HSW=8;
DWORD PPL=19;
DWORD VBP=16;
DWORD VFP=4;
DWORD VSW=1;
DWORD LPP=239;
DWORD CLKDIV=5;
DWORD CPL=319;
DWORD IOE=0;
DWORD IPC=1;
DWORD IHS=1;
DWORD IVS=1;
DWORD RGB=1;
DWORD LIGHT=0;



    if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\GDI\\LCD"),0,0, &hKey))
    {
       
        dwSize = sizeof(DWORD);
        if (ERROR_SUCCESS == RegQueryValueEx(hKey,
                                               TEXT("LCDWIDTH"),
                                               NULL,
                                               &dwType,
                                               (LPBYTE)&dwAngle,
                                               &dwSize))
        {
            
   // LDI_MSG((_T("[LDI]--LDI_deinitialize_LCD_module() : %d\n\r"), dwAngle));
        }
RegQueryValueEx(hKey,  TEXT("ScreenWidth"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[0]=dwAngle;
RegQueryValueEx(hKey,  TEXT("ScreenHeight"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[1]=dwAngle;
RegQueryValueEx(hKey,  TEXT("HBP"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[2]=dwAngle;
RegQueryValueEx(hKey,  TEXT("HFP"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[3]=dwAngle;
RegQueryValueEx(hKey,  TEXT("HSW"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[4]=dwAngle;
RegQueryValueEx(hKey,  TEXT("PPL"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[5]=dwAngle;
RegQueryValueEx(hKey,  TEXT("VBP"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[6]=dwAngle;
RegQueryValueEx(hKey,  TEXT("VFP"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[7]=dwAngle;
RegQueryValueEx(hKey,  TEXT("VSW"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[8]=dwAngle;
RegQueryValueEx(hKey,  TEXT("LPP"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[9]=dwAngle;
RegQueryValueEx(hKey,  TEXT("CLKDIV"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[10]=dwAngle;
RegQueryValueEx(hKey,  TEXT("CPL"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[11]=dwAngle;
RegQueryValueEx(hKey,  TEXT("IOE"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[12]=dwAngle;
RegQueryValueEx(hKey,  TEXT("IPC"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[13]=dwAngle;
RegQueryValueEx(hKey,  TEXT("IHS"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[14]=dwAngle;
RegQueryValueEx(hKey,  TEXT("IVS"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[15]=dwAngle;
RegQueryValueEx(hKey,  TEXT("RGB"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[16]=dwAngle;
RegQueryValueEx(hKey,  TEXT("LIGHT"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[17]=dwAngle;


        RegCloseKey(hKey);
    }
RETAILMSG(1, (TEXT("wNUM_BLOCKS : %d %d \r\n"), svsbuf[0], svsbuf[1]));


    return dwAngle;
}


LDI_ERROR LDI_fill_output_device_information(void *pDevInfo)
{
LDI_ERROR error = LDI_SUCCESS;
tDevInfo *pDeviceInfo;
DWORD LCD_WD;


LDI_MSG((_T("[LDI]++LDI_fill_output_device_information()\n\r")));


if (pDevInfo == NULL)
{
LDI_ERR((_T("[LDI:ERR] LDI_fill_output_device_information() : Null Parameter\n\r")));
error = DISP_ERROR_NULL_PARAMETER;
goto CleanUp;
}


pDeviceInfo = (tDevInfo *)pDevInfo;
LCD_WD=GetLcdValueFromReg();


pDeviceInfo->RGBOutMode = LCD_RGB_OUT_MODE;
pDeviceInfo->uiWidth = svsbuf[0];//;
pDeviceInfo->uiHeight = svsbuf[1];//LCD_HEIGHT;
pDeviceInfo->VBPD_Value =svsbuf[6];// LCD_VBPD;
pDeviceInfo->VFPD_Value = svsbuf[7];//LCD_VFPD;
pDeviceInfo->VSPW_Value = svsbuf[8];//LCD_VSPW;
pDeviceInfo->HBPD_Value = svsbuf[2];//LCD_HBPD;
pDeviceInfo->HFPD_Value = svsbuf[3];//LCD_HFPD;
pDeviceInfo->HSPW_Value = svsbuf[4];//LCD_HSPW;
pDeviceInfo->VCLK_Polarity =svsbuf[9];// LCD_VCLK_POLARITY;
pDeviceInfo->HSYNC_Polarity =svsbuf[10];// LCD_HSYNC_POLARITY;
pDeviceInfo->VSYNC_Polarity =svsbuf[11];// LCD_VSYNC_POLARITY;
pDeviceInfo->VDEN_Polarity = svsbuf[12];//LCD_VDEN_POLARITY;
pDeviceInfo->PNR_Mode = svsbuf[13];//LCD_PNR_MODE;
pDeviceInfo->VCLK_Source = svsbuf[14];//LCD_VCLK_SOURCE;
pDeviceInfo->VCLK_Direction = svsbuf[15];//LCD_VCLK_DIRECTION;
pDeviceInfo->Frame_Rate =svsbuf[16];// LCD_FRAME_RATE; // VCLK (Max 10 MHz)


CleanUp:


LDI_MSG((_T("[LDI]--LDI_fill_output_device_information()\n\r")));


return error;
}

3还要改个地方s3c2416_disp.cpp 
DWORD   svsbuf[18];


int
GetLcdValueFromReg()
{
    HKEY hKey;
    int nRet = DMDO_0;
DWORD   dwSize, dwAngle, dwType = REG_DWORD;
DWORD   ScreenWidth=320;
DWORD ScreenHeight=240;
DWORD HBP=38;
DWORD HFP=2;
DWORD HSW=8;
DWORD PPL=19;
DWORD VBP=16;
DWORD VFP=4;
DWORD VSW=1;
DWORD LPP=239;
DWORD CLKDIV=5;
DWORD CPL=319;
DWORD IOE=0;
DWORD IPC=1;
DWORD IHS=1;
DWORD IVS=1;
DWORD RGB=1;
DWORD LIGHT=0;



    if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\GDI\\LCD"),0,0, &hKey))
    {
       
        dwSize = sizeof(DWORD);
        if (ERROR_SUCCESS == RegQueryValueEx(hKey,
                                               TEXT("LCDWIDTH"),
                                               NULL,
                                               &dwType,
                                               (LPBYTE)&dwAngle,
                                               &dwSize))
        {
            
   // LDI_MSG((_T("[LDI]--LDI_deinitialize_LCD_module() : %d\n\r"), dwAngle));
        }
RegQueryValueEx(hKey,  TEXT("ScreenWidth"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[0]=dwAngle;
RegQueryValueEx(hKey,  TEXT("ScreenHeight"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[1]=dwAngle;
RegQueryValueEx(hKey,  TEXT("HBP"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[2]=dwAngle;
RegQueryValueEx(hKey,  TEXT("HFP"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[3]=dwAngle;
RegQueryValueEx(hKey,  TEXT("HSW"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[4]=dwAngle;
RegQueryValueEx(hKey,  TEXT("PPL"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[5]=dwAngle;
RegQueryValueEx(hKey,  TEXT("VBP"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[6]=dwAngle;
RegQueryValueEx(hKey,  TEXT("VFP"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[7]=dwAngle;
RegQueryValueEx(hKey,  TEXT("VSW"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[8]=dwAngle;
RegQueryValueEx(hKey,  TEXT("LPP"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[9]=dwAngle;
RegQueryValueEx(hKey,  TEXT("CLKDIV"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[10]=dwAngle;
RegQueryValueEx(hKey,  TEXT("CPL"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[11]=dwAngle;
RegQueryValueEx(hKey,  TEXT("IOE"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[12]=dwAngle;
RegQueryValueEx(hKey,  TEXT("IPC"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[13]=dwAngle;
RegQueryValueEx(hKey,  TEXT("IHS"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[14]=dwAngle;
RegQueryValueEx(hKey,  TEXT("IVS"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[15]=dwAngle;
RegQueryValueEx(hKey,  TEXT("RGB"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[16]=dwAngle;
RegQueryValueEx(hKey,  TEXT("LIGHT"),  NULL,&dwType, (LPBYTE)&dwAngle,&dwSize);
svsbuf[17]=dwAngle;


        RegCloseKey(hKey);
    }
RETAILMSG(1, (TEXT("wNUM_BLOCKS : %d %d \r\n"), svsbuf[0], svsbuf[1]));


    return dwAngle;
}




static void InitDisplay(void)
{
UINT8 pagewidth_in_byte = 0,offsize_in_byte = 0;
volatile S3C2416_IOPORT_REG *s2416IOP ;//= (S3C2416_IOPORT_REG *)OALPAtoVA(S3C2416_BASE_REG_PA_IOPORT, FALSE);
volatile S3C2416_LCD_REG    *s2416LCD ;//= (S3C2416_LCD_REG *)OALPAtoVA(S3C2416_BASE_REG_PA_LCD, FALSE);
//volatile S3C2416_INTR_REG *s2416INTR = (S3C2416_INTR_REG *)OALPAtoVA(S3C2416_BASE_REG_PA_INTR, FALSE);





    s2416LCD = (S3C2416_LCD_REG *)DrvLib_MapIoSpace(S3C2416_BASE_REG_PA_LCD, sizeof(S3C2416_LCD_REG), FALSE);
    if (s2416LCD == NULL)
    {
        DISPDRV_ERR((_T("[DISPDRV:ERR] AllocResource() : m_pLcdConReg DrvLib_MapIoSpace() Failed \n\r")));
//        return FALSE;
    }


    s2416IOP = (S3C2416_IOPORT_REG *)DrvLib_MapIoSpace(S3C2416_BASE_REG_PA_IOPORT, sizeof(S3C2416_IOPORT_REG), FALSE);
    if (s2416IOP == NULL)
    {
        DISPDRV_ERR((_T("[DISPDRV:ERR] AllocResource() : m_pGPIOReg DrvLib_MapIoSpace() Failed \n\r")));
      //  return FALSE;
    }


  


UINT8 clkval=0;
UINT16 hsync_cnt,vclk_cnt;
UINT16 lcd_horizon_value,lcd_line_value;
UINT8 lcd_vbpd,lcd_vfpd,lcd_vspw,lcd_hbpd,lcd_hfpd,lcd_hspw;
UINT8 lcd_frame_rate;
int i;
unsigned short *pFB;


#if 1
/*
enable lcd power gph11 ->H
s2416IOP->GPHDAT |= (1<<11);
s2416IOP->GPHCON &= ~(0x3<<22);
s2416IOP->GPHCON = (0x1<<22);
*/
// memset((void *)IMAGE_FRAMEBUFFER_UA_BASE, 0xFFFF, LCD_ARRAY_SIZE_TFT_16BIT);



// Set up the LCD controller registers to display a power-on bitmap image.
//
s2416IOP->MISCCR |= (1<<28); // select LCD controller for TFT lcd controller


s2416IOP->GPCUDP = 0xFFFFFFFF;
s2416IOP->GPCCON = 0xAAAAAAAA;


s2416IOP->GPDUDP = 0xFFFFFFFF;
s2416IOP->GPDCON = 0xAAAAAAAA;




s2416IOP->GPLCON = s2416IOP->GPLCON & ~(0x3ff<<20) | (0x1<< 28) | (0x1<< 26) | (0x1<< 24) | (0x1<< 22) | (0x1<< 20);
s2416IOP->GPLDAT |= (0x1f<<10);






lcd_horizon_value = svsbuf[0];
lcd_line_value =  svsbuf[1];
lcd_vbpd = svsbuf[6];
lcd_vfpd = svsbuf[7];
lcd_vspw = svsbuf[8];
lcd_hbpd = svsbuf[2];
lcd_hfpd = svsbuf[3];
lcd_hspw = svsbuf[4];
lcd_frame_rate = svsbuf[16];


pagewidth_in_byte = lcd_horizon_value/8*16;
offsize_in_byte = 0;


//LcdWindowOnOff(LCD_WIN_ALL,LCD_OFF);
s2416LCD->WINCON0 &= ~0x01;
s2416LCD->WINCON1 &= ~0x01;




//LcdEnvidOnOff(LCD_OFF);
s2416LCD->VIDCON0 &= (~3); // ENVID Off using Per Frame method


//Basic_Display_Setting(window,WINCONx_16BPP_565,lcd_horizon_value,0);


s2416LCD->VIDCON0 = VIDCON0_S_RGB_IF|VIDCON0_S_RGB_PAR|VIDCON0_S_VCLK_GATING_OFF|VIDCON0_S_CLKDIR_DIVIDED|VIDCON0_S_CLKSEL_HCLK;


hsync_cnt = (lcd_vbpd+lcd_vfpd+lcd_vspw+lcd_line_value);
vclk_cnt = (lcd_hbpd+lcd_hfpd+lcd_hspw+lcd_horizon_value);


//clkval = (UINT8)(((float)S3C2416_HCLK/(float)(hsync_cnt*vclk_cnt*lcd_frame_rate*2))+0.5)-1;
clkval = (LCD_TFT_CLKVAL + 1);
s2416LCD->VIDCON0 |= (clkval <<VIDCON0_CLKVAL_F_SHIFT);


s2416LCD->VIDCON1 = VIDCON1_S_HSYNC_INVERTED|VIDCON1_S_VSYNC_INVERTED;


s2416LCD->VIDTCON0=((lcd_vbpd-1)<<VIDTCON0_BPD_S)|((lcd_vfpd-1)<<VIDTCON0_FPD_S)|(lcd_vspw-1);
s2416LCD->VIDTCON1=((lcd_hbpd-1)<<VIDTCON0_BPD_S)|((lcd_hfpd-1)<<VIDTCON0_FPD_S)|(lcd_hspw-1);
s2416LCD->VIDTCON2 = ((lcd_line_value-1)<<VIDTCON2_LINEVAL_S)|(lcd_horizon_value-1);
#if 1
//s2416LCD->WINCON0 = (0<<WINCON_SWAP_S)|(WINCONx_16WORD_BURST<<WINCON_BURSTLEN_S)|(WINCONx_16BPP_565<<WINCON_BPP_S); // 4word burst, 16bpp,
s2416LCD->WINCON0 = (0<<WINCON_SWAP_S)|(WINCONx_16WORD_BURST<<WINCON_BURSTLEN_S)|(WINCONx_16BPP_565<<WINCON_BPP_S); // 4word burst, 16bpp, 
s2416LCD->VIDOSD0A = (0<<VIDOSDxAB_HORIZON_X_S)|(0);
// s2416LCD->VIDOSD0B = ((lcd_horizon_value-1)<<VIDOSDxAB_HORIZON_X_S)|(lcd_line_value-1);
s2416LCD->VIDOSD0B = ((lcd_horizon_value-1)<<VIDOSDxAB_HORIZON_X_S)|(lcd_line_value-1);


s2416LCD->VIDW00ADD0B0 = (UINT32)IMAGE_FRAMEBUFFER_DMA_BASE;
// buffer size 
s2416LCD->VIDW00ADD1B0 = (UINT32)IMAGE_FRAMEBUFFER_DMA_BASE + (lcd_horizon_value*lcd_line_value*2);
// buffer size 
s2416LCD->VIDW00ADD2B0 = (offsize_in_byte<<VIDWxADD2_OFFSET_SIZE_S)|(lcd_horizon_value*2);


s2416LCD->WINCON0 |= (1<<WINCON_SWAP_S);
//*WxKEYCON0_Reg_Addr[win_num] = 0;
//*WINxMAP_Reg_Addr[win_num] = 0;
s2416LCD->WINCON0 |= 0x1; // enable Win0
s2416LCD->WINCON1 = 0x0; // disable Win1
#endif
s2416LCD->VIDCON0 |= 0x3;


//s2416INTR->INTSUBMSK |= (0xf << IRQ_SUB_LCD1); // MASK all LCD Sub Interrupt


RETAILMSG(1,(TEXT("IMAGE_FRAMEBUFFER_UA_BASE\n")));



#if 1 //HJ_del 20120210
//enable backlight
s2416IOP->GPBUDP &= ~0x3;
s2416IOP->GPBCON = (s2416IOP->GPBCON & ~((3<<6)|(3<<2)|(3<<0))) | ((1<<6)|(1<<2)|(1<<0)); // Backlight Pwm control
s2416IOP->GPBDAT |=((1<<0) |(1<<3));


s2416IOP->GPBDAT &= ~(1<<1);

s2416IOP->GPBCON = s2416IOP->GPBCON & ~(0x3<<0) | (0x1<<0);
s2416IOP->GPBDAT = s2416IOP->GPBDAT | 0x1;


#endif
//s2416IOP->GPBCON = s2416IOP->GPBCON & ~(0x3<<0) | (0x1<<0);
//s2416IOP->GPBDAT = s2416IOP->GPBDAT | 0x1;
#endif
}




S3C2416Disp::S3C2416Disp()
{
    DWORD dwSplashFrameBufferSize;
//volatile S3C2416_LCD_REG *s2416LCD = (S3C2416_LCD_REG *)OALPAtoVA(S3C2416_BASE_REG_PA_LCD, FALSE);


    DISPDRV_MSG((_T("[DISPDRV] ++S3C2416Disp::S3C2416Disp()\n\r")));


    m_pLcdConReg = NULL;
    m_pGPIOReg = NULL;
    m_pSPIReg = NULL;


    m_VideoMemoryPhysicalBase = NULL;
    m_VideoMemoryVirtualBase = NULL;
    m_VideoMemorySize = 0;
    m_pVideoMemoryHeap = NULL;


    m_hVideoDrv = NULL;


    m_CursorVisible = FALSE;
    m_CursorDisabled = TRUE;
    m_CursorForcedOff = FALSE;
    memset (&m_CursorRect, 0x0, sizeof(m_CursorRect));


    m_InDDraw = FALSE;


    InitalizeOverlayContext();


    m_bTVDMARunning = FALSE;


//---------------------
// Setup Mode Information
//---------------------
GetLcdValueFromReg();


    // Initialize Screen Dimensions
    m_dwDeviceScreenWidth = svsbuf[0];//LCD_WIDTH;
    m_dwDeviceScreenHeight = svsbuf[1];// LCD_HEIGHT;
    m_nScreenWidthSave = m_dwDeviceScreenWidth;
    m_nScreenHeightSave = m_dwDeviceScreenHeight;
InitDisplay();


    // Initialize Rotate Mode
    m_iRotate = GetRotateModeFromReg();
    SetRotateParams();


    //----------------------------------------
    // Initialize ModeInfoEX, modeInfo Data Structure
    //----------------------------------------


    //Setup ModeInfoEx, ModeInfo
    m_pModeEx = &m_ModeInfoEx;
    m_pMode = &m_ModeInfoEx.modeInfo;
    memset(m_pModeEx, 0, sizeof(GPEModeEx));


#if (LCD_BPP == 16)
    m_pModeEx->ePixelFormat = ddgpePixelFormat_565;
#elif (LCD_BPP == 32)
    m_pModeEx->ePixelFormat = ddgpePixelFormat_8888;
#endif


    // Fill GPEMode modeInfo
    m_pMode->modeId = 0;
    m_pMode->width = m_nScreenWidth;
    m_pMode->height = m_nScreenHeight;
    m_pMode->format = EDDGPEPixelFormatToEGPEFormat[m_pModeEx->ePixelFormat];
    m_pMode->Bpp = EGPEFormatToBpp[m_pMode->format];
    m_pMode->frequency = 60;        // Usually LCD Panel require 60Hz


    // Fill DDGPEStandardHeader
    m_pModeEx->dwSize = sizeof(GPEModeEx);
    m_pModeEx->dwVersion = GPEMODEEX_CURRENTVERSION;


    // Fill ModeInfoEX
    m_pModeEx->dwPixelFourCC = 0;                                // Should be Zero
    m_pModeEx->dwPixelFormatData = 0;                            // Don't care
    m_pModeEx->lPitch = m_dwDeviceScreenWidth*(m_pMode->Bpp/8);
    m_pModeEx->dwFlags = 0;                                        // Should be Zero
    m_pModeEx->dwRBitMask = gBitMasks[0];
    m_pModeEx->dwGBitMask = gBitMasks[1];
    m_pModeEx->dwBBitMask = gBitMasks[2];
    m_pModeEx->dwAlphaBitMask = 0x00000000;


    // Initialize Power State
    m_VideoPowerState = VideoPowerOn;


    // Mapping Virtual Address (SFR, VideoMemory)
    if (AllocResource() == FALSE)
    {
        DISPDRV_ERR((_T("[DISPDRV:ERR] S3C2416Disp() : AllocResource() Fail\n\r")));
        return;
    }


    // Clear Video Memory (Leave frame buffer for splash image)
    dwSplashFrameBufferSize = m_dwDeviceScreenWidth*m_dwDeviceScreenHeight*(m_pMode->Bpp/8);
    memset ((void *)(m_VideoMemoryVirtualBase+dwSplashFrameBufferSize), 0x0, m_VideoMemorySize-dwSplashFrameBufferSize);


#if G2D_ACCELERATE
    // Enable Block Power and Clock Source
    // Todo : Power Management in Video Driver
//    DevHWPowerGating(HWPWR_2D_ON);
//    DevHWClockGating(HWCLK_2D_ON);


    m_oG2D = new FIMGSE2D;
    if(m_oG2D == NULL)
    {
        DISPDRV_ERR((_T("[DISPDRV:ERR] S3C2416Disp() : 2D Accelerator Initialization Fail\n\r")));
    }


    // Initialize Interrupt (Event, Interrupt)
    if (m_oG2D)
    {
        BOOL bResult;


        bResult = m_oG2D->InitializeInterrupt();
        if(bResult==FALSE)
        {
            DISPDRV_ERR((_T("[DISPDRV:ERR] InitializeInterrupt() 2D Object is failed.\n\r")));
        }
    }
    else
    {
        DISPDRV_ERR((_T("[DISPDRV:ERR] InitializeInterrupt() : 2D Object is not created.\n\r")));
    }


#endif


    // Initialize Critical Section
    InitializeCriticalSection(&m_csDevice);
    InitializeCriticalSection(&m_cs2D);


    // Initialize Display Controller
    if (DevInitialize() == FALSE)
    {
        DISPDRV_ERR((_T("[DISPDRV:ERR] S3C2416Disp() : InitializeDevice() Fail\n\r")));
        return;
    }


    AdvertisePowerInterface(g_hmodDisplayDll);


    DISPDRV_MSG((_T("[DISPDRV] --S3C2416Disp::S3C2416Disp()\n\r")));
}

5，应用程序

// AutoAddLcdDlg.cpp : 实现文件
//


#include "stdafx.h"
#include "AutoAddLcd.h"
#include "AutoAddLcdDlg.h"
#include "shellapi.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CAutoAddLcdDlg 对话框


CAutoAddLcdDlg::CAutoAddLcdDlg(CWnd* pParent /*=NULL*/)
: CDialog(CAutoAddLcdDlg::IDD, pParent)
{
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}


void CAutoAddLcdDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
}


BEGIN_MESSAGE_MAP(CAutoAddLcdDlg, CDialog)
#if defined(_DEVICE_RESOLUTION_AWARE) && !defined(WIN32_PLATFORM_WFSP)
ON_WM_SIZE()
#endif
//}}AFX_MSG_MAP
ON_BN_CLICKED(IDC_BUTTON1, &CAutoAddLcdDlg::OnBnChangeLcd)
END_MESSAGE_MAP()




// CAutoAddLcdDlg 消息处理程序


BOOL CAutoAddLcdDlg::OnInitDialog()
{
CDialog::OnInitDialog();


// 设置此对话框的图标。当应用程序主窗口不是对话框时，框架将自动
//  执行此操作
SetIcon(m_hIcon, TRUE); // 设置大图标
SetIcon(m_hIcon, FALSE); // 设置小图标


// TODO: 在此添加额外的初始化代码
OnBnChangeLcd();
return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}


#if defined(_DEVICE_RESOLUTION_AWARE) && !defined(WIN32_PLATFORM_WFSP)
void CAutoAddLcdDlg::OnSize(UINT /*nType*/, int /*cx*/, int /*cy*/)
{
if (AfxIsDRAEnabled())
{
DRA::RelayoutDialog(
AfxGetResourceHandle(), 
this->m_hWnd, 
DRA::GetDisplayMode() != DRA::Portrait ? 
MAKEINTRESOURCE(IDD_AUTOADDLCD_DIALOG_WIDE) : 
MAKEINTRESOURCE(IDD_AUTOADDLCD_DIALOG));
}
}
#endif


#define CTL_CODE( DeviceType, Function, Method, Access ) (                 \
    ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
)


//
#define METHOD_BUFFERED                 0
#define FILE_ANY_ACCESS                 0
#define    IOCTL_SVE_FIMD_SET_INTERFACE_PARAM    \
        CTL_CODE(SVE_DEVICE_TYPE, SVE_FIMD_SET_INTERFACE_PARAM, METHOD_BUFFERED, FILE_ANY_ACCESS)


typedef enum
{
    DISP_VIDOUT_RGBIF,
    DISP_VIDOUT_I80IF_LDI0,
    DISP_VIDOUT_I80IF_LDI1,
} DISP_VIDOUT_MODE;


typedef enum
{
    DISP_16BIT_RGB565_P = 0,
    DISP_16BIT_RGB565_S,
    DISP_18BIT_RGB666_P,
    DISP_18BIT_RGB666_S,
    DISP_24BIT_RGB888_P,
    DISP_24BIT_RGB888_S,
} DISP_RGBIFOUT_MODE;


typedef struct _tDevInfo
{
    DISP_VIDOUT_MODE VideoOutMode;
    DISP_RGBIFOUT_MODE RGBOutMode;
    unsigned int uiWidth;
    unsigned int uiHeight;
    unsigned int VBPD_Value;
    unsigned int VFPD_Value;
    unsigned int VSPW_Value;
    unsigned int HBPD_Value;
    unsigned int HFPD_Value;
    unsigned int HSPW_Value;
    unsigned int VCLK_Polarity;
    unsigned int HSYNC_Polarity;
    unsigned int VSYNC_Polarity;
    unsigned int VDEN_Polarity;
    unsigned int PNR_Mode;
    unsigned int VCLK_Source;
    unsigned int Frame_Rate;
    unsigned int VCLK_Direction;
} tDevInfo;


typedef struct
{
    tDevInfo tRGBDevInfo;            // RGB I/F Device Information
} SVEARG_FIMD_OUTPUT_IF;


#define IVCLK_FALL_EDGE (0<<7)
#define IVCLK_RISE_EDGE (1<<7)
#define IHSYNC_HIGH_ACTIVE (0<<6)
#define IHSYNC_LOW_ACTIVE (1<<6)
#define IVSYNC_HIGH_ACTIVE (0<<5)
#define IVSYNC_LOW_ACTIVE (1<<5)
#define IVDEN_HIGH_ACTIVE (0<<4)
#define IVDEN_LOW_ACTIVE (1<<4)


#define PNRMODE_RGB_P (0<<13)
#define PNRMODE_BGR_P (1<<13)
#define PNRMODE_RGB_S (2<<13)
#define PNRMODE_BGR_S (3<<13)
#define PNRMODE_MASK (3<<13)




#define CLKSEL_F_HCLK (0<<2)
#define CLKSEL_F_LCDCLK (1<<2)
#define CLKDIR_DIRECT (0<<4)
#define CLKDIR_DIVIDED (1<<4)


#define LCD_WIDTH 320
#define LCD_HEIGHT 240
#define LCD_VBPD 15
#define LCD_VFPD 4
#define LCD_VSPW 3
#define LCD_HBPD 38
#define LCD_HFPD 20
#define LCD_HSPW 30
#define LCD_RGB_OUT_MODE DISP_16BIT_RGB565_S
#define LCD_VCLK_POLARITY IVCLK_RISE_EDGE
#define LCD_HSYNC_POLARITY IHSYNC_LOW_ACTIVE
#define LCD_VSYNC_POLARITY IVSYNC_LOW_ACTIVE
#define LCD_VDEN_POLARITY IVDEN_HIGH_ACTIVE
#define LCD_PNR_MODE PNRMODE_RGB_P
#define LCD_VCLK_SOURCE CLKSEL_F_HCLK
#define LCD_VCLK_DIRECTION CLKDIR_DIVIDED
#define LCD_FRAME_RATE 60
#define LCD_TFT_CLKVAL 9
#define LCD_BPP 16


int  LDI_fill_output_device_information(void *pDevInfo)
{
// LDI_ERROR error = LDI_SUCCESS;
tDevInfo *pDeviceInfo;


// LDI_MSG((_T("[LDI]++LDI_fill_output_device_information()\n\r")));


if (pDevInfo == NULL)
{
// LDI_ERR((_T("[LDI:ERR] LDI_fill_output_device_information() : Null Parameter\n\r")));
// error = DISP_ERROR_NULL_PARAMETER;
// goto CleanUp;
}


pDeviceInfo = (tDevInfo *)pDevInfo;


pDeviceInfo->RGBOutMode = LCD_RGB_OUT_MODE;
pDeviceInfo->uiWidth = LCD_WIDTH;
pDeviceInfo->uiHeight = LCD_HEIGHT;
pDeviceInfo->VBPD_Value = LCD_VBPD;
pDeviceInfo->VFPD_Value = LCD_VFPD;
pDeviceInfo->VSPW_Value = LCD_VSPW;
pDeviceInfo->HBPD_Value = LCD_HBPD;
pDeviceInfo->HFPD_Value = LCD_HFPD;
pDeviceInfo->HSPW_Value = LCD_HSPW;
pDeviceInfo->VCLK_Polarity = LCD_VCLK_POLARITY;
pDeviceInfo->HSYNC_Polarity = LCD_HSYNC_POLARITY;
pDeviceInfo->VSYNC_Polarity = LCD_VSYNC_POLARITY;
pDeviceInfo->VDEN_Polarity = LCD_VDEN_POLARITY;
pDeviceInfo->PNR_Mode = LCD_PNR_MODE;
pDeviceInfo->VCLK_Source = LCD_VCLK_SOURCE;
pDeviceInfo->VCLK_Direction = LCD_VCLK_DIRECTION;
pDeviceInfo->Frame_Rate = LCD_FRAME_RATE; // VCLK (Max 10 MHz)


//CleanUp:


// LDI_MSG((_T("[LDI]--LDI_fill_output_device_information()\n\r")));


return 0;
}




typedef enum
{
    SVE_RESOURCE_API_BASE = 100,


    // Resource Request/Release IOCTL(FIMD)
    SVE_RSC_REQUEST_FIMD_INTERFACE,
    SVE_RSC_RELEASE_FIMD_INTERFACE,
    SVE_RSC_REQUEST_FIMD_WIN0,
    SVE_RSC_RELEASE_FIMD_WIN0,
    SVE_RSC_REQUEST_FIMD_WIN1,
    SVE_RSC_RELEASE_FIMD_WIN1,
    SVE_RESOURCE_API_END,


    // FIMD Function IOCTL
    SVE_FIMD_FUNCTION_API_BASE = 200,
    SVE_FIMD_SET_INTERFACE_PARAM,
    SVE_FIMD_SET_OUTPUT_RGBIF,
    SVE_FIMD_SET_OUTPUT_ENABLE,
    SVE_FIMD_SET_OUTPUT_DISABLE,
    SVE_FIMD_SET_WINDOW_MODE,
    SVE_FIMD_SET_WINDOW_POSITION,
    SVE_FIMD_SET_WINDOW_FRAMEBUFFER,
    SVE_FIMD_SET_WINDOW_COLORMAP,
    SVE_FIMD_SET_WINDOW_ENABLE,
    SVE_FIMD_SET_WINDOW_DISABLE,
    SVE_FIMD_SET_WINDOW_BLEND_DISABLE,
    SVE_FIMD_SET_WINDOW_BLEND_COLORKEY,
    SVE_FIMD_SET_WINDOW_BLEND_ALPHA,
    SVE_FIMD_WAIT_FRAME_INTERRUPT,
    SVE_FIMD_GET_OUTPUT_STATUS,
    SVE_FIMD_GET_WINDOW_STATUS,
    SVE_FIMD_FUNCTION_API_END,


    // Power Management IOCTL
    SVE_PM_POWER_API_BASE = 1000,
    SVE_PM_SET_POWER_ON,
    SVE_PM_SET_POWER_OFF,
    SVE_PM_GET_POWER_STATUS,
    SVE_PM_POWER_API_END,


    SVE_API_ENUM_END
} SVE_API_FUNCTION_CODE;    // 0x0 ~ 0xFFF
DWORD   svsbuf[18];
int
SetLcdValueFromReg()
{
    HKEY hKey;
    int nRet = DMDO_0;
DWORD   dwSize, dwAngle, dwType = REG_DWORD;
DWORD   ScreenWidth=320;
DWORD ScreenHeight=240;
DWORD HBP=38;
DWORD HFP=2;
DWORD HSW=8;
DWORD PPL=19;
DWORD VBP=16;
DWORD VFP=4;
DWORD VSW=1;
DWORD LPP=239;
DWORD CLKDIV=5;
DWORD CPL=319;
DWORD IOE=0;
DWORD IPC=1;
DWORD IHS=1;
DWORD IVS=1;
DWORD RGB=1;
DWORD LIGHT=0;



    if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\GDI\\LCD"),0,0, &hKey))
    {
       
        dwSize = sizeof(DWORD);
        if (ERROR_SUCCESS == RegQueryValueEx(hKey,
                                               TEXT("LCDWIDTH"),
                                               NULL,
                                               &dwType,
                                               (LPBYTE)&dwAngle,
                                               &dwSize))
        {
            
   // LDI_MSG((_T("[LDI]--LDI_deinitialize_LCD_module() : %d\n\r"), dwAngle));RegSetValueEx(hkey, _T("1"), 0, REG_SZ, (LPBYTE)_T("内容"), len));//字符串 


        }
dwAngle=svsbuf[0];
RegSetValueEx(hKey,  TEXT("ScreenWidth"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[1];
RegSetValueEx(hKey,  TEXT("ScreenHeight"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
#if 1
dwAngle=svsbuf[2];
RegSetValueEx(hKey,  TEXT("HBP"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[3];
RegSetValueEx(hKey,  TEXT("HFP"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[4];
RegSetValueEx(hKey,  TEXT("HSW"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[5];
RegSetValueEx(hKey,  TEXT("PPL"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[6];
RegSetValueEx(hKey,  TEXT("VBP"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[7];
RegSetValueEx(hKey,  TEXT("VFP"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[8];
RegSetValueEx(hKey,  TEXT("VSW"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[9];
RegSetValueEx(hKey,  TEXT("LPP"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[10];
RegSetValueEx(hKey,  TEXT("CLKDIV"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[11];
RegSetValueEx(hKey,  TEXT("CPL"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[12];
RegSetValueEx(hKey,  TEXT("IOE"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[13];
RegSetValueEx(hKey,  TEXT("IPC"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[14];
RegSetValueEx(hKey,  TEXT("IHS"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[15];
RegSetValueEx(hKey,  TEXT("IVS"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[16];
RegSetValueEx(hKey,  TEXT("RGB"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
dwAngle=svsbuf[17];
RegSetValueEx(hKey,  TEXT("LIGHT"),  NULL,REG_DWORD, (LPBYTE)&dwAngle,4);
#endif
        RegCloseKey(hKey);
    }


    return dwAngle;
}
#define    SVE_DEVICE_TYPE    (0xA000)        // SVE-unique device type
void CAutoAddLcdDlg::OnBnChangeLcd()
{  
#if 1
bool svs=false;
int kl;
int i=0,m=12,x;int y[18]={12,13,4,4,4,4,4,4,4,4,7,4,4,4,4,4,4,6};
int j[21],value[18];
CString cs;
char sRead[18];
char buf[14];
//MessageBox(_T("1"));
char* buff[]={"ScreenWidth=","ScreenHeight=","HBP=","HFP=","HSW=","PPL=","VBP=","VFP=","VSW=","LPP=","CLKDIV=","CPL=","IOE=","IPC=","IHS=","IVS=","RGB=","LIGHT="};
CFile mFile;//(_T("\\FlashDisk\\LCDconfig.ini"),CFile::modeRead);
CFileException ex;




   if (!mFile.Open(_T("\\FlashDisk\\LCDconfig.ini"), CFile::modeRead | CFile::shareDenyWrite, &ex))
   {
   MessageBox(_T("error"));
   }


for( x=1;x<=18;x++)
{


while(1)
{
memset(buf,0,14);
mFile.Seek(i++,CFile::begin);
mFile.Read(buf,m);
if (strcmp(buff[x-1], buf) == 0)
{
j[x]=--i;
svs=true;
i=i+m;
m=y[x];
break;
}

}


}


for(int x=0;x<17;x++)
{

memset(buf,0,14);
mFile.Seek(j[x+1]+y[x],CFile::begin);
mFile.Read(buf,j[x+2]-j[x+1]-y[x]-2);
//svsbuf[x]=buf[0]+buf[1]+buf[2]
for(i=j[x+2]-j[x+1]-y[x]-2-1;i>=0;i--)
{
kl=1;
for(int k=0;k<i;k++)
kl*=10;
svsbuf[x]+=(buf[j[x+2]-j[x+1]-y[x]-2-1-i]-48)*kl;


}
//cs.Format(_T("%d %d %d %d %d %d"),svsbuf[x],buf[0],buf[1],buf[2],x,j[x+2]-j[x+1]-y[x]-2);
//MessageBox(cs);
}
mFile.Close();
SetLcdValueFromReg();
#endif
;
typedef  BOOL  (WINAPI *_TouchCalibrate)();   
  
HINSTANCE  hinstance = LoadLibrary(_T("coredll.dll"));   
  
if  (hinstance == NULL)   
{   
  return;   
}   
  
//定义一个函数指针   
_TouchCalibrate TouchCalibrate = NULL;   
  
//获取函数入口地址   
TouchCalibrate = (_TouchCalibrate)GetProcAddress(hinstance , L"TouchCalibrate");   
  
if (TouchCalibrate == NULL)   
{   
  return;   
}   
  
TouchCalibrate ();   
  
FreeLibrary(hinstance ); 
SendMessage(WM_CLOSE); 
}


SVS4414
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
wince 编程资料\wince 全屏显示应用程序
05-19
### Wince全屏显示应用程序知识点解析 #### 一、Wince简介 Windows CE（简称Wince）是微软公司开发的一款嵌入式操作系统，它具备高度可定制性，并且支持多种处理器架构，例如ARM、x86等。由于其灵活性与低资源消耗...
wince6.0 触摸屏校准程序
04-13
触摸屏校准程序通常基于WinCE 6.0系统提供的API（应用程序接口）来实现。这些API包含了与硬件交互、图形绘制和用户输入处理相关的函数，使得开发者能够创建自定义的校准解决方案。程序可能包括以下几个关键部分： 1...
s3c2416 AT070TN83的LCD wince6.0驱动移植
hong60104的专栏
12-02 1427
原文作者地址：http://blog.csdn.net/anthone_ligang/article/details/6837369 1 LCD外部引脚介绍         VSYNC: 帧同步信号,表示扫描1帧的开始，一帧也就是LCD显示的一个画面。          HSYNC: 行同步信号，表示扫描1行的开始。          VDEN：数据使能信号。
基于S3C6410&WINCE6.0的LCD驱动详解
armeasy的专栏
12-10 5776
      花了几天时间把6410的点屏代码研究了一下，这里分享出来供大家参考。      先大致说下目前LCD的类型以及渠道。针对手持设备，如手机，PMP，MID，GPS，UMPC，相机等，大多采用的是TFT，LTPS（低温多晶硅屏），OLED等。其中以TFT屏用的最广泛，LTPS屏以其色彩鲜艳，视角广而闻名，目前也逐渐多起来。OLED显示效果是以上三者中最好的，能够达到全视角，而且在阳光照
lcd时钟输出分析
lin415804的专栏
11-28 3370
lcd控制有24个数据线（rgb各八根），一个vsync（一个帧的开始和结束），一个hsync（一行的开始和结束），一个vden（有效点的开始，有效点开始就至高），一个rgb_clk（一个脉冲表示一个点）。 lcd有3中时钟线，hsync（行场），vsync（垂直场），vden（一个行场中的有效点） hsync有3部分组成：前沿，后延，有效点。前沿后延是跟屏幕规格书有关，有效点就是分辨率中的水
WinCE下应用程序开机自启动
toradexsh的博客
07-21 9443
1). 简介 在嵌入式设备中通常开机启动后会要求直接显示应用程序界面，而不是系统桌面，甚至为了避免客户随意或者无心修改到应用或者其他配置，是需要隐藏桌面的，本文就介绍在WinCE下开机自启动应用程序的相关设置。 本文验证相关配置的硬件平台采用Toradex Colibri i.MX6 ARM计算机模块 (基于NXP/Freescale i.MX6 SoC)和Colibri Eva Boar
wince下应用程序自启动
pc102的专栏
03-27 587
WinCE开机即运行定制的Shell是很多系统的基本要求，有时还需要屏蔽WinCE自带的Shell。WinCE中程序的自启动，一般有两个实现方法，修改注册表和添加自启动快捷方式。修改注册表比较方便，如下：        [HKEY_LOCAL_MACHINE\init]           "Launch70"="MyApp.exe"          "Depend70"=hex:14
wince 应用程序
05-22
在这个"Windows CE应用程序"的压缩包中，我们看到包含了"winCE游戏代码"。这意味着其中包含的是专门为Windows CE平台编写的源代码，这些代码可能是用C++或其他支持的语言编写的，旨在在Windows CE设备上运行游戏。...
WinCE触摸屏校正程序
08-05
标题“WinCE触摸屏校正程序”涉及到的是在Windows CE操作系统环境下对触摸屏进行校准的软件工具。Windows CE是一种嵌入式操作系统，常用于掌上电脑、移动设备和工业控制设备等。在这个系统中，触摸屏是用户交互的...
实现wince 下的应用程序自动运行的方法
02-04
将你的应用程序`MyApp.exe`复制到目标目录，即`X:\WINCE420\PUBLIC\MY2410\RelDir\MY2410Release\`。接着，你需要在工程的`project.bib`文件中，`FILES`部分添加一条记录，指示编译系统将`MyApp.exe`包含进内核映像...
s3c6410 + wince6.0 内核中修改LCD尺寸进度条
aristolto的专栏
09-04 1768
在目录C:\WINCE600\PLATFORM\SMDK6410\SRC\INC\options.h中进行修改LCD尺寸，进度条颜色位置等。 一、选择LCD尺寸 //#define LCD_N43 //#define LCD_T35 //#define LCD_X35   #define LCD_L80 //#define LCD_A70 //#define LCD_VGA1
关于wince 下LCD 控制器设置成RGB888 24bit 的相关问题
lqxandroid2012的专栏
11-12 2508
在论坛找了一个topic ，自己也来分析一下。 http://bbs.csdn.net/topics/350122995?page=1#post-392888121 —— 100分:开帖讨论WINCE下24位色显示瓶颈 引用 39 楼 JNU_kinke 的回复: 你要在驱动中和初始化LCD为32bit颜色深度，然后在显示24bit图片时就不会
【OpenCV】MindVision相机Get_Image
Taily老段的专栏
06-16 7309
#include "CameraApi.h" #include #include #include using namespace std; using namespace cv; #pragma comment(lib, "MVCAMSDK.lib") //---------------------------------// UINT m_threa
K210 车牌识别项目单片机代码，所用语言为C语言
最新发布
08-24
K210 车牌识别项目单片机代码，所用语言为C语言
源代码-博购企业名录搜索软站留言簿.zip
08-24
源代码-博购企业名录搜索软站留言簿.zip
项目使用华为云_ModelArts_AI_开发平台进行训练部署，
08-24
项目使用华为云_ModelArts_AI_开发平台进行训练部署，采用_Mask_R-CNN_算法模型_ma-mask-rcnn
WinCE应用程序开发要点：Unicode与工具选择
开发流程通常包括创建debug版的OS，然后使用相应的工具进行应用程序开发，包括设置和执行调试，以及根据需要进行代码修改和重新编译。 Windows CE应用程序开发需要开发者对Unicode、编程接口、工具选择以及调试...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值