Technisch artikel

HotPDF CompressDocument: compacte font subsets in Delphi

Twee Chinese tekens gezet in SimSun en door een gewone TrueType-subsetter gehaald laten nog steeds zo'n 25 KB aan ingebedde fontdata in de PDF achter. De contouren van die twee ideogrammen zijn een splinter daarvan. De rest is slotboekhouding: de subset hield de originele glyphnummering aan, dus hij draagt nog steeds een locatie-entry en een breedte-entry voor elke glyph-ID tot aan de hoogste die hij behield, en in een CJK-lettertype zitten de ideogrammen diep in een zeer grote tabel. Nummer de overlevenden vanaf nul, laat een /CIDToGIDMap-stream vertalen, en dezelfde twee tekens passen in ongeveer 3 KB

Waar de bytes gaan in een ijle fontsubset

Een ijle subset blijft zwaar omdat hij weigert een glyph te verplaatsen. HotPDF schrijft Unicode-tekst als een Type 0 font boven een CIDFontType2-nakomeling, en de content stream toont elke glyph bij zijn originele glyph-ID gebruikt als CID. Met /CIDToGIDMap /Identity zegt ISO 32000-1 §9.7.4.2 tegen de viewer om die CID rechtstreeks als glyphindex te behandelen. Nummer de glyphs in het fontprogramma opnieuw en laat alles andere met rust, en elk teken op de pagina wijst naar de verkeerde contour. De nummering houden is het goedkope, veilige antwoord. Zijn prijs is dat loca en hmtx elk slot tot aan de hoogste behouden GID moeten dekken, leeg of niet

Stel dat een CJK-lettertype 28.000 glyphs aangeeft en één van uw twee tekens bij het einde zit. Een loca-tabel in lang formaat spendeert 4 bytes per slot, ruwweg 112 KB, en volledige horizontale metrics spendeert nog eens 4 bytes per slot. Dat is ruim 200 KB aan tabellen vóór compressie, bijna alles nullen en herhaalde offsets. Flate krimpt zulke reeksen heel goed, maar kan ze niet laten verdwijnen, en daar komt het merendeel van die 25 KB vandaan. Een Latijns lettertype met een paar duizend glyphs draagt dezelfde structuur op een tiende van de schaal, dus de kost landt echt op documenten die Chinees, Japans of Koreaans mengen

Welke glyphs in de eerste plaats overleven (composietcomponenten, alternatieven die shaping binnenhaalt) wordt eerder beslist, door de font subset closure-regels voor gevormde glyphs. Compactering verandert alleen wat de overlevenden kosten zodra die set vastligt

Compacte font subsets achter een CIDToGIDMap-stream

THotPDF.CompactFontSubsetting nummert de behouden glyphs om in een dicht bereik vanaf nul, herbouwt de glyph-tabellen voor alleen die glyphs en schrijft een expliciete /CIDToGIDMap-stream op de CIDFont. ISO 32000-1 §9.7.4.2 definieert die stream als een array van tweebige, big-endian glyph-IDs geïndexeerd op CID: de GID voor CID n zit op byte-offset 2n. Content streams, de /W-breedtearray en de ToUnicode-CMap houden allemaal de originele nummers als CID aan. Alleen de stap van CID naar glyph verschuift naar de map, dus niets dat al op een pagina staat geschreven hoeft te worden aangeraakt

De property werkt op zichzelf. U hebt de rest van de compressiemachine niet nodig om kleinere fonts te krijgen, en voor een rapport dat vooral CJK-tekst is doet dit stelletje instellingen het meeste werk:

