···

       
6
       
 
       
### Quick usage

     

       
7
       
 
       


     

       
8
       
 
       
To quickly set up and use a framebuffer Flanterm instance, it is possible to

     

       
9
       
-
       
use the `flanterm_fb_simple_init()` function as such:

     

       
10
       
 
       
```c

     

       
11
       
 
       
#include <flanterm/flanterm.h>

     

       
12
       
 
       
#include <flanterm/backends/fb.h>

     

       
13
       
 
       


     

       
14
       
-
       
struct flanterm_context *ft_ctx = flanterm_fb_simple_init(

     

       
15
       
-
       
    framebuffer_ptr, framebuffer_width, framebuffer_height, framebuffer_pitch

     

       
16
       
-
       
);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
17
       
 
       
```

     

       
18
       
-
       
Where `framebuffer_{ptr,width,height,pitch}` represent the corresponding info

     

       
19
       
-
       
about the framebuffer to use for this given instance.

     

       
0
       
 
       

     

       
0
       
 
       

     

       
20
       
 
       


     

       
21
       
 
       
To then print to the terminal instance, simply use the `flanterm_write()`

     

       
22
       
 
       
function on the given instance. For example:

     

···

       
6
       
 
       
### Quick usage

     

       
7
       
 
       


     

       
8
       
 
       
To quickly set up and use a framebuffer Flanterm instance, it is possible to

     

       
9
       
+
       
use the `flanterm_fb_init()` function as such:

     

       
10
       
 
       
```c

     

       
11
       
 
       
#include <flanterm/flanterm.h>

     

       
12
       
 
       
#include <flanterm/backends/fb.h>

     

       
13
       
 
       


     

       
14
       
+
       
struct flanterm_context *ft_ctx = flanterm_fb_init(

     

       
15
       
+
       
        NULL,

     

       
16
       
+
       
        NULL,

     

       
17
       
+
       
        framebuffer_ptr, width, height, pitch,

     

       
18
       
+
       
        red_mask_size, red_mask_shift,

     

       
19
       
+
       
        green_mask_size, green_mask_shift,

     

       
20
       
+
       
        blue_mask_size, blue_mask_shift,

     

       
21
       
+
       
        NULL, NULL,

     

       
22
       
+
       
        NULL, NULL,

     

       
23
       
+
       
        NULL, NULL,

     

       
24
       
+
       
        NULL, 0, 0, 1,

     

       
25
       
+
       
        0, 0,

     

       
26
       
+
       
        0

     

       
27
       
+
       
    );

     

       
28
       
 
       
```

     

       
29
       
+
       
Where `framebuffer_ptr, width, height, pitch` and `{red,green,blue}_mask_{size,shift}`

     

       
30
       
+
       
represent the corresponding info about the framebuffer to use for this given instance.

     

       
31
       
+
       


     

       
32
       
+
       
The meaning of the other arguments can be found in `backends/fb.h`.

     

       
33
       
 
       


     

       
34
       
 
       
To then print to the terminal instance, simply use the `flanterm_write()`

     

       
35
       
 
       
function on the given instance. For example:

     

···

       
406
       
 
       
  0x00, 0x00, 0x00, 0x00

     

       
407
       
 
       
};

     

       
408
       
 
       


     

       
409
       
-
       
#ifdef FLANTERM_FB_SUPPORT_BPP

     

       
410
       
 
       
static inline __attribute__((always_inline)) uint32_t convert_colour(struct flanterm_context *_ctx, uint32_t colour) {

     

       
411
       
 
       
    struct flanterm_fb_context *ctx = (void *)_ctx;

     

       
412
       
 
       
    uint32_t r = (colour >> 16) & 0xff;

     
···

       
414
       
 
       
    uint32_t b =  colour & 0xff;

     

       
415
       
 
       
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);

     

       
416
       
 
       
}

     

       
417
       
-
       
#else

     

       
418
       
-
       
#define convert_colour(CTX, COLOUR) (COLOUR)

     

       
419
       
-
       
#endif

     

       
420
       
 
       


     

       
421
       
 
       
