Technischer Artikel

Identity-Tm im Content-Stream: Peephole ohne Risiko

Nehmen wir einen Content-Stream, wie ein Reportgenerator ihn schreiben könnte, BT (Invoice) Tj 1 0 0 1 0 0 Tm (Total) Tj ET, und streichen wir das 1 0 0 1 0 0 Tm, weil seine sechs Zahlen die Identity-Matrix buchstabieren. Rendert man das Ergebnis, beginnt "Total" nicht mehr am Ursprung des Textraums. Es beginnt dort, wo "Invoice" endete, auf derselben Grundlinie. Ein Identity-Tm ist nur dann redundant, während die Textmatrix und die Textzeilenmatrix bereits die Identity halten: direkt nach BT, oder direkt nach einem anderen Identity-Tm

Die Löschung ist verführerisch, weil dieselben sechs Zahlen vor einem cm wirklich totes Gewicht sind. Ein Content-Stream-Optimierer, der beide Operatoren gleich behandelt, schrumpft etliche Streams korrekt. Dann trifft er auf einen Generator, der ein Identity-Tm als Wagenrücklauf benutzt, und der Text wandert

Warum ist 1 0 0 1 0 0 Tm nicht immer ein No-op?

Die beiden Operatoren rechnen Verschiedenes. ISO 32000-1 §8.4.4 definiert cm als Verkettung seines Operanden mit der aktuellen Transformationsmatrix; multipliziert man eine beliebige Matrix mit der Identity, bekommt man dieselbe Matrix zurück, 1 0 0 1 0 0 cm lässt sich also überall löschen, wo es auftaucht. Tm ist eine Zuweisung. Nach §9.4.2 setzt es sowohl die Textmatrix als auch die Textzeilenmatrix auf seine Operanden und wirft weg, was sie hielten, ob es also etwas ändert, hängt ganz an den Operatoren davor

