Benötige hilfe für Fonts

Durch 'vergleichende Dateiforschung' hab ich folgendes
rausgefunden:

Am Anfang des ByteArrays steht ein Header. Der Aufbau des
Headers ist im Kommentar darüber dokumentiert.

Bsp:
Ich hab mir mal den Font 'Terminal' erzeugen lassen.
Der Anfang der Daten lautet:

    0x06, 0xFA, 0x06, 0x0C, 0x01, 0x01, 0xFE,

Wende ich jetzt die Beschreibung von weiter oben an, dann
lese ich:

  uint16_t font_size_in.....       06FA
  uint8_t  font_Width_in_Pixel     06
  uint8_t  font_Height_in_Pixel    0C
  uint8_t  font_Bits_per_Pixel      1
  uint8_t  font_First_Char          1
  uint8_t  font_Last_Char          FE

danach kommen laut Kommentar
 font_Last_Char - font_First_Char +1
Bytes die für jeden Character die tatsaechliche Pixelbreite
angibt. FE - 1 + 1 = FE, also 254

Ohne das jetzt nachgezählt zu haben, schaut das plausibel aus.
Da sind ungefähr 250 Bytes, die entweder alle Werte von 2 bis 5
enthalten.
Danach gehts weiter mit

    0xFE, 0x91, 0x24, 0x81, 0x92, 0x24, 0xFE, 0xE1, 0x1F, 0xB7, 0xF3,
0x37, 0xB7, 0xE3, 0x1F, 0x7C,

Wenn ich das mal binaer umwandle

  FE 11111110
  91 10010001
  24 00100100
  81 10000001
  92 10010010
  24 00100100
  FE 11111110
  E1 11100001


und immer 12 Bits zusammenfasse (Fonthöhe) ergibt sich
(Trickreicherweise sieht es so aus als ob die fehlenden Bits
links angefügt werden muessen, also so

  FE         11111110
           ^
           |
         ----
  91 10010001
)

     000111111110
     001001001001
     001010000001
     001001001001
     000111111110

um 90 Grad zur Seite gedreht und alle 1 durch * ersetzt
ergibt das


       ***
         
         
      **  *
         
         
      ** **
        *
         
       ***

und das entspricht dann eigentlich schon dem Muster im
Fonteditor.

Probier mal ein bischen rum. Lass dir einen Font generieren.
Dann setze ein Feld auf gefüllt und vergleiche was sich in der
Datei verändert. Damit hab ich das was ich bis jetzt habe
rausgefunden.

Ich hab mal ein DOS-Programm geschrieben, dass
die Daten auswertet. Das Ganze ist in keinster Weise
optimiert, sondern es geht nur darum, den Zugriff mal
zu testen.

#include <stdio.h>

typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;

#define FONT Terminal

static uint8_t Terminal[] = {
    0x06, 0xFA, 0x06, 0x0C, 0x01, 0x01, 0xFE,
    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x02, 0x05, 0x03, 0x05, 0x05,
0x04, 0x04, 0x04, 0x05, 0x04,

   ...
   ... hier kommen die Daten rein, so wie sie vom
   ... Fontgenerator kommen
   ...

    0xF0, 0x03, 0x11, 0x50, 0x02, 0x25, 0xB0, 0x01, 0x32, 0x90, 0x02,
0x29, 0x60, 0x02, 0x00, 0x80,
    0x0F, 0xF8, 0x80, 0x0F, 0x00
};

struct Font {
  uint16_t Len;
  uint8_t  Width;
  uint8_t  Height;
  uint8_t  Bits;
  uint8_t  First;
  uint8_t  Last;
};

struct Font* pDesc;
uint8_t* pWidths;
uint8_t* pData;
uint16_t Index[256];

uint8_t GetBit( uint16_t BitPos )
{
  uint16_t ByteNr = BitPos / 8;
  uint8_t BitNr = BitPos % 8;

  return ( pData[ ByteNr ] & ( 1 << BitNr ) ) != 0;
}

void PrintCharacter( uint8_t Code )
{
  uint16_t BitPos;
  uint8_t i, j, Bit;

  printf( "%d - %c (%d):\n", Code, Code, Index[Code] );

  BitPos = Index[Code] * pDesc->Height;
  printf( "Start: Byte %d, Bit %d\n", BitPos / 8, BitPos % 8 );

  for( i = 0; i < pWidths[Code - pDesc->First]; ++i ) {
    for( j = 0; j < pDesc->Height; ++j ) {
      Bit = GetBit( BitPos++ );
      if( Bit )
        printf( "*" );
      else
        printf( " " );
    }
    printf( "\n" );
  }
}

int main()
{
  uint8_t i;
  uint16_t Tmp;

  pDesc = (struct Font*)FONT;

  printf( "Total Length: %d\n", pDesc->Len );
  printf( "Width:   %d\n", pDesc->Width );
  printf( "Height:  %d\n", pDesc->Height );
  printf( "Bits:    %d\n", pDesc->Bits );
  printf( "Erstes:  %d\n", pDesc->First );
  printf( "Letztes: %d\n", pDesc->Last );

  pWidths = FONT + 7;
  pData   = FONT + 7 + ( FONT[6] - FONT[5] + 1 ) ;

  Tmp = 0;
  for( i = pDesc->First; i < pDesc->Last; ++i ) {
    Index[i] = Tmp;
    Tmp += pWidths[i - pDesc->First];
  }

  for( i = pDesc->First; i < pDesc->Last; ++i )
    PrintCharacter( i );
}

Ach ja.
Mit RLE (Run length encoding) kompremierten Fonts
kommt der Code nicht klar. Da wirst du selbst ran
muessen. Erkennbar ist RLE daran, dass das MSB in
'Bits' gesetzt ist. Anders ausgedrückt: sobald Bits
nicht mehr 1 ist, geht alles schief.