static void flanterm_fb_save_state(struct flanterm_context *_ctx) {

     

       
422
       
 
       
    struct flanterm_fb_context *ctx = (void *)_ctx;

     
···

       
879
       
 
       
    void *(*_malloc)(size_t),

     

       
880
       
 
       
    void (*_free)(void *, size_t),

     

       
881
       
 
       
    uint32_t *framebuffer, size_t width, size_t height, size_t pitch,

     

       
882
       
-
       
#ifdef FLANTERM_FB_SUPPORT_BPP

     

       
883
       
 
       
    uint8_t red_mask_size, uint8_t red_mask_shift,

     

       
884
       
 
       
    uint8_t green_mask_size, uint8_t green_mask_shift,

     

       
885
       
 
       
    uint8_t blue_mask_size, uint8_t blue_mask_shift,

     

       
886
       
-
       
#endif

     

       
887
       
 
       
#ifndef FLANTERM_FB_DISABLE_CANVAS

     

       
888
       
 
       
    uint32_t *canvas,

     

       
889
       
 
       
#endif

     
···

       
907
       
 
       
        }

     

       
908
       
 
       
    }

     

       
909
       
 
       


     

       
910
       
-
       
#ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       
911
       
-
       
#endif

     

       
912
       
-
       


     

       
913
       
-
       
#ifdef FLANTERM_FB_SUPPORT_BPP

     

       
914
       
 
       
    if (red_mask_size < 8 || red_mask_size != green_mask_size || red_mask_size != blue_mask_size) {

     

       
915
       
 
       
        return NULL;

     

       
916
       
 
       
    }

     

       
917
       
-
       
#endif

     

       
918
       
 
       


     

       
919
       
 
       
    if (_malloc == NULL) {

     

       
920
       
 
       
#ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     
···

       
946
       
 
       
    struct flanterm_context *_ctx = (void *)ctx;

     

       
947
       
 
       
    memset(ctx, 0, sizeof(struct flanterm_fb_context));

     

       
948
       
 
       


     

       
949
       
-
       
#ifdef FLANTERM_FB_SUPPORT_BPP

     

       
950
       
 
       
    ctx->red_mask_size = red_mask_size;

     

       
951
       
 
       
    ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8);

     

       
952
       
 
       
    ctx->green_mask_size = green_mask_size;

     

       
953
       
 
       
    ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8);

     

       
954
       
 
       
    ctx->blue_mask_size = blue_mask_size;

     

       
955
       
 
       
    ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8);

     

       
956
       
-
       
#endif

     

       
957
       
 
       


     

       
958
       
 
       
    if (ansi_colours != NULL) {

     

       
959
       
 
       
        for (size_t i = 0; i < 8; i++) {

     

···

       
406
       
 
       
  0x00, 0x00, 0x00, 0x00

     

       
407
       
 
       
};

     

       
408
       
 
       


     

       
0
       
 
       

     

       
409
       
 
       
static inline __attribute__((always_inline)) uint32_t convert_colour(struct flanterm_context *_ctx, uint32_t colour) {

     

       
410
       
 
       
    struct flanterm_fb_context *ctx = (void *)_ctx;

     

       
411
       
 
       
    uint32_t r = (colour >> 16) & 0xff;

     
···

       
413
       
 
       
    uint32_t b =  colour & 0xff;

     

       
414
       
 
       
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);

     

       
415
       
 
       
}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
416
       
 
       


     

       
417
       
 
       
static void flanterm_fb_save_state(struct flanterm_context *_ctx) {

     

       
418
       
 
       
    struct flanterm_fb_context *ctx = (void *)_ctx;

     
···

       
875
       
 
       
    void *(*_malloc)(size_t),

     

       
876
       
 
       
    void (*_free)(void *, size_t),

     

       
877
       
 
       
    uint32_t *framebuffer, size_t width, size_t height, size_t pitch,

     

       
0
       
 
       

     

       
878
       
 
       
    uint8_t red_mask_size, uint8_t red_mask_shift,

     

       
879
       
 
       
    uint8_t green_mask_size, uint8_t green_mask_shift,

     

       
880
       
 
       
    uint8_t blue_mask_size, uint8_t blue_mask_shift,

     

       
0
       
 
       

     

       
881
       
 
       
#ifndef FLANTERM_FB_DISABLE_CANVAS

     

       
882
       
 
       
    uint32_t *canvas,

     

       
883
       
 
       
#endif

     
···

       
901
       
 
       
        }

     

       
