JPEG CompressionQuality ermitteln

**Schwedenbitter**

CompressionQuality besagt, wie verlustbehaftet die Komprimierung ist. Bei 100% wird ohne Verlust komprimiert, bei kleineren Werten steigt der Verlust, d. h. die Bildqualität nimmt ab oder anders ausgedrückt: Das dekomprimierte Bild stimmt nicht mit dem Bild vor der Komprimierung überein. (Auch wenn die Bilder für das menschliche Auge gleich aussehen.)

https://de.wikipedia.org/wiki/JPEG

Dem ist nichts hinzuzufügen.
CompressionQuality ist nicht irgend ein Wert, sondern gemeint ist der von Vcl.Imaging.jpeg.TJPEGImage.CompressionQuality , was dem geneigten Leser aber klar wird. Und da ich das Thema nicht erstellt habe, kann ich dessen Titel nicht beeinflussen.
[EDIT]Bedeutet 100 wirklich, dass es ohne Verlust komprimiert wird? Ich denke, dass zumindest die JPEG-Version von Delphi immer verlustbehaftet ist. Ich probiere das zur Not auch aus.[/EDIT]

Zitat von mensch72:

... Nach meiner Methode des "relativen Größenvergleichs" wären beide Dateien gleich gut komprimiert und hätten für meine Software die selbe "CompressionQuality".

Und genau das macht mein Code: er probiert aus, bei welcher CompressionQuality die gepackten Daten genauso groß wie in der Quelldatei sind

Ab jetzt befasse ich mich damit, wie man das ganze noch mit GDI+ realisiert. Damit tue ich mich im Moment noch schwer, weil es im Internet nur extrem wenige Quellen zu Delphi und GDI+ gibt...

**TiGü**

Zitat von Schwedenbitter:

Ab jetzt befasse ich mich damit, wie man das ganze noch mit GDI+ realisiert. Damit tue ich mich im Moment noch schwer, weil es im Internet nur extrem wenige Quellen zu Delphi und GDI+ gibt...

Guck dir mal die Unit Winapi.GDIOBJ (und Winapi.GDIPUTIL) an.
Mithilfe der ersten Unit wird ein hilfreicher Wrapper (Klassen basiert) über die flachen GDI+-Funktionen gestülpt.
Alle Methoden sind protected oder public, so dass man auch selber den Wrapper erweitern und mit hilfreichen Ableitungen arbeiten kann.
Er ähnelt der Klassen basierten C++ API und von daher ist die MSDN ein guter Anlaufpunkt für Informationen.
Auch als Delpi-Programmierer sollte man andere native Sprachen zumindest lesen können.
Der C++-Beispielcode ist in der Regel gut zu verstehen.

https://msdn.microsoft.com/en-us/lib...(v=vs.85).aspx

So wie mir bekannt ist kannst du diese nur zuweisen..

Ich habe meinen eigenen Wrapper..

markieren

Delphi-Quellcode:

			    QualityModeInvalid   = -1;

    QualityModeDefault   =  0;

    QualityModeLow       =  1; // Best performance

    QualityModeHigh      =  2; // Best rendering Quality

zusammenfalten · markieren

Delphi-Quellcode:

			function GDIP_SaveImageToFile(filename: WideString; image: Cardinal; Quality: Integer

): GPSTATUS; stdcall;

var

  rSplit: TSplitStrArray;

  encoderCLSID: TGUID;

  ext: string;

  IntI: Integer;

  format: string;

  EncoderParameters: PEncoderParameters;

  SaveQuality: Integer;

  listSize: UINT;

