Probleme beim Formatumwandeln von Bilddaten auf STM32746Disco

[J. T. (chaoskind)]

MoinMoin,

irgendwie blick ich grad nich durch.... Folgende Situation:

Ich hab ein bmp-Bild von nem Online Gedöns in ein Array von 8bit/byte 
umwandeln lassen. Das hat auch super geklappt. Das Bild hat 12*65 Pixel 
zu je 8bit Rot, 8bit Grün und 8bit Blau.

Wenn ich dass Bild dann darstellen lasse, kommt auch genau das raus, was 
ich vorher in Paint gemalt hab.

  while (Y < 65)
  {
    while (X < 12)
    {
      BSP_LCD_DrawPixel(   X, Y, ( 0xFF000000 + (Bild_8b[i] << 16) + (Bild_8b[i+1] << 8) + (Bild_8b[i+2]) )   );
      X++;
      i +=3;
    }
    X = 0;
    Y++;
  }
  Y = 0;
  i = 0;

Nun lasse ich folgende Zeilen auf das Array los:

void Convert_8bTo32b(uint8_t *Bild_8b, uint32_t *Bild_32b, uint32_t Size)
{
  uint32_t i = 0;
  uint32_t X = 0;

  while (X < Size/4)
  {
    *( Bild_32b + X ) = ( 0xFF000000 + ( *(Bild_8b + i) << 16 ) + ( *(Bild_8b + i + 1) << 8 ) + ( *(Bild_8b + i + 2) ) );
    i += 3;
    X++;
  }

}

damit mir daraus ein Array von 32bit/"byte"-Werten gemacht wird. Weil 
wegen ARGB.

Wenn ich das 32bit-Array dann darstellen lasse:

  while (Y < 65)
  {
    while (X < 12)
    {
      BSP_LCD_DrawPixel(X, Y, (*(Bild_32b + (X*Y) + X )));
      X++;
    }
    X = 0;
    Y++;
  }
  Y = 0;

kommen höchst interesaante Muster bei raus, aber nicht mein kleines 
häßliches Männchen...

Bilder muss ich gleich extra anhängen, irgendwie will mein Handy grad 
nicht mit meinem Laptop reden ?!?!

Ich hab mir auch schon im SingleStep Modus die Arrays anzeigen lassen, 
die Konvertierung scheint so weit richtig zu sein, die ersten zig paar 
Werte und ein paar Stichproben haben jeweils richtige Werte ergeben.

Andrerseits hat mir das Konstrukt für die 32bit-Arrays bisher auch immer 
treue Dienste geleistet und nicht hübsche Muster gezaubert.

Findet jdm auf die Schnelle nen Fehler?

( 0xFF000000 + ( *(Bild_8b + i) << 16 ) + ( *(Bild_8b + i + 1) << 8 ) + ( *(Bild_8b + i + 2) ) );

und

(   X, Y, ( 0xFF000000 + (Bild_8b[i] << 16) + (Bild_8b[i+1] << 8) + (Bild_8b[i+2]) )   );

sollte doch die selben Elemente ansprechen/auslesen, wenn ich vorher den 
Pointer Bild_8bPt = &Bild[0] setze?

mit verwirrten Grüßen,
Chaos

[J. T. (chaoskind)]

Hier die Bilder. Die Quali is eher Semideluxe... Aber schlechtes Licht, 
schlechte Kamera und winziges Bild auf dem Display, watt soll man tun.

P.S. es macht nicht interessante Muster, sondern immer das eine.

[J. T. (chaoskind)]

Hier nochmal etwas besser, das Muster bzw das Foto von selbigem.

[J. T. (chaoskind)]

Schon ne Stunde online und 20 mal angeguckt und noch niemand hat sich 
über das viele Schwarz auf den Fotos beschwert. Ich bin beieindruckt

[pegel (Gast)]

Deine ganzen Index Aufrufe und Wandlungen geben für sich doch einzelne 
Werte zurück.
Die kannst du bevor du alle vereinigst einzeln prüfen,
dann zeigt sich ob es einen Unterschied macht.

[J. T. (chaoskind)]

pegel schrieb:
> Deine ganzen Index Aufrufe und Wandlungen geben für sich doch einzelne
> Werte zurück.
> Die kannst du bevor du alle vereinigst einzeln prüfen,
> dann zeigt sich ob es einen Unterschied macht