§9.4.1 sagt, BT startet beide Matrizen auf der Identity. Von dort bewegt fast alles innerhalb eines Textobjekts mindestens eine von ihnen. Td, TD, T* und ein Nicht-Identity-Tm verlegen die Textzeilenmatrix. Jeder textzeigende Operator (Tj, TJ, ' und ") schiebt die Textmatrix um die Breite der Glyphen weiter, die er gerade gemalt hat, und die letzten beiden starten vorher eine neue Zeile. Hat irgendeiner davon gelaufen, ist ein Identity-Tm ein echter Sprung zurück zum Ursprung. Der Invoice-Stream von oben baut auf diesem Sprung auf

Einen Stream von Hand zu verfolgen klärt das schnell. Treibt man das Invoice-Beispiel durch den Content-Stream-CTM- und Textmatrix-State-Tracker, zeigt der Record cm, das auf die CTM verkettet, während Tm beide Textmatrizen überschreibt — zwei verschiedene Update-Regeln hinter identischen Operanden

PDFlibPas behandelt 1 0 0 1 0 0 cm und 1 0 0 1 0 0 Tm unterschiedlich: cm rechtsmultipliziert die CTM und ist überall ein No-op, während Tm Tm und Tlm komplett ersetzt, und jedes Tj rückt Tm um die gemalte Breite weiter — ein Identity-Tm nach angezeigtem Text ist also ein echter Reset
Der Reportgenerator verließ sich auf diesen Reset: Ohne das Identity-Tm landete Total unmittelbar nach Invoice auf derselben Grundlinie, und nichts schlug fehl, loggte oder warnte, bis hin zum Drucker des Kunden

Wie PDF Library for Delphi entscheidet, welches Identity-Tm fällt

PDF Library for Delphi fällt jedes Identity-cm in ihrem Peephole-Durchlauf, und fällt ein Identity-Tm nur dann, wenn ein Rückwärtsscan von diesem Operator BT oder ein anderes Identity-Tm erreicht, bevor er auf etwas stößt, das die Textmatrizen bewegt haben könnte. Der Test für "Identity" ist numerisch: Der Operator braucht exakt sechs Zahlen-Operanden gleich 1, 0, 0, 1, 0, 0, 1.0 0 0 1.0 0 0 Tm qualifiziert sich also ebenfalls. Rückwärts laufend sortiert der Scan jeden Operator, dem er begegnet, in eine von zwei Gruppen:

  • Stoppen und Tm behalten: Td, TD, T*, ein Nicht-Identity-Tm, Tj, TJ, ', ", ET, jeder Operator, den der Parser nicht kennt, oder der Anfang des Streams
  • Weitersteppen und weiterscannen: Operatoren, die Textmatrix oder Textzeilenmatrix nie anfassen, etwa Tf, Tc, Farb-Setter, gs, Marked-Content-Operatoren, Do und cm

Ein früheres Identity-Tm beendet den Scan zugunsten der Löschung, ob der Optimizer es behält oder es bereits zur Entfernung vorgemerkt hat. In beiden Fällen ließ es beide Matrizen auf der Identity, derselbe Zustand, den BT hinterlässt. Deshalb kollabieren drei Identity-Tm-Operatoren in Reihe direkt nach BT zu nichts

PDFlibPas RemoveIdentityMatrices läuft von jedem Identity-Tm rückwärts: Tf, Tc, Farb-Setter, gs und cm werden übergangen, während Td, TD, T*, ein Nicht-Identity-Tm, Tj, TJ, ein unbekannter Operator oder ET den Scan stoppt und das Tm behält, und BT bürgt für das Entfernen
Ein früheres Identity-Tm stoppt den Scan ebenfalls, denn ob behalten oder bereits zur Löschung vorgemerkt — es ließ beide Matrizen auf der Identity, und in keinem Fall verschiebt der Optimizer eine Glyphe

Die konservativen Stopps sind Absicht. Ein unbekannter Operator könnte eine Vendor-Erweiterung sein, die alles Mögliche tut, der Scan weigert sich also, über ihn hinweg zu schließen. Nach ET gibt es kein offenes Textobjekt, und ein dort sitzendes Identity-Tm hat kein BT, das für die Matrixwerte bürgt. Der Scan schaut sich außerdem immer nur einen Content-Stream an. Das zählt für Seiten, deren /Contents ein Array ist: PDF erlaubt, dass ein Textobjekt in einem Stream beginnt und im nächsten weiterläuft, eine Ebene also, die mitten in einem Textobjekt ohne eigenes BT beginnt, behält ihr Identity-Tm, selbst wenn die vorherige Ebene es redundant gemacht hätte

Wir halten das für die richtige Seite, auf der man sich irrt. Matrizen über Stream-Grenzen hinweg zu verfolgen oder unbekannte Operatoren zu simulieren würde vielleicht vierzehn Bytes unkomprimierten Texts pro exotischer Datei bergen. Es falsch zu machen verschiebt eine Glyphe auf einer gedruckten Rechnung. Kosten und Risiko sind nicht in derselben Liga

Ein Nebeneffekt ist wissenswert, weil er das Bild in der Ausgabe verändert. Derselbe Durchlauf entfernt auch Textobjekte mit nichts darin, BT 1 0 0 1 0 0 Tm ET verschwindet also komplett: Zuerst fällt das Identity-Tm, und das BT/ET-Paar, das es zurücklässt, ist leer

Den Optimizer auf einem Content-Stream-Schnipsel fahren

Der Optimierer arbeitet auf demselben geparsten TPDFContentProgram-Modell, das man nutzen würde, um Seitentext auf Instruktions-Ebene zu bearbeiten, wie im Artikel zum Charakter-zu-Content-Byte-Mapping. So lässt sich die Regel leicht an einem String ausprobieren, bevor man sie einem ganzen Dokument vertraut. Der Helfer unten parst einen decodierten Stream, fährt TPDFContentPeepholeOptimizer und gibt das Ergebnis mit einer Instruktion pro Zeile aus. CanonicalNumbers vor Parse zu setzen spiegelt den Save-Zeit-Durchlauf, der jede Zahl mit fixer Präzision umschreibt

uses
  PDFlibContentModel, PDFlibContentOptimize;

function OptimizeSnippet(const Source: AnsiString): AnsiString;
var
  Prog: TPDFContentProgram;
  Optimizer: TPDFContentPeepholeOptimizer;
begin
  Result := Source;
  Prog := TPDFContentProgram.Create;
  try
    Prog.CanonicalNumbers := True; // dieselbe Zahlenbehandlung wie der Save-Durchlauf
    if not Prog.Parse(Source) then
      Exit; // grober struktureller Schaden: die Bytes in Ruhe lassen
    Optimizer := TPDFContentPeepholeOptimizer.Create(Prog);
    try
      Optimizer.Run; // liefert die Anzahl der entfernten Instruktionen
    finally
      Optimizer.Free;
    end;
    Result := Prog.Emit; // eine Instruktion pro Zeile, mit #10 getrennt
  finally
    Prog.Free;
  end;
end;

// Entfernt: Tm direkt nach BT, die zweite von zwei Identity-Tm in Folge
//   OptimizeSnippet('BT /F1 12 Tf 1 0 0 1 0 0 Tm (hello) Tj ET')
// Behalten: Tm nach Td, nach Tj, nach einem Nicht-Identity-Tm oder außerhalb von BT
//   OptimizeSnippet('BT (Invoice) Tj 1 0 0 1 0 0 Tm (Total) Tj ET')

Treibt man den Invoice-Stream hindurch, überlebt das Identity-Tm, denn der Rückwärtsscan trifft lange vor BT auf ein Tj. Stellt man /F1 12 Tf, 2 Tc und 0 g zwischen BT und das Identity-Tm, fällt es trotzdem, keines davon fasst die Textmatrizen an. Der interessante Fall ist BT 10 20 Td 1 0 0 1 0 0 Tm 1 0 0 1 0 0 Tm. Er verliert exakt einen Operator. Das erste Identity-Tm macht die Bewegung rückgängig, die das Td gemacht hat, und nur das zweite ist redundant

Parse gibt nur bei grobem Schaden False zurück, etwa einem nicht terminierten String oder Dictionary. Unbekannte Operatoren parsen fein und bleiben im Programm, wo sie als harte Stopps für den Scan wirken

Wann läuft der Peephole-Optimizer tatsächlich?

Der Optimizer läuft nur innerhalb des Kompressionsdurchlaufs, und nur auf Seiten-Content-Streams, die nicht bereits Flate-komprimiert sind. TPDFlib.SetOptimizeContentStreams(1) ist der Default, und derselbe Schalter erscheint als Feld OptimizeContentStreams von TPDFlibSaveOptions; CompressContent und CompressPage ehren ihn beide. Ein Stream, dessen /Filter bereits /FlateDecode ist, wird komplett übersprungen, eine typische komprimierte PDF zu laden und erneut zu speichern lässt ihre Operatoren also exakt, wie sie waren. Unkomprimiert gespeicherte Streams werden decodiert, optimiert und dann Flate-komprimiert. Scheitert ein Stream am Parsen, wird sein ursprünglicher decodierter Byte-Bestand unverändert komprimiert

PDFlibPas startet den Peephole-Optimizer nur innerhalb des Kompressionsdurchlaufs zur Speicherzeit: TPDFPageTree.Compress ehrt SetOptimizeContentStreams, ein Stream mit bereits gesetztem /FlateDecode-Filter wird komplett übersprungen, ein unparsebarer Stream wird mit unveränderten Original-Bytes komprimiert, und NormalizeContentStreams ruft den Optimizer nie auf
Übersprungene komprimierte Streams sind der stille Teil: Vorhandene PDF laden, erneut speichern — die Operatoren kommen unangetastet heraus, denn der Optimizer schreibt nur Streams um, die er zuvor selbst dekodiert hat
var
  Lib: TPDFlib;
  Options: TPDFlibSaveOptions;
begin
  Lib := TPDFlib.Create;
  try
    if Lib.LoadFromFile('report.pdf', '') <> 1 then
      Exit;
    // Unkomprimierte Streams laufen durch die Peephole-Regeln, dann durch Flate
    Lib.SetOptimizeContentStreams(1);
    Lib.CompressContent;
    Lib.SaveToFile('report-optimized.pdf');

    // Dieselbe Wahl über die gebündelten Save-Options; False meldet ab
    Options.CompressContent := True;
    Options.CompressFonts := True;
    Options.CompressImages := True;
    Options.Linearize := False;
    Options.KeepModDate := False;
    Options.OptimizeContentStreams := False;
    Options.GarbageCollect := False;
    Options.PackObjectStreams := True;
    Lib.SaveToFileOptions('report-plain.pdf', Options);
  finally
    Lib.Free;
  end;
end;

Den Default an lassen. Jede Transformation im Durchlauf ist ausgabeäquivalent, und die Identity-Matrix-Regel jagt ein Muster, das viele Generatoren emittieren, die jedes Textobjekt mit BT 1 0 0 1 0 0 Tm eröffnen. Abschalten lohnt sich vor allem, wenn man die eigene unkomprimierte Ausgabe gegen das Geschriebene diffen will, oder wenn man eine Basislinie braucht. Für diese Basislinie parst TPDFlib.NormalizeContentStreams Content und gibt ihn mit kanonischen Abständen und Zahlen wieder aus, ruft den Optimizer aber nie auf, der Größenabstand zwischen einem normalisierten und einem optimierten Save ist also das, was die Peephole-Regeln beisteuerten. Erwartung moderat, neben den größeren Gewinnen, die der Artikel zur PDF-Dateigrößen-Optimierung mit Font-Subsetting beschreibt

Ein Test, der eine Form deckt, definiert die Regel nicht

Ein Test, der BT 1 0 0 1 0 0 Tm (hello) Tj ET in einen Optimierer füttert und behauptet, kein Tm bleibe übrig, nagelt eine Form fest: Ein Identity-Tm direkt nach BT wird entfernt. Er sagt nichts über ein Identity-Tm nach Td oder nach angezeigtem Text. Diese eine Assertion als "Identity-Tm ist immer entfernbar" zu lesen ist ein leichter Fehler, und ein teurer, denn das Sample besteht in beide Richtungen. Tests für eine Regel wie diese brauchen die behaltenen Formen neben den entfernbaren aufgeschrieben

Der Helfer unten zählt die Tm-Operatoren, die überleben, und prüft dann eine Tabelle von Eingaben. ExpectTm gegen die Assertion Ihres Test-Frameworks tauschen; es ist nicht Teil der Bibliothek

uses
  SysUtils, PDFlibContentModel, PDFlibContentOps, PDFlibContentOptimize;

function TmCountAfterOptimize(const Source: AnsiString): Integer;
var
  Prog: TPDFContentProgram;
  Optimizer: TPDFContentPeepholeOptimizer;
  I: Integer;
begin
  Result := -1; // -1 signalisiert einen Parse-Fehler
  Prog := TPDFContentProgram.Create;
  try
    if not Prog.Parse(Source) then
      Exit;
    Optimizer := TPDFContentPeepholeOptimizer.Create(Prog);
    try
      Optimizer.Run;
    finally
      Optimizer.Free;
    end;
    Result := 0;
    for I := 0 to Prog.Count - 1 do
      if Prog[I].Op = coTextMatrix then
        Inc(Result);
  finally
    Prog.Free;
  end;
end;

// Ihr eigener Prüf-Helfer, hier vorgeschlagen; durch eine echte Assertion ersetzen
procedure ExpectTm(const Source: AnsiString; Expected: Integer);
var
  Actual: Integer;
begin
  Actual := TmCountAfterOptimize(Source);
  if Actual <> Expected then
    raise Exception.CreateFmt('%s: expected %d Tm, got %d',
      [string(Source), Expected, Actual]);
end;

procedure CheckIdentityTmRule;
begin
  // Entfernbare Formen
  ExpectTm('BT /F1 12 Tf 1 0 0 1 0 0 Tm (hello) Tj ET', 0);
  ExpectTm('BT 1 0 0 1 0 0 Tm 1 0 0 1 0 0 Tm (a) Tj ET', 0);
  ExpectTm('BT /F1 12 Tf 2 Tc 0 g 1 0 0 1 0 0 Tm (a) Tj ET', 0);
  // Formen, die das Identity-Tm behalten müssen
  ExpectTm('BT (Invoice) Tj 1 0 0 1 0 0 Tm (Total) Tj ET', 1);
  ExpectTm('BT 10 20 Td 1 0 0 1 0 0 Tm 1 0 0 1 0 0 Tm (a) Tj ET', 1);
  ExpectTm('BT 2 0 0 2 5 5 Tm (a) Tj 1 0 0 1 0 0 Tm (b) Tj ET', 2);
  ExpectTm('1 0 0 1 0 0 Tm (a) Tj', 1);    // kein umschließendes BT
  ExpectTm('BT ET 1 0 0 1 0 0 Tm', 1);     // nach ET
end;

Die letzten beiden Zeilen wirken albern, bis man sich erinnert, dass geschichtete /Contents-Arrays exakt solche Fragmente produzieren. Ein Stream, der mitten im Textobjekt beginnt, hat kein BT, und ein Identity-Tm nach ET gehört zu gar keinem Textobjekt. Beide bleiben. Das leere BT ET-Paar in der letzten Zeile entfernt die Empty-Text-Object-Regel, weshalb der Zähler Tm-Operatoren prüft statt ganze Strings zu vergleichen

Was die Regel aufgibt, ist das gelegentliche Identity-Tm mitten im Textobjekt, ein paar Bytes pro Seite, bevor Flate sie überhaupt sieht. Was sie kauft, ist eine Garantie, auf der das Design des Optimierers ruht: Keine Transformation im Durchlauf verändert die sichtbare Seite. Ein Größenoptimierer, der Text verschiebt, ist ein Rendering-Bug mit guter Kompressionsrate

Wer PDF-Content in Delphi oder C++Builder erzeugt oder nachbearbeitet, bekommt in der PDF Library for Delphi and C++Builder den Content-Stream-Parser, diesen Peephole-Durchlauf und die oben gezeigten Save-Optionen, dazu NormalizeContentStreams, um eine saubere, unoptimierte Basislinie zum Vergleichen zu erzeugen