begin

  ext := ExtractFileExt(filename);

  rSplit := Split(IMAGETYPES, ';');

  for IntI := 0 to High(rSplit) do

  begin

    if rSplit[IntI] = ext then

    begin

      case IntI of

        0:

          format := 'image/jpeg';

        1:

          format := 'image/png';

        2:

          format := 'image/bmp';

        3:

          format := 'image/gif';

        4:

          format := 'image/tiff';

        5:

          format := 'image/x-icon';

        6:

          format := 'image/x-emf';

        7:

          format := 'image/x-wmf';

      else

        begin

          result := UnknownImageFormat;

          exit;

        end;

      end;

      break;

    end;

  end;

  SkinEngine.GetEncoderClsid(format, encoderCLSID);

  GdipGetEncoderParameterListSize(Image, @encoderCLSID, listSize);

  getmem(EncoderParameters, listSize);

  GdipGetEncoderParameterList(Image, @encoderClsid, listSize, EncoderParameters);

  SaveQuality := max(min(Quality, 100), 0);

  if (SaveQuality = 0) then

    SaveQuality := 100;

  EncoderParameters.Count := 1;

  EncoderParameters.Parameter[0].Guid := EncoderQuality;

  EncoderParameters.Parameter[0].NumberOfValues := 1;

  EncoderParameters.Parameter[0].Type_ := 4;

  EncoderParameters.Parameter[0].Value := @SaveQuality;

  Result := GdipSaveImageToFile(image, PWideChar(filename), @encoderCLSID, EncoderParameters);

  freemem(EncoderParameters, listSize);

end;

so könnte das aussehen.

gruss

**Schwedenbitter**

Zitat von TiGü:

...
Guck dir mal die Unit Winapi.GDIOBJ (und Winapi.GDIPUTIL) an.
Mithilfe der ersten Unit wird ein hilfreicher Wrapper (Klassen basiert) über die flachen GDI+-Funktionen gestülpt.
...

Die hatte ich schon entdeckt. Mir fehlen im Grunde "nur" 3 Dinge:

Wie speichert man das Originalbild in einen Stream, ohne neu zu komprimieren (zur Ermittlung der Ausgangsgröße)?
Wie setzt man die Kompressionsrate? Das hat EWeiss schon sehr schön gezeigt. Auch wenn das recht kompliziert aussieht. Danke dafür!
Wie speichert man die Datei dieses Mal neu komprimiert testweise in einen Stream und ermittelt dessen Größe? (Also wie 1.)

Zitat von TiGü:

Auch als Delpi-Programmierer sollte man andere native Sprachen zumindest lesen können.
Der C++-Beispielcode ist in der Regel gut zu verstehen.

https://msdn.microsoft.com/en-us/lib...(v=vs.85).aspx

msdn.microsoft.com ist immer mein erster Anlaufpunkt. Oft haben sie auch

Code dabei.
Ich stufe mich selbst aber als Laien - also nix Delpi-Programmierer - ein und versuche trotzdem halbwegs zu verstehen, was ich tue. Und da stolpere ich über so Sachen wie ISTREAM & Co. die scheinbar so gar nichts mit dem mir bekannnten T(Memory)Stream gemeinsam haben. Und ich sehe auch am übersetzten Code von EWeiss, dass es offenbar doch nicht einfacher geht, wie ich es erhofft hatte. Mit GDI+ werden es scheinbar zwangsläufig mehr als die 20 Zeilen...

P.S. Gibt es eine Funktion, mit der man TStatus in String übersetzen lassen kann? Ich kann das auch selbst. Aber wenn es das gibt, muss ich mir nicht die Arbeit machen.

**TiGü**

Zitat von Schwedenbitter:

Die hatte ich schon entdeckt. Mir fehlen im Grunde "nur" 3 Dinge:

Wie speichert man das Originalbild in einen Stream, ohne neu zu komprimieren (zur Ermittlung der Ausgangsgröße)?
Wie setzt man die Kompressionsrate? Das hat EWeiss schon sehr schön gezeigt. Auch wenn das recht kompliziert aussieht. Danke dafür!
Wie speichert man die Datei dieses Mal neu komprimiert testweise in einen Stream und ermittelt dessen Größe? (Also wie 1.)

msdn.microsoft.com ist immer mein erster Anlaufpunkt. Oft haben sie auch

Code dabei.
Ich stufe mich selbst aber als Laien - also nix Delpi-Programmierer - ein und versuche trotzdem halbwegs zu verstehen, was ich tue. Und da stolpere ich über so Sachen wie ISTREAM & Co. die scheinbar so gar nichts mit dem mir bekannnten T(Memory)Stream gemeinsam haben. Und ich sehe auch am übersetzten Code von EWeiss, dass es offenbar doch nicht einfacher geht, wie ich es erhofft hatte. Mit GDI+ werden es scheinbar zwangsläufig mehr als die 20 Zeilen...

