Hi Sandeep,
Unfortunately there is no performant way of running LVGL in landscape mode, however there are a couple of ways of doing it, one where you rotate the whole frame buffer and another where you limit the lvl frame buffer memory so it repeatedly renders areas of the screen and you then rotate those areas to the final frame buffer.
I tried both ways here and the speed is not acceptable for either of them, there is more info in these threads:
https://community.nxp.com/t5/i-MX-RT/Framebuffer-rotation-Some-advice-needed-VGLite-PXP-LCDIFV2/m-p/...
https://community.nxp.com/t5/i-MX-RT/PXP-Rotation-with-destination-offsets-not-divisible-by-BLOCK/m-...
The PXP rotate functionality is limited to 8x8 or 16x16 blocks, here is some code that will rotate arbitrary sizes to arbitrary positions:
static void blit_90(PXP_Type *base, void *pDestBuffer, uint16_t uDestBufferWidth, uint16_t uDestBufferHeight, void *pSourceBuffer, uint16_t uSourceBufferWidth, uint16_t uSourceBufferHeight, uint16_t uX, uint16_t uY, uint8_t uBytesPerPixel)
{
// blit source 90 degrees rotated to destination
uint16_t uRotatedX = uDestBufferWidth - uSourceBufferHeight - uY;
uint16_t uRotatedY = uX;
uint16_t uRemW;
uint16_t uRemH;
if(uSourceBufferWidth >= 16 && uSourceBufferHeight >= 16)
{
uRemW = uSourceBufferWidth % 16;
uRemH = uSourceBufferHeight % 16;
uint16_t uBlitW = uSourceBufferWidth - uRemW;
uint16_t uBlitH = uSourceBufferHeight - uRemH;
uint16_t uSourceHOffset = uRemH ? ((uRemH+1) * uSourceBufferWidth * uBytesPerPixel) : 0;
PXP_Init(base);
/* PS configure. */
const pxp_ps_buffer_config_t psBufferConfig = {
.pixelFormat = kPXP_PsPixelFormatRGB565,
.swapByte = false,
.bufferAddr = (uint32_t)pSourceBuffer - uSourceHOffset,
.bufferAddrU = 0U,
.bufferAddrV = 0U,
.pitchBytes = uSourceBufferWidth * uBytesPerPixel,
};
PXP_SetProcessSurfaceBackGroundColor(base, 0U);
PXP_SetProcessSurfaceBufferConfig(base, &psBufferConfig);
// Disable AS.
PXP_SetAlphaSurfacePosition(base, 0xFFFFU, 0xFFFFU, 0U, 0U);
// rotate
PXP_SetRotateConfig(base, kPXP_RotateProcessSurface, kPXP_Rotate90, kPXP_FlipDisable);
PXP_SetProcessSurfacePosition(base, 0, 0, uSourceBufferHeight -1, uSourceBufferWidth -1);
// Output config.
outputBufferConfig.pixelFormat = kPXP_OutputPixelFormatRGB565;
outputBufferConfig.interlacedMode = kPXP_OutputProgressive;
outputBufferConfig.buffer0Addr = (uint32_t) (pDestBuffer + (uRotatedY * uDestBufferWidth * uBytesPerPixel) + ((uRotatedX + uRemH) * uBytesPerPixel));
outputBufferConfig.buffer1Addr = 0U;
outputBufferConfig.pitchBytes = uDestBufferWidth * uBytesPerPixel;
outputBufferConfig.width = uBlitH;
outputBufferConfig.height = uBlitW;
PXP_SetOutputBufferConfig(base, &outputBufferConfig);
// Disable CSC1, it is enabled by default.
PXP_EnableCsc1(base, false);
// off we go
PXP_Start(base);
// Wait for process complete.
while (!(kPXP_CompleteFlag & PXP_GetStatusFlags(base)))
{
}
PXP_ClearStatusFlags(base, kPXP_CompleteFlag);
}
else
{
uRemW = uSourceBufferWidth;
uRemH = uSourceBufferHeight;
}
// tidy up remainders
if(uRemH)
{
//need bottom uRemH lines
uint16_t *pSource = (uint16_t *)pSourceBuffer + (uSourceBufferWidth * (uSourceBufferHeight - uRemH));
uint16_t *pDestBase = (uint16_t *)pDestBuffer + uRemH + uRotatedX -1 + (uRotatedY * uDestBufferWidth) ;
for(int16_t uH = 0; uH < uRemH; uH++)
{
uint16_t *pDest = pDestBase - uH;
for(uint16_t uW = 0; uW < uSourceBufferWidth -uRemW; uW++)
{
*pDest = *pSource;
pDest += uDestBufferWidth;
pSource++;
}
pSource+=uRemW;
}
}
if(uRemW)
{
//need right uRemW columns
uint16_t *pSourceBase = (uint16_t *)pSourceBuffer - uRemW + (uSourceBufferWidth * uSourceBufferHeight);
uint16_t *pDestBase = (uint16_t *)pDestBuffer + ((uRotatedY + uSourceBufferWidth - uRemW) * uDestBufferWidth) + uRotatedX;
for(int16_t uW = 0; uW < uRemW; uW++)
{
uint16_t *pDest = pDestBase + (uW * uDestBufferWidth);
uint16_t *pSource = pSourceBase + uW;
for(uint16_t uH = 0; uH < uSourceBufferHeight; uH++)
{
*pDest = *pSource;
pSource -= uSourceBufferWidth;
pDest++;
}
}
}
}
The main problem is that lvl runs very slowly even without the rotation because they spin the cpu waiting for their internal PXP calls to finish in the cpu rendering code they have rather than batching it up properly, so updating the full screen takes around 11ms and uses 100% cpu (this is without the rotate cost), I haven't looked at the RTOS version maybe that works a bit better.
I came to the conclusion that the CPU cost of using LVGL on this screen was far too much.
If you want to try it out though the simplest set the lvl display up to be 1280x720 and give it its own full frame buffer, then in the flushDisplay:
static void DEMO_FlushDisplay(lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p)
{
// copy
//resetCpuCycleCount();
DCACHE_CleanInvalidateByRange((uint32_t)s_frameBuffer, DEMO_FB_SIZE);
DCACHE_CleanInvalidateByRange((uint32_t)color_p, DEMO_FB_SIZE);
blit_90(PXP, s_frameBuffer, 720, 1280, color_p, 1+(area->x2-area->x1), 1+(area->y2-area->y1), area->x1, area->y1, 2 );
lv_disp_flush_ready(disp_drv);
}
Where s_frameBuffer is our real frame buffer.
This is all single buffer to keep it easy.
