Linux Frame Buffer para TCC

Olá pessoal !

Pretendia usar a biblioteca SDL para uma Mini Distro ( Uriel Linux ) mas vi que a biblioteca é imensa com as dependências ...

Então resolvi fazer uma API GRÁFICA do zero usando Linux Frame Buffer.

Projeto aqui:
https://github.com/gokernel2017/sgFrameBuffer_for_TCC

Essa API é minúscula e em teste ainda ...

OBS1: como o nome do projeto diz, é somente para o compilador TCC
OBS2: os BITMAPS não está implementado "clipping" e por isso não se deve escrever fora do tamanho do BITMAP ...

Pelo que vi agora (2019/05/06 00:15), achei algumas coisas estranhas em sg.h.

  • Linhas 4 e 6, bem como 5 e 7, são redefinições dos mesmos tipos.
  • Se Uint16 e Uint32 são redefinições dos tipos padronizados uint16_t e uint32_t (que, por sua vez, são apelidos para tipos nativos), para que criar mais nomes para os mesmos tipos?
  • Se você usou typedef para esses dois apelidos, por que usou macro para definir UCHAR? E por que a diferença de estilo entre os nomes (tudo maiúsculo × apena primeira letra maiúscula)?
  • Cadê os cabeçalhos das funções definidas em sg.c?
  • Não seria conveniente usar include guards para evitar problemas de reinclusão do mesmo cabeçalho?
  • Por que redeifinir símbolos que estão em outras partes da biblioteca, em vez de usar os arquivos de cabeçalho que acompanham essas partes da biblioteca?


... “Principium sapientiae timor Domini, et scientia sanctorum prudentia.” (Proverbia 9:10)

Olá "paulo1205" !


RESPOSTAS:
a) • Se Uint16 e [/i]Uint32[/i] são redefinições dos tipos padronizados uint16_t e uint32_t (que, por sua vez, são apelidos para tipos nativos), para que criar mais nomes para os mesmos tipos?
Para mim esses tipos são novos ... por isso redefini, mas olhando o arquivo ( stddef.h ) vi que estavam definidos lá.

b) • Se você usou typedef para esses dois apelidos, por que usou macro para definir UCHAR? E por que a diferença de estilo entre os nomes (tudo maiúsculo × apena primeira letra maiúscula)?
Preferi definir UCHAR como um macro ... por isso "TODO MAIÚSCULO".

c) • Cadê os cabeçalhos das funções definidas em sg.c?
Fiz tudo nas pressas então fica no BETA ainda ... depois vou definir .

d) • Por que redeifinir símbolos que estão em outras partes da biblioteca, em vez de usar os arquivos de cabeçalho que acompanham essas partes da biblioteca?
Se você se refere a isso ?
---------------------------------------------------------------
int open (const char *path, int oflag, ...);
int close (int fd);
int ioctl (int fd, unsigned long request, ...);
void *mmap (void *addr, size_t length, int prot, int flags, int fd, int offset);
int munmap (void *addr, size_t len);
---------------------------------------------------------------

Se a resposta acima for sim então vai a info:
O compilador TCC não tem essas acima definidas ...

Se esqueci algo favor informar ...

OBS: já fiz as correções lá no projeto ...

Estou implementando para compilar com o GCC também ... quem quiser compilar usando o GCC basta incluir isso no arquivo ( sg.c ):
-----------------------------------------------------
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <linux/fb.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <wchar.h>
#include <time.h>
-----------------------------------------------------

E retirar as linhas com:
-----------------------------------------------------
#include <tcclib.h>
#include "sg.h"
-----------------------------------------------------

E modificar isso:

    struct sg_var_screeninfo

    struct sg_fix_screeninfo

Para isso:

    struct fb_var_screeninfo

    struct fb_fix_screeninfo

 

E obrigado "paulo1205" pela as observações ... fique a vontade para comentar ...

Pronto atualizado e testado mas BETA ainda ...

Vou implementar melhor ( sgBlit32() ) ... para uma melhor velocidade ...

Projeto atualizado e função( sgBlit32 ) melhor implementada !

O que fiz foi isso ... função de baixo melhor implementada:

//-------------------------------------------------------------------

// O BMP tem um tamanho de:

// 800 x 600

//

// entao o LOOP para copiar todos os bytes seria de:

//

// 600 * 800 * 4 = 1.920.000

//

// RESUMO:

//   funcao lenta devido ao LOOP grande ...

//

