Artículo técnico

CompressDocument de HotPDF: subsets compactos en Delphi

Dos caracteres chinos compuestos en SimSun y pasados por un subsetter TrueType ordinario todavía dejan unos 25 KB de data de fuente incrustada en el PDF. Los contornos de esos dos ideografías son una fracción de eso. El resto es contabilidad de slots: el subset conservó la numeración original de glyphs, así que todavía lleva una entrada de localización y una entrada de ancho por cada glyph ID hasta el más alto que retuvo, y en una cara CJK los ideografías viven hondo en una tabla muy grande. Renumere los sobrevivientes desde cero, deje que un stream /CIDToGIDMap traduzca, y los mismos dos caracteres caben en unos 3 KB

A dónde van los bytes en un subset de fuente disperso

Un subset disperso se queda pesado porque se niega a mover ningún glyph. HotPDF escribe texto Unicode como una fuente Type 0 sobre un descendiente CIDFontType2, y el content stream muestra cada glyph por su glyph ID original usado como CID. Con /CIDToGIDMap /Identity, el ISO 32000-1 §9.7.4.2 le dice al visor que trate ese CID directamente como el índice de glyph. Renumere los glyphs dentro del programa de fuente y deje todo lo demás tranquilo, y cada carácter de la página apunta al contorno equivocado. Conservar la numeración es la respuesta barata y segura. Su precio es que loca y hmtx deben cubrir cada slot hasta el GID más alto conservado, vacío o no

Suponga que una cara CJK declara 28,000 glyphs y uno de sus dos caracteres queda cerca del final. Una tabla loca de formato largo gasta 4 bytes por slot, unos 112 KB, y las métricas horizontales completas gastan otros 4 bytes por slot. Eso es más de 200 KB de tablas antes de comprimir, casi todo ceros y offsets repetidos. Flate encoge rachas así muy bien, pero no puede hacerlas desaparecer, que es de donde viene la mayor parte de esos 25 KB. Una cara latina con unos miles de glyphs lleva la misma estructura a una décima de la escala, así que el costo realmente cae sobre los documentos que mezclan texto chino, japonés o coreano

Qué glyphs sobreviven en primer lugar (componentes compuestos, alternates que el shaping metió) se decide antes, por las reglas de cierre de subsets de fuentes para glyphs con shaping. La compactación solo cambia cuánto cuestan los sobrevivientes una vez que ese conjunto queda fijo

Subsets de fuentes compactos detrás de un stream CIDToGIDMap

THotPDF.CompactFontSubsetting renumera los glyphs conservados en un rango denso que arranca en cero, reconstruye las tablas de glyphs solo para esos glyphs, y escribe un stream /CIDToGIDMap explícito sobre el CIDFont. El ISO 32000-1 §9.7.4.2 define ese stream como un arreglo de glyph IDs de dos bytes, big-endian, indexado por CID: el GID para el CID n está en el offset de byte 2n. Los content streams, el arreglo de anchos /W y la CMap de ToUnicode conservan todos los números originales como CIDs. Solo el paso de CID a glyph se muda al mapa, así que nada de lo ya escrito a una página tiene que tocarse

La propiedad funciona por sí sola. No necesita el resto de la maquinaria de compresión para obtener fuentes más chicas, y para un reporte que es mayormente texto CJK este par de configuraciones hace la mayor parte del trabajo:

Pdf.EnableFontSubsetting := True;
Pdf.CompactFontSubsetting := True;   // usable sin CompressDocument
Pdf.BeginDoc;
Pdf.CurrentPage.SetFont('SimSun', [], 12);
Pdf.CurrentPage.TextOut(40, 40, 0, WideString('Total: '#$4E2D#$6587));
Pdf.EndDoc;
Comparación entre un subset de fuentes disperso de HotPDF, que retiene entradas loca y hmtx por cada glyph ID original hasta el GID retenido más alto, y la salida de CompactFontSubsetting que renumera los glyphs conservados de forma densa desde cero y mapea los CIDs mediante un stream CIDToGIDMap mientras los content streams, /W y ToUnicode quedan sin cambios
La renumeración saca el costo del programa de la fuente y lo mete en un pequeño stream de mapa — dos caracteres SimSun bajaron de 24.8 KB a 3.1 KB sin tocar un byte del contenido ya escrito

La compactación aplica a un tipo específico de fuente. HotPDF construye subsets compactos para caras TrueType Type 0: las que se configuran mediante SetFont con EnableFontSubsetting activado, y la cara registrada mediante RegisterUnicodeTTF. Una fuente TrueType simple se localiza a través del cmap dentro de su propio programa de fuente, y la renumeración dejaría ese cmap apuntando a los glyphs equivocados, así que las fuentes simples conservan el subset disperso. Las caras OpenType-CFF también lo conservan. Si la construcción compacta falla para una fuente en particular, HotPDF escribe el subset disperso para esa fuente y sigue con el documento. La propiedad viene apagada de fábrica, así que la salida existente queda idéntica byte a byte hasta que usted opte por entrar; bajo PDF/A la cara Unicode registrada siempre recibe un subset compacto

Una trampa queda del lado de la lectura. Un stream /CIDToGIDMap parece que pertenece junto a las CMaps, pero es binario crudo sin bloques begincidchar, y entregarlo a un tokenizer de CMap produce un mapeo vacío sin error alguno. Si su propia tooling extrae texto o mide glyphs de estos archivos, lea el mapa como pares de 16 bits planos

¿Qué cambia CompressDocument para un documento?

THotPDF.CompressDocument pide prestadas seis configuraciones del escritor más el tope de object streams en BeginDoc y devuelve cada una en EndDoc. Antes de que la versión del PDF quede decidida, HotPDF anota sus valores y luego configura:

  • Compression en cmFlateDecode y CompressionLevel en clMaximum
  • EnableFontSubsetting y CompactFontSubsetting en True
  • UseXRefStream y UseObjectStreams en True, según ISO 32000-1 §7.5.7 y §7.5.8
  • El tope de objetos por contenedor en 250 en lugar de los 100 de siempre, salvo que usted ya haya configurado el suyo mediante ConfigureAdaptiveObjectStreamPacking

Los object streams necesitan PDF 1.5, así que una Version más vieja se sube a 1.5 cuando la versión no está bloqueada. PDF/A-1 prohíbe sin más los cross-reference streams y los object streams, así que un documento PDF/A-1 conserva su tabla de cross-reference clásica y recibe solo el trabajo de Flate y de fuentes. Las imágenes se escriben exactamente como usted las incrustó; nada se remuestrea ni se recomprime con pérdida

Diagrama del ciclo de vida de CompressDocument de HotPDF en Delphi: BeginDoc anota los valores propios del escritor, sobrescribe seis settings incluidos Compression y UseObjectStreams para un solo documento, y EndDoc devuelve cada valor prestado en su finally más externo mientras la propiedad CompressDocument sigue en True
Seis settings del escritor y el tope de object streams se piden prestados por exactamente un documento y se devuelven cuando EndDoc corre, así que un reporte fallido nunca deja al componente atascado en compresión máxima
var
  Pdf: THotPDF;
begin
  Pdf := THotPDF.Create(nil);
  try
    Pdf.AutoLaunch := False;
    Pdf.FileName := 'invoice-2026-1042.pdf';
    Pdf.CompressDocument := True;    // lo aplica BeginDoc, lo deshace EndDoc
    Pdf.BeginDoc;
    Pdf.CurrentPage.SetFont('Arial', [], 12);
    Pdf.CurrentPage.TextOut(40, 40, 0, 'Invoice 2026-1042');
    Pdf.CurrentPage.SetFont('SimSun', [], 12);
    Pdf.CurrentPage.TextOut(40, 60, 0, WideString(#$5408#$8BA1));
    Pdf.EndDoc;
  finally
    Pdf.Free;
  end;
end;

La restauración corre en el finally más externo de EndDoc. Eso importa para un componente que vive en un data module y escribe cientos de reportes al día: una excepción a mitad de un reporte no deja el siguiente trabajo corriendo a compresión máxima con el subsetting forzado. La propiedad CompressDocument en sí se queda True, así que el siguiente documento recibe el mismo tratamiento, y solo las configuraciones prestadas regresan

La versión recibe un manejo más cuidadoso. HotPDF deshace su propia subida a 1.5 solo si el documento sigue terminando en 1.5. Cuando otra característica empuja el archivo más alto durante la corrida (una fuente OpenType incrustada que necesita 1.6, digamos), la versión más alta se queda, que es exactamente el resultado que usted obtendría sin compresión. Para un componente de larga vida este es un diseño más seguro que configurar las seis propiedades a mano una vez al arrancar, porque los valores puestos a mano se quedan para cada trabajo posterior, incluidos los editables

Recortar sintaxis, offsets y empaquetado de object streams

Cuando las fuentes y los streams ya son chicos, los diccionarios y la data de cross-reference pasan a ser el mayor costo restante, y el escritor de object streams que usa CompressDocument también los recorta. El formato del contenedor en sí está cubierto en la guía de object streams y actualizaciones incrementales. Encima de eso, el camino de compresión agrega cuatro refinamientos:

  • Sintaxis compacta según ISO 32000-1 §7.2.2: un espacio se escribe solo donde dos tokens de otro modo quedarían pegados como caracteres regulares, así que /Type /Page se vuelve /Type/Page
  • Los campos del cross-reference stream usan cualquier ancho que §7.5.8.2 permita, así que un archivo de menos de 16 MB guarda cada offset en 3 bytes en lugar de 4
  • Hasta 250 objetos entran en cada object stream; contenedores menos numerosos y más grandes le dan a Flate más repetición con que trabajar
  • En un archivo sin encriptar el Catalog y el diccionario Info también se empaquetan en object streams, mientras que la salida encriptada los deja en el nivel superior

La sintaxis compacta choca con cualquier cosa que parche un archivo buscando en su texto. Firmar es el caso obvio. El valor de la firma se rellena después de que el archivo se escribe, localizando los placeholders literales /ByteRange ( y /Contents < en los bytes de salida. Escritos compactos, esos se vuelven /ByteRange( y /Contents<, y una búsqueda literal nunca los encuentra. HotPDF por eso escribe los diccionarios de firma (Type Sig o DocTimeStamp, o FT Sig) y el diccionario de encriptación con el layout con espacios. Cualquier script post-guardado suyo que grepee /Type /Page o tokens con espacios similares necesita un patrón que tolere el espacio faltante

¿Se puede comprimir un PDF que ya está cargado?

Sí. La sobrecarga con opciones CompressLoadedDocument(Options, AInfo) corre los mismos pasos sin pérdida sobre un archivo existente. Con THPDFLoadedDocumentCompressionOptions.Default remueve recursos de página sin uso, fusiona fuentes y form XObjects idénticos, hace subsetting de las fuentes incrustadas con subsets compactos activados, recomprime streams sin filtrar, Flate, LZW, ASCII85, ASCIIHex y RunLength con Flate siempre que el resultado sea más chico, y cambia el próximo guardado a object streams. HighRatioFlate viene apagado por defecto, y los object streams se saltan para PDF/A-1 y para guardados incrementales. La sobrecarga de CompressLoadedDocument sin parámetros es la llamada más angosta: solo comprime con Flate los streams almacenados sin comprimir

var
  Doc: THotPDF;
  Options: THPDFLoadedDocumentCompressionOptions;
  Info: THPDFLoadedDocumentCompressionInfo;
begin
  Doc := THotPDF.Create(nil);
  try
    Doc.AutoLaunch := False;
    Doc.LoadFromFile('quarterly-report.pdf');
    Options := THPDFLoadedDocumentCompressionOptions.Default;
    // Options.AllowSignatureInvalidation := True;  // solo si perder las firmas es aceptable
    Doc.CompressLoadedDocument(Options, Info);
    if Info.RefusedBySignaturePolicy then
      Writeln(Format('Left untouched: %d signature fields', [Info.SignatureCount]))
    else
    begin
      Writeln(Format('Compact fonts: %d, bytes saved before object streams: %d',
        [Info.Fonts.CompactSubsetFontCount, Info.BytesSaved]));
      Doc.SaveLoadedDocument('quarterly-report-compact.pdf');
    end;
  finally
    Doc.Free;
  end;
end;

Los archivos firmados se manejan como una sola decisión. Cada paso reescribe bytes que una firma cubre, así que un documento con campos de firma se rechaza como un todo: la llamada devuelve 0, pone RefusedBySignaturePolicy y no cambia nada. Poner AllowSignatureInvalidation deja que el trabajo siga adelante, y Info.SignaturesInvalidated entonces registra que las firmas ya no verifican. Deje esa opción apagada en trabajos por lotes. Una carpeta de contratos comprimida durante la noche es un mal lugar para descubrir que la mitad llevaba firmas

Flujo de CompressLoadedDocument de HotPDF en Delphi: la llamada remueve recursos de página sin uso, fusiona fuentes y forms idénticos, hace subsetting de las fuentes embebidas con subsets compactos, recomprime streams con Flate solo cuando el resultado es más chico, y enciende los object streams para el próximo guardado, mientras que los campos de firma disparan RefusedBySignaturePolicy y dejan el archivo intacto
Cada paso reescribe bytes que una firma cubre, así que el documento entero se rechaza salvo que usted permita explícitamente la invalidación — Info.BytesSaved entonces suma solo el trabajo de recursos, fuentes y streams

La compactación en el camino de cargados es más estricta que en el camino de creación, por una razón que viene directo del formato de archivo. Para cuando las fuentes se subsetean, el decodificador ya convirtió cada CID en un GID a través del /CIDToGIDMap que el archivo llevara, pero un nuevo mapa compacto tiene que indexarse por CID. Los dos solo se alinean cuando CID iguala a GID. HotPDF por eso compacta un programa de fuente solo cuando cada fuente que lo usa es una CIDFontType2 con /CIDToGIDMap Identity. Los programas que ya tienen un stream de mapa, las fuentes TrueType simples y las fuentes con /CIDSet reciben el subset disperso. También las caras con tablas de glyphs de color (COLR, sbix, CBDT o SVG), porque la reconstrucción compacta conserva solo tablas de contornos y soltaría las capas de color

Lea Info.BytesSaved por lo que es. Suma los pasos de recursos, fuentes y streams, mientras que la ganancia de object streams aparece solo cuando SaveLoadedDocument escribe el archivo, así que compare tamaños de archivo en disco para la cifra completa

Copias finales contra documentos que todavía cambian

Las ganancias siguen cuánto del archivo es estructura sin comprimir y data de fuente sobredimensionada, y el conteo de páginas tiene poco que ver. Para un documento de tres páginas de texto mixto inglés y chino en Arial y SimSun con ambas fuentes completamente incrustadas, el archivo sin comprimir corre unos 10 MB; generado con CompressDocument llega a unos 20 KB, la mayor parte del descuento por el subsetting de fuentes, y CompressLoadedDocument aterriza en el mismo rango para el original sin comprimir. Un PDF que ya es compacto apenas se mueve. Los archivos cargados de fotos ganan poco, porque ninguno de los dos caminos toca la data de imágenes

El costo es la editabilidad. Una fuente subset solo puede mostrar los caracteres que el documento ya usa, así que un AcroForm que alguien llena después, o una edición incremental que agrega texto nuevo en la misma fuente, puede toparse con glyphs faltantes. Los object streams empaquetados también dejan de ser legibles en un editor de texto, lo que frena cualquier sesión de depuración que arranque abriendo el PDF en Notepad. Active CompressDocument para copias finales: facturas archivadas, estados de cuenta, cualquier cosa que se genera una vez y solo se lee después. Para plantillas y formularios que alguien aguas abajo va a llenar, déjelo apagado y conserve las fuentes completas

Si genera los mismos reportes CJK cada noche, empareje los subsets compactos con la caché de subsets de fuentes persistente en disco para que el trabajo de subsetting no se rehaga en cada corrida. Y cuando compare dos salidas nocturnas, haga diff por contenido de objeto. Un campo cambiado re-Flatea su object stream entero, así que un diff de bytes muestra mucho más cambio del que realmente sucedió

Los detalles de propiedades, records y opciones de todo lo anterior están en la referencia de la página de producto del HotPDF Delphi PDF component