Pdf.EnableFontSubsetting := True;
Pdf.CompactFontSubsetting := True;   // bruikbaar zonder CompressDocument
Pdf.BeginDoc;
Pdf.CurrentPage.SetFont('SimSun', [], 12);
Pdf.CurrentPage.TextOut(40, 40, 0, WideString('Total: '#$4E2D#$6587));
Pdf.EndDoc;
Vergelijking van een ijle HotPDF fontsubset, die loca- en hmtx-entries voor elke originele glyph-ID tot aan de hoogste behouden GID vasthoudt, tegen CompactFontSubsetting-uitvoer die behouden glyphs dicht vanaf nul hernummert en CIDs via een CIDToGIDMap-stream mapt terwijl content streams, /W en ToUnicode ongewijzigd blijven
Hernummeren verplaatst de kost uit het fontprogramma naar één kleine mapstream — twee SimSun-tekens dalen van zo'n 25 KB naar zo'n 3 KB zonder ook maar één byte van al geschreven inhoud aan te raken

Compactering geldt voor een specifieke soort font. HotPDF bouwt compacte subsets voor Type 0 TrueType-letters: die via SetFont worden gezet terwijl EnableFontSubsetting aan staat, en het via RegisterUnicodeTTF geregistreerde lettertype. Een simpel TrueType-font wordt via de cmap in zijn eigen fontprogramma gelokaliseerd, en hernummeren zou die cmap naar de verkeerde glyphs laten wijzen, dus simpele fonts houden de ijle subset. OpenType-CFF-letters houden hem ook. Faalt de compacte bouw voor een bepaald font, dan schrijft HotPDF voor dat font de ijle subset en gaat met het document verder. De property staat standaard uit, dus bestaande uitvoer blijft byte-identiek totdat u zich aanmeldt; onder PDF/A krijgt de geregistreerde Unicode-letter altijd een compacte subset

Eén valkuil zit aan de leeskant. Een /CIDToGIDMap-stream lijkt naast de CMaps te horen, maar hij is kale binary zonder begincidchar-blokken, en hem aan een CMap-tokenizer geven levert een lege mapping op zonder enige fout. Als uw eigen tooling tekst extraheert of glyphs meet uit deze bestanden, lees de map dan als gewone 16-bit paren

Wat verandert CompressDocument voor één document?

THotPDF.CompressDocument leent zes writersinstellingen plus de object-stream-cap bij BeginDoc en geeft elk ervan bij EndDoc terug. Voordat de PDF-versie vastligt, neemt HotPDF uw waarden op en zet dan:

  • Compression op cmFlateDecode en CompressionLevel op clMaximum
  • EnableFontSubsetting en CompactFontSubsetting op True
  • UseXRefStream en UseObjectStreams op True, volgens ISO 32000-1 §7.5.7 en §7.5.8
  • De cap voor objecten per container op 250 in plaats van de gebruikelijke 100, tenzij u al uw eigen waarde via ConfigureAdaptiveObjectStreamPacking zette

Object streams willen PDF 1.5, dus een oudere Version wordt verhoogd naar 1.5 als de versie niet is vergrendeld. PDF/A-1 verbiedt cross-reference- en object streams ronduit, dus een PDF/A-1-document houdt zijn klassieke cross-reference-tabel en krijgt alleen het Flate- en fontwerk. Beelden worden precies zo geschreven als u ze insloot; niets wordt geresampled of met verlies hercomprimeerd

Diagram van de HotPDF CompressDocument-levenscyclus in Delphi: BeginDoc neemt de eigen waarden van de writer op, overrulet zes instellingen waaronder Compression en UseObjectStreams voor één document, en EndDoc zet elke geleende waarde terug in zijn buitenste finally terwijl de property CompressDocument zelf True blijft
Zes writer-instellingen en de object-stream-cap worden geleend voor precies één document en teruggegeven zodra EndDoc draait, zodat een mislukte rapport het component nooit achterlaat vastgezet op maximale compressie
var
  Pdf: THotPDF;
begin
  Pdf := THotPDF.Create(nil);
  try
    Pdf.AutoLaunch := False;
    Pdf.FileName := 'invoice-2026-1042.pdf';
    Pdf.CompressDocument := True;    // toegepast door BeginDoc, teruggedraaid door 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;

De terugzet draait in de buitenste finally van EndDoc. Dat telt voor een component die in een data module woont en dagelijks honderden rapporten schrijft: een exception halverwege één rapport laat de volgende job niet draaien op maximale compressie met subsetting geforceerd aan. De property CompressDocument zelf blijft True, dus het volgende document krijgt dezelfde behandeling, en alleen de geleende instellingen gaan terug

De versie krijgt zorgvuldigere afhandeling. HotPDF draait zijn eigen verhoging naar 1.5 alleen terug als het document nog steeds op 1.5 eindigt. Duwt een andere functie het bestand tijdens de run hoger (een ingebed OpenType-font dat 1.6 nodig heeft bijvoorbeeld), dan blijft de hogere versie staan, precies het resultaat dat u zonder compressie kreeg. Voor een langlevend component is dat een veiliger ontwerp dan de zes properties eenmaal bij de opstart met de hand te zetten, want met de hand gezette waarden blijven voor elke latere job hangen, ook de instelbare

Syntax, offsets en object-stream-packing bijslijpen

Zodra fonts en streams klein zijn, worden de dictionaries en de cross-reference-data de grootste resterende post, en de object-stream-schrijver die CompressDocument gebruikt snoeit ook die. Het containerformaat zelf wordt behandeld in de gids over object streams en incrementele updates. Daarbovenop voegt het compressiepad vier verfijningen toe:

  • Compacte syntax per ISO 32000-1 §7.2.2: een spatie wordt alleen geschreven waar twee tokens anders als gewone tekens aan elkaar zouden plakken, dus /Type /Page wordt /Type/Page
  • Cross-reference-streamvelden gebruiken elke breedte die §7.5.8.2 toestaat, dus een bestand onder 16 MB slaat elke offset in 3 bytes op in plaats van 4
  • Tot 250 objecten gaan in elke object stream; minder, grotere containers geven Flate meer herhaling om mee te werken
  • In een onversleuteld bestand gaan de Catalog en het Info-dictionary ook in object streams, terwijl versleutelde uitvoer ze op het topniveau houdt

Compacte syntax botst met alles dat een bestand patcht door in zijn tekst te zoeken. Ondertekenen is de voor de hand liggende zaak. De handtekeningwaarde wordt pas ingevuld nadat het bestand is geschreven, door de letterlijke placeholders /ByteRange ( en /Contents < in de uitvoerbytes op te sporen. Compact gespeld worden ze /ByteRange( en /Contents<, en een letterlijke zoekactie vindt ze nooit. HotPDF schrijft handtekeningdictionaries (Type Sig of DocTimeStamp, of FT Sig) en het versleutelingsdictionary daarom met de gespatieerde opmaak. Elk eigen post-save-script dat op /Type /Page of vergelijkbare gespatieerde tokens zoekt, heeft een patroon nodig dat de ontbrekende spatie tolereert

Kunt u een PDF comprimeren die al geladen is?

Ja. De options-overload CompressLoadedDocument(Options, AInfo) draait dezelfde verliesloze stappen op een bestaand bestand. Met THPDFLoadedDocumentCompressionOptions.Default verwijdert hij ongebruikte paginabronnen, voegt hij identieke fonts en form XObjects samen, subset hij ingebedde fonts met compacte subsets aan, hercomprimeert hij ongefilterde, Flate-, LZW-, ASCII85-, ASCIIHex- en RunLength-streams met Flate zodra het resultaat kleiner is, en zet hij de volgende opslag op object streams. HighRatioFlate staat standaard uit, en object streams worden overgeslagen voor PDF/A-1 en bij incrementele opslagen. De parameterloze overload CompressLoadedDocument is de smallere aanroep: hij Flate-comprimeert alleen streams die ongecomprimeerd zijn opgeslagen

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;  // alleen als het verlies van handtekeningen acceptabel is
    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;

Ondertekende bestanden worden als één beslissing behandeld. Elke stap herschrijft bytes die een handtekening dekt, dus een document met handtekeningvelden wordt als geheel geweigerd: de aanroep geeft 0 terug, zet RefusedBySignaturePolicy en verandert niets. AllowSignatureInvalidation zetten laat het werk doorgaan, en Info.SignaturesInvalidated registreert dan dat de handtekeningen niet langer verifiëren. Laat die optie uit in batchjobs. Een map met contracten die 's nachts wordt gecomprimeerd is een slechte plek om te ontdekken dat de helft handtekeningen droeg

Stroom van HotPDF CompressLoadedDocument in Delphi: de aanroep verwijdert ongebruikte paginabronnen, voegt identieke fonts en formulieren samen, subset ingesloten fonts met compacte subsets, hercomprimeert streams met Flate alleen als het resultaat kleiner is, en zet object streams aan voor de volgende save, terwijl handtekeningvelden RefusedBySignaturePolicy activeren en het bestand onaangeroerd laten
Elke stap herschrijft bytes die een handtekening dekt, dus het hele document wordt geweigerd tenzij u invalidatie expliciet toestaat — Info.BytesSaved somt daarna alleen de resource-, font- en streamwerk op

Compactering op het ladepad is strenger dan op het creatiepad, om een reden die rechtstreeks uit het bestandsformaat komt. Tegen de tijd dat fonts worden gesubset heeft de decoder elke CID al in een GID omgezet via welke /CIDToGIDMap het bestand ook droeg, maar een nieuwe compacte map moet op CID geïndexeerd zijn. De twee vallen alleen samen als CID gelijk is aan GID. HotPDF compact daarom een fontprogramma alleen als elk font dat het gebruikt een CIDFontType2 is met een Identity-/CIDToGIDMap. Programma's die al een mapstream hebben, simpele TrueType-fonts en fonts met een /CIDSet krijgen de ijle subset. Letters met kleurglyftabellen (COLR, sbix, CBDT of SVG) ook, want de compacte herbouw houdt alleen contouurtabellen aan en zou de kleurlagen vallen laten

Lees Info.BytesSaved voor wat het is. Het sommeert de stappen voor bronnen, fonts en streams, terwijl de object-stream-winst pas verschijnt wanneer SaveLoadedDocument het bestand schrijft, dus vergelijk bestandsgroottes op schijf voor het volledige cijfer

Eindversies tegenover documenten die nog veranderen

De winst volgt hoeveel van een bestand ongecomprimeerde structuur en overtollige fontdata is, en het pagina-aantal heeft weinig ermee te maken. Voor een document van drie pagina's met gemengde Engelse en Chinese tekst in Arial en SimSun, met beide fonts volledig ingebed, komt het ongecomprimeerde bestand op zo'n 10 MB; gegenereerd met CompressDocument komt het op ruwweg 20 KB uit, met het grootste deel van de daling uit fontsubsetting, en CompressLoadedDocument belandt voor het ongecomprimeerde origineel in hetzelfde bereik. Een PDF die al compact is beweegt nauwelijks. Fotozware bestanden winnen weinig, want geen van beide paden raakt beelddata aan

De prijs is bewerkbaarheid. Een subsetfont kan alleen de tekens tonen die het document al gebruikt, dus een AcroForm die iemand later invult, of een incrementele edit die nieuwe tekst in hetzelfde font toevoegt, kan op ontbrekende glyphs stuiten. Gepakte object streams houden ook op leesbaar te zijn in een teksteditor, wat elke debugsessie vertraagt die begint met de PDF in Kladblok openen. Zet CompressDocument aan voor eindversies: gearchiveerde facturen, afschriften, alles wat één keer wordt gegenereerd en daarna alleen wordt gelezen. Voor sjablonen en formulieren die stroomafwaarts iemand zal invullen, laat hem uit en houd de volledige fonts aan

Genereert u elke nacht dezelfde CJK-rapporten, koppel compacte subsets dan aan de persistente font subset cache op schijf zodat het subsetwerk niet bij elke run opnieuw wordt gedaan. En vergelijkt u twee nachtelijke uitvoer, diff ze dan op objectinhoud. Eén veranderd veld Flate zijn hele object stream opnieuw, dus een byte-diff toont veel meer verandering dan er werkelijk plaatsvond

Property-, record- en optiondetails voor alles hierboven staan in de referentie op de productpagina van HotPDF Delphi PDF component