Java OpenGL/JOGL Darstellung on 10Bit Bilddaten die in einem ByteArray gespeichert sind

[Manule]

Hallo!

Ich bekomme 10 Bit Graustufen Pixelwerte über USB in einem ByteArray geliefert welches dann in etwa so aussieht:

imgData[0] enthält die ersten 8 Bit vom ersten Pixel.
imgData[1] enthält die letzten 2 Bit vom ersten Pixel und die ersten 6 Bit vom zweiten Pixel.
imgData[2] enthält die restlichen 4 Bit vom zweiten Pixel und die ersten 4 Bit vom dritten Pixel, etc...

In einer früheren Version habe ich bereits 8 Bit Daten bekommen. Ein Pixel entsprach also jeweils einem Indize in dem ByteArray und ich konnte das einfach über einen ByteBuffer mit dem ich die imgData gewrappt habe und TexImage2D darstellen:

gl.glTexImage2D(GL2.GL_TEXTURE_2D, 0, 1, 1280, 1024, 0,
	        GL2.GL_LUMINANCE, GL2.GL_UNSIGNED_BYTE, buffer);

Wie sieht das jetzt aber mit den 10 Bit Daten aus.
Kann ich die überhaupt so direkt in OpenGL bzw. jogl rein stecken?
Ich habe da etwas von glPixelStore und Pixel Packing bzw. Unpacking gelesen aber irgendwie werde ich da nicht so ganz schlau draus. Entsprechende Beispiele kann ich auch nicht finden aber vielleicht hat ja hier schon einmal jemand damit Erfahrungen gesammelt.

Alternativ kann ich meine Pixel auch zum Beispiel in ein BitSet schreiben und von dort aus in ein IntegerArray damit jedes Indize wieder einem pixel entspricht.
Dann weis ich aber wiederum nicht wie ich bei OpenGL die Graustufen skaliere also der Wert 0 im Array schwarz entspricht und 1023 weiß da ja im IntegerArray 32 Bit zur Verfügung stehen und nicht nur 10...
Außerdem wird das evtl. langsam wenn ich relativ schnell Bilder aufnehmen will und vor jedem Bild in ein BitSet und von dort aus in ein IntegerArray geschrieben wird.

Danke schon einmal im vorraus

 

[Cry & Die]

Versuch doch einfach mal die 10-bit Werte on-the-fly in 8-bit Werte zu konvertieren und wie bisher zu behandeln. Wenns nicht sehr große Auflösungen sind, sollte das noch schnell genug gehen. Der Aufwand ist ja linear im Verhältnis zu der Pixelanzahl. Floating-Point-Arithmetik ist dazu auch nicht nötig.

Grundidee ist eine Schleife, die mit ein bisschen hin- und hershiften die 10-bit Werte aus dem Byte-Array klaubt, skaliert, und in ein neues Pixelarray mit 8-bit-Werten steckt. Ohne Bitsets oder ähnliches.

Ungetester Pseudocode ohne Gewähr, hoffe die Idee dahinter wird klar:

byte[] output = new byte[pixelcount];
int pixeldone = 0;
int bitoffset = 0;
while (pixeldone < pixelcount) {
  int arrayoffset1 = bitoffset / 8; // in welchem byte beginnt die 10-bit folge?
  int arrayoffset2 = arrayoffset1 + 1; // ein 10-bit erstreckt sich immer über 2 bytes!
  int tmp = input[arrayoffset1] | (input[arrayoffset2] >> 8); // die zwei bytes zusammensetzen
  tmp <<= bitoffset % 10; // so shiften dass der 10 bit wert bei bit 0 beginnt
  tmp &= 0b1111111111; // alles außer den ersten 10 bits auf 0 setzen
  // jetzt den 10-bitwert in tmp auf 8 bit umskalieren
  output[pixeldone] = tmp;
  pixeldone++;
  bitoffset += 10;
}

Sollte das zu langsam sein, kann ich leider gerade auch nicht helfen. Ob und wie OpenGL mit 10-bit Texturen umgehen kann weiß ich leider nicht.