textc - fbtext

#define FREETYPE_MAJOR  == 2
#define FREETYPE_MINOR == 3
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <linux/fb.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_CACHE_H
#include FT_CACHE_SMALL_BITMAPS_H

// Schriftdatei setzen
#define FONT "/usr/share/fonts/md_khmurabi_10.ttf"

enum {LEFT, CENTER, RIGHT};
enum {VERY_SMALL, SMALL, BIG};

// Schriftgr�ssen festlegen
#define FONTHEIGHT_VERY_SMALL 16
#define FONTHEIGHT_SMALL      32
#define FONTHEIGHT_BIG        40

// Libfreetype Zeugs
FT_Error        error;
FT_Library      library;
FTC_Manager     manager;
FTC_SBitCache       cache;
FTC_SBit        sbit;
#if FREETYPE_MAJOR  == 2 && FREETYPE_MINOR == 0
FTC_Image_Desc      desc;
#else
FTC_ImageTypeRec    desc;
#endif
FT_Face         face;
FT_UInt         prev_glyphindex;
FT_Bool         use_kerning;
FT_Error MyFaceRequester(FTC_FaceID face_id, FT_Library library, FT_Pointer request_data, FT_Face *aface);

// Framebuffer Zeugs
unsigned char *lfb;
int StartX;
int StartY;
int fb;
struct fb_fix_screeninfo fix_screeninfo;
struct fb_var_screeninfo var_screeninfo;

// **************************************************************************************************************
// Renderroutinen f�r Text und einfache Boxen
// **************************************************************************************************************

// Freetype - MyFaceRequester
FT_Error MyFaceRequester(FTC_FaceID face_id, FT_Library library, FT_Pointer request_data, FT_Face *aface)
{
    FT_Error result;

    result = FT_New_Face(library, face_id, 0, aface);

    if(!result) printf("Freetype <Schrift \"%s\" geladen>\n", (char*)face_id);
    else        printf("Freetype <Schrift \"%s\" fehlgeschlagen>\n", (char*)face_id);

    return result;
}

// Freetype - RenderChar
int RenderChar(FT_ULong currentchar, int sx, int sy, int ex, unsigned char *color)
{
    if (currentchar == 32) return;

    int row, pitch, bit, x = 0, y = 0;
    FT_UInt glyphindex;
    FT_Vector kerning;
    FT_Error error;
    int tmpcolor;

    if(!(glyphindex = FT_Get_Char_Index(face, currentchar)))
    {
        printf("Freetype <FT_Get_Char_Index> fuer Zeichen %x \"%c\" fehlgeschlagen\n", (int)currentchar,(int)currentchar);
        return 0;
    }

#if FREETYPE_MAJOR == 2 && FREETYPE_MINOR == 0
    if((error = FTC_SBit_Cache_Lookup(cache, &desc, glyphindex, &sbit)))
#else
    FTC_Node anode;
    if((error = FTC_SBitCache_Lookup(cache, &desc, glyphindex, &sbit, &anode)))
#endif
    {
        printf("Freetype <FTC_SBitCache_Lookup> fuer Zeichen %x \"%c\" fehlgeschlagen. Fehler: 0x%.2X>\n", (int)currentchar,(int)currentchar, error);
        return 0;
    }
    if(use_kerning)
    {
        FT_Get_Kerning(face, prev_glyphindex, glyphindex, ft_kerning_default, &kerning);

        prev_glyphindex = glyphindex;
        kerning.x >>= 6;
    }
    else
        kerning.x = 0;

        if(sx + sbit->xadvance >= ex) return -1;
        for(row = 0; row < sbit->height; row++)
        {
            for(pitch = 0; pitch < sbit->pitch; pitch++)
            {
                for(bit = 7; bit >= 0; bit--)
                {
                    if(pitch*8 + 7-bit >= sbit->width) break; /* render needed bits only */
                    if((sbit->buffer[row * sbit->pitch + pitch]) & 1<<bit) {
                    memcpy(lfb + StartX*4 + sx*4 + (sbit->left + kerning.x + x)*4 + fix_screeninfo.line_length*(StartY + sy - sbit->top + y), color, 4);
                    }
                    x++;
                }
            }
            x = 0;
            y++;
        }

        return sbit->xadvance + kerning.x;
}

