Brauche Hilfe beim Run-Length-Decoding

[RalleYTN]

Also ich wollte mein eigenes Bildformat machen, dass ich schnell einlesen kann.
Schreiben die Pixeldaten werden mit diesem Algorithmus auf den OutputStream geschrieben.

       boolean hasAlpha = data.hasAlpha();
       boolean isGrayscale = data.isGrayscale();
       int[] pixels = data.getPixels();
       int index = 1;
       int oldPixel = pixels[0];
       int repeat = 1;
      
       do {
          
           int pixel = pixels[index++];
          
           if(oldPixel != pixel || repeat == 255) {
              
               int alpha = (pixel >> 24) & 0xFF;
               int blue = (pixel >> 16) & 0xFF;
               int green = (pixel >> 8) & 0xFF;
               int red = pixel & 0xFF;
              
               imageStream.write(repeat);
              
               if(hasAlpha && !isGrayscale) {
                  
                   writeInt(imageStream, pixel, true);
                  
               } else if(!hasAlpha && !isGrayscale) {
                  
                   imageStream.write(blue);
                   imageStream.write(green);
                   imageStream.write(red);
                  
               } else if(hasAlpha && isGrayscale) {
                  
                   imageStream.write(alpha);
                   imageStream.write(blue);
                  
               } else if(!hasAlpha && isGrayscale) {
                  
                   imageStream.write(blue);
               }
              
               repeat = 0;
           }
          
           oldPixel = pixel;
           ++repeat;
          
       } while(index < pixels.length);

Jetzt wollte ich das ganze wieder mit diesem Algorithmus auslesen:

       boolean hasAlpha = getBit(flags, 0);
       boolean grayscale = getBit(flags, 1);
       int[] pixels = new int[width * height];

       for(int index = 0; index < pixels.length;) {
           
           int pixel = 0;
           int repeat = imageStream.read();

           if(hasAlpha && !grayscale) {
               
               pixel = readSignedInt(imageStream, true);
               
           } else if(hasAlpha && grayscale) {
               
               int alpha = imageStream.read();
               int color = imageStream.read();
               
               pixel = ((alpha & 0xFF) << 24) | ((color & 0xFF) << 16) | ((color & 0xFF) << 8) | (color & 0xFF);
               
           } else if(!hasAlpha && !grayscale) {
               
               int blue = imageStream.read();
               int green = imageStream.read();
               int red = imageStream.read();
               
               pixel = ((255 & 0xFF) << 24) | ((blue & 0xFF) << 16) | ((green & 0xFF) << 8) | (red & 0xFF);
               
           } else if(!hasAlpha && grayscale) {
               
               int color = imageStream.read();
               pixel = ((255 & 0xFF) << 24) | ((color & 0xFF) << 16) | ((color & 0xFF) << 8) | (color & 0xFF);
           }

           for(int r = 0; r < repeat; r++) {
               
               pixels[index++] = pixel;
           }
       }

Jedoch hänge ich hier in einer Endlosschleife weil index um 2 zu klein ist. Wenn ich die Schleife vorher abbreche sieht das Bild auch nicht richtig aus.

Was mache ich falsch?

 

[RalleYTN]

Hier auch noch mal die Bilder, damit man sich etwas darunter vorstellen kann wenn ich sage das Ergebnis sieht komisch aus. Rechts ist es so wie es sein sollte und links so wie es ist.

 

[Thallius]

Auf jeden Fall schreibst du schonmal nicht die letzten Pixel. Deshalb ist beim einlesen auch Index nicht groß genug. Du solltest auch beim einlesen die Anzahl Bytes im Stream nehmen und nicht die Größe des Bildes. Dann macht es auch nichts aus wenn zu wenig Pixel im Stream sind.
Weiterhin ist es natürlich nicht wirklich schnell für jedes Pixel abzufragen welches Format es hat. Schreibe für jedes pixelformat eine eigene Routine. Ist nicht so elegant dürfte aber deutlich performanter sein.

 

[RalleYTN]

