Articolo tecnico

HotPDF CompressDocument: subset di font compatti in Delphi

Due caratteri cinesi composti in SimSun e passati per un subsetter TrueType ordinario lasciano comunque circa 25 KB di dati font incorporati nel PDF. I contorni di quei due ideogrammi sono una fettina di quello. Il resto è contabilità degli slot: il subset ha conservato la numerazione originale dei glifi, quindi porta ancora una voce di localizzazione e una voce di larghezza per ogni glyph ID fino al più alto che ha trattenuto, e in un font CJK gli ideogrammi stanno in fondo a una tabella molto grande. Rinumerate i sopravvissuti da zero, lasciate che uno stream /CIDToGIDMap traduca, e gli stessi due caratteri stanno in circa 3 KB

Dove finiscono i byte in un subset di font sparso

Un subset sparso resta pesante perché si rifiuta di muovere qualsiasi glifo. HotPDF scrive testo Unicode come font Type 0 sopra un discendente CIDFontType2, e lo stream di contenuto mostra ogni glifo col suo glyph ID originale usato come CID. Con /CIDToGIDMap /Identity, ISO 32000-1 §9.7.4.2 dice al viewer di trattare quel CID direttamente come indice del glifo. Rinumerate i glifi dentro il programma del font e lasciate stare tutto il resto, e ogni carattere sulla pagina punta al contorno sbagliato. Conservare la numerazione è la risposta economica e sicura. Il suo prezzo è che loca e hmtx devono coprire ogni slot fino al GID più alto conservato, vuoto o no

Immaginate un font CJK che dichiara 28.000 glifi e uno dei vostri due caratteri seduto vicino alla fine. Una tabella loca in formato lungo spende 4 byte per slot, circa 112 KB, e i metrici orizzontali completi ne spendono altri 4 per slot. Sono oltre 200 KB di tabelle prima della compressione, quasi tutti zeri e offset ripetuti. Flate stringe molto bene sequenze così, ma non può farle sparire, ed è da lì che viene la maggior parte di quei 25 KB. Un font latino con qualche migliaio di glifi porta la stessa struttura a un decimo della scala, quindi il costo ricade davvero sui documenti che mescolano testo cinese, giapponese o coreano

Quali glifi sopravvivano in partenza (componenti composite, alternate tirate dentro dallo shaping) viene deciso prima, dalle regole di chiusura del subset dei font per i glifi modellati. La compattazione cambia solo ciò che i sopravvissuti costano una volta fissato quel set

Subset di font compatti dietro uno stream CIDToGIDMap

THotPDF.CompactFontSubsetting rinumera i glifi conservati in un intervallo denso che parte da zero, ricostruisce le tabelle dei glifi solo per quei glifi e scrive uno stream /CIDToGIDMap esplicito sul CIDFont. ISO 32000-1 §9.7.4.2 definisce quello stream come un array di glyph ID a due byte big-endian indicizzato per CID: il GID per il CID n sta all'offset di byte 2n. Gli stream di contenuto, l'array di larghezze /W e la CMap ToUnicode conservano tutti i numeri originali come CID. Solo il passo da CID a glifo si sposta nella mappa, quindi nulla di già scritto su una pagina deve essere toccato

La proprietà lavora da sola. Non vi serve il resto della macchina della compressione per avere font più piccoli, e per un report che è per lo più testo CJK questa coppia di impostazioni fa la maggior parte del lavoro:

Pdf.EnableFontSubsetting := True;
Pdf.CompactFontSubsetting := True;   // usabile senza CompressDocument
Pdf.BeginDoc;
Pdf.CurrentPage.SetFont('SimSun', [], 12);
Pdf.CurrentPage.TextOut(40, 40, 0, WideString('Total: '#$4E2D#$6587));
Pdf.EndDoc;
Confronto tra un subset di font HotPDF sparso, che trattiene voci loca e hmtx per ogni glyph ID originale fino al GID trattenuto più alto, e l'output di CompactFontSubsetting che rinumera i glyph conservati densamente da zero e mappa i CID attraverso uno stream CIDToGIDMap mentre content stream, /W e ToUnicode restano invariati
La rinumerazione sposta il costo fuori dal programma del font e in un unico piccolo stream di mappa — due caratteri SimSun scendono da circa 25 KB a circa 3 KB senza toccare un byte di contenuto già scritto

La compattazione si applica a una specifica specie di font. HotPDF costruisce subset compatti per i font Type 0 TrueType: quelli impostati tramite SetFont con EnableFontSubsetting acceso, e il font registrato tramite RegisterUnicodeTTF. Un font TrueType semplice si localizza tramite la cmap dentro il proprio programma del font, e la rinumerazione lascerebbe quella cmap che punta ai glifi sbagliati, quindi i font semplici conservano il subset sparso. Anche i font OpenType-CFF lo conservano. Se la costruzione compatta fallisce per un particolare font, HotPDF scrive il subset sparso per quel font e prosegue con il documento. La proprietà è spenta per default, quindi l'output esistente resta identico byte per byte finché non aderite; sotto PDF/A il font Unicode registrato riceve sempre un subset compatto

Una trappola sta sul lato lettura. Uno stream /CIDToGIDMap sembra appartenga accanto alle CMap, ma è binario grezzo senza blocchi begincidchar, e consegnarlo a un tokenizer di CMap produce una mappatura vuota senza alcun errore. Se i vostri strumenti estraggono testo o misurano glifi da questi file, leggete la mappa come coppie a 16 bit semplici

Che cosa cambia CompressDocument per un solo documento?

THotPDF.CompressDocument prende in prestito sei impostazioni dello scrittore più il tetto degli object stream a BeginDoc e restituisce ognuna a EndDoc. Prima che la versione PDF sia decisa, HotPDF registra i vostri valori e poi imposta:

  • Compression a cmFlateDecode e CompressionLevel a clMaximum
  • EnableFontSubsetting e CompactFontSubsetting a True
  • UseXRefStream e UseObjectStreams a True, per ISO 32000-1 §7.5.7 e §7.5.8
  • Il tetto di oggetti per contenitore a 250 invece dei soliti 100, a meno che non abbiate già impostato il vostro tramite ConfigureAdaptiveObjectStreamPacking

Gli object stream vogliono PDF 1.5, quindi una Version più vecchia viene alzata a 1.5 quando la versione non è bloccata. PDF/A-1 vieta direttamente cross-reference e object stream, quindi un documento PDF/A-1 conserva la sua tabella dei riferimenti incrociati classica e riceve solo il lavoro Flate e font. Le immagini vengono scritte esattamente come le avete incorporate; nulla viene ricampionato o ricompresso con perdita

Diagramma del ciclo di vita di HotPDF CompressDocument in Delphi: BeginDoc registra i valori propri dello scrittore, sovrascrive sei impostazioni tra cui Compression e UseObjectStreams per un solo documento, e EndDoc ripristina ogni valore preso in prestito nel suo finally più esterno mentre la proprietà CompressDocument stessa resta True
Sei impostazioni dello scrittore e il tetto degli object stream sono presi in prestito per esattamente un documento e restituiti quando EndDoc gira, così un report fallito non lascia mai il componente bloccato alla compressione massima
var
  Pdf: THotPDF;
begin
  Pdf := THotPDF.Create(nil);
  try
    Pdf.AutoLaunch := False;
    Pdf.FileName := 'invoice-2026-1042.pdf';
    Pdf.CompressDocument := True;    // applicata da BeginDoc, annullata da 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;

Il ripristino gira nel finally più esterno di EndDoc. Conta per un componente che vive in un data module e scrive centinaia di report al giorno: un'eccezione a metà di un report non lascia il job successivo girare alla compressione massima con il subsetting forzato. La proprietà CompressDocument in sé resta True, così il documento successivo riceve lo stesso trattamento, e solo le impostazioni prese in prestito tornano indietro

La versione riceve una gestione più attenta. HotPDF annulla la propria alzata a 1.5 solo se il documento finisce comunque a 1.5. Quando un'altra funzionalità spinta dal percorso porta il file più su durante l'esecuzione (un font OpenType incorporato che richiede 1.6, per dire), la versione più alta resta, che è esattamente il risultato che avreste avuto senza compressione. Per un componente a lunga vita questa è una struttura più sicura che impostare le sei proprietà a mano una volta all'avvio, perché i valori scritti a mano restano per ogni job successivo, inclusi quelli modificabili

Tagliare sintassi, offset e impacchettamento degli object stream

Una volta che font e stream sono piccoli, i dizionari e i dati dei riferimenti incrociati diventano il costo rimanente più grande, e lo scrittore di object stream usato da CompressDocument taglia anche quelli. Il formato del contenitore in sé è coperto nella guida a object stream e aggiornamenti incrementali. Sopra di essa, il percorso di compressione aggiunge quattro raffinamenti:

  • Sintassi compatta per ISO 32000-1 §7.2.2: uno spazio viene scritto solo dove due token altrimenti girerebbero insieme come caratteri regolari, così /Type /Page diventa /Type/Page
  • I campi dello stream cross-reference usano qualsiasi larghezza §7.5.8.2 permetta, così un file sotto 16 MB conserva ogni offset in 3 byte invece di 4
  • Fino a 250 oggetti finiscono in ogni object stream; contenitori meno numerosi e più grandi danno a Flate più ripetizione su cui lavorare
  • In un file non cifrato il Catalog e il dizionario Info vengono impacchettati negli object stream, mentre l'output cifrato li tiene al livello superiore

La sintassi compatta urta contro qualsiasi cosa patchi un file cercando nel suo testo. La firma è il caso ovvio. Il valore della firma viene riempito dopo che il file è scritto, localizzando i segnaposto letterali /ByteRange ( e /Contents < nei byte di output. Scritti in modo compatto diventano /ByteRange( e /Contents<, e una ricerca letterale non li trova mai. HotPDF quindi scrive i dizionari di firma (Type Sig o DocTimeStamp, o FT Sig) e il dizionario di cifratura con il layout spaziato. Qualsiasi vostro script post-salvataggio che fa grep di /Type /Page o token simili spaziati ha bisogno di un pattern che tolleri lo spazio mancante

Puoi comprimere un PDF già caricato?

Sì. L'overload con opzioni CompressLoadedDocument(Options, AInfo) esegue gli stessi passi lossless su un file esistente. Con THPDFLoadedDocumentCompressionOptions.Default rimuove le risorse di pagina inutilizzate, fonde font e form XObject identici, crea subset dei font incorporati con subset compatti accesi, ricomprime con Flate gli stream non filtrati, Flate, LZW, ASCII85, ASCIIHex e RunLength ogni volta che il risultato è più piccolo, e commuta il prossimo salvataggio sugli object stream. HighRatioFlate è spento per default, e gli object stream vengono saltati per PDF/A-1 e per i salvataggi incrementali. L'overload CompressLoadedDocument senza parametri è la chiamata più stretta: comprime con Flate solo gli stream conservati non compressi

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 se perdere le firme è accettabile
    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;

I file firmati vengono trattati come una decisione unica. Ogni passo riscrive byte che una firma copre, quindi un documento con campi di firma viene rifiutato nel suo insieme: la chiamata restituisce 0, imposta RefusedBySignaturePolicy e non cambia nulla. Impostare AllowSignatureInvalidation lascia proseguire il lavoro, e Info.SignaturesInvalidated registra allora che le firme non verificano più. Lasciate quell'opzione spenta nei job in batch. Una cartella di contratti compressa durante la notte è un posto poor per scoprire che metà portava firme

Flusso di HotPDF CompressLoadedDocument in Delphi: la chiamata rimuove le risorse di pagina inutilizzate, fonde font e form identici, crea subset dei font incorporati con subset compatti, ricomprime gli stream con Flate solo quando il risultato è più piccolo, e accende gli object stream per il prossimo salvataggio, mentre i campi di firma scatenano RefusedBySignaturePolicy e lasciano il file intoccato
Ogni passo riscrive byte che una firma copre, quindi l'intero documento viene rifiutato a meno che tu non autorizzi esplicitamente l'invalidazione — Info.BytesSaved poi somma solo il lavoro su risorse, font e stream

La compattazione sul percorso loaded è più severa che sul percorso di creazione, per una ragione che viene dritta dal formato del file. Quando i font vengono sottoposti a subset, il decoder ha già trasformato ogni CID in un GID attraverso qualsiasi /CIDToGIDMap il file portasse, ma una nuova mappa compatta deve essere indicizzata per CID. Le due coincidono solo quando CID è uguale a GID. HotPDF quindi compatta un programma del font solo quando ogni font che lo usa è un CIDFontType2 con /CIDToGIDMap Identity. I programmi che hanno già uno stream di mappa, i font TrueType semplici e i font con /CIDSet ricevono il subset sparso. Così i font con tabelle di glifi a colori (COLR, sbix, CBDT o SVG), perché la ricostruzione compatta conserva solo le tabelle dei contorni e butta i livelli colore

Leggete Info.BytesSaved per ciò che è. Somma i passi risorse, font e stream, mentre il guadagno degli object stream appare solo quando SaveLoadedDocument scrive il file, quindi confrontate le dimensioni dei file su disco per la cifra completa

Copie finali contro documenti che cambiano ancora

I guadagni seguono quanto di un file è struttura non compressa e dati font sovradimensionati, e il numero di pagine c'entra poco. Per un documento di tre pagine di testo misto inglese e cinese in Arial e SimSun con entrambi i font completamente incorporati, il file non compresso corre sui 10 MB; generato con CompressDocument arriva a circa 20 KB, la maggior parte del calo dal subsetting dei font, e CompressLoadedDocument atterra nello stesso intervallo per l'originale non compresso. Un PDF già compatto si muove appena. I file carichi di foto guadagnano poco, perché nessuno dei due percorsi tocca i dati immagine

Il costo è la modificabilità. Un font subset può mostrare solo i caratteri che il documento usa già, quindi un AcroForm che qualcuno compila dopo, o una modifica incrementale che aggiunge nuovo testo nello stesso font, può beccare glifi mancanti. Gli object stream impacchettati smettono anche di essere leggibili in un editor di testo, il che rallenta qualsiasi sessione di debugging che comincia aprendo il PDF in Notepad. Accendete CompressDocument per le copie finali: fatture archiviate, estratti conto, qualsiasi cosa generata una volta e poi solo letta. Per i template e i moduli che qualcuno a valle compilerà, lasciatelo spento e conservate i font completi

Se generate gli stessi report CJK ogni notte, abbinate i subset compatti alla cache persistente dei subset dei font su disco così il lavoro di subsetting non viene rifatto a ogni giro. E quando confrontate due output notturni, diffateli per contenuto degli oggetti. Un campo cambiato ri-Flate il suo intero object stream, quindi un diff a byte mostra molto più cambiamento di quello realmente avvenuto

Dettagli di proprietà, record e opzioni per tutto quanto sopra sono nel riferimento sulla pagina del prodotto del componente PDF HotPDF per Delphi