PureBoard

Verfasst: **09.07.2007 20:09**

Nachdem ich nun vollkommen entnervt und mit x Versuchen nach eigenen Fehler gesucht habe, weiß ich einfach nicht mehr weiter...

Ich benutzer Dev-C++ mit SDL Version 1.2.8 . Ich verwende eigentlich nur den direkten Zugriff auf den Grafikspeicher mit Lock/Unlock/usw. und muss sagen, dass mein Code EIGENTLICH funktioniert.

Ich habe eine Klasse für einen Renderer erstellt, die mit einem Befehl Farben im Float-Format in den SDL-Buffer schreibt. Wenn ich die Klassen-internen Bufferpointer NICHT erhöhe, klappt der Code wunderbar und ich sehe mein gerendertes Bild. Wenn ich aber die Pointer auf Klassen-interne Buffer mit jedem PIxel (logischweise) erhöhe, erhalte im "stderr.txt"-Logfile den folgenden Fehler:

Fatal signal: Segmentation Fault (SDL Parachute Deployed)

und das Programm wird ohne Wenn und Aber (anscheinden von SDL selbst) geschlossen. Der Code der Funktion:

Code: Alles auswählen

void LE::LE_Renderer::Swap()
{
    pixel_screen* pos_screen =          screen;
    pixel_alpha*  pos_alpha  =          alpha;
    Uint8*        pos_app    = (Uint8*) surface->pixels;
    float alpha_screen;
    
    // jeden pixel im surface durchgehen und mit errechnetem farbwert beschreiben
    for (int pxcount = 0; pxcount < pixels; pxcount++)
    {
      
      cerr << pxcount << "/" << pixels
           << " alpha: " << pos_alpha << "/" << end_alpha
           << " screen: " << pos_screen << "/" << end_screen <<endl>a;
      
      // temporär weggekürzt!
      pos_app[0] = 255;
      pos_app[1] = 0;
      pos_app[2] = 255;
      pos_app[3] = 255;
      
      pos_screen += sizeof(pixel_screen);
      pos_alpha  += sizeof(pixel_alpha);
      pos_app += surface->format->BytesPerPixel;
    }
}

Ich weiß, ohne die restlichen Definitionen der Klasse usw. ist er recht unbrauchbar... Aber ev. hilft es. Mein Code ist schon recht groß und würde vermutlich den Rahmen des spontan zumutbaren sprengen...

Kann mir da irgendwer helfen? Ich hab einfach keine Ahnung, was das soll. Selbst die Größen, der allokierte Speicher, die Speicherposition, usw... stimmen eigentlich alle. Ich sehe darin keinen logischen Fehler!

Verfasst: **09.07.2007 20:15**

> (SDL Parachute Deployed)
Fallschirm ausgesetzt?

....is das ne verarsche und hast du dir nen virus eingefangen?

Verfasst: **09.07.2007 20:18**

Der Fehler ist durchaus per Google zu finden, nur gibts da nix sinnvolles drüber. Das ist KEIN Virus, glaub mir...

Parachute = Wahrscheinlich im Sinne von "Programm beenden, bevor es einen Systemfehler verursacht..." ...

Verfasst: **09.07.2007 20:37**

Das ist nur opensource Humor... musst mal beim nächsten configure-make-install irgendeines Programmes auf den output achten, da gibt es auch häufig solche Späße.

Edit: auf einen flüchtigen blick würde ich vermuten, dass du den framebuffer zum überlauf bringst.
Verschiebst du nicht mit pos_screen += sizeof(pixel_screen); den Zeiger des Framebuffers bei jedem durchlauf?

Verfasst: **09.07.2007 21:33**

Ja, ich gehe alle Pixel durch und muss darum (logischerweise) den nächsten Pixel im internen Buffer ermitteln und auf auf die Position "pos_app" (der wirkliche Framebuffer von SDL) spiegeln.

pos_screen = im internen Screenbuffer
pos_alpha = im internen Alphabuffer
pos_app = im Grafikbuffer von SDL

Ich verwende intern 2 Buffer für Grafikeffekte und den SDL-Buffer für die Bildschirmausgabe. Ohne diese 2 Buffer funktioniert die Routine einbahnfrei, hier der Code um die beiden Buffer anzufordern:

Code: Alles auswählen

  // maße setzen
    w = nw;
    h = nh;
    pixels = w * h;
    
    // abstände ausrechnen
    pitch_screen = sizeof(pixel_screen) * w;
    pitch_alpha  = sizeof(pixel_alpha)  * w;
    
    // buffergrößen errechnen
    size_screen = pixels * sizeof(pixel_screen);
    size_alpha  = pixels * sizeof(pixel_alpha);
    
    cout << "size_alpha:  " << size_alpha  << endl;
    cout << "size_screen: " << size_screen << endl;
    cout << endl;
    
    end_screen = screen + size_screen - sizeof(pixel_screen);
    end_alpha  = alpha  + size_alpha  - sizeof(pixel_alpha);
    
    // buffer erstellen
    screen = (pixel_screen*) malloc(size_screen);
    alpha  = (pixel_alpha*)  malloc(size_alpha);

Rein rechnerisch ja auch richtig, hm...

Edit:

Zaphod hat geschrieben:Edit: auf einen flüchtigen blick würde ich vermuten, dass du den framebuffer zum überlauf bringst.

Laut den Debuganzeigen komme ich ja nicht einmal zum Ende

. Scheint aber der Grund zu sein, dennoch wird höchstens ein 30stel der realen Buffergröße ausgefüllt.