J. T. schrieb:
> Ich hab mir auch schon im SingleStep Modus die Arrays anzeigen lassen,
> die Konvertierung scheint so weit richtig zu sein, die ersten zig paar
> Werte und ein paar Stichproben haben jeweils richtige Werte ergeben

Wie gesagt, das macht er ordentlich. Aber da auch meine 
"32bit-Malfunktion" funktioniert, wundere ich mich, wo der Fehler 
herkommt. Das Rot vom Hemd und das Schwarz der Hose finden sich ja 
irgendwie auch wieder in den Kringeln.

Auch ändern des While(x <12) auf (x<11) oder 13 brachte bei  der 8bit 
Variante wie erwartet eine um 45 verzerrte version vom Männchen. Bei der 
32bit Variante ist es schwer  zu sagen, ob es das selbe Muster gleich 
verzerrt ist oder nicht.

[Jim M. (turboj)]

J. T. schrieb:
> Wenn ich das 32bit-Array dann darstellen lasse:

Leider ist da der Fehlerteufel drin:

 BSP_LCD_DrawPixel(X, Y, (*(Bild_32b + (X*Y) + X )));
       X++;

Es hätte eher

BSP_LCD_DrawPixel(X, Y, (*(Bild_32b + (12*Y) + X )));
       X++;

heissen müssen.

Mit einem einfacheren Testmuster hätte man den Fehler deutlich leichter 
finden können.

[J. T. (chaoskind)]

Jim M. schrieb:
> BSP_LCD_DrawPixel(X, Y, (*(Bild_32b + (12*Y) + X )));
>        X++;

OOHHH MEIN GOTT!!! Ich danke dir. Wie ich diese Art von Fehler hasse. Da 
schlägt irgendwann die Betriebsblindheit gaaanz fies zu :D

Ich hatte grad einfach mal das ganze spasseshalber größer gemacht und 
wollt grad schreiben:

Irgendwie scheint da schon ne Art System drin zu stecken. Und dann steht 
da die Lösung. Es ist irgendwie ein ganz hübscher Effekt.

[J. T. (chaoskind)]

Hier nochmal Bilder dazu.

[Olaf (Gast)]

> OOHHH MEIN GOTT!!! Ich danke dir. Wie ich diese Art von Fehler hasse.

Dann solltest du vielleicht lernen den Debugger deiner 
Entwicklungsumgebung zu nutzen. Damit setzt du dann 2-3Breakpoints 
schaust die Daten an, hast eine Idee in welcher Ecke der Fehler liegt, 
gehst das Stueck mal im Singlestep durch und schaust dir dabei die 
Variablen genau an und schwups ist der Fehler gefunden.

Olaf

[J. T. (chaoskind)]

Olaf schrieb:
> Dann solltest du vielleicht lernen den Debugger deiner
> Entwicklungsumgebung zu nutzen. Damit setzt du dann 2-3Breakpoints
> schaust die Daten an, hast eine Idee in welcher Ecke der Fehler liegt,
> gehst das Stueck mal im Singlestep durch und schaust dir dabei die
> Variablen genau an und schwups ist der Fehler gefunden.

Würd ich dir normalerweise uneingeschränkt zustimmen. Aber hättest du 
den Thread ganz gelesen, hättest du gelesen, dass ich das getan habe.

Aber wenn du auf (X*y +y, *pointer) eingeschossen bist, weil es in der 
ursprünglichen Version (Xmax*y, Y, *pointer) hieß, hilft das leider auch 
nicht weiter, sondern sorgt nur für Verzweiflung :D

In meinem Kopf machte es nur "Ok ein Pixel wurde gemalt... mhh ja ist 
die richtige Position (halt das Pixel neben dem vorherigen). In der 
Tabelle angeguckt, was an dem Pointer steht.. Mh ja die Farbe kommt auch 
hin. HÄÄÄÄÄÄ???? WOOHER KOMMT DIESER FEHLER NUR??? X*Y+X ist doch auch 
richtig, hat ja immer geklappt"

Mir war halt klar, dass der Fehler an der Stelle liegen muss, aber die 
Betriebsblindheit gaukelte mir Richtigkeit vor.