Bmp Laden Größer 512*512

GenialerIdiot

Ich habe einen Texturloader für OpenGL geschrieben, der auch gut funktioniert außer ich versuche Texturen zu laden die Größer 512*512 sind (z.B. 1024*1024).
Das Problem ist das ich bei zu Großen Bildern irgendwie für Bildhöhe und Bildbreite 0,0 aus der Bitmap lese (bei kleineren Bilder aber korrekt z.B. 255,255).
Die Bilder sind alle 24Bit ,Unkomprimiert von Hand Erstellt in Paint Shop Pro8.
Mein Compiler ist C++Builder6 und ich nutze OpenGL 2.0 (Ich weis das es im Builder leichter geht aber ich möchte den Loader unabhängig vom Builder halten.)
Den Folgenden Code habe ich aufs nötigste Reduziert, ich denke es müsste das wichtigste drinnen stehen. Der Fehler müsste eigentlich in "BITMAP* loadWindowsBitmap(char* path)" sein.

typedef class bData {
    public:
        long                fSize;
        char                name[999];
        char                type[10];
        void*               data;
} bData;
//-------------------------------------------------------------------------
BITMAP*         bmp;//der Standart Windows Datentyp
bmp = loadWindowsBitmap("XY.bmp");

gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, bmp->bmWidth, bmp->bmHeight, GL_RGB, GL_UNSIGNED_BYTE, (GLubyte*)bmp->bmBits);
//--------------------------------------------------------------------------
//  Binäres Datei laden
bData* loadFile(char* path) {
bData*    data = new bData();
FILE*   file;
long    fSize, result;

    file = fopen(path, "rb");

        if(file == NULL) {
            //Bild nicht vorhanden
        } else {
            data->fSize = getFileSize(file);
            data->data = malloc(fSize);

            result = fread(data->data, data->fSize, 1, file);
        }

    fclose(file);

    return data;
}
//  ---------------------------------------------------
//  BITMAP aus Binärdaten laden
BITMAP* loadWindowsBitmap(char* path) 
{
    BITMAP* bmp = (BITMAP*) malloc(sizeof(BITMAP));
    bData*   data;
    long    bmSize;

    data = loadFile(path);

    memcpy(&bmp->bmType,      (byte*)data->data+0 ,2);
    memcpy(&bmp->bmWidth,     (byte*)data->data+18,4);
    memcpy(&bmp->bmHeight,    (byte*)data->data+22,4);
    memcpy(&bmp->bmPlanes,    (byte*)data->data+26,2);
    memcpy(&bmp->bmBitsPixel,      (byte*)data->data+28,2);

    bmp->bmWidthBytes = bmp->bmWidth*bmp->bmBitsPixel/8;
    bmSize = bmp->bmWidthBytes*bmp->bmHeight;

    bmp->bmBits = (void*) malloc(sizeof(byte)*bmSize);
    memcpy(bmp->bmBits, (byte*)data->data+54, bmSize );

    return bmp;
}

Kóyaánasqatsi

Woher kommt loadWindowsBitmap? Zeig mal den Funktionsrumpf, dann kann man vielleicht mehr sagen.

GenialerIdiot

Ist das nicht das was du meinst ?
Was meinst du sonst ?

BITMAP* loadWindowsBitmap(char* path) 
{ 
    BITMAP* bmp = (BITMAP*) malloc(sizeof(BITMAP)); 
    bData*   data; 
    long    bmSize; 

    data = loadFile(path); 

    memcpy(&bmp->bmType,      (byte*)data->data+0 ,2); 
    memcpy(&bmp->bmWidth,     (byte*)data->data+18,4); 
    memcpy(&bmp->bmHeight,    (byte*)data->data+22,4); 
    memcpy(&bmp->bmPlanes,    (byte*)data->data+26,2); 
    memcpy(&bmp->bmBitsPixel,      (byte*)data->data+28,2); 

    bmp->bmWidthBytes = bmp->bmWidth*bmp->bmBitsPixel/8; 
    bmSize = bmp->bmWidthBytes*bmp->bmHeight; 

    bmp->bmBits = (void*) malloc(sizeof(byte)*bmSize); 
    memcpy(bmp->bmBits, (byte*)data->data+54, bmSize ); 

    return bmp; 
}

Edit:
Und das habe ich natürlich noch in der Headerdatei:
BITMAP* loadWindowsBitmap(char* path);

GenialerIdiot

Problem gelöst, wie immer dummer schreibfehler
data->data = malloc(fSize); muss in wirklichkeit
data->data = malloc(data->fSize); heißen
Dadurch wurde nicht genug Speicher Reserviert, was ein relativ schwer zu findender Fehler ist.

Mach den Code Morgen sauber und Poste ihn dann Komplett falls jemand intresse an einem Byte basierenden Texturloader hatt^^

dot

Vielleicht ein paar Anmerkungen:

Warum verwendest du mal new und mal malloc()?
Du hast in loadWindowsBitmap() ein Memory Leak weil data nirgendwo freigegeben wird.
Der Code funktioniert nur mit Bitmaps deren Breite * 3 ein ganzzahliges Vielfaches von 4 ist. In jedem anderen Fall geht das so nicht da die Scanlines einer Bitmap mit einem Zero Padding auf 4 Byte ausgerichtet sind.
Der Offset vom Dateianfang zu den Bilddaten muss nicht zwangsweise 54 Byte betragen. Der richtige Wert steht im BITMAPFILEHEADER.
Wofür ist der Member name deiner bData, der wird nirgendwo verwendet? Und selbst wenn sind 999 Zeichen wohl etwas groß!?
Der Code geht implizit davon aus dass es sich um eine gültige Bitmap im einzigen unterstützen Format handelt, in jedem anderen Fall ist das Verhalten undefiniert. Du solltest zumindest checken ob es sich bei der Datei überhaupt um eine 24bit .bmp handelt.
typedef class ist nicht notwendig, class allein reicht. Prinzipiell könnte bData auch einfach ein struct sein.
Ich würd die Pfade an die Funktionen als const char* übergeben.
Wenn die Datei nicht geöffnet werden kann returned loadFile() eine bData voller uninitialisierter Werte.
Die BITMAP Struktur die du da zurücklieferst entspricht nicht unbedingt den Vorgaben der WinAPI. Ich würd wenn dann ein eigenes struct definieren sonst kommt noch jemand auf die Idee dieses Ding an eine WinAPI Funktion zu übergeben und wundert sich warums nicht funktioniert...
sizeof(byte) ist immer 1

GenialerIdiot

Puh das sind sehr viele Anregungen, für die ich dir sehr dankbar bin^^
Ich werde die Punkte Morgen Abarbeiten und sicherlich einige Umsetzen

P.S.
Wo bei mir 1,2 Punkte bewusst wahren und unter das besagte Sauber machen fallen.