Hardwarebeschleunigung für Java2D

[Kiamur]

Hallo,

ich habe das Problem, dass in meiner Software Bilder im 20Hz Takt gezeichnet und dargestellt werden sollen. Die Bilder haben eine Größe von 512x400 Pixel und sind in der Software als BufferedImage definiert. Auf dieses Image wird mit einem timer.scheduleAtFixedRate()-Aufruf alle 50ms ein Datensatzt bestehend aus 512 Koordinatenpunkten eine Kurve auf das BufferedImage gezeichnet. Zum Zeichnen benutze ich ein Java2D Graphics Objekt.
Zunächst wird mit einem GeneralPath die darzustellende Kurve erstellt, und anschließend auf das BufferedImage gezeichnet.

Das Problem ist, dass die CPU Belastung bei der Bildgröße 512x400 Pixel annähernd 100% beträgt. Es handelt sich um einen 1,8GHz Pentium 4 Computer. Verringere ich die Größe des BufferedImages auf 512x350 Pixel ist die CPU Belastung deutlich zurückgegangen. Komisch ist auch, das die CPU Belastung kleiner wird, wenn ich das original große Image mit einem anderen Fenster zum Teil verdecke. Also, das Programm läuft und zeichnet die Kurven mit 20Hz. Die CPU Belastung ist bei fast 100%. Nehme ich nun ein anderes Anwendungsfenster und verdecke mit diesem nur einen Teil des BufferedImages auf dem Bildschirm (so, dass ich noch sehen kann, dass darauf die Kurven gezeichnet werden), so geht die CPU Belastung auch deutlich zurück.

Für mich sieht das so aus, als ob die CPU ständig die Pixel-Daten des Bildes vom Hauptspeicher zur Grafikkarte schaufeln muss, und dabei ab einer bestimmten Bildgröße nicht mehr hinterherkommt.
Die Frage ist nun, wie ich mein Bild direkt im Grafikkartenspeicher ablegen kann, um die CPU überhaupt nicht mehr zu belasten. Ich habe auch schon das VolatileImage ausprobiert, das ja angeblich direkt hardwarebeschleunigt wird. Leider hatte ich dort genau die selben Performanceprobleme. Ach ja, die Grafikkarte hat einen Radeon 9000 mobility Chip mit 64MB RAM. Diese sollte doch mein kleines Bild gut zeichnen können, oder?

Nun gibt es ja die sogenannten Java-Features (z.B. "-Dsun.java2d.opengl=True"). Die scheinen allerdings keinen Effekt zu haben.
Kann mir jemand von euch eine generelle Vorgehensweise empfehlen, wie man am Besten versuchen sollte die Hardwarebeschleunigung für Java2D zu aktivieren? Leider habe ich dazu auch nicht viel aussagekräftiges Material im Web gefunden.

Gruß,
Maik

 

[Gast]

unter windows ist die schon default mässig aktiviert. wenn du nen fenster drüber schiebst, dann wird das was drunter ist auch nicht gezeichnet, is ja klar.

versuch deine zeichenroutinen irgendwie zu optimieren

 

[tuxedo]

Hast du in deiner Zeichenroutinge/Schleife vielleicht irgendwo das Schlüsselwort "new" benutzt? Was machst du noch alles in der Zeichenroutine?

- Alex

 

[Kiamur]

Hallo ihr zwei,

erst mal danke, dass ihr euch meiner angenommen habt.

@Gast: du hast recht, Windows merkt ja selber, welcher Bereich in der Anzeige neu gezeichnet werden muss. Ich verdecke meine Grafik allerdings nur teilweise mit einem darüber liegenden Fenster. Bsp: wenn meine Grafik 512x400 Pixel groß ist, und ich ein genau gleich großes Fenster nehme und dieses langsam von unten auf meine Grafik schiebe, dann kommt irgendwann schlagartig der Punkt, an dem meine CPU Belastung von 100% auf 20% zurückgeht. ich kann die gezeichneten Kurven in meiner Grafik immer noch sehen. Das heißt doch, dass alle Berechnungen die ich zum Kurvenzeichnen durchführe nicht für die hohe CPU Belastung verantwortlich sind, sondern nur die Größe der Grafik. Windows merkt ja, dass dort ein anderes Fenster auf meiner Grafik hängt, und schickt (meiner Meinung nach) nur den teil zur Anzeige (-> zur Grafikkarte), der auch wirklich sichtbar ist für den Anwender.

