vg_helper.c

Go to the documentation of this file.

/*
 * C
 *
 * Copyright 2022-2026 MicroEJ Corp. All rights reserved.
 * MicroEJ Corp. PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 * Build: 7E4D1F7C
 */
 
#include "vg_configuration.h"
 
// -----------------------------------------------------------------------------
// VG Pack Sanity Check
// -----------------------------------------------------------------------------
 
/*
 * Sanity check between the expected version of the VG Pack used by the VEE Port
 * and the actual version of this file (MicroVG Abstraction Layer's file).
 *
 * If an error is raised here, it means that a new version of the VG Pack has been
 * installed in the VEE Port or the MicroVG Abstraction Layer has been updated without any change
 * in the VEE Port. In both cases, the versions must be coherent (see the Release
 * Notes: https://docs.microej.com/en/latest/VEEPortingGuide/vgReleaseNotes.html).
 */
 
#if (defined(LLVG_MAJOR_VERSION) && (LLVG_MAJOR_VERSION != 1)) || (defined(LLVG_MINOR_VERSION) && \
    (LLVG_MINOR_VERSION < 8))
#error "This Abstraction Layer is only compatible with VG Pack [1.8.0,2.0.0["
#endif
 
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
 
#include <LLVG_MATRIX_impl.h>
 
#include "vg_helper.h"
#include "vg_trace.h"
#include "vg_drawing.h"
#include "bsp_util.h"
 
#if defined VG_FEATURE_PATH
#include "vg_path.h"
#endif
 
#if defined VG_FEATURE_FONT
#include <freetype/internal/ftobjs.h>
#include <inttypes.h>
#include "vg_freetype.h"
 
VG_LOG_DECLARE_MODULE()
#endif
 
#if defined VG_FEATURE_FONT_COMPLEX_LAYOUT && (VG_FEATURE_FONT_COMPLEX_LAYOUT == 1)
#include "hb.h"
#include "hb-ft.h"
#endif
 
// -----------------------------------------------------------------------------
// Defines
// -----------------------------------------------------------------------------
 
#define MIN_HIGH_SURROGATE  ((unsigned short)0xD800)
#define MAX_HIGH_SURROGATE  ((unsigned short)0xDBFF)
#define MIN_LOW_SURROGATE   ((unsigned short)0xDC00)
#define MAX_LOW_SURROGATE   ((unsigned short)0xDFFF)
#define MIN_SUPPLEMENTARY_CODE_POINT 0x010000
 
#define GET_NEXT_CHARACTER(t, l, o) ((o) >= (l) ? (unsigned short)0 : (t)[o])
 
#if defined VG_FEATURE_FONT_COMPLEX_LAYOUT && (VG_FEATURE_FONT_COMPLEX_LAYOUT == 1)
#define IS_SIMPLE_LAYOUT (!(face->face_flags & FT_FACE_FLAG_COMPLEX_LAYOUT))
#else
#define IS_SIMPLE_LAYOUT true
#endif // VG_FEATURE_FONT_COMPLEX_LAYOUT
 
// -----------------------------------------------------------------------------
// Public Globals
// -----------------------------------------------------------------------------
 
/*
 * @brief Identifies the MicroVG group to trace an event.
 */
int32_t LLVG_TRACE_group;
 
// -----------------------------------------------------------------------------
// Private Globals
// -----------------------------------------------------------------------------
 
static jfloat g_identity_matrix[LLVG_MATRIX_SIZE];
 
#if defined VG_FEATURE_FONT
static FT_Face face;
 
// Freetype layout variables
static const unsigned short *current_text;
static unsigned int current_length;
static int current_offset;
static FT_UInt previous_glyph_index; // previous glyph index for kerning
#endif
 
#if defined VG_FEATURE_FONT_COMPLEX_LAYOUT && (VG_FEATURE_FONT_COMPLEX_LAYOUT == 1)
// Harfbuzz layout variables
static hb_glyph_info_t *glyph_info;
static hb_glyph_position_t *glyph_pos;
static unsigned int glyph_count;
static int current_glyph;
static hb_buffer_t *buf;
// The shaper built from the font face named by current_faceHandle, and that face's handle. A
// handle of 0 means no shaper is held.
static hb_font_t *hb_font;
static jint current_faceHandle;
#endif
 
// -----------------------------------------------------------------------------
// LLVG_impl.h functions
// -----------------------------------------------------------------------------
 