// Freetype - Stringlaenge
int GetStringLen(const char *string, int size)
{
    int stringlen = 0;

    switch (size)
    {
        case VERY_SMALL: desc.width = desc.height = FONTHEIGHT_VERY_SMALL; break;
        case SMALL     : desc.width = desc.height = FONTHEIGHT_SMALL     ; break;
        case BIG       : desc.width = desc.height = FONTHEIGHT_BIG       ; break;
    }
    prev_glyphindex = 0;
    while(*string != '\0')
    {
        stringlen += RenderChar(*string, -1, -1, -1, "");
        string++;
    }

    return stringlen;
}

// Freetype - Render String
void RenderString(const char *string, int sx, int sy, int maxwidth, int layout, int size, unsigned char *color)
{
    int stringlen, ex, charwidth;
    switch (size)
    {
        case VERY_SMALL: desc.width = desc.height = FONTHEIGHT_VERY_SMALL; break;
        case SMALL     : desc.width = desc.height = FONTHEIGHT_SMALL     ; break;
        case BIG       : desc.width = desc.height = FONTHEIGHT_BIG       ; break;
    }
    if(layout != LEFT)
    {
        stringlen = GetStringLen(string, size);
        switch(layout)
        {
            case CENTER:    if(stringlen < maxwidth) sx += (maxwidth - stringlen)/2;
                    break;
            case RIGHT: if(stringlen < maxwidth) sx += maxwidth - stringlen;
        }
    }
    prev_glyphindex = 0;
    ex = sx + maxwidth;
    while(*string != '\0' && *string != '\n')
    {
        if((charwidth = RenderChar(*string, sx, sy, ex, color)) == -1) return; /* string > maxwidth */
        sx += charwidth;
        string++;
    }
}

// Render Box
void RenderBox(int sx, int sy, int ex, int ey, unsigned char *color)
{

    int loop;
    int tx;

        for(; sy <= ey; sy++)
        {
            for(tx=0; tx <= (ex-sx); tx++)
            {
            memcpy(lfb + StartX*4 + sx*4 + (tx*4) + fix_screeninfo.line_length*(StartY + sy),color,4);
            }
        }

}


// **************************************************************************************************************
// Hauptroutine
// **************************************************************************************************************

