commit f62c969bde48e7433bb205477abd7ae7470df1d2 · pci.express/flanterm.zig

+19 -6

README.md

···

       6
       6
        
       ### Quick usage

     

       7
       7
        
       

     

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

     

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

     

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

     

       10
       10
        
       ```c

     

       11
       11
        
       #include <flanterm/flanterm.h>

     

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

     

       13
       13
        
       

     

       14
       14
       -
       struct flanterm_context *ft_ctx = flanterm_fb_simple_init(

     

       15
       15
       -
           framebuffer_ptr, framebuffer_width, framebuffer_height, framebuffer_pitch

     

       16
       16
       -
       );

     

       14
       14
       +
       struct flanterm_context *ft_ctx = flanterm_fb_init(

     

       15
       15
       +
               NULL,

     

       16
       16
       +
               NULL,

     

       17
       17
       +
               framebuffer_ptr, width, height, pitch,

     

       18
       18
       +
               red_mask_size, red_mask_shift,

     

       19
       19
       +
               green_mask_size, green_mask_shift,

     

       20
       20
       +
               blue_mask_size, blue_mask_shift,

     

       21
       21
       +
               NULL, NULL,

     

       22
       22
       +
               NULL, NULL,

     

       23
       23
       +
               NULL, NULL,

     

       24
       24
       +
               NULL, 0, 0, 1,

     

       25
       25
       +
               0, 0,

     

       26
       26
       +
               0

     

       27
       27
       +
           );

     

       17
       28
        
       ```

     

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

     

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

     

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

     

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

     

       31
       31
       +
       

     

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

     

       20
       33
        
       

     

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

     

       22
       35
        
       function on the given instance. For example:

-13

backends/fb.c

···

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

     

       407
       407
        
       };

     

       408
       408
        
       

     

       409
       409
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

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

     

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

     

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

     
···

       414
       413
        
           uint32_t b =  colour & 0xff;

     

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

     

       416
       415
        
       }

     

       417
       417
       -
       #else

     

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

     

       419
       419
       -
       #endif

     

       420
       416
        
       

     

       421
       417
        
       static void flanterm_fb_save_state(struct flanterm_context *_ctx) {

     

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

     
···

       879
       875
        
           void *(*_malloc)(size_t),

     

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

     

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

     

       882
       882
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

       883
       878
        
           uint8_t red_mask_size, uint8_t red_mask_shift,

     

       884
       879
        
           uint8_t green_mask_size, uint8_t green_mask_shift,

     

       885
       880
        
           uint8_t blue_mask_size, uint8_t blue_mask_shift,

     

       886
       886
       -
       #endif

     

       887
       881
        
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       888
       882
        
           uint32_t *canvas,

     

       889
       883
        
       #endif

     
···

       907
       901
        
               }

     

       908
       902
        
           }

     

       909
       903
        
       

     

       910
       910
       -
       #ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       911
       911
       -
       #endif

     

       912
       912
       -
       

     

       913
       913
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

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

     

       915
       905
        
               return NULL;

     

       916
       906
        
           }

     

       917
       917
       -
       #endif

     

       918
       907
        
       

     

       919
       908
        
           if (_malloc == NULL) {

     

       920
       909
        
       #ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     
···

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

     

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

     

       948
       937
        
       

     

       949
       949
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

       950
       938
        
           ctx->red_mask_size = red_mask_size;

     

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

     

       952
       940
        
           ctx->green_mask_size = green_mask_size;

     

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

     

       954
       942
        
           ctx->blue_mask_size = blue_mask_size;

     

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

     

       956
       956
       -
       #endif

     

       957
       944
        
       

     

       958
       945
        
           if (ansi_colours != NULL) {

     

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

+2 -13

backends/fb.h

···

       72
       72
        
           size_t height;

     

       73
       73
        
           size_t bpp;

     

       74
       74
        
       

     

       75
       75
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

       76
       75
        
           uint8_t red_mask_size, red_mask_shift;

     

       77
       76
        
           uint8_t green_mask_size, green_mask_shift;

     

       78
       77
        
           uint8_t blue_mask_size, blue_mask_shift;

     

       79
       79
       -
       #endif

     

       80
       78
        
       

     

       81
       79
        
           size_t font_bits_size;

     

       82
       80
        
           uint8_t *font_bits;

     
···

       119
       117
        
       };

     

       120
       118
        
       

     

       121
       119
        
       struct flanterm_context *flanterm_fb_init(

     

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

     

       122
       121
        
           void *(*_malloc)(size_t),

     

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

     

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

     

       125
       125
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

       126
       124
        
           uint8_t red_mask_size, uint8_t red_mask_shift,

     

       127
       125
        
           uint8_t green_mask_size, uint8_t green_mask_shift,

     

       128
       126
        
           uint8_t blue_mask_size, uint8_t blue_mask_shift,

     

       129
       129
       -
       #endif

     

       130
       127
        
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       131
       128
        
           uint32_t *canvas,

     

       132
       129
        
       #endif

     
···

       140
       137
        
       

     

       141
       138
        
       #ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC

     

       142
       139
        
       static inline struct flanterm_context *flanterm_fb_simple_init(

     

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

     

       144
       144
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

       145
       145
       -
           ,

     

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

     

       146
       141
        
           uint8_t red_mask_size, uint8_t red_mask_shift,

     

       147
       142
        
           uint8_t green_mask_size, uint8_t green_mask_shift,

     

       148
       143
        
           uint8_t blue_mask_size, uint8_t blue_mask_shift

     

       149
       149
       -
       #endif

     

       150
       144
        
       ) {

     

       151
       145
        
           return flanterm_fb_init(

     

       152
       146
        
               NULL,

     

       153
       147
        
               NULL,

     

       154
       148
        
               framebuffer, width, height, pitch,

     

       155
       155
       -
       #ifdef FLANTERM_FB_SUPPORT_BPP

     

       156
       149
        
               red_mask_size, red_mask_shift,

     

       157
       150
        
               green_mask_size, green_mask_shift,

     

       158
       151
        
               blue_mask_size, blue_mask_shift,

     

       159
       159
       -
       #endif

     

       160
       160
       -
       #ifndef FLANTERM_FB_DISABLE_CANVAS

     

       161
       161
       -
               NULL,

     

       162
       162
       -
       #endif

     

       163
       152
        
               NULL, NULL,

     

       164
       153
        
               NULL, NULL,

     

       165
       154
        
               NULL, NULL,