// See the header file for the function documentation
void LLVG_IMPL_initialize(jint trace_group) {
    // initializes the tracer
    LLVG_TRACE_group = trace_group;
 
    // configures the matrix used as identity matrix (immutable)
    LLVG_MATRIX_IMPL_identity(g_identity_matrix);
 
    // Configures the drawing engine
    VG_DRAWING_initialize();
 
    // configures the path engine
#ifdef VG_FEATURE_PATH
    VG_PATH_initialize();
#endif
 
    // configures the font engine
#if defined VG_FEATURE_FONT &&                                                              \
    (defined VG_FEATURE_FONT_FREETYPE_VECTOR || defined VG_FEATURE_FONT_FREETYPE_BITMAP) && \
    (VG_FEATURE_FONT == VG_FEATURE_FONT_FREETYPE_VECTOR || VG_FEATURE_FONT == VG_FEATURE_FONT_FREETYPE_BITMAP)
 
    VG_FREETYPE_initialize();
#endif
}
 
// --------------------------------------------------------------------------------
// UI Pack > 14.5.1 function
// --------------------------------------------------------------------------------
 
// See the header file for the function documentation
BSP_DECLARE_WEAK_FCNT void LLUI_DISPLAY_waitAsynchronousDrawingEnd(void) {
    // cannot wait the end of drawing with UI packs [14.4.0-14.5.1]
}
 
// -----------------------------------------------------------------------------
// vg_helper.h functions
// -----------------------------------------------------------------------------
 
// See the header file for the function documentation
int VG_HELPER_get_utf(const unsigned short *textCharRam, int length, int *offset) {
    unsigned short highPart = GET_NEXT_CHARACTER(textCharRam, length, *offset);
    int ret = 0; // means "error" (see doc)
 
    if ((highPart >= MIN_HIGH_SURROGATE) && (highPart <= MAX_HIGH_SURROGATE)) {
        if (*offset < (length - 1)) {
            unsigned short lowPart = GET_NEXT_CHARACTER(textCharRam, length, *(offset) + 1);
 
            if ((lowPart >= MIN_LOW_SURROGATE) && (lowPart <= MAX_LOW_SURROGATE)) {
                *offset += 2;
 
                ret = 0;
                ret += ((int)highPart - (int)MIN_HIGH_SURROGATE);
                ret <<= (int)10;
                ret += ((int)lowPart - (int)MIN_LOW_SURROGATE);
                ret += (int)MIN_SUPPLEMENTARY_CODE_POINT;
            }
            // else: invalid surrogate pair
        }
        // else: missing second part of surrogate pair
    } else {
        *offset += 1;
 
        // standard character
        ret = 0x0000FFFF & (int)highPart;
    }
 
    return ret;
}
 
#if defined VG_FEATURE_FONT
// See the header file for the function documentation
void VG_HELPER_layout_configure(int faceHandle, const unsigned short *text, int length) {
    // Configuring starts a new iteration, so whatever a caller that stopped before the end of its own
    // iteration left open is released here.
    VG_HELPER_layout_stop();
 
    face = (FT_Face)faceHandle;
    // For Misra rule 2.7
    (void)text;
    (void)length;
 
    if (IS_SIMPLE_LAYOUT) {
        // Freetype variables initialisation
        current_text = text;
        current_length = length;
        current_offset = 0;
        previous_glyph_index = 0;
    } else {
#if defined VG_FEATURE_FONT_COMPLEX_LAYOUT && (VG_FEATURE_FONT_COMPLEX_LAYOUT == 1)
        // load font in Harfbuzz only when faceHandle changes
        if (faceHandle != current_faceHandle) {
            if (0 != current_faceHandle) {
                hb_font_destroy(hb_font);
            }
            // FT_Set_Pixel_Sizes() must be called before hb_ft_font_create()
            FT_Set_Pixel_Sizes(face, 0, face->units_per_EM);  /* set character size */
            hb_font = hb_ft_font_create(face, NULL);
            current_faceHandle = faceHandle;
        }
 
        buf = hb_buffer_create();
        hb_buffer_add_utf16(buf, (const uint16_t *)text, length, 0, -1);
 
        hb_buffer_guess_segment_properties(buf);
 
        hb_shape(hb_font, buf, NULL, 0);
 
        glyph_info = hb_buffer_get_glyph_infos(buf, &glyph_count);
        glyph_pos = hb_buffer_get_glyph_positions(buf, &glyph_count);
 
        current_glyph = 0;
#endif // VG_FEATURE_FONT_COMPLEX_LAYOUT
    }
}
 
// See the header file for the function documentation
void VG_HELPER_layout_dispose(int faceHandle) {
#if defined VG_FEATURE_FONT_COMPLEX_LAYOUT && (VG_FEATURE_FONT_COMPLEX_LAYOUT == 1)
    if (faceHandle == current_faceHandle) {
        hb_font_destroy(hb_font);
        hb_font = NULL;
        current_faceHandle = 0;
    }
#else
    (void)faceHandle;
#endif // VG_FEATURE_FONT_COMPLEX_LAYOUT
}
 