//-------------------------------------------------------------------

//

void sgBlit32 (BMP *bmp) {

    int i, y;

    register UCHAR *data = bmp->data;



    // loop 1: 600

    for (y = 0; y < bmp->h; y++) {



        UCHAR *p = (UCHAR*)(FB.screen + (y * FB.line_length + 0 * 4));



        // loop 2: 800 * 4

        for (i = 0; i < bmp->w * 4; i++) {



            *p++ = *data++; // copia apenas 1 byte de cada vez ... PESSIMA IDEIA ;)



        }

    }

}



//-------------------------------------------------------------------

// O BMP tem um tamanho de:

// 800 x 600

//

// entao o LOOP para copiar todos os bytes seria de:

//

// 600 * 800 = 480.000

//

// RESUMO:

//   funcao MELHORADA devido ao LOOP MENOR ...

//

// DETALHE:

//   nessa funcao copia 4 bytes de uma vez ... na funcao acima copia apenas 1 byte ...

//

//-------------------------------------------------------------------

//

void sgBlit32 (BMP *bmp) {

    int i, y;

    register UCHAR *data = bmp->data;



    // loop 1: 600

    for (y = 0; y < bmp->h; y++) {



        UCHAR *p = (UCHAR*)(FB.screen + (y * FB.line_length + 0 * 4));



        // loop 2: 800

        for (i = 0; i < bmp->w; i++) {

            //

            // ... copy 4 bytes ... ;)

            //

            *(unsigned int *)( p ) = *(unsigned int *)( data );



            p += 4;

            data += 4;

        }

    }

}

 

RESUMO:
O loop que era grande ( 1.920.000 ) ficou menor ( 480.000 )...

OBS:
Depois vou tentar melhorar mais a velocidade dessa função ... ;)

Olá pessoal !

Atualizei o projeto e fiz um test de FPS(Frames Por Segundos) ...



No meu Note Core i3 ficou assim os resultados:
-----------------------------------------------------------------
1: Com a implementação antiga de ( sgBlit32() ), o FPS ficou em media:
137 FPS.

2: Com a implementação melhorada de ( sgBlit32() ), o FPS ficou em media:
550 FPS.
-----------------------------------------------------------------

Exemplo função main:

int main (void) {

    int color;

    BMP *b = NULL;



    printf ("Sizeof sg_fix_screeninfo = %d\n", (int)sizeof(struct sg_fix_screeninfo));

    printf ("Sizeof sg_var_screeninfo = %d\n", (int)sizeof(struct sg_var_screeninfo));



    if (sgInit()) {



        if ((b = sgNewBmp32(800,600))) {

            printf ("BITMAP CRIADO 800 X 600\n");

        }



        if (FB.bpp == 16)

            color = makecol16(255,130,30); // orange

        if (FB.bpp == 32)

            color = makecol32(255,130,30);



        if (FB.bpp == 32 && b) {

            sprintf (buf, "%s", "FPS: %d", fps);

            hlineBMP32 (b, 50, 50, 450, color);  // -

            hlineBMP32 (b, 50, 150, 450, color); // -

            vlineBMP32 (b, 50, 50, 150, color);  // |

            vlineBMP32 (b, 450, 50, 150, color); // |

            DrawText (b, "Please Wait 15 SECONDS: ...", 100, 75, color);

            DrawText (b, buf, 100, 100, color);



            for (;;) {



                //

                // each SECOND:

                //

                long t = time (NULL);

                if (t != now) {

                    now = t;

                    if (count < 0)

                        break;

                    sprintf (buf, "FPS: %d | Wait %d", fps, count--);

                    fps = 0;



                    // bg: FPS test

                    //---------------------------------------

                    hlineBMP32 (b, 100, 100, 300, 0);  // -

                    hlineBMP32 (b, 100, 101, 300, 0);  // -

                    hlineBMP32 (b, 100, 102, 300, 0);  // -

                    hlineBMP32 (b, 100, 103, 300, 0);  // -

                    hlineBMP32 (b, 100, 104, 300, 0);  // -

                    hlineBMP32 (b, 100, 105, 300, 0);  // -

                    hlineBMP32 (b, 100, 106, 300, 0);  // -

                    hlineBMP32 (b, 100, 107, 300, 0);  // -

                    hlineBMP32 (b, 100, 108, 300, 0);  // -

                    hlineBMP32 (b, 100, 109, 300, 0);  // -

                    hlineBMP32 (b, 100, 110, 300, 0);  // -

                    hlineBMP32 (b, 100, 111, 300, 0);  // -

                    hlineBMP32 (b, 100, 112, 300, 0);  // -

                    hlineBMP32 (b, 100, 113, 300, 0);  // -

                    hlineBMP32 (b, 100, 114, 300, 0);  // -

                    //---------------------------------------



                    DrawText (b, buf, 100, 100, color);



                }// if (t != now)



                fps++;



                //

                // Update/display the BMP

                //

                sgBlit32 (b);



            }// for (;;)



        }// if (FB.bpp == 32 && b)



        sgQuit();

    }



    printf ("Exiting With Sucess:\n");



    return 0;

}



 