P.S. Gibt es eine Funktion, mit der man TStatus in String übersetzen lassen kann? Ich kann das auch selbst. Aber wenn es das gibt, muss ich mir nicht die Arbeit machen.

Kann ich auf all diese Fragen und offenen Punkte mit einem Quellcodeschnipsel antworten?
Beim Result musste sehen wie du es brauchst.
Komprimierte Größe im Verhältnis zu unkomprimierte Größe oder andersrum.
Ggf. hauste da noch ne * 100 dazu. Wie du magst.

zusammenfalten · markieren

Delphi-Quellcode:

			function GetCompressRatio(const AJpegFilename: string): Double;

var

  Status: Winapi.GDIPAPI.TStatus;

  Image: Winapi.GDIPOBJ.TGPImage;

  OriginalStream, CompressStream: System.Classes.TMemoryStream;

  OriginalStreamAdapter, CompressStreamAdapter: Winapi.ActiveX.IStream;

  ImageFormat, EncoderCLSID: TGUID;

  EncoderParams: Winapi.GDIPAPI.TEncoderParameters;

  SaveQuality: Vcl.Imaging.jpeg.TJPEGQualityRange; // Integer geht natürlich auch!

begin

  Result := 0;

  OriginalStream := TMemoryStream.Create;

  CompressStream := TMemoryStream.Create;

  // mit soOwned räumt der TStreamAdapter den TMemoryStream auf

  OriginalStreamAdapter := TStreamAdapter.Create(OriginalStream, soOwned);

  CompressStreamAdapter := TStreamAdapter.Create(CompressStream, soOwned);

  Image := Winapi.GDIPOBJ.TGPImage.Create(AJpegFilename);

  try

    if Assigned(Image) and (Image.GetWidth > 0) and (Image.GetHeight > 0) then

    begin

      Status := Image.GetRawFormat(ImageFormat);

      if (Status = TStatus.Ok) and (ImageFormat = ImageFormatJPEG) then

      begin

        if Winapi.GDIPUTIL.GetEncoderClsid('image/jpeg', EncoderCLSID) > -1 then

        begin

          // Bild OHNE Komprimierung im Stream speichern

          Status := Image.Save(OriginalStreamAdapter, EncoderCLSID);

          OutputDebugString(PWideChar(Winapi.GDIPUTIL.GetStatus(Status)));

          SaveQuality := 50; // oder was du magst für die Kompressionsrate

          FillChar(EncoderParams, SizeOf(EncoderParams), 0);

          EncoderParams.Count := 1;

          EncoderParams.Parameter[0].Guid := EncoderQuality;

          EncoderParams.Parameter[0].NumberOfValues := 1;

          EncoderParams.Parameter[0].Type_ := EncoderParameterValueTypeLong;

          EncoderParams.Parameter[0].Value := @SaveQuality;

          // Bild MIT Komprimierung im Stream speichern

          Status := Image.Save(CompressStreamAdapter, EncoderCLSID, @EncoderParams);

          OutputDebugString(PWideChar(Winapi.GDIPUTIL.GetStatus(Status)));

          Result := CompressStream.Size / OriginalStream.Size;

        end;

      end

      else

        OutputDebugString(PWideChar(Winapi.GDIPUTIL.GetStatus(Status)));

    end;

  finally

    Image.Free;

  end;

end;

Wenn du mit TStatus GPStatus meinst jo..

zusammenfalten · markieren

Delphi-Quellcode:

			  Status =(

    Ok,

    GenericError,

    InvalidParameter,

    OutOfMemory,

    ObjectBusy,

    InsufficientBuffer,

    NotImplemented,

    Win32Error,

    WrongState,

    Aborted,

    FileNotFound,

    ValueOverflow,

    AccessDenied,

    UnknownImageFormat,

    FontFamilyNotFound,

    FontStyleNotFound,

    NotTrueTypeFont,

    UnsupportedGdiplusVersion,

    GdiplusNotInitialized,

    PropertyNotFound,

    PropertyNotSupported

  );

  TStatus = Status;

