/** ****************************************************************************** * @file lcdconf.c * @author MCD Application Team * @brief This file implements the configuration for the GUI library ****************************************************************************** * @attention * * Copyright (c) 2017 STMicroelectronics. * All rights reserved. * * This software is licensed under terms that can be found in the LICENSE file * in the root directory of this software component. * If no LICENSE file comes with this software, it is provided AS-IS. * ****************************************************************************** *//* ... */ /* Includes ------------------------------------------------------------------*/ #include "LCDConf.h" #include "GUI_Private.h" /** @addtogroup STEMWIN_LIBRARY * @{ *//* ... */ /** @defgroup STEMWIN_LIBRARY * @brief This file contains the USB Configuration * @{ *//* ... */ /** @defgroup STEMWIN_LIBRARY_Private_TypesDefinitions * @{ *//* ... */ /** * @} *//* ... */ /** @defgroup STEMWIN_LIBRARY_Private_Defines * @{ *//* ... */ #undef LCD_SWAP_XY #undef LCD_MIRROR_Y #define LCD_SWAP_XY 1 #define LCD_MIRROR_Y 1 #define XSIZE_PHYS 240 #define YSIZE_PHYS 320 #define NUM_BUFFERS 1 // Number of multiple buffers to be used #define NUM_VSCREENS 2 // Number of virtual screens to be used #define BK_COLOR GUI_DARKBLUE 7 defines #undef GUI_NUM_LAYERS #define GUI_NUM_LAYERS 1 #define COLOR_CONVERSION_0 GUICC_M8888I #define DISPLAY_DRIVER_0 GUIDRV_LIN_32 #if (GUI_NUM_LAYERS > 1) #define COLOR_CONVERSION_1 GUICC_M8888I #define DISPLAY_DRIVER_1 GUIDRV_LIN_32 /* ... */#endif #ifndef XSIZE_PHYS #error Physical X size of display is not defined! #endif #ifndef YSIZE_PHYS #error Physical Y size of display is not defined! #endif #ifndef NUM_VSCREENS #define NUM_VSCREENS 1 #else #if (NUM_VSCREENS <= 0) #error At least one screeen needs to be defined! #endif/* ... */ #endif #if (NUM_VSCREENS > 1) && (NUM_BUFFERS > 1) #error Virtual screens and multiple buffers are not allowed! #endif #define LCD_LAYER0_FRAME_BUFFER ((uint32_t)0xD0200000) #define LCD_LAYER1_FRAME_BUFFER ((uint32_t)0xD0400000) /** * @} *//* ... */ /** @defgroup STEMWIN_LIBRARY_Private_Macros * @{ *//* ... */ /* Redirect bulk conversion to DMA2D routines */ #define DEFINEDMA2D_COLORCONVERSION(PFIX, PIXELFORMAT) \ static void Color2IndexBulk_##PFIX##DMA2D(LCD_COLOR * pColor, void * pIndex, U32 NumItems, U8 SizeOfIndex) { \ DMA2D_Color2IndexBulk(pColor, pIndex, NumItems, SizeOfIndex, PIXELFORMAT); \ }DMA2D (LCD_COLOR * pColor, void * pIndex, U32 NumItems, U8 SizeOfIndex) { ... } \ static void Index2ColorBulk_##PFIX##DMA2D(void * pIndex, LCD_COLOR * pColor, U32 NumItems, U8 SizeOfIndex) { \ DMA2D_Index2ColorBulk(pIndex, pColor, NumItems, SizeOfIndex, PIXELFORMAT); \ }DMA2D (void * pIndex, LCD_COLOR * pColor, U32 NumItems, U8 SizeOfIndex) { ... } ... /** * @} *//* ... */ /** @defgroup STEMWIN_LIBRARY_Private_Variables * @{ *//* ... */ LTDC_HandleTypeDef hltdc; static DMA2D_HandleTypeDef hdma2d; static LCD_LayerPropTypedef layer_prop[GUI_NUM_LAYERS]; static const LCD_API_COLOR_CONV * apColorConvAPI[] = { COLOR_CONVERSION_0, #if GUI_NUM_LAYERS > 1 COLOR_CONVERSION_1, #endif ...}; static U32 aBufferDMA2D [XSIZE_PHYS * sizeof(U32)]; static U32 aBuffer_FG [XSIZE_PHYS * sizeof(U32)]; static U32 aBuffer_BG [XSIZE_PHYS * sizeof(U32)]; /** * @} *//* ... */ /** @defgroup STEMWIN_LIBRARY_Private_FunctionPrototypes * @{ *//* ... */ static uint32_t LCD_LL_GetPixelformat(uint32_t LayerIndex); static void DMA2D_CopyBuffer(uint32_t LayerIndex, void * pSrc, void * pDst, uint32_t xSize, uint32_t ySize, uint32_t OffLineSrc, uint32_t OffLineDst); static void DMA2D_FillBuffer(uint32_t LayerIndex, void * pDst, uint32_t xSize, uint32_t ySize, uint32_t OffLine, uint32_t ColorIndex); static void LCD_LL_Init(void); static void LCD_LL_LayerInit(uint32_t LayerIndex); static void CUSTOM_CopyBuffer(int32_t LayerIndex, int32_t IndexSrc, int32_t IndexDst); static void CUSTOM_CopyRect(int32_t LayerIndex, int32_t x0, int32_t y0, int32_t x1, int32_t y1, int32_t xSize, int32_t ySize); static void CUSTOM_FillRect(int32_t LayerIndex, int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t PixelIndex); static void DMA2D_Index2ColorBulk(void * pIndex, LCD_COLOR * pColor, uint32_t NumItems, U8 SizeOfIndex, uint32_t PixelFormat); static void DMA2D_Color2IndexBulk(LCD_COLOR * pColor, void * pIndex, uint32_t NumItems, U8 SizeOfIndex, uint32_t PixelFormat); static void BSP_LCD_DrawBitmap8bpp(int32_t LayerIndex, int32_t x, int32_t y, U8 const * p, int32_t xSize, int32_t ySize, int32_t BytesPerLine); static void BSP_LCD_DrawBitmap16bpp(int32_t LayerIndex, int32_t x, int32_t y, U16 const * p, int32_t xSize, int32_t ySize, int32_t BytesPerLine); static void DMA2D_AlphaBlendingBulk(LCD_COLOR * pColorFG, LCD_COLOR * pColorBG, LCD_COLOR * pColorDst, U32 NumItems); static void DMA2D_AlphaBlending(LCD_COLOR * pColorFG, LCD_COLOR * pColorBG, LCD_COLOR * pColorDst, U32 NumItems); static LCD_PIXELINDEX * _LCD_GetpPalConvTable(const LCD_LOGPALETTE GUI_UNI_PTR * pLogPal, const GUI_BITMAP GUI_UNI_PTR * pBitmap, int LayerIndex); static LCD_COLOR DMA2D_MixColors(LCD_COLOR Color, LCD_COLOR BkColor, U8 Intens); static void LCD_MixColorsBulk(U32 * pFG, U32 * pBG, U32 * pDst, unsigned OffFG, unsigned OffBG, unsigned OffDest, unsigned xSize, unsigned ySize, U8 Intens); DEFINEDMA2D_COLORCONVERSION(M8888I, LTDC_PIXEL_FORMAT_ARGB8888) DEFINEDMA2D_COLORCONVERSION(M888, LTDC_PIXEL_FORMAT_ARGB8888) DEFINEDMA2D_COLORCONVERSION(M565, LTDC_PIXEL_FORMAT_RGB565) DEFINEDMA2D_COLORCONVERSION(M1555I, LTDC_PIXEL_FORMAT_ARGB1555) DEFINEDMA2D_COLORCONVERSION(M4444I, LTDC_PIXEL_FORMAT_ARGB4444) static uint32_t GetBufferSize(uint32_t LayerIndex); /** * @} *//* ... */ /** @defgroup STEMWIN_LIBRARY_Private_Functions * @{ *//* ... */ /******************************************************************************* LTDC and DMA2D BSP Routines *******************************************************************************//* ... */ /** * @brief DMA2D MSP Initialization * This function configures the hardware resources used in This application: * - Peripheral's clock enable * - Peripheral's GPIO Configuration * @param hdma2d: DMA2D handle pointer * @retval None *//* ... */ void HAL_DMA2D_MspInit(DMA2D_HandleTypeDef *hdma2d) { /* Enable peripheral */ __HAL_RCC_DMA2D_CLK_ENABLE(); }{ ... } /** * @brief DMA2D MSP De-Initialization * This function frees the hardware resources used in This application: * - Disable the Peripheral's clock * @param hdma2d: DMA2D handle pointer * @retval None *//* ... */ void HAL_DMA2D_MspDeInit(DMA2D_HandleTypeDef *hdma2d) { /* Enable DMA2D reset state */ __HAL_RCC_DMA2D_FORCE_RESET(); /* Release DMA2D from reset state */ __HAL_RCC_DMA2D_RELEASE_RESET(); }{ ... } /** * @brief LTDC MSP Initialization * This function configures the hardware resources used in This application: * - Peripheral's clock enable * - Peripheral's GPIO Configuration * @param hltdc: LTDC handle pointer * @retval None *//* ... */ void HAL_LTDC_MspInit(LTDC_HandleTypeDef *hltdc) { GPIO_InitTypeDef GPIO_Init_Structure; /* Enable peripherals and GPIO Clocks */ /* Enable the LTDC Clock */ __HAL_RCC_LTDC_CLK_ENABLE(); /* Enable GPIO Clock */ __HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); __HAL_RCC_GPIOC_CLK_ENABLE(); __HAL_RCC_GPIOD_CLK_ENABLE(); __HAL_RCC_GPIOF_CLK_ENABLE(); __HAL_RCC_GPIOG_CLK_ENABLE(); /* Configure peripheral GPIO */ /* GPIOs Configuration */ /* +------------------------+-----------------------+----------------------------+ + LCD pins assignment + +------------------------+-----------------------+----------------------------+ | LCD_TFT R2 <-> PC.10 | LCD_TFT G2 <-> PA.06 | LCD_TFT B2 <-> PD.06 | | LCD_TFT R3 <-> PB.00 | LCD_TFT G3 <-> PG.10 | LCD_TFT B3 <-> PG.11 | | LCD_TFT R4 <-> PA.11 | LCD_TFT G4 <-> PB.10 | LCD_TFT B4 <-> PG.12 | | LCD_TFT R5 <-> PA.12 | LCD_TFT G5 <-> PB.11 | LCD_TFT B5 <-> PA.03 | | LCD_TFT R6 <-> PB.01 | LCD_TFT G6 <-> PC.07 | LCD_TFT B6 <-> PB.08 | | LCD_TFT R7 <-> PG.06 | LCD_TFT G7 <-> PD.03 | LCD_TFT B7 <-> PB.09 | ------------------------------------------------------------------------------- | LCD_TFT HSYNC <-> PC.06 | LCDTFT VSYNC <-> PA.04 | | LCD_TFT CLK <-> PG.07 | LCD_TFT DE <-> PF.10 | ----------------------------------------------------- *//* ... */ /* GPIOA configuration */ GPIO_Init_Structure.Pin = GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_6 | GPIO_PIN_11 | GPIO_PIN_12; GPIO_Init_Structure.Mode = GPIO_MODE_AF_PP; GPIO_Init_Structure.Pull = GPIO_NOPULL; GPIO_Init_Structure.Speed = GPIO_SPEED_FAST; GPIO_Init_Structure.Alternate= GPIO_AF14_LTDC; HAL_GPIO_Init(GPIOA, &GPIO_Init_Structure); /* GPIOB configuration */ GPIO_Init_Structure.Pin = GPIO_PIN_8 | \ GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11; HAL_GPIO_Init(GPIOB, &GPIO_Init_Structure); /* GPIOC configuration */ GPIO_Init_Structure.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_10; HAL_GPIO_Init(GPIOC, &GPIO_Init_Structure); /* GPIOD configuration */ GPIO_Init_Structure.Pin = GPIO_PIN_3 | GPIO_PIN_6; HAL_GPIO_Init(GPIOD, &GPIO_Init_Structure); /* GPIOF configuration */ GPIO_Init_Structure.Pin = GPIO_PIN_10; HAL_GPIO_Init(GPIOF, &GPIO_Init_Structure); /* GPIOG configuration */ GPIO_Init_Structure.Pin = GPIO_PIN_6 | GPIO_PIN_7 | \ GPIO_PIN_11; HAL_GPIO_Init(GPIOG, &GPIO_Init_Structure); /* GPIOB configuration */ GPIO_Init_Structure.Pin = GPIO_PIN_0 | GPIO_PIN_1; GPIO_Init_Structure.Alternate= GPIO_AF9_LTDC; HAL_GPIO_Init(GPIOB, &GPIO_Init_Structure); /* GPIOG configuration */ GPIO_Init_Structure.Pin = GPIO_PIN_10 | GPIO_PIN_12; HAL_GPIO_Init(GPIOG, &GPIO_Init_Structure); /* Set LTDC Interrupt to the lowest priority */ HAL_NVIC_SetPriority(LTDC_IRQn, 0xF, 0); /* Enable LTDC Interrupt */ HAL_NVIC_EnableIRQ(LTDC_IRQn); }{ ... } /** * @brief LTDC MSP De-Initialization * This function frees the hardware resources used in This application: * - Disable the Peripheral's clock * @param hltdc: LTDC handle pointer * @retval None *//* ... */ void HAL_LTDC_MspDeInit(LTDC_HandleTypeDef *hltdc) { /* Reset peripherals */ /* Enable LTDC reset state */ __HAL_RCC_LTDC_FORCE_RESET(); /* Release LTDC from reset state */ __HAL_RCC_LTDC_RELEASE_RESET(); }{ ... } /** * @brief Line Event callback. * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains * the configuration information for the specified LTDC. * @retval None *//* ... */ void HAL_LTDC_LineEvenCallback(LTDC_HandleTypeDef *hltdc) { uint32_t Addr; uint32_t layer; for (layer = 0; layer < GUI_NUM_LAYERS; layer++) { if (layer_prop[layer].pending_buffer >= 0) { /* Calculate address of buffer to be used as visible frame buffer */ Addr = layer_prop[layer].address + layer_prop[layer].xSize * layer_prop[layer].ySize * layer_prop[layer].pending_buffer * layer_prop[layer].BytesPerPixel; HAL_LTDC_SetAddress(hltdc, Addr, layer); __HAL_LTDC_RELOAD_IMMEDIATE_CONFIG(hltdc); /* Notify STemWin that buffer is used */ GUI_MULTIBUF_ConfirmEx(layer, layer_prop[layer].pending_buffer); /* Clear pending buffer flag of layer */ layer_prop[layer].pending_buffer = -1; }if (layer_prop[layer].pending_buffer >= 0) { ... } }for (layer = 0; layer < GUI_NUM_LAYERS; layer++) { ... } HAL_LTDC_ProgramLineEvent(hltdc, 0); }{ ... } /******************************************************************************* Display configuration *******************************************************************************//* ... */ /** * @brief Called during the initialization process in order to set up the * display driver configuration * @param None * @retval None *//* ... */ void LCD_X_Config(void) { uint32_t i; LCD_LL_Init(); /* At first initialize use of multiple buffers on demand */ #if (NUM_BUFFERS > 1) for (i = 0; i < GUI_NUM_LAYERS; i++) { GUI_MULTIBUF_ConfigEx(i, NUM_BUFFERS); }for (i = 0; i < GUI_NUM_LAYERS; i++) { ... } /* ... */#endif /* Set display driver and color conversion for 1st layer */ GUI_DEVICE_CreateAndLink(DISPLAY_DRIVER_0, COLOR_CONVERSION_0, 0, 0); /* Set size of 1st layer */ if (LCD_GetSwapXYEx(0)) { LCD_SetSizeEx (0, YSIZE_PHYS, XSIZE_PHYS); LCD_SetVSizeEx(0, YSIZE_PHYS * NUM_VSCREENS, XSIZE_PHYS); }if (LCD_GetSwapXYEx(0)) { ... } else { LCD_SetSizeEx (0, XSIZE_PHYS, YSIZE_PHYS); LCD_SetVSizeEx(0, XSIZE_PHYS, YSIZE_PHYS * NUM_VSCREENS); }else { ... } #if (GUI_NUM_LAYERS > 1) /* Set display driver and color conversion for 2nd layer */ GUI_DEVICE_CreateAndLink(DISPLAY_DRIVER_1, COLOR_CONVERSION_1, 0, 1); /* Set size of 2nd layer */ if (LCD_GetSwapXYEx(1)) { LCD_SetSizeEx (1, YSIZE_PHYS, XSIZE_PHYS); LCD_SetVSizeEx(1, YSIZE_PHYS * NUM_VSCREENS, XSIZE_PHYS); }if (LCD_GetSwapXYEx(1)) { ... } else { LCD_SetSizeEx (1, XSIZE_PHYS, YSIZE_PHYS); LCD_SetVSizeEx(1, XSIZE_PHYS, YSIZE_PHYS * NUM_VSCREENS); }else { ... } /* ... */#endif /*Initialize GUI Layer structure */ layer_prop[0].address = LCD_LAYER0_FRAME_BUFFER; #if (GUI_NUM_LAYERS > 1) layer_prop[1].address = LCD_LAYER1_FRAME_BUFFER; #endif /* Setting up VRam address and custom functions for CopyBuffer-, CopyRect- and FillRect operations */ for (i = 0; i < GUI_NUM_LAYERS; i++) { layer_prop[i].pColorConvAPI = (LCD_API_COLOR_CONV *)apColorConvAPI[i]; layer_prop[i].pending_buffer = -1; /* Set VRAM address */ LCD_SetVRAMAddrEx(i, (void *)(layer_prop[i].address)); /* Remember color depth for further operations */ layer_prop[i].BytesPerPixel = LCD_GetBitsPerPixelEx(i) >> 3; /* Set custom functions for several operations */ LCD_SetDevFunc(i, LCD_DEVFUNC_COPYBUFFER, (void(*)(void))CUSTOM_CopyBuffer); LCD_SetDevFunc(i, LCD_DEVFUNC_COPYRECT, (void(*)(void))CUSTOM_CopyRect); /* Filling via DMA2D does only work with 16bpp or more */ if (LCD_LL_GetPixelformat(i) <= LTDC_PIXEL_FORMAT_ARGB4444) { LCD_SetDevFunc(i, LCD_DEVFUNC_FILLRECT, (void(*)(void))CUSTOM_FillRect); LCD_SetDevFunc(i, LCD_DEVFUNC_DRAWBMP_8BPP, (void(*)(void))BSP_LCD_DrawBitmap8bpp); }if (LCD_LL_GetPixelformat(i) <= LTDC_PIXEL_FORMAT_ARGB4444) { ... } /* Set up drawing routine for 16bpp bitmap using DMA2D */ if (LCD_LL_GetPixelformat(i) == LTDC_PIXEL_FORMAT_RGB565) { LCD_SetDevFunc(i, LCD_DEVFUNC_DRAWBMP_16BPP, (void(*)(void))BSP_LCD_DrawBitmap16bpp); /* Set up drawing routine for 16bpp bitmap using DMA2D. Makes only sense with RGB565 */ }if (LCD_LL_GetPixelformat(i) == LTDC_PIXEL_FORMAT_RGB565) { ... } /* Set up custom color conversion using DMA2D, works only for direct color modes because of missing LUT for DMA2D destination */ GUICC_M1555I_SetCustColorConv(Color2IndexBulk_M1555IDMA2D, Index2ColorBulk_M1555IDMA2D); /* Set up custom bulk color conversion using DMA2D for ARGB1555 */ GUICC_M565_SetCustColorConv (Color2IndexBulk_M565DMA2D, Index2ColorBulk_M565DMA2D); /* Set up custom bulk color conversion using DMA2D for RGB565 */ GUICC_M4444I_SetCustColorConv(Color2IndexBulk_M4444IDMA2D, Index2ColorBulk_M4444IDMA2D); /* Set up custom bulk color conversion using DMA2D for ARGB4444 */ GUICC_M888_SetCustColorConv (Color2IndexBulk_M888DMA2D, Index2ColorBulk_M888DMA2D); /* Set up custom bulk color conversion using DMA2D for RGB888 */ GUICC_M8888I_SetCustColorConv(Color2IndexBulk_M8888IDMA2D, Index2ColorBulk_M8888IDMA2D); /* Set up custom bulk color conversion using DMA2D for ARGB8888 */ /* Set up custom alpha blending function using DMA2D */ GUI_SetFuncAlphaBlending(DMA2D_AlphaBlending); /* Set up custom alpha blending function using DMA2D */ /* Set up custom function for translating a bitmap palette into index values. Required to load a bitmap palette into DMA2D CLUT in case of a 8bpp indexed bitmap *//* ... */ GUI_SetFuncGetpPalConvTable(_LCD_GetpPalConvTable); /* Set up a custom function for mixing up single colors using DMA2D */ GUI_SetFuncMixColors(DMA2D_MixColors); /* Set up a custom function for mixing up arrays of colors using DMA2D */ GUI_SetFuncMixColorsBulk(LCD_MixColorsBulk); }for (i = 0; i < GUI_NUM_LAYERS; i++) { ... } }{ ... } /** * @brief This function is called by the display driver for several purposes. * To support the according task the routine needs to be adapted to * the display controller. Please note that the commands marked with * 'optional' are not cogently required and should only be adapted if * the display controller supports these features * @param LayerIndex: Index of layer to be configured * @param Cmd :Please refer to the details in the switch statement below * @param pData :Pointer to a LCD_X_DATA structure * @retval Status (-1 : Error, 0 : Ok) *//* ... */ int LCD_X_DisplayDriver(unsigned LayerIndex, unsigned Cmd, void * pData) { int32_t r = 0; uint32_t addr; int32_t xPos, yPos; uint32_t Color; switch (Cmd) { case LCD_X_INITCONTROLLER: LCD_LL_LayerInit(LayerIndex); break; case LCD_X_INITCONTROLLER: case LCD_X_SETORG: addr = layer_prop[LayerIndex].address + ((LCD_X_SETORG_INFO *)pData)->yPos * layer_prop[LayerIndex].xSize * layer_prop[LayerIndex].BytesPerPixel; HAL_LTDC_SetAddress(&hltdc, addr, LayerIndex); break; case LCD_X_SETORG: case LCD_X_SHOWBUFFER: layer_prop[LayerIndex].pending_buffer = ((LCD_X_SHOWBUFFER_INFO *)pData)->Index; break; case LCD_X_SHOWBUFFER: case LCD_X_SETLUTENTRY: HAL_LTDC_ConfigCLUT(&hltdc, (uint32_t *)&(((LCD_X_SETLUTENTRY_INFO *)pData)->Color), 1, LayerIndex); break; case LCD_X_SETLUTENTRY: case LCD_X_ON: __HAL_LTDC_ENABLE(&hltdc); break; case LCD_X_ON: case LCD_X_OFF: __HAL_LTDC_DISABLE(&hltdc); break; case LCD_X_OFF: case LCD_X_SETVIS: if(((LCD_X_SETVIS_INFO *)pData)->OnOff == ENABLE ) { __HAL_LTDC_LAYER_ENABLE(&hltdc, LayerIndex); }if (((LCD_X_SETVIS_INFO *)pData)->OnOff == ENABLE) { ... } else { __HAL_LTDC_LAYER_DISABLE(&hltdc, LayerIndex); }else { ... } __HAL_LTDC_RELOAD_IMMEDIATE_CONFIG(&hltdc); break; case LCD_X_SETVIS: case LCD_X_SETPOS: HAL_LTDC_SetWindowPosition(&hltdc, ((LCD_X_SETPOS_INFO *)pData)->xPos, ((LCD_X_SETPOS_INFO *)pData)->yPos, LayerIndex); break; case LCD_X_SETPOS: case LCD_X_SETSIZE: GUI_GetLayerPosEx(LayerIndex, (int*)&xPos, (int*)&yPos); layer_prop[LayerIndex].xSize = ((LCD_X_SETSIZE_INFO *)pData)->xSize; layer_prop[LayerIndex].ySize = ((LCD_X_SETSIZE_INFO *)pData)->ySize; HAL_LTDC_SetWindowPosition(&hltdc, xPos, yPos, LayerIndex); break; case LCD_X_SETSIZE: case LCD_X_SETALPHA: HAL_LTDC_SetAlpha(&hltdc, ((LCD_X_SETALPHA_INFO *)pData)->Alpha, LayerIndex); break; case LCD_X_SETALPHA: case LCD_X_SETCHROMAMODE: if(((LCD_X_SETCHROMAMODE_INFO *)pData)->ChromaMode != 0) { HAL_LTDC_EnableColorKeying(&hltdc, LayerIndex); }if (((LCD_X_SETCHROMAMODE_INFO *)pData)->ChromaMode != 0) { ... } else { HAL_LTDC_DisableColorKeying(&hltdc, LayerIndex); }else { ... } break; case LCD_X_SETCHROMAMODE: case LCD_X_SETCHROMA: Color = ((((LCD_X_SETCHROMA_INFO *)pData)->ChromaMin & 0xFF0000) >> 16) |\ (((LCD_X_SETCHROMA_INFO *)pData)->ChromaMin & 0x00FF00) |\ ((((LCD_X_SETCHROMA_INFO *)pData)->ChromaMin & 0x0000FF) << 16); HAL_LTDC_ConfigColorKeying(&hltdc, Color, LayerIndex); break; case LCD_X_SETCHROMA: default: r = -1;default }switch (Cmd) { ... } return r; }{ ... } /******************************************************************************* Static code *******************************************************************************//* ... */ /** * @brief Initialize the LCD Controller. * @param LayerIndex : layer Index. * @retval None *//* ... */ static void LCD_LL_LayerInit(uint32_t LayerIndex) { uint32_t i; static uint32_t LUT[256]; LTDC_LayerCfgTypeDef layer_cfg; if (LayerIndex < GUI_NUM_LAYERS) { /* Layer configuration */ layer_cfg.WindowX0 = 0; layer_cfg.WindowX1 = XSIZE_PHYS; layer_cfg.WindowY0 = 0; layer_cfg.WindowY1 = YSIZE_PHYS; layer_cfg.PixelFormat = LCD_LL_GetPixelformat(LayerIndex); layer_cfg.FBStartAdress = layer_prop[LayerIndex].address; layer_cfg.Alpha = 255; layer_cfg.Alpha0 = 0; layer_cfg.Backcolor.Blue = 0; layer_cfg.Backcolor.Green = 0; layer_cfg.Backcolor.Red = 0; layer_cfg.BlendingFactor1 = LTDC_BLENDING_FACTOR1_PAxCA; layer_cfg.BlendingFactor2 = LTDC_BLENDING_FACTOR2_PAxCA; layer_cfg.ImageWidth = XSIZE_PHYS; layer_cfg.ImageHeight = YSIZE_PHYS; HAL_LTDC_ConfigLayer(&hltdc, &layer_cfg, LayerIndex); /* Enable LUT on demand */ if (LCD_GetBitsPerPixelEx(LayerIndex) <= 8) { /* Enable usage of LUT for all modes with <= 8bpp*/ HAL_LTDC_EnableCLUT(&hltdc, LayerIndex); }if (LCD_GetBitsPerPixelEx(LayerIndex) <= 8) { ... } else { /* Optional CLUT initialization for AL88 mode (16bpp)*/ if (layer_prop[LayerIndex].pColorConvAPI == GUICC_88666I) { HAL_LTDC_EnableCLUT(&hltdc, LayerIndex); for (i = 0; i < 256; i++) { LUT[i] = LCD_API_ColorConv_8666.pfIndex2Color(i); }for (i = 0; i < 256; i++) { ... } HAL_LTDC_ConfigCLUT(&hltdc, LUT, 256, LayerIndex); }if (layer_prop[LayerIndex].pColorConvAPI == GUICC_88666I) { ... } }else { ... } }if (LayerIndex < GUI_NUM_LAYERS) { ... } }{ ... } /** * @brief Initialize the LCD Controller. * @param LayerIndex : layer Index. * @retval None *//* ... */ static void LCD_LL_Init(void) { static RCC_PeriphCLKInitTypeDef PeriphClkInitStruct; /* DeInit */ hltdc.Instance = LTDC; HAL_LTDC_DeInit(&hltdc); /* Initialization of ILI9341 component*/ ili9341_Init(); /* Set LCD Timings */ hltdc.Init.HorizontalSync = 9; hltdc.Init.VerticalSync = 1; hltdc.Init.AccumulatedHBP = 29; hltdc.Init.AccumulatedVBP = 3; hltdc.Init.AccumulatedActiveH = 323; hltdc.Init.AccumulatedActiveW = 269; hltdc.Init.TotalHeigh = 327; hltdc.Init.TotalWidth = 279; /* background value */ hltdc.Init.Backcolor.Blue = 0; hltdc.Init.Backcolor.Green = 0; hltdc.Init.Backcolor.Red = 0; /* LCD clock configuration */ /* PLLSAI_VCO Input = HSE_VALUE/PLL_M = 1 MHz */ /* PLLSAI_VCO Output = PLLSAI_VCO Input * PLLSAIN = 192 MHz */ /* PLLLCDCLK = PLLSAI_VCO Output/PLLSAIR = 192/4 = 48 MHz */ /* LTDC clock frequency = PLLLCDCLK / LTDC_PLLSAI_DIVR_8 = 48/8 = 6 MHz */ PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LTDC; PeriphClkInitStruct.PLLSAI.PLLSAIN = 192; PeriphClkInitStruct.PLLSAI.PLLSAIR = 4; PeriphClkInitStruct.PLLSAIDivR = RCC_PLLSAIDIVR_8; HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct); /* Polarity */ hltdc.Init.HSPolarity = LTDC_HSPOLARITY_AL; hltdc.Init.VSPolarity = LTDC_VSPOLARITY_AL; hltdc.Init.DEPolarity = LTDC_DEPOLARITY_AL; hltdc.Init.PCPolarity = LTDC_PCPOLARITY_IPC; hltdc.Instance = LTDC; HAL_LTDC_Init(&hltdc); HAL_LTDC_ProgramLineEvent(&hltdc, 0); /* Configure the DMA2D default mode */ hdma2d.Init.Mode = DMA2D_R2M; hdma2d.Init.ColorMode = DMA2D_RGB565; hdma2d.Init.OutputOffset = 0x0; hdma2d.Instance = DMA2D; if(HAL_DMA2D_Init(&hdma2d) != HAL_OK) { while (1); }if (HAL_DMA2D_Init(&hdma2d) != HAL_OK) { ... } }{ ... } /** * @brief Return Pixel format for a given layer * @param LayerIndex : Layer Index * @retval Status ( 0 : 0k , 1: error) *//* ... */ static uint32_t LCD_LL_GetPixelformat(uint32_t LayerIndex) { const LCD_API_COLOR_CONV * pColorConvAPI; if (LayerIndex >= GUI_NUM_LAYERS) { return 0; }if (LayerIndex >= GUI_NUM_LAYERS) { ... } pColorConvAPI = layer_prop[LayerIndex].pColorConvAPI; if (pColorConvAPI == GUICC_M8888I) { return LTDC_PIXEL_FORMAT_ARGB8888; }if (pColorConvAPI == GUICC_M8888I) { ... } else if (pColorConvAPI == GUICC_M888) { return LTDC_PIXEL_FORMAT_RGB888; }else if (pColorConvAPI == GUICC_M888) { ... } else if (pColorConvAPI == GUICC_M565) { return LTDC_PIXEL_FORMAT_RGB565; }else if (pColorConvAPI == GUICC_M565) { ... } else if (pColorConvAPI == GUICC_M1555I) { return LTDC_PIXEL_FORMAT_ARGB1555; }else if (pColorConvAPI == GUICC_M1555I) { ... } else if (pColorConvAPI == GUICC_M4444I) { return LTDC_PIXEL_FORMAT_ARGB4444; }else if (pColorConvAPI == GUICC_M4444I) { ... } else if (pColorConvAPI == GUICC_8666) { return LTDC_PIXEL_FORMAT_L8; }else if (pColorConvAPI == GUICC_8666) { ... } else if (pColorConvAPI == GUICC_1616I) { return LTDC_PIXEL_FORMAT_AL44; }else if (pColorConvAPI == GUICC_1616I) { ... } else if (pColorConvAPI == GUICC_88666I) { return LTDC_PIXEL_FORMAT_AL88; }else if (pColorConvAPI == GUICC_88666I) { ... } while (1); }{ ... } /********************************************************************* * * CopyBuffer *//* ... */ static void DMA2D_CopyBuffer(uint32_t LayerIndex, void * pSrc, void * pDst, uint32_t xSize, uint32_t ySize, uint32_t OffLineSrc, uint32_t OffLineDst) { uint32_t PixelFormat; PixelFormat = LCD_LL_GetPixelformat(LayerIndex); DMA2D->CR = 0x00000000UL | (1 << 9); /* Set up pointers */ DMA2D->FGMAR = (uint32_t)pSrc; DMA2D->OMAR = (uint32_t)pDst; DMA2D->FGOR = OffLineSrc; DMA2D->OOR = OffLineDst; /* Set up pixel format */ DMA2D->FGPFCCR = PixelFormat; /* Set up size */ DMA2D->NLR = (uint32_t)(xSize << 16) | (U16)ySize; DMA2D->CR |= DMA2D_CR_START; /* Wait until transfer is done */ while (DMA2D->CR & DMA2D_CR_START) { }while (DMA2D->CR & DMA2D_CR_START) { ... } }{ ... } /********************************************************************* * * FillBuffer *//* ... */ static void DMA2D_FillBuffer(uint32_t LayerIndex, void * pDst, uint32_t xSize, uint32_t ySize, uint32_t OffLine, uint32_t ColorIndex) { uint32_t PixelFormat; PixelFormat = LCD_LL_GetPixelformat(LayerIndex); /* Set up mode */ DMA2D->CR = 0x00030000UL | (1 << 9); DMA2D->OCOLR = ColorIndex; /* Set up pointers */ DMA2D->OMAR = (uint32_t)pDst; /* Set up offsets */ DMA2D->OOR = OffLine; /* Set up pixel format */ DMA2D->OPFCCR = PixelFormat; /* Set up size */ DMA2D->NLR = (uint32_t)(xSize << 16) | (U16)ySize; DMA2D->CR |= DMA2D_CR_START; /* Wait until transfer is done */ while (DMA2D->CR & DMA2D_CR_START) { }while (DMA2D->CR & DMA2D_CR_START) { ... } }{ ... } /********************************************************************* * * GetBufferSize *//* ... */ static uint32_t GetBufferSize(uint32_t LayerIndex) { uint32_t BufferSize; BufferSize = layer_prop[LayerIndex].xSize * layer_prop[LayerIndex].ySize * layer_prop[LayerIndex].BytesPerPixel; return BufferSize; }{ ... } /********************************************************************* * * CUSTOM_CopyBuffer *//* ... */ static void CUSTOM_CopyBuffer(int32_t LayerIndex, int32_t IndexSrc, int32_t IndexDst) { uint32_t BufferSize, AddrSrc, AddrDst; BufferSize = GetBufferSize(LayerIndex); AddrSrc = layer_prop[LayerIndex].address + BufferSize * IndexSrc; AddrDst = layer_prop[LayerIndex].address + BufferSize * IndexDst; DMA2D_CopyBuffer(LayerIndex, (void *)AddrSrc, (void *)AddrDst, layer_prop[LayerIndex].xSize, layer_prop[LayerIndex].ySize, 0, 0); layer_prop[LayerIndex].buffer_index = IndexDst; }{ ... } /********************************************************************* * * CUSTOM_CopyRect *//* ... */ /** * @brief Copy rectangle * @param LayerIndex : Layer Index * @param x0: X0 position * @param y0: Y0 position * @param x1: X1 position * @param y1: Y1 position * @param xSize: X size. * @param ySize: Y size. * @retval None *//* ... */ static void CUSTOM_CopyRect(int32_t LayerIndex, int32_t x0, int32_t y0, int32_t x1, int32_t y1, int32_t xSize, int32_t ySize) { U32 AddrSrc, AddrDst; AddrSrc = layer_prop[LayerIndex].address + (y0 * layer_prop[LayerIndex].xSize + x0) * layer_prop[LayerIndex].BytesPerPixel; AddrDst = layer_prop[LayerIndex].address + (y1 * layer_prop[LayerIndex].xSize + x1) * layer_prop[LayerIndex].BytesPerPixel; DMA2D_CopyBuffer(LayerIndex, (void *)AddrSrc, (void *)AddrDst, xSize, ySize, layer_prop[LayerIndex].xSize - xSize, layer_prop[LayerIndex].xSize - xSize); }{ ... } /********************************************************************* * * CUSTOM_FillRect *//* ... */ static void CUSTOM_FillRect(int32_t LayerIndex, int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t PixelIndex) { uint32_t BufferSize, AddrDst; int32_t xSize, ySize; if (GUI_GetDrawMode() == GUI_DM_XOR) { LCD_SetDevFunc(LayerIndex, LCD_DEVFUNC_FILLRECT, NULL); LCD_FillRect(x0, y0, x1, y1); LCD_SetDevFunc(LayerIndex, LCD_DEVFUNC_FILLRECT, (void(*)(void))CUSTOM_FillRect); }if (GUI_GetDrawMode() == GUI_DM_XOR) { ... } else { xSize = x1 - x0 + 1; ySize = y1 - y0 + 1; BufferSize = GetBufferSize(LayerIndex); AddrDst = layer_prop[LayerIndex].address + BufferSize * layer_prop[LayerIndex].buffer_index + (y0 * layer_prop[LayerIndex].xSize + x0) * layer_prop[LayerIndex].BytesPerPixel; DMA2D_FillBuffer(LayerIndex, (void *)AddrDst, xSize, ySize, layer_prop[LayerIndex].xSize - xSize, PixelIndex); }else { ... } }{ ... } /** * @brief * @param pColor * @param NumItems * @retval None *//* ... */ static void DMA2D_LoadLUT(LCD_COLOR * pColor, uint32_t NumItems) { DMA2D->FGCMAR = (uint32_t)pColor; /* Foreground PFC Control Register */ DMA2D->FGPFCCR = LTDC_PIXEL_FORMAT_RGB888 /* Pixel format */ | ((NumItems - 1) & 0xFF) << 8; /* Number of items to load */ DMA2D->FGPFCCR |= (1 << 5); /* Start loading */ }{ ... } /** * @brief * @param pColorSrc: Source address * @param pColorDst: Destination address * @param NumItems * @retval None *//* ... */ static void InvertAlpha_SwapRB(LCD_COLOR * pColorSrc, LCD_COLOR * pColorDst, uint32_t NumItems) { uint32_t Color; do { Color = *pColorSrc++; *pColorDst++ = ((Color & 0x000000FF) << 16) /* Swap red <-> blue */ | (Color & 0x0000FF00) /* Green */ | ((Color & 0x00FF0000) >> 16) /* Swap red <-> blue */ | ((Color & 0xFF000000) ^ 0xFF000000); /* Invert alpha */ ...} while (--NumItems); }{ ... } /** * @brief Color format of DMA2D is different to STemWin color format. This routine * inverts alpha that it is compatible to STemWin and vice versa * @param pColorSrc * @param pColorDst * @param NumItems * @retval None *//* ... */ static void InvertAlpha(LCD_COLOR * pColorSrc, LCD_COLOR * pColorDst, uint32_t NumItems) { uint32_t Color; do { Color = *pColorSrc++; *pColorDst++ = Color ^ 0xFF000000; /* Invert alpha */ ...} while (--NumItems); }{ ... } /** * @brief * @param pColorFG * @param pColorBG * @param pColorDst * @param NumItems * @retval None *//* ... */ static void DMA2D_AlphaBlendingBulk(LCD_COLOR * pColorFG, LCD_COLOR * pColorBG, LCD_COLOR * pColorDst, U32 NumItems) { /* Set up mode */ DMA2D->CR = 0x00020000UL | (1 << 9); /* Control Register (Memory to memory with blending of FG and BG and TCIE) */ /* Set up pointers */ DMA2D->FGMAR = (uint32_t)pColorFG; /* Foreground Memory Address Register */ DMA2D->BGMAR = (uint32_t)pColorBG; /* Background Memory Address Register */ DMA2D->OMAR = (uint32_t)pColorDst; /* Output Memory Address Register (Destination address) */ /* Set up offsets */ DMA2D->FGOR = 0; /* Foreground Offset Register */ DMA2D->BGOR = 0; /* Background Offset Register */ DMA2D->OOR = 0; /* Output Offset Register */ /* Set up pixel format */ DMA2D->FGPFCCR = LTDC_PIXEL_FORMAT_ARGB8888; /* Foreground PFC Control Register (Defines the FG pixel format) */ DMA2D->BGPFCCR = LTDC_PIXEL_FORMAT_ARGB8888; /* Background PFC Control Register (Defines the BG pixel format) */ DMA2D->OPFCCR = LTDC_PIXEL_FORMAT_ARGB8888; /* Output PFC Control Register (Defines the output pixel format) */ /* Set up size */ DMA2D->NLR = (uint32_t)(NumItems << 16) | 1; /* Number of Line Register (Size configuration of area to be transferred) */ /* Execute operation */ DMA2D->CR |= DMA2D_CR_START; while (DMA2D->CR & DMA2D_CR_START) { }while (DMA2D->CR & DMA2D_CR_START) { ... } }{ ... } #if defined (__GNUC__) /*!< GNU Compiler */ #pragma GCC optimize ("O0") #endif /** * @brief Function for mixing up 2 colors with the given intensity. * If the background color is completely transparent the * foreground color should be used unchanged. * @param Color * @param BkColor * @param Intens * @retval LCD_COLOR *//* ... */ static LCD_COLOR DMA2D_MixColors(LCD_COLOR Color, LCD_COLOR BkColor, U8 Intens) { uint32_t ColorFG, ColorBG, ColorDst; if ((BkColor & 0xFF000000) == 0xFF000000) { return Color; }if ((BkColor & 0xFF000000) == 0xFF000000) { ... } ColorFG = Color ^ 0xFF000000; ColorBG = BkColor ^ 0xFF000000; /* Set up mode */ DMA2D->CR = 0x00020000UL | (1 << 9); /* Control Register (Memory to memory with blending of FG and BG and TCIE) */ /* Set up pointers */ DMA2D->FGMAR = (uint32_t)&ColorFG; /* Foreground Memory Address Register */ DMA2D->BGMAR = (uint32_t)&ColorBG; /* Background Memory Address Register */ DMA2D->OMAR = (uint32_t)&ColorDst; /* Output Memory Address Register (Destination address) */ /* Set up pixel format */ DMA2D->FGPFCCR = LTDC_PIXEL_FORMAT_ARGB8888 | (1UL << 16) | ((uint32_t)Intens << 24); DMA2D->BGPFCCR = LTDC_PIXEL_FORMAT_ARGB8888 | (0UL << 16) | ((uint32_t)(255 - Intens) << 24); DMA2D->OPFCCR = LTDC_PIXEL_FORMAT_ARGB8888; /* Set up size */ DMA2D->NLR = (uint32_t)(1 << 16) | 1; /* Number of Line Register (Size configuration of area to be transferred) */ /* Execute operation */ DMA2D->CR |= DMA2D_CR_START; /* Control Register (Start operation) */ /* Wait until transfer is done */ while (DMA2D->CR & DMA2D_CR_START) { }while (DMA2D->CR & DMA2D_CR_START) { ... } return (ColorDst ^ 0xFF000000); }{ ... } /** * @brief * @param pSrc * @param pDst * @param PixelFormatSrc * @param PixelFormatDst * @param NumItems * @retval None *//* ... */ static void DMA2D_ConvertColor(void * pSrc, void * pDst, uint32_t PixelFormatSrc, uint32_t PixelFormatDst, uint32_t NumItems) { /* Set up mode */ DMA2D->CR = 0x00010000UL | (1 << 9); /* Control Register (Memory to memory with pixel format conversion and TCIE) */ /* Set up pointers */ DMA2D->FGMAR = (uint32_t)pSrc; /* Foreground Memory Address Register (Source address) */ DMA2D->OMAR = (uint32_t)pDst; /* Output Memory Address Register (Destination address) */ /* Set up offsets */ DMA2D->FGOR = 0; /* Foreground Offset Register (Source line offset) */ DMA2D->OOR = 0; /* Output Offset Register (Destination line offset) */ /* Set up pixel format */ DMA2D->FGPFCCR = PixelFormatSrc; /* Foreground PFC Control Register (Defines the input pixel format) */ DMA2D->OPFCCR = PixelFormatDst; /* Output PFC Control Register (Defines the output pixel format) */ /* Set up size */ DMA2D->NLR = (uint32_t)(NumItems << 16) | 1; /* Number of Line Register (Size configuration of area to be transferred) */ /* Execute operation */ DMA2D->CR |= DMA2D_CR_START; while (DMA2D->CR & DMA2D_CR_START) { }while (DMA2D->CR & DMA2D_CR_START) { ... } }{ ... } /** * @brief The STemWin function LCD_GetpPalConvTable() normally translates the given colors into * index values for the display controller. In case of index based bitmaps without * transparent pixels we load the palette only to the DMA2D LUT registers to be * translated (converted) during the process of drawing via DMA2D. * @param pLogPal * @param pBitmap * @param LayerIndex * @retval LCD_PIXELINDEX *//* ... */ static LCD_PIXELINDEX * _LCD_GetpPalConvTable(const LCD_LOGPALETTE GUI_UNI_PTR * pLogPal, const GUI_BITMAP GUI_UNI_PTR * pBitmap, int LayerIndex) { void (* pFunc)(void); int32_t DoDefault = 0; /* Check if we have a non transparent device independent bitmap */ if (pBitmap->BitsPerPixel == 8) { pFunc = LCD_GetDevFunc(LayerIndex, LCD_DEVFUNC_DRAWBMP_8BPP); if (pFunc) { if (pBitmap->pPal) { if (pBitmap->pPal->HasTrans) { DoDefault = 1; }if (pBitmap->pPal->HasTrans) { ... } }if (pBitmap->pPal) { ... } else { DoDefault = 1; }else { ... } }if (pFunc) { ... } else { DoDefault = 1; }else { ... } }if (pBitmap->BitsPerPixel == 8) { ... } else { DoDefault = 1; }else { ... } /* Default palette management for other cases */ if (DoDefault) { /* Return a pointer to the index values to be used by the controller */ return LCD_GetpPalConvTable(pLogPal); }if (DoDefault) { ... } /* Convert palette colors from ARGB to ABGR */ InvertAlpha_SwapRB((U32 *)pLogPal->pPalEntries, aBufferDMA2D, pLogPal->NumEntries); /* Load LUT using DMA2D */ DMA2D_LoadLUT(aBufferDMA2D, pLogPal->NumEntries); /* Return something not NULL */ return aBufferDMA2D; }{ ... } /** * @brief * @param pColorFG * @param pColorBG * @param pColorDst * @param Intens * @param NumItems * @retval None *//* ... */ static void DMA2D_MixColorsBulk(LCD_COLOR * pColorFG, LCD_COLOR * pColorBG, LCD_COLOR * pColorDst, U8 Intens, uint32_t NumItems) { /* Set up mode */ DMA2D->CR = 0x00020000UL | (1 << 9); /* Control Register (Memory to memory with blending of FG and BG and TCIE) */ /* Set up pointers */ DMA2D->FGMAR = (uint32_t)pColorFG; /* Foreground Memory Address Register */ DMA2D->BGMAR = (uint32_t)pColorBG; /* Background Memory Address Register */ DMA2D->OMAR = (uint32_t)pColorDst; /* Output Memory Address Register (Destination address) */ /* Set up pixel format */ DMA2D->FGPFCCR = LTDC_PIXEL_FORMAT_ARGB8888 | (1UL << 16) | ((uint32_t)Intens << 24); DMA2D->BGPFCCR = LTDC_PIXEL_FORMAT_ARGB8888 | (0UL << 16) | ((uint32_t)(255 - Intens) << 24); DMA2D->OPFCCR = LTDC_PIXEL_FORMAT_ARGB8888; /* Set up size */ DMA2D->NLR = (uint32_t)(NumItems << 16) | 1; /* Number of Line Register (Size configuration of area to be transferred) */ /* Execute operation */ DMA2D->CR |= DMA2D_CR_START; while (DMA2D->CR & DMA2D_CR_START) { }while (DMA2D->CR & DMA2D_CR_START) { ... } }{ ... } /** * @brief * @param pColorFG * @param pColorBG * @param pColorDst * @param NumItems * @retval None *//* ... */ static void DMA2D_AlphaBlending(LCD_COLOR * pColorFG, LCD_COLOR * pColorBG, LCD_COLOR * pColorDst, U32 NumItems) { /* Invert alpha values */ InvertAlpha(pColorFG, aBuffer_FG, NumItems); InvertAlpha(pColorBG, aBuffer_BG, NumItems); /* Use DMA2D for mixing */ DMA2D_AlphaBlendingBulk(aBuffer_FG, aBuffer_BG, aBufferDMA2D, NumItems); /* Invert alpha values */ InvertAlpha(aBufferDMA2D, pColorDst, NumItems); }{ ... } /** * @brief This routine is used by the STemWin color conversion routines to use DMA2D for * color conversion. It converts the given index values to 32 bit colors. * Because STemWin uses ABGR internally and 0x00 and 0xFF for opaque and fully * transparent the color array needs to be converted after DMA2D has been used. * @param pIndex * @param pColor * @param NumItems * @param SizeOfIndex * @param PixelFormat * @retval None *//* ... */ static void DMA2D_Index2ColorBulk(void * pIndex, LCD_COLOR * pColor, uint32_t NumItems, U8 SizeOfIndex, uint32_t PixelFormat) { /* Use DMA2D for the conversion */ DMA2D_ConvertColor(pIndex, aBufferDMA2D, PixelFormat, LTDC_PIXEL_FORMAT_ARGB8888, NumItems); /* Convert colors from ARGB to ABGR and invert alpha values */ InvertAlpha_SwapRB(aBufferDMA2D, pColor, NumItems); }{ ... } /** * @brief This routine is used by the STemWin color conversion routines to use DMA2D for * color conversion. It converts the given 32 bit color array to index values. * Because STemWin uses ABGR internally and 0x00 and 0xFF for opaque and fully * transparent the given color array needs to be converted before DMA2D can be used. * @param pColor * @param pIndex * @param NumItems * @param SizeOfIndex * @param PixelFormat * @retval None *//* ... */ static void DMA2D_Color2IndexBulk(LCD_COLOR * pColor, void * pIndex, uint32_t NumItems, U8 SizeOfIndex, uint32_t PixelFormat) { /* Convert colors from ABGR to ARGB and invert alpha values */ InvertAlpha_SwapRB(pColor, aBufferDMA2D, NumItems); /* Use DMA2D for the conversion */ DMA2D_ConvertColor(aBufferDMA2D, pIndex, LTDC_PIXEL_FORMAT_ARGB8888, PixelFormat, NumItems); }{ ... } /** * @brief * @param pFG * @param pBG * @param pDst * @param OffFG * @param OffBG * @param OffDest * @param xSize * @param ySize * @param Intens * @retval None *//* ... */ static void LCD_MixColorsBulk(U32 * pFG, U32 * pBG, U32 * pDst, unsigned OffFG, unsigned OffBG, unsigned OffDest, unsigned xSize, unsigned ySize, U8 Intens) { int32_t y; GUI_USE_PARA(OffFG); GUI_USE_PARA(OffDest); for (y = 0; y < ySize; y++) { /* Invert alpha values */ InvertAlpha(pFG, aBuffer_FG, xSize); InvertAlpha(pBG, aBuffer_BG, xSize); DMA2D_MixColorsBulk(aBuffer_FG, aBuffer_BG, aBufferDMA2D, Intens, xSize); InvertAlpha(aBufferDMA2D, pDst, xSize); pFG += xSize + OffFG; pBG += xSize + OffBG; pDst += xSize + OffDest; }for (y = 0; y < ySize; y++) { ... } }{ ... } /** * @brief * @param pSrc * @param pDst * @param OffSrc * @param OffDst * @param PixelFormatDst * @param xSize * @param ySize * @retval None *//* ... */ static void DMA2D_DrawBitmapL8(void * pSrc, void * pDst, uint32_t OffSrc, uint32_t OffDst, uint32_t PixelFormatDst, uint32_t xSize, uint32_t ySize) { /* Set up mode */ DMA2D->CR = 0x00010000UL | (1 << 9); /* Control Register (Memory to memory with pixel format conversion and TCIE) */ /* Set up pointers */ DMA2D->FGMAR = (uint32_t)pSrc; /* Foreground Memory Address Register (Source address) */ DMA2D->OMAR = (uint32_t)pDst; /* Output Memory Address Register (Destination address) */ /* Set up offsets */ DMA2D->FGOR = OffSrc; /* Foreground Offset Register (Source line offset) */ DMA2D->OOR = OffDst; /* Output Offset Register (Destination line offset) */ /* Set up pixel format */ DMA2D->FGPFCCR = LTDC_PIXEL_FORMAT_L8; /* Foreground PFC Control Register (Defines the input pixel format) */ DMA2D->OPFCCR = PixelFormatDst; /* Output PFC Control Register (Defines the output pixel format) */ /* Set up size */ DMA2D->NLR = (uint32_t)(xSize << 16) | ySize; /* Number of Line Register (Size configuration of area to be transferred) */ /* Execute operation */ DMA2D->CR |= DMA2D_CR_START; /* Start operation */ /* Wait until transfer is done */ while (DMA2D->CR & DMA2D_CR_START) { }while (DMA2D->CR & DMA2D_CR_START) { ... } }{ ... } /** * @brief * @param LayerIndex * @param x * @param y * @param p * @param xSize * @param ySize * @param BytesPerLine * @retval None *//* ... */ static void BSP_LCD_DrawBitmap16bpp(int32_t LayerIndex, int32_t x, int32_t y, U16 const * p, int32_t xSize, int32_t ySize, int32_t BytesPerLine) { uint32_t BufferSize, AddrDst; int32_t OffLineSrc, OffLineDst; BufferSize = GetBufferSize(LayerIndex); AddrDst = layer_prop[LayerIndex].address + BufferSize * layer_prop[LayerIndex].buffer_index + (y * layer_prop[LayerIndex].xSize + x) * layer_prop[LayerIndex].BytesPerPixel; OffLineSrc = (BytesPerLine / 2) - xSize; OffLineDst = layer_prop[LayerIndex].xSize - xSize; DMA2D_CopyBuffer(LayerIndex, (void *)p, (void *)AddrDst, xSize, ySize, OffLineSrc, OffLineDst); }{ ... } /** * @brief * @param LayerIndex * @param x * @param y * @param p * @param xSize * @param ySize * @param BytesPerLine * @retval None *//* ... */ static void BSP_LCD_DrawBitmap8bpp(int32_t LayerIndex, int32_t x, int32_t y, U8 const * p, int32_t xSize, int32_t ySize, int32_t BytesPerLine) { uint32_t BufferSize, AddrDst; int32_t OffLineSrc, OffLineDst; uint32_t PixelFormat; BufferSize = GetBufferSize(LayerIndex); AddrDst = layer_prop[LayerIndex].address + BufferSize * layer_prop[LayerIndex].buffer_index + (y * layer_prop[LayerIndex].xSize + x) * layer_prop[LayerIndex].BytesPerPixel; OffLineSrc = BytesPerLine - xSize; OffLineDst = layer_prop[LayerIndex].xSize - xSize; PixelFormat = LCD_LL_GetPixelformat(LayerIndex); DMA2D_DrawBitmapL8((void *)p, (void *)AddrDst, OffLineSrc, OffLineDst, PixelFormat, xSize, ySize); }{ ... }