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
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*, unTmno 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,Doycm
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
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
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