zusammenfalten · markieren

Delphi-Quellcode:

			  cStatus : Array[TStatus] of String =(

    'Ok',

    'GenericError',

    'InvalidParameter',

    'OutOfMemory',

    'ObjectBusy',

    'InsufficientBuffer',

    'NotImplemented',

    'Win32Error',

    'WrongState',

    'Aborted',

    'FileNotFound',

    'ValueOverflow',

    'AccessDenied',

    'UnknownImageFormat',

    'FontFamilyNotFound',

    'FontStyleNotFound',

    'NotTrueTypeFont',

    'UnsupportedGdiplusVersion',

    'GdiplusNotInitialized',

    'PropertyNotFound',

    'PropertyNotSupported'

  );

gruss

**Schwedenbitter**

Danke Euch allen für die tatkräftige Hilfe!

Zitat von EWeiss:

Wenn du mit TStatus GPStatus meinst jo..

Genau die meine ich. Und wenn ich Deinen Code richtig deute, gibt es entsprechendes also weder in Winapi.GDIPAPI , Winapi.GDIPOBJ noch Winapi.GDIPUTIL ?

Ich habe das jetzt mal umgestellt und es klappt (jedenfalls bei mir) tatsächlich:

zusammenfalten · markieren

Delphi-Quellcode:

			Function CalcCompressionQuality(Const Image: GPIMAGE;

   Const MustFit: Boolean = False): TJPEGQualityRange;

Var

   aMS                  : TMemoryStream;

   aFormat, aEncoder      : TGUID;

   aSA                  : Winapi.ActiveX.IStream;

   aSize                  : Int64;

   lQ, hQ, Piv, oldPiv   : Integer;

   aEncParams            : Winapi.GDIPAPI.TEncoderParameters;

Begin

   Result:= 100;                                    // im Zeifel: beste Qualität!

   If (GdipGetImageRawFormat(Image, @aFormat) = Status.Ok) And

      (aFormat = ImageFormatJPEG) And               // nur bei JPEG ausführen

      (GetEncoderClsid('image/jpeg', aEncoder) > -1) Then

   Begin

      aMS:= TMemoryStream.Create;                  // TMemoryStream erzeugen

      aSA:= TStreamAdapter.Create(aMS, soOwned);   // aMS wird selbst aufgeräumt

      If (GdipSaveImageToStream(Image, aSA, @aEncoder, nil) = Status.Ok) Then

      Begin

         aSize:= aMS.Size;                           // Originalgröße ermitteln

         lQ:=    Low( Result);                     // untere Grenze

         hQ:=    High(Result);                     // obere Grenze

         Piv:=  (hQ - lQ) Div 2;                     // in der Mitte anfangen

         Repeat

            aMS.Clear;                              // Stream leeren

            FillChar(aEncParams, SizeOf(aEncParams), 0);

            aEncParams.Count:= 1;

            With aEncParams.Parameter[0] Do

            Begin

               Guid:=           EncoderQuality;      // um diese Einstellung geht es

               NumberOfValues:= 1;

               Type_:=          EncoderParameterValueTypeLong;

               Value:=          @Piv               // CompressionQuality setzen

            End;

            oldPiv:= Piv;                           // altes Pivot-Element merken

            If (GdipSaveImageToStream(Image, aSA, @aEncoder, @aEncParams) = Status.Ok) Then

            Begin

               If (aMS.Size > aSize) Then            // Ergebnis ist zu groß

               Begin

                  hQ:= Piv;                        // obere Grenze = aktueller Wert

                  Piv:= Piv - ((hQ - lQ) Div 2);   // neuen Wert berechnen

               End

               Else Begin                           // Ergebnis kleiner oder gleich

                  lQ:= Piv;                        // untere Grenze = aktueller Wert

                  Piv:= Piv + ((hQ - lQ) Div 2);   // neuen Wert berechnen

               End;

            End

            Else Break;                              // bei Fehlern abbrechen

         Until (Piv = oldPiv);                     // noch näher geht es nicht

         aSA:= nil;   // sicherheitshalber (http://www.delphipraxis.net/1384246-post23.html)

         If (MustFit) And                           // auf keinen Fall größer !!!

            (aMS.Size > aSize) Then                  // immer noch zu groß

               Result:= Pred(Piv)                  // => eine Nummer kleiner

         Else   Result:= Piv;                        // aMS.Size = aSize => exakten Wert übergeben

      End;

   End;