main(argc,argv)
int argc;
char *argv[];
{
    // Setze Offsets (Startpunkt links oben), der Framebuffer hat 720x576pixel,
    // danke Overscan der TV Ger�te meist nur ca. 640x480 nutzbar
    StartX=60;
    StartY=60;

    // Framebuffer oeffnen
    fb=open("/dev/fb/0", O_RDWR);
    if (fb == -1)
    {
        printf("Framebuffer failed\n");
        return;
    }

    // Framebuffer initialisieren und Infos auslesen
    if(ioctl(fb, FBIOGET_FSCREENINFO, &fix_screeninfo) == -1)
    {
        printf("Framebuffer: <FBIOGET_FSCREENINFO fehlgeschlagen>\n");
        return;
    }

    if(ioctl(fb, FBIOGET_VSCREENINFO, &var_screeninfo) == -1)
    {
        printf("Framebuffer: <FBIOGET_VSCREENINFO fehlgeschlagen>\n");
        return;
    }

    // Framebuffermodus auf 720x576 und 32 Bit initialisieren
    var_screeninfo.yres=var_screeninfo.yres_virtual=576;
    var_screeninfo.xres=var_screeninfo.xres_virtual=720;
    var_screeninfo.bits_per_pixel=32;
    if(ioctl(fb, FBIOPUT_VSCREENINFO, &var_screeninfo) == -1)
    {
        printf("Framebuffer: <FBIOPUT_VSCREENINFO fehlgeschlagen>\n");
        return;
    }

    if(ioctl(fb, FBIOGET_FSCREENINFO, &fix_screeninfo) == -1)
    {
        printf("Framebuffer: <FBIOGET_FSCREENINFO fehlgeschlagen>\n");
        return;
    }

    // Framebuffer in Speicher mappen
    if(!(lfb = (unsigned char*)mmap(0, fix_screeninfo.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fb, 0)))
    {
        printf("Framebuffer: <Speichermapping fehlgeschlagen>\n");
        return;
    }

    // Freetype initialisieren
    if((error = FT_Init_FreeType(&library)))
    {
        printf("Freetype <FT_Init_FreeType fehlgeschlagen. Fehler: 0x%.2X>", error);
        munmap(lfb, fix_screeninfo.smem_len);
        return;
    }

    if((error = FTC_Manager_New(library, 1, 2, 0, &MyFaceRequester, NULL, &manager)))
    {
        printf("Freetype <FTC_Manager_New fehlgeschlagen. Fehler: 0x%.2X>\n", error);
        FT_Done_FreeType(library);
        munmap(lfb, fix_screeninfo.smem_len);
        return;
    }

    if((error = FTC_SBitCache_New(manager, &cache)))
    {
        printf("Freetype <FTC_SBitCache_New fehlgeschlagen. Fehler: 0x%.2X>\n", error);
        FTC_Manager_Done(manager);
        FT_Done_FreeType(library);
        munmap(lfb, fix_screeninfo.smem_len);
        return;
    }

    if((error = FTC_Manager_Lookup_Face(manager, FONT, &face)))
    {
        printf("Freetype <FTC_Manager_Lookup_Face fehlgeschlagen. Fehler: 0x%.2X>\n", error);
        FTC_Manager_Done(manager);
        FT_Done_FreeType(library);
        munmap(lfb, fix_screeninfo.smem_len);
        return;
    }
    else
        desc.face_id = FONT;


    use_kerning = FT_HAS_KERNING(face);

#if FREETYPE_MAJOR  == 2 && FREETYPE_MINOR == 0
    desc.image_type = ftc_image_mono;
#else
    desc.flags = FT_LOAD_MONOCHROME;
#endif

    // Screen leeren, der komplette Speicherbereich wird mit 0 beschrieben, was beim 32Bit
    // Framebuffer der 7025 der Farbe schwarz mit 100% transparent entspricht, sprich man
    // sieht das dahinter liegende Bild des MPEG Decoders
    memset(lfb, 0, var_screeninfo.yres*fix_screeninfo.line_length);

    // Hier zeichnen wir eine schwarze Box in den Framebuffer, die StartX/StartY Werte werden
    // dabei ber�cksichtigt.
    // F�r die Farbe wird ein 32 Bit Wert �bergeben, dass dem Format BGRA entspricht, sprich
    // das erste Byte ist der Blauwert, das 2. Gr�n und das 3. Rot. Der vierte Wert bestimmt den
    // Alphawert, wobei bei der 7025 xFF (255) f�r nicht transparent und x00 (0) f�r 100% Transparenz
    // steht.
    //        x,y,x1 ,y1 ,farbe
    RenderBox(0,0,600,456,"\x00\x00\x00\xFF");

    // Nun geben wir einen Text an der Position x=20,y=20 (StartX/StartY kommt automatisch hinzu)
    // und sagen dass der String nicht breiter sein darf als 400 Pixel. Ben�tigt der Text mehr Platz,
    // wird er abgeschnitten.
    // F�r die Ausrichtung gibt es LEFT, RIGHT und CENTER und bestimmt die Ausrichtung des Textes
    // innerhalb der angegebenen Breite (hier 400 Pixel). F�r die Schriftgr�sse stehen VERY_SMALL, SMALL
    // und BIG zur Verf�gung. Die (Pixel)Gr�ssen daf�r wurden weiter oben definiert. Die Farbangabe
    // entspricht der Farbangabe der RenderBox Funktion (siehe oben).
    //           text    ,x  ,y  ,breite, ausrichtung, gr�sse, farbe
    RenderString("Hallo !", 20, 20,   400,        LEFT,    BIG, "\xFF\xFF\xFF\xFF");

    // Warte 10 Sekunden
    sleep(10);


    // Programmende

    // Libfreetype aufr�umen
    FTC_Manager_Done(manager);
    FT_Done_FreeType(library);

    // Framebuffer wieder leeren (Transparent machen), Speicher freigeben,
    // Framebufefr Device schliessen
    memset(lfb, 0, var_screeninfo.yres*fix_screeninfo.line_length);
    munmap(lfb, fix_screeninfo.smem_len);
    close(fb);
    exit(0);
}