#endif /* if defined VG_FEATURE_FONT */
 
#if defined VG_FEATURE_FONT
// See the header file for the function documentation
bool VG_HELPER_layout_load_glyph(uint32_t *glyph_idx, int *x_advance, int *y_advance, int *x_offset, int *y_offset) {
    // Initiate return value with default values
    *glyph_idx = 0;
    *x_advance = 0;
    *y_advance = 0;
    *x_offset = 0;
    *y_offset = 0;
 
    bool ret = false;
 
    if (IS_SIMPLE_LAYOUT) {
        // Freetype layout
        FT_ULong next_char = VG_HELPER_get_utf(current_text, current_length, &current_offset);
        if (0 != next_char) {
            FT_UInt glyph_index = FT_Get_Char_Index(face, next_char);
 
            int error = FT_Load_Glyph(face, glyph_index, FT_LOAD_NO_SCALE);
            if (FT_ERR(Ok) != error) {
                VG_LOG_ERROR("Error while loading glyphid %u: 0x%x, refer to fterrdef.h", glyph_index,
                             error);
            }
 
            *x_advance = face->glyph->advance.x;
 
            // Compute Kerning
            if (FT_HAS_KERNING(face) && previous_glyph_index && glyph_index) {
                FT_Vector delta;
                FT_Get_Kerning(face, previous_glyph_index, glyph_index, FT_KERNING_UNSCALED, &delta);
 
                *x_offset = delta.x;
                *x_advance += delta.x;
            }
 
            previous_glyph_index = glyph_index;
 
            *glyph_idx = glyph_index;
 
            ret = true;
        }
    } else {
#if defined VG_FEATURE_FONT_COMPLEX_LAYOUT && (VG_FEATURE_FONT_COMPLEX_LAYOUT == 1)
        // Harfbuzz layout
        if (((unsigned int)0) != glyph_count) {
            *glyph_idx = glyph_info[current_glyph].codepoint;
            *x_advance = glyph_pos[current_glyph].x_advance / 64;
            *y_advance = glyph_pos[current_glyph].y_advance / 64;
            *x_offset = glyph_pos[current_glyph].x_offset / 64;
            *y_offset = glyph_pos[current_glyph].y_offset / 64;
 
            glyph_count--;
            current_glyph++;
 
            // Load glyph
            int error = FT_Load_Glyph(face, *glyph_idx, FT_LOAD_NO_SCALE);
            if (FT_ERR(Ok) != error) {
                VG_LOG_ERROR("Error while loading glyphid %" PRIu32 ": 0x%x, refer to fterrdef.h", *glyph_idx, error);
            }
 
            ret = true;
        } else {
            if (NULL != buf) {
                hb_buffer_destroy(buf);
                buf = NULL;
            }
            ret = false;
        }
#endif // VG_FEATURE_FONT_COMPLEX_LAYOUT
    }
 
    return ret;
}
 
// See the header file for the function documentation
void VG_HELPER_layout_stop(void) {
#if defined VG_FEATURE_FONT_COMPLEX_LAYOUT && (VG_FEATURE_FONT_COMPLEX_LAYOUT == 1)
    if (NULL != buf) {
        // The buffer, not the remaining count, is what says an iteration is still open: the count
        // reaches zero when the last glyph is handed out, one call before the iteration ends.
        hb_buffer_destroy(buf);
        buf = NULL;
        glyph_count = 0;
    }
#endif // VG_FEATURE_FONT_COMPLEX_LAYOUT
}
 
#endif /* if defined VG_FEATURE_FONT */
 
// See the header file for the function documentation
const jfloat * VG_HELPER_check_matrix(const jfloat *matrix) {
    return (NULL == matrix) ? g_identity_matrix : matrix;
}
 
// See the header file for the function documentation
uint32_t VG_HELPER_apply_alpha(uint32_t color, uint32_t alpha) {
    uint32_t color_alpha = (((color >> 24) & (uint32_t)0xff) * alpha) / (uint32_t)255;
    return (color & (uint32_t)0xffffff) | (color_alpha << 24);
}
 
// See the header file for the function documentation
void VG_HELPER_prepare_matrix(jfloat *dest, jfloat x, jfloat y, const jfloat *matrix) {
    const jfloat *local_matrix = VG_HELPER_check_matrix(matrix);
 
    if ((0 != x) || (0 != y)) {
        // Create translate matrix for initial x,y translation from graphicscontext.
        LLVG_MATRIX_IMPL_setTranslate(dest, x, y);
        LLVG_MATRIX_IMPL_concatenate(dest, local_matrix);
    } else {
        // use original matrix
        LLVG_MATRIX_IMPL_copy(dest, local_matrix);
    }
}
 
// -----------------------------------------------------------------------------
// EOF
// -----------------------------------------------------------------------------