902
       
 
       
    }

     

       
903
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
904
       
 
       
    if (red_mask_size < 8 || red_mask_size != green_mask_size || red_mask_size != blue_mask_size) {

     

       
905
       
 
       
        return NULL;

     

       
906
       
 
       
    }

     

       
0
       
 
       

     

       
907
       
 
       


     

       
908
       
 
       
    if (_malloc == NULL) {

     

       
909
       
 
       
#ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     
···

       
935
       
 
       
    struct flanterm_context *_ctx = (void *)ctx;

     

       
936
       
 
       
    memset(ctx, 0, sizeof(struct flanterm_fb_context));

     

       
937
       
 
       


     

       
0
       
 
       

     

       
938
       
 
       
    ctx->red_mask_size = red_mask_size;

     

       
939
       
 
       
    ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8);

     

       
940
       
 
       
    ctx->green_mask_size = green_mask_size;

     

       
941
       
 
       
    ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8);

     

       
942
       
 
       
    ctx->blue_mask_size = blue_mask_size;

     

       
943
       
 
       
    ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8);

     

       
0
       
 
       

     

       
944
       
 
       


     

       
945
       
 
       
    if (ansi_colours != NULL) {

     

       
946
       
 
       
        for (size_t i = 0; i < 8; i++) {

     

···

       
72
       
 
       
    size_t height;

     

       
73
       
 
       
    size_t bpp;

     

       
74
       
 
       


     

       
75
       
-
       
#ifdef FLANTERM_FB_SUPPORT_BPP

     

       
76
       
 
       
    uint8_t red_mask_size, red_mask_shift;

     

       
77
       
 
       
    uint8_t green_mask_size, green_mask_shift;

     

       
78
       
 
       
    uint8_t blue_mask_size, blue_mask_shift;

     

       
79
       
-
       
#endif

     

       
80
       
 
       


     

       
81
       
 
       
    size_t font_bits_size;

     

       
82
       
 
       
    uint8_t *font_bits;

     
···

       
119
       
 
       
};

     

       
120
       
 
       


     

       
121
       
 
       
struct flanterm_context *flanterm_fb_init(

     

       
0
       
 
       

     

       
122
       
 
       
    void *(*_malloc)(size_t),

     

       
123
       
 
       
    void (*_free)(void *, size_t),

     

       
124
       
 
       
    uint32_t *framebuffer, size_t width, size_t height, size_t pitch,

     

       
125
       
-
       
#ifdef FLANTERM_FB_SUPPORT_BPP

     

       
126
       
 
       
    uint8_t red_mask_size, uint8_t red_mask_shift,

     

       
127
       
 
       
    uint8_t green_mask_size, uint8_t green_mask_shift,

     

       
128
       
 
       
    uint8_t blue_mask_size, uint8_t blue_mask_shift,

     

       
129
       
-
       
#endif

     

       
130
       
 
       
#ifndef FLANTERM_FB_DISABLE_CANVAS

     

       
131
       
 
       
    uint32_t *canvas,

     

       
132
       
 
       
#endif

     
···

       
140
       
 
       


     

       
141
       
 
       
#ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       
142
       
 
       
static inline struct flanterm_context *flanterm_fb_simple_init(

     

       
143
       
-
       
    uint32_t *framebuffer, size_t width, size_t height, size_t pitch

     

       
144
       
-
       
#ifdef FLANTERM_FB_SUPPORT_BPP

     

       
145
       
-
       
    ,

     

       
146
       
 
       
    uint8_t red_mask_size, uint8_t red_mask_shift,

     

       
147
       
 
       
    uint8_t green_mask_size, uint8_t green_mask_shift,

     

       
148
       
 
       
    uint8_t blue_mask_size, uint8_t blue_mask_shift

     

       
149
       
-
       
#endif

     

       
150
       
 
       
) {

     

       
151
       
 
       
    return flanterm_fb_init(

     

       
152
       
 
       
        NULL,

     

       
153
       
 
       
        NULL,

     

       
154
       
 
       
        framebuffer, width, height, pitch,

     

       
155
       
-
       
#ifdef FLANTERM_FB_SUPPORT_BPP

     

       
156
       
 
       
        red_mask_size, red_mask_shift,

     

       
157
       
 
       
        green_mask_size, green_mask_shift,

     

       
158
       
 
       
        blue_mask_size, blue_mask_shift,

     

       
159
       
-
       
#endif

     

       
160
       
-
       
#ifndef FLANTERM_FB_DISABLE_CANVAS

     

       
161
       
-
       
        NULL,

     

       
162
       
-
       
#endif

     

       
163
       
 
       
        NULL, NULL,

     

       
164
       
 
       
        NULL, NULL,

     

       
165
       
 
       
        NULL, NULL,

     

···

       
72
       
 
       
    size_t height;

     

       
73
       
 
       
    size_t bpp;

     

       
74
       
 
       


     

       
0
       
 
       

     

       
75
       
 
       
    uint8_t red_mask_size, red_mask_shift;

     

       
76
       
 
       
    uint8_t green_mask_size, green_mask_shift;

     

       
77
       
 
       
    uint8_t blue_mask_size, blue_mask_shift;

     

       
0
       
 
       

     

       
78
       
 
       


     

       
79
       
 
       
    size_t font_bits_size;

     

       
80
       
 
       
    uint8_t *font_bits;

     
···

       
117
       
 
       
};

     

       
118
       
 
       


     

       
119
       
 
       
struct flanterm_context *flanterm_fb_init(

     

       
120
       
+
       
    // If _malloc and _free are nulled, use the bump allocated instance (1 use only).

     

       
121
       
 
       
    void *(*_malloc)(size_t),

     

       
122
       
 
       
    void (*_free)(void *, size_t),

     

       
123
       
 
       
    uint32_t *framebuffer, size_t width, size_t height, size_t pitch,

     

       
0
       
 
       

     

       
124
       
 
       
    uint8_t red_mask_size, uint8_t red_mask_shift,

     

       
125
       
 
       
    uint8_t green_mask_size, uint8_t green_mask_shift,

     

       
126
       
 
       
    uint8_t blue_mask_size, uint8_t blue_mask_shift,

     

       
0
       
 
       

     

       
127
       
 
       
#ifndef FLANTERM_FB_DISABLE_CANVAS

     

       
128
       
 
       
    uint32_t *canvas,

     

       
129
       
 
       
#endif

     
···

       
137
       
 
       


     

       
138
       
 
       
#ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       
139
       
 
       
static inline struct flanterm_context *flanterm_fb_simple_init(

     

       
140
       
+
       
    uint32_t *framebuffer, size_t width, size_t height, size_t pitch,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
141
       
 
       
    uint8_t red_mask_size, uint8_t red_mask_shift,

     

       
142
       
 
       
    uint8_t green_mask_size, uint8_t green_mask_shift,

     

       
143
       
 
       
    uint8_t blue_mask_size, uint8_t blue_mask_shift

     

       
0
       
 
       

     

       
144
       
 
       
) {

     

       
145
       
 
       
    return flanterm_fb_init(

     

       
146
       
 
       
        NULL,

     

       
147
       
 
       
        NULL,

     

       
148
       
 
       
        framebuffer, width, height, pitch,

     

       
0
       
 
       

     

       
149
       
 
       
        red_mask_size, red_mask_shift,

     

       
150
       
 
       
        green_mask_size, green_mask_shift,

     

       
151
       
 
       
        blue_mask_size, blue_mask_shift,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
152
       
 
       
        NULL, NULL,

     

       
153
       
 
       
        NULL, NULL,

     

       
154
       
 
       
        NULL, NULL,