Meine Idee ist nun, dass dieses verschieben der Grafikdaten das Problem ist. Läge die Grafik aber von vorn herein im Grafikkartenspeicher, so hätte die CPU mit irgendwelchen verschiebungen doch nichts mehr am Hut, und die Belastung mässte eigentlich noch weiter zurückgehen.

Vielleicht habe ich da ja auch etwas nicht richtig verstanden, aber ich denke, dass Hardwarebeschleunigung doch genau solche Dinge beinhaltet, oder? Also das Zeichnen und die Speicherhaltung geschehen direkt in der grafikkarte, so dass die CPU nicht belastet wird.

@alex0801: Ich mache einige dynamische Gridberechnungen, und die einzigen beiden new Aufrufe sind einmal der GeneralPath und eine Line2D. Aber ich bin nach wie vor der Meinung, dass es an der Größe der Grafik liegt, da ja (wie oben beschrieben) alle Zeichenroutinen unverändert weiterarbeiten, wenn ich die Grafik mit einem anderen Fenster teilweise verdecke.

Gruß,
Maik

 

[tuxedo]

Ohne einen Brocken Code lässt sich nicht viel sagen/analysieren.

Ich kann dir nur sagen, dass ich schon fenster in 1400x1050 gezeichnet habe und damit über 5000 mit einem GPS-Empfänger aufgezeichnete Wegpunkte (verbunden mit Linien, also eine Art Kartendarstellung) dargestellt habe. Dazu kamen dann noch Weitere Gimmicks wie Städenamen und deren Position auf der Karte. Lief alles ziemlich flüssig ohne 100% CPU-Last.

Generell gilt: Nur weil etwas funktioniert heisst es nicht, dass es korrekt implementiert ist. Lass mal n bisschen Code sehen. Vielleicht finden wir dann den vermeintlichen Fehler.

- Alex

 

[Kiamur]

Okay, hier ist der Code meiner Zeichenmethode . . . .

