Artículo técnico

Tm identidad en streams de PDF: remoción peephole segura

Tome un content stream que un generador de reportes podría escribir, BT (Invoice) Tj 1 0 0 1 0 0 Tm (Total) Tj ET, y quite el 1 0 0 1 0 0 Tm porque sus seis números deletrean la matriz identidad. Renderice el resultado y "Total" ya no comienza en el origen del espacio de texto. Comienza donde terminó "Invoice", sobre la misma línea base. Un Tm identidad es redundante solo mientras la matriz de texto y la matriz de línea de texto ya sostienen la identidad: directamente después de BT, o directamente después de otro Tm identidad

La eliminación es tentadora porque los mismos seis números realmente son peso muerto delante de cm. Un optimizador de content streams que trate a los dos operadores por igual va a encoger muchos streams correctamente. Entonces se encuentra con un generador que usa un Tm identidad como retorno de carro, y el texto se mueve

¿Por qué 1 0 0 1 0 0 Tm no siempre es un no-op?

Los dos operadores hacen aritmética distinta. ISO 32000-1 §8.4.4 define cm como concatenar su operando con la matriz de transformación actual; multiplique cualquier matriz por la identidad y recibe la misma matriz de vuelta, así que 1 0 0 1 0 0 cm se puede borrar donde sea que aparezca. Tm es una asignación. Bajo §9.4.2 fija tanto la matriz de texto como la matriz de línea de texto a sus operandos y tira lo que ellas sostuvieran, así que si cambia algo depende por completo de los operadores delante de él

