ui_display_brs.h File Reference

Provides some implementations of the LLUI_DISPLAY_impl.h functions relating to the display buffer strategy (BRS). More...

#include <LLUI_DISPLAY_impl.h>
#include "ui_util.h"
#include "ui_configuration.h"
#include "ui_trace.h"

Go to the source code of this file.

Functions
DRAWING_Status	UI_DISPLAY_BRS_restore (MICROUI_GraphicsContext *gc, MICROUI_Image *old_back_buffer, ui_rect_t *rect)
	Restores (copies) the given rectangular region from old back buffer to the graphics context's current buffer (the destination buffer can be retrieved thanks LLUI_DISPLAY_getBufferAddress(&gc->image)). More...

Detailed Description

Provides some implementations of the LLUI_DISPLAY_impl.h functions relating to the display buffer strategy (BRS).

A BRS

• implements the LLUI_DISPLAY_impl.h's API LLUI_DISPLAY_IMPL_refresh() and LLUI_DISPLAY_IMPL_newDrawingRegion().
• calls the LLUI_DISPLAY_impl.h's API LLUI_DISPLAY_IMPL_flush() to let the display driver transmit / copy / flush back buffer data to the front buffer or swap back and front buffer (double or triple buffer management).
• ensures the coherence of the back buffer's content before and after a flush.

Several BRS are available in ui_configuration.h (the implementation has to select one of them).

Author

MicroEJ Developer Team

Version

14.5.5

Definition in file ui_display_brs.h.

Function Documentation

UI_DISPLAY_BRS_restore()

DRAWING_Status UI_DISPLAY_BRS_restore	(	MICROUI_GraphicsContext *	gc,
		MICROUI_Image *	old_back_buffer,
		ui_rect_t *	rect
	)

Restores (copies) the given rectangular region from old back buffer to the graphics context's current buffer (the destination buffer can be retrieved thanks LLUI_DISPLAY_getBufferAddress(&gc->image)).

When the copy is synchronous (immediate), the implementation has to return DRAWING_DONE. When the copy is asynchronous (performed by a DMA for instance), the the implementation has to return DRAWING_RUNNING. As the end of the asynchronous copy, the implementation has to call LLUI_DISPLAY_notifyAsynchronousDrawingEnd() to unlock the caller of this function.

The implementation of this function is optional; a weak function provides a simple implementation using memcpy().

Parameters

[in]	gc	the MicroUI GraphicsContext that targets the current back buffer
[in]	old_back_buffer	a MicroUI Image that symbolizes (targets) the old back buffer.
[in]	rect	the rectangular region to copy from old back buffer to new back buffer.

Returns

the drawing status.

Definition at line 33 of file ui_display_brs.c.

                                                                             {
    DRAWING_Status ret;
    uint32_t bpp = LLUI_DISPLAY_getImageBPP(old_back_buffer);
    uint32_t width = UI_RECT_get_width(rect);
    uint32_t height = UI_RECT_get_height(rect);
 
    if (8u > bpp) {
        // this weak function is not designed to target this kind of buffer
        // -> let the standard function copyImage() performing the job
        ret = UI_DRAWING_copyImage(gc, old_back_buffer, rect->x1, rect->y1, width, height, rect->x1, rect->y1);
    } else {
        uint8_t *dst = LLUI_DISPLAY_getBufferAddress(&gc->image);
        uint8_t *src = LLUI_DISPLAY_getBufferAddress(old_back_buffer);
        uint32_t stride = LLUI_DISPLAY_getStrideInBytes(&gc->image);
 
        dst += rect->y1 * stride;
        src += rect->y1 * stride;
 
        if ((0 == rect->x1) && (old_back_buffer->width == width)) {
            // a simple memcpy is required!
            (void)memcpy(dst, src, stride * height);
        } else {
            // have to perform one memcpy per line
            dst += rect->x1 * bpp / 8u;
            src += rect->x1 * bpp / 8u;
            uint32_t size = width * bpp / 8u;
 
            for (uint32_t y = 0; y < height; y++) {
                (void)memcpy(dst, src, size);
                dst += stride;
                src += stride;
            }
        }
 
        // the memcpy() above draws in the back buffer with the CPU, so it is notified like any other
        // software drawing: on a VEE port whose buffers sit in a cached memory, the next drawing may be a
        // GPU one and it has to flush the cache first. The bpp < 8 branch above needs no notification:
        // UI_DRAWING_copyImage() notifies by itself when it falls back to software.
        LLUI_DISPLAY_IMPL_notifyDrawingSoft(gc);
 
        ret = DRAWING_DONE;
    }
    return ret;
}