Artículo técnico

Tm identidad en streams PDF: eliminación peephole segura

Toma un content stream que podría escribir un generador de informes, BT (Invoice) Tj 1 0 0 1 0 0 Tm (Total) Tj ET, y quita el 1 0 0 1 0 0 Tm porque sus seis números deletrean la matriz identidad. Renderiza el resultado y "Total" ya no empieza en el origen del espacio de texto. Empieza 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 tras BT, o directamente tras otro Tm identidad

El borrado tienta porque los mismos seis números son realmente peso muerto delante de un cm. Un optimizador de content streams que trate los dos operadores por igual encogerá montones de streams correctamente. Hasta que encuentra 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 es siempre 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; multiplica cualquier matriz por la identidad y recuperas la misma matriz, así que 1 0 0 1 0 0 cm se puede borrar dondequiera que aparezca. Tm es una asignación. Bajo la §9.4.2 fija la matriz de texto y la matriz de línea de texto con sus operandos y tira lo que sostuvieran, así que si cambia algo depende por completo de los operadores delante de él

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

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

PDFlibPas trata de forma distinta 1 0 0 1 0 0 cm y 1 0 0 1 0 0 Tm: cm multiplica por la derecha la CTM y es un no-op en cualquier sitio, mientras que Tm sustituye de plano Tm y Tlm, y cada Tj avanza la Tm el ancho que pintó, así que un Tm identidad tras texto mostrado es un reset genuino
El generador de informes cuenta con ese reset: borrar el Tm identidad pinta Total inmediatamente después de Invoice sobre la misma línea base, y nada falla, registra ni avisa de 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 pasada 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 nada que pudiera haber movido las matrices de texto. El test de "identidad" es numérico: 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 cualifica. Caminando hacia atrás, el escaneo mete cada operador que encuentra en uno de dos grupos:

  • Parar 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 por encima y seguir escaneando: operadores que nunca tocan la matriz de texto ni la de línea de texto, como Tf, Tc, los que fijan color, gs, los operadores de marked-content, Do y cm

Un Tm identidad anterior termina el escaneo en favor del borrado tanto si el optimizador lo está conservando como si ya lo tiene programado para eliminarse. En cualquier caso dejó ambas matrices en la identidad, que es el mismo estado que deja BT. Por eso una racha de tres operadores Tm identidad justo tras BT colapsa a nada

RemoveIdentityMatrices de PDFlibPas camina hacia atrás desde cada Tm identidad: Tf, Tc, los que fijan color, gs y cm se saltan, 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 descartarlo
Un Tm identidad anterior también detiene el escaneo, porque conservado o ya programado para borrarse dejó ambas matrices en la identidad — pase lo que pase, el optimizador nunca mueve un glifo

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. Tras 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 además mira un content stream cada vez. Eso importa para las páginas cuyo /Contents es un array: PDF deja que un objeto de texto empiece 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 incluso cuando la capa anterior lo habría vuelto redundante

Nos parece el lado equivocado correcto. Rastrear matrices a través de fronteras de stream, o simular operadores desconocidos, recuperaría quizá catorce bytes de texto sin comprimir por archivo raro. Equivocarse mueve un glifo en una factura impresa. El coste y el riesgo no están en la misma liga

Un efecto derivado merece conocerse porque cambia lo que ves en la salida. La misma pasada también elimina los 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

Ejecutar el optimizador sobre un fragmento de content stream

El optimizador trabaja sobre el mismo modelo TPDFContentProgram parseado que usarías para editar el texto de página al nivel de instrucción, como en el paseo por el mapeo de carácter a byte de contenido. Eso hace fácil probar la regla sobre una cadena antes de fiarle un documento entero. El helper de abajo parsea un stream decodificado, ejecuta TPDFContentPeepholeOptimizer, y emite el resultado una instrucción por línea. Fijar CanonicalNumbers antes de Parse refleja la pasada de guardado, 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 la pasada de guardado
    if not Prog.Parse(Source) then
      Exit; // daño estructural grave: deja los bytes tranquilos
    Optimizer := TPDFContentPeepholeOptimizer.Create(Prog);
    try
      Optimizer.Run; // devuelve el número de instrucciones eliminadas
    finally
      Optimizer.Free;
    end;
    Result := Prog.Emit; // una instrucción por línea, separadas por #10
  finally
    Prog.Free;
  end;