Weiterhin ist es natürlich nicht wirklich schnell für jedes Pixel abzufragen welches Format es hat. Schreibe für jedes pixelformat eine eigene Routine. Ist nicht so elegant dürfte aber deutlich performanter sein.

Ja ich weiß ist noch nicht ganz so schnell. erstmal soll es funktionieren. Die Sache die das ganze gerade sehr langsam macht ist dass ich "InputStream#read" mindestens 20000 mal durchführe. dabei könnte ich das Bild komplett in den Arbeitsspeicher mit gerade mal 4 Mal read laden.

 

[httpdigest]

Die Sache die das ganze gerade sehr langsam macht ist dass ich "InputStream#read" mindestens 20000 mal durchführe. dabei könnte ich das Bild komplett in den Arbeitsspeicher mit gerade mal 4 Mal read laden.

-> https://docs.oracle.com/javase/7/docs/api/java/io/InputStream.html#read(byte[], int, int)

oder schalte einen BufferedInputStream davor. Dieser sorgt dann selbst dafür, dass die bytes chunkweise vom darunterliegenden InputStream per read(byte[], int, int) gelesen werden und nicht byte für byte.

 

[RalleYTN]

-> https://docs.oracle.com/javase/7/docs/api/java/io/InputStream.html#read(byte[], int, int)

oder schalte einen BufferedInputStream davor. Dieser sorgt dann selbst dafür, dass die bytes chunkweise vom darunterliegenden InputStream per read(byte[], int, int) gelesen werden und nicht byte für byte.

Ich wusste das schon war bloß zu faul es zu ändern als ich es gemerkt habe.
Ich versuche gerade es umzustellen aber jetzt laufe ich in eine IndexOutOfBoundsException.

    public static final int[] readPixels(InputStream imageStream, int flags, int width, int height) throws IOException {
       
       boolean hasAlpha = getBit(flags, 0);
       boolean grayscale = getBit(flags, 1);
       int[] pixels = new int[width * height];

       try(ByteArrayOutputStream buffer = new ByteArrayOutputStream()) {
           
           write(imageStream, buffer); // Schreibt die Bilddaten in 4KB Chunks auf den buffer
           byte[] data = buffer.toByteArray();
           
                  if(!hasAlpha && !grayscale) {readPixelsBGR(data, pixels);
           } else if( hasAlpha && !grayscale) {readPixelsABGR(data, pixels);
           } else if(!hasAlpha &&  grayscale) {readPixelsG(data, pixels);
           } else if( hasAlpha &&  grayscale) {readPixelsAG(data, pixels);
           }
       }
       
       return pixels;
   }
    private static final void readPixelsBGR(byte[] data, int[] pixels) {
       
       int index = 0;
       
       for(int offset = 0; offset < data.length; offset += 5) {
           
           int repetitions = data[offset] & 0xFF;
           
           for(int repetition = 0; repetition < repetitions; repetition++) {
               
               // Index sorgt hier für OutOfBounds
               pixels[index++] = ((data[offset + 1] & 0xFF) << 24) | ((data[offset + 2] & 0xFF) << 16) | ((data[offset + 3] & 0xFF) << 8) | (data[offset + 4] & 0xFF);
           }
       }
   }

 

[RalleYTN]

OK vergesst das mit der OutOfBoundsException. Ich war einfach blöde und habe an dieser Stelle Alpha mit beachtet obwohl es das nicht gibt. Bild sieht jedoch immer noch nicht richtig aus.

 

[mrBrown]

Bild sieht jedoch immer noch nicht richtig aus.

Gibts irgendwo den Code irgendwo als ganzes zum auschecken?

Weiterhin ist es natürlich nicht wirklich schnell für jedes Pixel abzufragen welches Format es hat. Schreibe für jedes pixelformat eine eigene Routine. Ist nicht so elegant dürfte aber deutlich performanter sein.

Alles ist eleganter als so eine if-Kaskade

 

[mihe7]

Was mache ich falsch?

Ich würde mal sagen, Du musst oldPixel und nicht pixel rausschreiben.

 

[RalleYTN]

Ich würde mal sagen, Du musst oldPixel und nicht pixel rausschreiben.

Das war die Lösung.