O objetivo é melhorar a implementação para ganhar mais 50% de performance ... !!!

OBS: O programa sai do loop depois de 15 segundos ...

Projeto com funcao ( sgBlit32() ) mais otimizada:

void sgBlit32 (BMP *bmp) {

    int i, y, size_w_div_2 = bmp->w/2;;

    register UCHAR *data = bmp->data;

    for (y = 0; y < bmp->h; y++) {

        UCHAR *p = (UCHAR*)(FB.screen + (y * FB.line_length + 0 * 4));

//        for (i = 0; i < bmp->w/2; i++) {

        for (i = 0; i < size_w_div_2; i++) {

            //

            // ... copy 8 bytes (long) ... ;)

            //

            *(unsigned long *)( p ) = *(unsigned long *)( data );

            p += 8;

            data += 8;

        }

    }

}

 

No teste do FPS aumentou de (550 em média) para (1085 em média) ...

O próximo objetivo é ganhar mais 30% de performance ... partindo agora talvez para ASSEMBLY !!!

OBS: O BMP precisa ter um tamanho de valor "par" ... devido a copiar 8 bytes de uma vez ... depois vou forçar/implementar isso ...

Olá pessoal !

O projeto mudou para esse novo endereço:
https://github.com/gokernel2017/sgfb

1: Falta implementar algumas teclas ( ACIMA, ABAIXO, ETC ).
2: Só está implementado por enquanto para desenhar em 32 BPP ( 4 bytes ).

Futuramente vou apagar o antigo endereço.

Vai continuar desenvolvendo para TCC, mesmo depois da outra postagem em que você constatou que o TCC produz código muito lento?


... “Principium sapientiae timor Domini, et scientia sanctorum prudentia.” (Proverbia 9:10)

Se você ver o código novo vai observar que informa para compilar usando o compilador gcc.

OBS: o código atual é tipo um programa pois estou fazendo alguns testes ainda, depois vou modificar para uma biblioteca.

E respondendo a sua pergunta:
Não sou sadomasoquista não ;).

Vou usar o gcc pois estou obtendo excelentes resultados !!!

Eu não cheguei a reexaminar o código fonte. A pergunta foi por causa do título do tópico.


... “Principium sapientiae timor Domini, et scientia sanctorum prudentia.” (Proverbia 9:10)

Olá pessoal !

Projeto aqui:
https://github.com/gokernel2017/sgfb

Projeto atualizado e Implementado desenho ( 16 e 32 BPP):
// 16/32 BPP:
LIBIMPORT void sgDrawRect (BMP *bmp, int x, int y, int w, int h, int color);
LIBIMPORT void sgDrawText (BMP *bmp, char *text, int x, int y, int color);

Implementado essas teclas ( arquivo: sgfb.h ):

//---------------------------

// START KEYS:

//---------------------------

#define SGK_TAB       9

#define SGK_ENTER     13

#define SGK_ESC       27

#define SGK_SPACE     32

//

// ...

//

#define SGK_BACKSPACE 127

// std SDLK_:

#define SGK_UP        273

#define SGK_DOWN      274

#define SGK_RIGHT     275 // ->

#define SGK_LEFT      276 // <-

#define SGK_INSERT    277

#define SGK_HOME      278

#define SGK_END       279

#define SGK_PAGEUP    280

#define SGK_PAGEDOWN  281

// std SDLK_:

#define SGK_F1        282

#define SGK_F2        283

#define SGK_F3        284

#define SGK_F4        285

#define SGK_F5        286

#define SGK_F6        287

#define SGK_F7        288

#define SGK_F8        289

#define SGK_F9        290

#define SGK_F10       291

#define SGK_F11       292

#define SGK_F12       293

//

#define SGK_DELETE    400

//---------------------------

// END KEYS:

//---------------------------