public void drawNewFrame()
  {
    g2dbi.setColor(Color.black);

    // If the frame container contains a new frame to be drawn, draw it. Else draw the old one
    // with the old drawing timestamp. This is needed for the possibility of applying a new
    // display y-offset on the actual drawn frame.
    if ((currentFrameBuffer = fc.getNextFrame()) != null)
    {
      workingFrameBuffer = currentFrameBuffer;
      //      actualizeTimestamp = true;
    }
    if (workingFrameBuffer != null)
    {
      // Set the y-label state in the control panel if necessary.
      switch (workingFrameBuffer.getTimeResolution())
      {
        case 0x00 :
          if (currentXLabelState != XLabelState._20uS)
          {
            cp.setXLabels(XLabelState._20uS);
            currentXLabelState = XLabelState._20uS;
          }
          break;
        case 0x01 :
          if (currentXLabelState != XLabelState._60uS)
          {
            cp.setXLabels(XLabelState._60uS);
            currentXLabelState = XLabelState._60uS;
          }
          break;
        case 0x02 :
          if (currentXLabelState != XLabelState._100uS)
          {
            cp.setXLabels(XLabelState._100uS);
            currentXLabelState = XLabelState._100uS;
          }
          break;
      }

      // Set the y-label state in the control panel if necessary.
      switch (workingFrameBuffer.getBitResolution())
      {
        case 0x00 :
          tempYLabelStateArrayIndex = 1;
          if (currentYLabelState != YLabelState._12BIT)
          {
            cp.applyYRelatedStates(_12BIT_RESOLUTION);
            currentYLabelState = YLabelState._12BIT;
            oHeight = _12BIT_RESOLUTION + 1;
            scaleHeight = ((float) oHeight / (float) height) / (float) 2;
            affTrans.setToTranslation(0, 0);
          }
          break;
        case 0x01 :
          tempYLabelStateArrayIndex = 8;
          if (currentYLabelState != YLabelState._11BIT)
          {
            cp.applyYRelatedStates(_11BIT_RESOLUTION);
            currentYLabelState = YLabelState._11BIT;
            oHeight = _11BIT_RESOLUTION + 1;
            scaleHeight = ((float) oHeight / (float) height) / (float) 2;
            affTrans.setToTranslation(0, height);
          }
          break;
        case 0x02 :
          tempYLabelStateArrayIndex = 22;
          if (currentYLabelState != YLabelState._10BIT)
          {
            cp.applyYRelatedStates(_10BIT_RESOLUTION);
            currentYLabelState = YLabelState._10BIT;
            oHeight = _10BIT_RESOLUTION + 1;
            scaleHeight = ((float) oHeight / (float) height) / (float) 2;
            affTrans.setToTranslation(0, height * 3);
          }
          break;
        case 0x03 :
          tempYLabelStateArrayIndex = 50;
          if (currentYLabelState != YLabelState._9BIT)
          {
            cp.applyYRelatedStates(_9BIT_RESOLUTION);
            currentYLabelState = YLabelState._9BIT;
            oHeight = _9BIT_RESOLUTION + 1;
            scaleHeight = ((float) oHeight / (float) height) / (float) 2;
            affTrans.setToTranslation(0, height * 7);
          }
          break;
      }

      // Clear old frame.
      g2dbi.clearRect(0, 0, width, height);
      g2dbi.setColor(Color.lightGray);
      Shape line = null;

      // Draw display grid.
      // Draw vertical lines.
      for (int i = 0; i < width + 1; i++)
      {
        if (i % 64 == 0 && i > 0)
          g2dbi.drawLine(i, 0, i, height);
      }

      // Draw horizontal lines dynamically. 
      if (currentYOffsetChanged)
      {
        int arrayIndex = 0;

        float scaledYOffset = currentYOffset / scaleHeight;

        // calculate the current y-position for the horizontal grid lines regarding the
        // current y-offset.
        for (int i = 0; i < currentHorizontalLinesYCoords.length; i++)
        {
          float currentYCoord = basicHorizontalLinesYCoords[i] - scaledYOffset;
          if (currentYCoord < 0.0)
          {
            int factor = Math.abs((int) currentYCoord) / height + 1;
            currentYCoord += factor * (float)height;
            tempYLabelStateArrayIndex += factor;
          }
          if (currentYCoord > (float)height)
          {
            int factor = (int) currentYCoord / height;
            currentYCoord -= factor * (float)height;
            tempYLabelStateArrayIndex -= factor;
          }

          currentHorizontalLinesYCoords[arrayIndex] = currentYCoord;
          arrayIndex++;
        }

        // Set the index in the label array for the y-coordinates labels in the control panel.
        cp.setYLabelsStringArrayIndex(tempYLabelStateArrayIndex);
        currentYOffsetChanged = false;
        // Set the y-coordinates for the y labels in the control panel. 
        Arrays.sort(currentHorizontalLinesYCoords);
        cp.setYLabelStringCoord((int) currentHorizontalLinesYCoords[0]);
        cp.setYLabels();
      }

      // Draw the horizontal lines.
      for (int i = 0; i < 7; i++)
        g2dbi.draw(new Line2D.Float(0, currentHorizontalLinesYCoords[i], width, currentHorizontalLinesYCoords[i]));

      // Draw black frame around currend buffered image. 
      g2dbi.setColor(Color.black);
      g2dbi.setStroke(bsLine);
      g2dbi.drawLine(0, 0, 0, height - 1);
      g2dbi.drawLine(0, 0, width - 1, 0);
      g2dbi.drawLine(width - 1, 0, width - 1, height - 1);
      g2dbi.drawLine(0, height - 1, width - 1, height - 1);

      // Draw new graph with actual frame buffer data on buffered image
      g2dbi.setColor(Color.darkGray);
      BasicStroke bsLine = (BasicStroke) g2dbi.getStroke();
      g2dbi.setStroke(triggerLineStroke);

      // Draw trigger-line.
      line = new Line2D.Float(0, (-triggerLevel - currentYOffset + oHeight) / scaleHeight, width - 1, (-triggerLevel - currentYOffset + oHeight) / scaleHeight);
      g2dbi.draw(affTrans.createTransformedShape(line));

      g2dbi.setColor(Color.black);
      g2dbi.setStroke(bsLine);

      GeneralPath gp = new GeneralPath();
      boolean moveToDone = false;

      // Build GeneralPath out of frame data.
      for (int i = 1; i < width - 1; i++)
      {
        if (!moveToDone)
        {
          gp.moveTo(i, (-workingFrameBuffer.getValue(i) - currentYOffset + oHeight) / scaleHeight);
          moveToDone = true;
        }
        else
          gp.lineTo(i, (-workingFrameBuffer.getValue(i) - currentYOffset + oHeight) / scaleHeight);
      }

      // Scale GeneralPath if necessary (without any zoom factor selected, the scaling factor '0' is applied
      // to the GeneralPath).
      gp.transform(affTrans);

      // Draw (scaled) GeneralPath.
      g2dbi.draw(gp);

      // Put additional information on the buffered image.
      g2dbi.setFont(new Font(getParent().getFont().getFontName(), Font.PLAIN, 16));
      g2dbi.clearRect(1, 1, width - 2, 22);
      g2dbi.drawString("Frame: ", 5, 18);
      g2dbi.drawString("Recorded:  ", 120, 18);
      g2dbi.drawString("Source: ", 385, 18);
      g2dbi.drawString(Integer.toString(workingFrameBuffer.getRunningFrameNumber()), 60, 18);
      g2dbi.drawString(sdf.format(workingFrameBuffer.getTimestamp().getTimeTag()), 200, 18);
      if (workingFrameBuffer.getDataProcessorSource() == dataProcessorSources.DATA_PROCESSOR_1)
        g2dbi.drawString("K", 445, 18);
      if (workingFrameBuffer.getDataProcessorSource() == dataProcessorSources.DATA_PROCESSOR_2)
        g2dbi.drawString("R", 445, 18);
    }

    // Force a repaint of the panel.
    repaint();
  }