§9.4.1 dice que BT arranca ambas matrices en la identidad. Desde ahí, casi todo lo que hay dentro de un objeto de texto mueve por lo menos una de ellas. Td, TD, T* y un Tm no identidad reposicionan la matriz de línea de texto. Cada operador de despliegue de texto (Tj, TJ, ' y ") avanza la matriz de texto por el ancho de los glifos que acaba de pintar, y los últimos dos además arrancan una línea nueva. Una vez que alguno de esos corrió, un Tm identidad es un salto genuino de vuelta al origen. El stream de la factura de arriba depende de ese salto

Trazar un stream a mano lo zanja rápido. Pase el ejemplo de la factura por el rastreador de estado de CTM y matriz de texto de content streams y el registro muestra cm concatenando sobre la CTM mientras Tm sobrescribe ambas matrices de texto — dos reglas de actualización distintas escondidas detrás de operandos idénticos

PDFlibPas trata 1 0 0 1 0 0 cm y 1 0 0 1 0 0 Tm de forma distinta: cm multiplica la CTM por la derecha y es un no-op en cualquier lugar, mientras que Tm reemplaza Tm y Tlm de plano, y cada Tj avanza el Tm por el ancho que pintó, así que un Tm identidad después de texto mostrado es un reinicio genuino
El generador de reportes cuenta con ese reinicio: borrar el Tm identidad pinta Total inmediatamente después de Invoice sobre la misma línea base, y nada falla, registra o advierte en el camino a la impresora del cliente

Cómo decide PDF Library for Delphi qué Tm identidad soltar

PDF Library for Delphi suelta cada cm identidad durante su pase peephole, y suelta un Tm identidad solo cuando un escaneo hacia atrás desde ese operador alcanza un BT u otro Tm identidad antes de encontrar cualquier cosa que haya podido mover las matrices de texto. La prueba de "identidad" es numérica: el operador necesita exactamente seis operandos numéricos iguales a 1, 0, 0, 1, 0, 0, así que 1.0 0 0 1.0 0 0 Tm también califica. Caminando hacia atrás, el escaneo mete cada operador que encuentra en uno de dos grupos:

  • Frenar y conservar el Tm: Td, TD, T*, un Tm no identidad, Tj, TJ, ', ", ET, cualquier operador que el parser no reconozca, o el inicio del stream
  • Pasar de largo y seguir escaneando: operadores que nunca tocan la matriz de texto ni la matriz de línea de texto, como Tf, Tc, los setters de color, gs, los operadores de marked-content, Do y cm

Un Tm identidad anterior termina el escaneo en favor de la eliminación sin importar si el optimizador lo está conservando o ya lo agendó para remover. De cualquier forma dejó ambas matrices en la identidad, que es el mismo estado que deja BT. Por eso una racha de tres operadores Tm identidad seguidos después de BT colapsa a nada

RemoveIdentityMatrices de PDFlibPas camina hacia atrás desde cada Tm identidad: Tf, Tc, los setters de color, gs y cm se pasan de largo, mientras que Td, TD, T*, un Tm no identidad, Tj, TJ, un operador desconocido o ET detiene el escaneo y conserva el Tm, y BT avala eliminarlo
Un Tm identidad anterior también detiene el escaneo, porque conservado o ya marcado para eliminación dejó ambas matrices en la identidad — de cualquier manera el optimizer nunca mueve un glyph

Las paradas conservadoras son deliberadas. Un operador desconocido podría ser una extensión de proveedor que haga cualquier cosa, así que el escaneo se niega a razonar más allá de él. Después de ET no hay ningún objeto de texto abierto, y un Tm identidad sentado ahí no tiene ningún BT que avale los valores de la matriz. El escaneo también mira un content stream a la vez. Eso importa para páginas cuyo /Contents es un arreglo: PDF deja que un objeto de texto comience en un stream y continúe en el siguiente, así que una capa que abre en medio de un objeto de texto, sin BT propio, conserva su Tm identidad aunque la capa anterior lo habría hecho redundante

Creemos que ese es el lado equivocarse correcto. Rastrear matrices a través de límites de streams, o simular operadores desconocidos, recuperaría quizás catorce bytes de texto sin comprimir por archivo raro. Equivocarse mueve un glifo en una factura impresa. El costo y el riesgo no juegan en la misma liga

Un efecto de arrastre vale conocer porque cambia lo que usted ve en la salida. El mismo pase también remueve objetos de texto sin nada dentro, así que BT 1 0 0 1 0 0 Tm ET desaparece por completo: el Tm identidad se va primero, y el par BT/ET que deja atrás queda vacío

Correr el optimizador sobre un fragmento de content stream

El optimizador trabaja sobre el mismo modelo parseado TPDFContentProgram que usted usaría para editar texto de página a nivel de instrucción, como en el recorrido de mapeo carácter-a-byte-de-contenido. Eso hace fácil probar la regla sobre una cadena antes de confiarle un documento entero. El helper de abajo parsea un stream decodificado, corre TPDFContentPeepholeOptimizer, y emite el resultado una instrucción por línea. Fijar CanonicalNumbers antes de Parse refleja el pase al guardar, que reescribe cada número a una precisión fija

uses
  PDFlibContentModel, PDFlibContentOptimize;

function OptimizeSnippet(const Source: AnsiString): AnsiString;
var
  Prog: TPDFContentProgram;
  Optimizer: TPDFContentPeepholeOptimizer;
begin
  Result := Source;
  Prog := TPDFContentProgram.Create;
  try
    Prog.CanonicalNumbers := True; // el mismo manejo de números que el pase al guardar
    if not Prog.Parse(Source) then
      Exit; // daño estructural grueso: deje los bytes tranquilos
    Optimizer := TPDFContentPeepholeOptimizer.Create(Prog);
    try
      Optimizer.Run; // devuelve el número de instrucciones removidas
    finally
      Optimizer.Free;
    end;
    Result := Prog.Emit; // una instrucción por línea, separadas por #10
  finally
    Prog.Free;
  end;
end;

// Removido: Tm directamente después de BT, el segundo de dos Tm identidad seguidos
//   OptimizeSnippet('BT /F1 12 Tf 1 0 0 1 0 0 Tm (hello) Tj ET')
// Conservado: Tm después de Td, después de Tj, después de un Tm no identidad, o fuera de BT
//   OptimizeSnippet('BT (Invoice) Tj 1 0 0 1 0 0 Tm (Total) Tj ET')

Corra el stream de la factura por aquí y el Tm identidad sobrevive, porque el escaneo hacia atrás golpea un Tj mucho antes de alcanzar el BT. Ponga /F1 12 Tf, 2 Tc y 0 g entre el BT y el Tm identidad y aun así se va, ya que ninguno de esos toca las matrices de texto. El caso interesante es BT 10 20 Td 1 0 0 1 0 0 Tm 1 0 0 1 0 0 Tm. Pierde exactamente un operador. El primer Tm identidad deshace el movimiento que hizo el Td, y solo el segundo es redundante

Parse devuelve False solo por daño grueso como una cadena sin terminar o un diccionario sin cerrar. Los operadores desconocidos parsean bien y se quedan en el programa, donde actúan como paradas duras para el escaneo

¿Cuándo corre en realidad el optimizer peephole?

El optimizador corre solo dentro del pase de compresión, y solo sobre streams de contenido de página que todavía no están comprimidos con Flate. TPDFlib.SetOptimizeContentStreams(1) es el valor por omisión, y el mismo interruptor aparece como el campo OptimizeContentStreams de TPDFlibSaveOptions; CompressContent y CompressPage lo respetan ambos. Un stream cuyo /Filter ya es /FlateDecode se salta por completo, así que cargar un PDF comprimido típico y guardarlo otra vez deja sus operadores exactamente como estaban. Los streams guardados sin comprimir se decodifican, optimizan y luego comprimen con Flate. Si un stream falla al parsear, sus bytes decodificados originales se comprimen sin cambios

PDFlibPas corre el optimizer peephole solo dentro del pase de compresión al guardar: TPDFPageTree.Compress respeta SetOptimizeContentStreams, un stream ya filtrado con /FlateDecode se salta por completo, un stream no parseable se comprime con sus bytes originales sin cambios, y NormalizeContentStreams nunca llama al optimizer
Los streams comprimidos que se saltan son la parte silenciosa: cargue un PDF existente, guárdelo otra vez, y sus operadores salen intactos porque el optimizer solo reescribe streams que decodificó primero
var
  Lib: TPDFlib;
  Options: TPDFlibSaveOptions;
begin
  Lib := TPDFlib.Create;
  try
    if Lib.LoadFromFile('report.pdf', '') <> 1 then
      Exit;
    // Los streams de página sin comprimir pasan por las reglas peephole, luego Flate
    Lib.SetOptimizeContentStreams(1);
    Lib.CompressContent;
    Lib.SaveToFile('report-optimized.pdf');

    // La misma elección vía las opciones de guardado incluidas; False se sale
    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;

Deje el valor por omisión activado. Cada transformación del pase es equivalente en salida, y la regla de la matriz identidad va tras un patrón que muchos generadores emiten, abriendo cada objeto de texto con BT 1 0 0 1 0 0 Tm. Apagarla tiene sentido sobre todo cuando usted quiere hacer diff de su propia salida sin comprimir contra lo que escribió, o cuando necesita una línea base. Para esa línea base, TPDFlib.NormalizeContentStreams parsea y re-emite el contenido con espaciado y números canónicos pero nunca llama al optimizador, así que la brecha de tamaño entre un guardado normalizado y un guardado optimizado es lo que contribuyeron las reglas peephole. Espere que sea modesta junto a las victorias mayores descritas en optimización de tamaño de archivos PDF con subsetting de fuentes

Una prueba que cubre una forma no define la regla

Una prueba que alimenta BT 1 0 0 1 0 0 Tm (hello) Tj ET a un optimizador y afirma que no queda ningún Tm fija una sola forma: un Tm identidad directamente después de BT se elimina. No dice nada sobre un Tm identidad después de Td o después de texto mostrado. Leer esa única aserción como "el Tm identidad siempre se puede remover" es un error fácil, y caro, porque la muestra pasa de cualquier forma. Las pruebas para cualquier regla como esta necesitan las formas conservadas escritas junto a las removibles

El helper de abajo cuenta los operadores Tm que sobreviven, y luego revisa una tabla de entradas. Cambie ExpectTm por la aserción de su framework de pruebas; no forma parte de la biblioteca

uses
  SysUtils, PDFlibContentModel, PDFlibContentOps, PDFlibContentOptimize;

function TmCountAfterOptimize(const Source: AnsiString): Integer;
var
  Prog: TPDFContentProgram;
  Optimizer: TPDFContentPeepholeOptimizer;
  I: Integer;
begin
  Result := -1; // -1 señala un fallo de parseo
  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;

// Su propio helper de comprobación, sugerido aquí; reemplácelo por una aserción real
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
  // Formas removibles
  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);
  // Formas que deben conservar el Tm identidad
  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);    // sin BT que las envuelva
  ExpectTm('BT ET 1 0 0 1 0 0 Tm', 1);     // después de ET
end;

Las últimas dos filas se ven tontas hasta que uno recuerda que los arreglos /Contents en capas producen exactamente esos fragmentos. Un stream que comienza a mitad de objeto de texto no tiene BT, y un Tm identidad después de ET no pertenece a ningún objeto de texto. Ambos se quedan. El par BT ET vacío de la última fila lo remueve la regla del objeto de texto vacío, razón por la cual el conteo revisa operadores Tm en vez de comparar cadenas completas

Lo que la regla deja ir es el ocasional Tm identidad en medio de un objeto de texto, unos bytes por página antes de que Flate siquiera los vea. Lo que compra es una garantía sobre la que descansa el diseño del optimizador: ninguna transformación del pase cambia la página visible. Un optimizador de tamaño que mueve texto es un bug de renderizado con una buena razón de compresión

Si usted genera o posprocesa contenido PDF en Delphi o C++Builder, la PDF Library for Delphi y C++Builder trae el parser de content streams, este pase peephole y las opciones de guardado mostradas arriba, junto con NormalizeContentStreams para producir una línea base limpia y sin optimizar contra la cual comparar