end;

// Eliminado: Tm directamente tras 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 tras Td, tras Tj, tras un Tm no identidad, o fuera de BT
//   OptimizeSnippet('BT (Invoice) Tj 1 0 0 1 0 0 Tm (Total) Tj ET')

Pasa el stream de factura por él y el Tm identidad sobrevive, porque el escaneo hacia atrás encuentra un Tj mucho antes de llegar al BT. Pon /F1 12 Tf, 2 Tc y 0 g entre el BT y el Tm identidad y aún así se va, porque 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 ante daño grave como una cadena o diccionario sin terminar. Los operadores desconocidos parsean bien y se quedan en el programa, donde actúan como paradas duras para el escaneo

¿Cuándo se ejecuta de verdad el optimizador peephole?

El optimizador corre solo dentro de la pasada de compresión, y solo sobre streams de contenido de página que no estén ya comprimidos con Flate. TPDFlib.SetOptimizeContentStreams(1) es el valor por defecto, y el mismo interruptor aparece como el campo OptimizeContentStreams de TPDFlibSaveOptions; CompressContent y CompressPage lo honran 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 almacenados 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 ejecuta el optimizador 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 optimizador
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 optimizador solo reescribe streams que decodificó antes
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 por las opciones de guardado incluidas; False renuncia
    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;

Deja el valor por defecto activado. Cada transformación de la pasada 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. Apagarlo tiene sentido sobre todo cuando quieres comparar tu propia salida sin comprimir contra lo que escribiste, o cuando necesitas 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 el hueco de tamaño entre un guardado normalizado y uno optimizado es lo que aportaron las reglas peephole. Espera que sea modesto junto a las ganancias mayores descritas en optimización de tamaño de archivos PDF con subsetting de fuentes

Un test que cubre una forma no define la regla

Un test que alimenta BT 1 0 0 1 0 0 Tm (hello) Tj ET a un optimizador y asevera que no queda ningún Tm fija una sola forma: un Tm identidad directamente tras BT se elimina. No dice nada sobre un Tm identidad tras un Td o tras texto mostrado. Leer esa única aserción como "el Tm identidad siempre es eliminable" es un error fácil, y caro, porque la muestra pasa de cualquier forma. Los tests de cualquier regla como esta necesitan las formas conservadas escritas al lado de las eliminables

El helper de abajo cuenta los operadores Tm que sobreviven, y luego comprueba una tabla de entradas. Sustituye ExpectTm por la aserción de tu framework de tests; 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;

// Tu propio helper de comprobación, sugerido aquí; sustitúyelo 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 eliminables
  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 envolvente
  ExpectTm('BT ET 1 0 0 1 0 0 Tm', 1);     // tras ET
end;

Las dos últimas filas parecen tonterías hasta que recuerdas que los arrays /Contents en capas producen exactamente esos fragmentos. Un stream que empieza a mitad de objeto de texto no tiene BT, y un Tm identidad tras ET no pertenece a ningún objeto de texto. Ambos se quedan. El par BT ET vacío de la última fila lo elimina la regla del objeto de texto vacío, razón por la que el recuento comprueba operadores Tm en lugar de comparar cadenas enteras

Lo que la regla renuncia es al Tm identidad ocasional en medio de un objeto de texto, unos bytes por página antes de que Flate los vea siquiera. Lo que compra es una garantía sobre la que descansa el diseño del optimizador: ninguna transformación de la pasada 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 generas o postprocesas contenido PDF en Delphi o C++Builder, la PDF Library for Delphi and C++Builder trae el parser de content streams, esta pasada peephole y las opciones de guardado mostradas arriba, junto a NormalizeContentStreams para producir una línea base limpia y sin optimizar con la que comparar