Gruß,
Maik

 

[Kiamur]

So, ich bin schon mal einen Schritt weiter . . . .

Ich hatte mich etwas zu sehr auf OpenGL Unterstützung konzentriert.

Mit dem Schalter -Dsun.java2d.noddraw=false habe ich 70% rausgeholt . . . .

Vielleicht sagt jetzt der eine oder andere, das DDraw eh schon automatisch aktiviert ist. Nach meinem Verständnis, dass ich aus dem ganzen Doku-Gelese gewonnen habe ist das aber nur im Vollbildmodus der Fall. Ansonsten ist es von vornherein nicht aktiviert. . . .

Naja, wie auch immer, jetzt läuft es schon mal viel besser. Der nächste Schritt wird sein aus meinem BufferedImage ein VolatileImage zu machen. Evtl. geht da noch mehr . . . . .

Gruß,
Maik

 

[Marco13]

MUSS der GeneralPath jedes mal neu erstellt werden?

 

[tuxedo]

Welche Java Version benutzt du? Hab gelesen dass es mit dem sun.java2d.noddraw ab einer bestimmten Java 5 Version Probleme gab. Wie und und ob sich das in Java 6 verhält: Kein Plan.

- Alex

 

[Kiamur]

Hallo,

ich habe nun aus meinem BufferedImage ein VolatileImage gemacht, und es lief unter 1.6.0_02 noch mal bis zu 15% schneller.
Dann habe ich mal die JRE gewechselt (nach 1.6.0_10 beta) und es ging mit den oben genannten Einstellungen wieder gar nichts mehr . . . . (diese JRE braucht einen Pixelshader 2.0, den die Grafikkarte nicht hat)
Jetzt habe ich in der aktuellen Version "-Dsun.java2d.d3d=true" eingestellt, und es läuft noch flüssiger, als unter 1.6.0_02 mit "-Dsun.java2d.noddraw=false".

Zusätzlich kann ich nun parallel zu meiner Grafik auch noch viele andere Grafiken anzeigen, ohne das die CPU-Belastung über 25-30% geht. Unter der ersten erfolgreichen Einstellung konnte ich nur maximal 2 zusätzliche Grafiken anzeigen. Bei der dritten hatte ich wieder 100% und nichts ging mehr.

Das einzige Problem bei der aktuellen Einstellung ist, das beim manuellen hineinzoomen in eine Grafik das Markierungsrechteck nicht flüssig gezeichnet wird, aber dass muss ich mir in der Software noch mal anschauen.

Mann o mann, diese ganzen Schalter und Versionsunterschiede sind ganz schön verwirrend.

Gruß,
Maik