End;

Eine Frage habe ich trotzdem noch: Wohin verschwindet Winapi.ActiveX.IStream ?
Dieser Stream kümmert sich um den ihm zugewiesenen TMemoryStream , so dass ich den nicht freigeben darf/muss. Aber trotz fehlender Freigabe von Winapi.ActiveX.IStream bringt mir mein Programm bei ReportMemoryLeaksOnShutdown:= True; am Ende keine Meldung.
Das wäre mir wichtig, weil mein Programm genauso lang läuft wieder Rechner und damit am Tag im Maximum mehrere hundert Bilder verarbeiten muss. Dass es am Ende des Programms automatisch aufgeräumt wird, reicht mir also leider nicht, wenn mir zwischendurch die Puste/der Speicher aus geht. Winapi.GDIPOBJ.TGPImage.Free ruft auch nur GdipDisposeImage(); auf...

Zitat:

gibt es entsprechendes also weder in

Nein gibt es nicht.

Der Aufruf ist einfach.
bsp.

markieren

Delphi-Quellcode:

			var

  Result: GPStatus;

....

Result := GdipSaveImageToFile(img, FullName, @encoderCLSID, nil);

lblStatus.Caption := 'Status = ' + (cStatus[Result]);

Zitat:

ruft auch nur GdipDisposeImage(); auf...

Der IStream gibt sich selbst frei wenn der Referenz Counter auf 0 ist.
Ein IStream := nil sollte ausreichen.

GdipDisposeImage gibt den Speicher frei vom geladenen GDI+ Image. Auch das ist vollkommen ausreichend.

gruss

**TiGü**

Zitat von Schwedenbitter:

Danke Euch allen für die tatkräftige Hilfe!

Zitat von EWeiss:

Wenn du mit TStatus GPStatus meinst jo..

Genau die meine ich. Und wenn ich Deinen Code richtig deute, gibt es entsprechendes also weder in Winapi.GDIPAPI , Winapi.GDIPOBJ noch Winapi.GDIPUTIL ?

Zitat von EWeiss:

Zitat:

gibt es entsprechendes also weder in

Nein gibt es nicht.

Der Aufruf ist einfach.
bsp.

Öh...das ist jetzt schon bissel fremdschämen mit euch.

In meinen Beispielcode habe ich dreimal folgende Zeile verwendet:

OutputDebugString(PWideChar(Winapi.GDIPUTIL.GetStatus(Status)));

Ich will das Wichtigste nochmal herausstellen:

Winapi.GDIPUTIL.GetStatus(Status);
Ich will ja jetzt nicht kritisch gucken, aber die Unit Winapi.GDIPUTIL ist gerade mal knapp 389 Zeilen lang.
Das hättest du durch leichtes durch scrollen aber auch selber finden können.

**TiGü**

Zitat von Schwedenbitter:

Eine Frage habe ich trotzdem noch: Wohin verschwindet Winapi.ActiveX.IStream ?
Dieser Stream kümmert sich um den ihm zugewiesenen TMemoryStream , so dass ich den nicht freigeben darf/muss. Aber trotz fehlender Freigabe von Winapi.ActiveX.IStream bringt mir mein Programm bei ReportMemoryLeaksOnShutdown:= True; am Ende keine Meldung.
Das wäre mir wichtig, weil mein Programm genauso lang läuft wieder Rechner und damit am Tag im Maximum mehrere hundert Bilder verarbeiten muss. Dass es am Ende des Programms automatisch aufgeräumt wird, reicht mir also leider nicht, wenn mir zwischendurch die Puste/der Speicher aus geht.

Bitte mit Interfaces, Reference Counting und dergleichen beschäftigen, dann werden alle Fragen beantwortet. Das Forum hier hat dazu einige Threads und Tutorials.
Auch einfach mal in TStreamAdapter.Destroy einen Haltepunkt setzen und den Call Stack nachvollziehen.