Technisch artikel

Ontbrekende lettertypen insluiten voor PDF/A in Delphi

Een leveranciers-PDF ziet er op het scherm perfect uit, toch weigert de PDF/A-validator hem met één regel: 00030 At least one font is not embedded. De viewer leende van begin af aan fonts van uw machine. Open de fontdescriptor in het bestand en bijna alles wat een ingesloten font nodig heeft staat er al in, tot aan de stamdikte en bounding box; wat ontbreekt is één streamverwijzing die het fontprogramma zelf vasthoudt

De batchvariant hiervan is iedereen bekend die een archiefopname-pipeline draait. Facturen, contracten en gescande formulieren komen van leveranciers en bureaus, elk bureau in het gebouw rendert ze prima, en de validator weigert bestand na bestand met dezelfde regel. Niemand stroomopwaarts gaat iets hergenereren. De pipeline moet repareren wat hij ontvangt, en dat is de klus die dit artikel behandelt. Zijn metgezel, het artikel over het detecteren van PDF/A- en PDF/UA-overtredingen met het preflight-rapport, vertelt u welke bestanden kapot zijn; dit artikel behandelt de meest voorkomende manier waarop ze kapot gaan

Wat fout 00030 eigenlijk vraagt

ISO 19005-1 §6.3.4 vereist dat elk font dat een conformerend bestand gebruikt zijn fontprogramma in dat bestand meedraagt. De redenering is kale archieflogica. Een document dat over vijftig jaar wordt geopend, op een machine die geen fonts deelt met de machine die het produceerde, moet identiek renderen, en een niet-ingesloten font is niets dan een instructie om iets te gaan zoeken dat Arial heet op welk systeem dan ook dat toevallig leest. Welke glyphs en metrics de vervanger ook heeft, dat is wat de lezer ziet

De gewoonte om niet in te sluiten gaat terug op de Standard 14-conventie. Vroege PDF beloofde dat elke viewer Helvetica, Times, Courier, Symbol en ZapfDingbats meebrengt, dus leerden generatoren die op naam te refereren en niets in te sluiten. Veel tooling doet dat nog. PDF/A trekt die vrijstelling in, en losLab PDF Library voor Delphi past hem aan de schrijfkant toe: met PDF/A- of PDF/X-modus actief geeft AddStandardFont 0 terug zonder een font te selecteren, want de bibliotheek bundelt de contouren van de Standard 14 niet en schrijft geen verwijzing die hij niet met een programma kan onderbouwen. AddTrueTypeFont met Embed=0 wordt onder PDF/A-modus gepromoveerd naar een volledige insluiting, terwijl Embed=2 (subset) ongewijzigd doorgaat, want een subset is nog steeds een ingesloten programma

Dat dekt bestanden die u zelf schrijft. Het bestand van een leverancier is lastiger, want de fontwoordenboeken zijn door de generator van iemand anders geschreven en u kunt hem niet om een tweede poging vragen. Voor die bestanden biedt de bibliotheek EmbedMissingFonts, dat een geladen document ter plekke repareert door elk ontbrekend programma uit de geïnstalleerde fonts te kopiëren naar de descriptor die het document al meedraagt

Waarom heeft een niet-ingesloten font maar één extra sleutel nodig?

Een generator die een niet-ingesloten TrueType-font wegschrijft produceert nog steeds een volledige FontDescriptor: FontName, FontBBox, Flags, Ascent, Descent, StemV, CapHeight. Wat hij achterwege laat is de stream die het fontprogramma vasthoudt, gerefereerd vanuit de descriptor als /FontFile2 voor TrueType-contouren of /FontFile3 voor op CFF gebaseerde CID-fonts. Dus voegt EmbedMissingFonts precies dat toe. Hij leest de programma-bytes, schrijft ze als een nieuwe met Flate gecomprimeerde stream met een /Length1-entry en hangt de verwijzing aan de descriptor die er al staat

Diagram van PDF Library voor Delphi bij een FontDescriptor-woordenboek voor en na EmbedMissingFonts: elke entry is al aanwezig en alleen de ontbrekende FontFile2-stream wordt toegevoegd vanuit het geïnstalleerde systeemfont
EmbedMissingFonts voegt één streamverwijzing toe aan een descriptor die al compleet is

Wij vinden die ter-plekke-aanpak de juiste default voor geërfde bestanden, en de reden is de Widths-array. Tekstposities in een PDF-content stream staan al vast; de viewer schuift door met de breedtes die de oorspronkelijke generator noteerde. Het fontwoordenboek herbouwen vanuit het geïnstalleerde font zou die breedtes vervangen door vers gemeten, en wijkt de geïnstalleerde versie van de letterface ook maar licht af van die van de auteur, dan hebt u het document veranderd dat u juist moest bewaren. Het woordenboek, de codering, de breedtes en elke content stream onaangeroerd laten betekent dat de pagina's nog naar dezelfde resourcenamen wijzen met dezelfde metrics

De wandeling dekt elk Font-woordenboek in het bestand, niet alleen die vanuit paginabronnen bereikbaar zijn, dus fonts die alleen in annotatie-appearances voorkomen of tussen pagina's worden gedeeld worden ook gepakt. Samengestelde Type0-fonts, het soort dat voor CJK-tekst en de meeste moderne Unicode-uitvoer wordt gemaakt, worden via hun afstammende CIDFont behandeld. De hele reparatie is één aanroep op een geladen document:

var
  PDF: TPDFlib;
  Repaired: Integer;
begin
  PDF := TPDFlib.Create;
  try
    if PDF.LoadFromFile('supplier-invoice.pdf', '') <> 1 then
      raise Exception.Create('Could not load PDF');

    // Geeft terug hoeveel fonts een programma kregen. Fonts die al
    // ingesloten zijn blijven met rust; fonts zonder geïnstalleerde match
    // worden overgeslagen en simpelweg niet meegeteld.
    Repaired := PDF.EmbedMissingFonts;
    Writeln(Format('%d font program(s) embedded', [Repaired]));

    PDF.SaveToFile('supplier-invoice-repaired.pdf');
  finally
    PDF.Free;
  end;
end;

Hoe de opzoeking in geïnstalleerde fonts namen matcht

BaseFont-namen in echte bestanden matchen zelden met de familienaam die Windows kent. EmbedMissingFonts normaliseert elke naam vóór de opzoeking:

  • Een subsetprefix (zes hoofdletters en een plusteken, als in KQBWTE+Calibri) wordt gestript
  • Alles na de eerste komma of het eerste koppelteken wordt als stijl gelezen, dus Arial,BoldItalic en Arial-BoldMT vragen allebei om een vette face, en Italic of Oblique vraagt om een cursieve
  • Achteraan de suffixen MT en PS worden weggegooid, dus ArialMT lost op tot Arial
  • Woont de face binnen een TrueType Collection (.ttc), dan worden de tabeloffsets bijgesteld zodat het ingesloten programma een geldig standalone font is

Het hardere probleem is dat de Windows-fontmapper nooit nee zegt. Vraagt GDI om een familie die niet is geïnstalleerd, dan geeft hij zonder klagen een vervangende face terug; vraagt u om vet op een familie die alleen een gewone face heeft, dan verdikt hij de contouren op het scherm. Elk van beide resultaten geeft u een perfect laadbaar fontprogramma dat het verkeerde font is. Daarom controleert de opzoeking of de face die GDI werkelijk selecteerde tegen de gevraagde familie past, spaties en hoofdletters negerend, en of de eigen vet- en cursief-bits van de face tegen de gevraagde stijl passen. Een mismatch op een van beide betekent dat het font wordt overgeslagen

Dat is een bewuste ruil. Een soepeler opzoeking zou het reparatieaantal bij elke batch opdrijven, en sommige van die "reparaties" zouden Arial Regular insluiten onder een font dat het document Arial,Bold noemt. ISO 19005-1 §6.3.6 vereist dat de breedtes in het fontwoordenboek overeenkomen met het ingesloten programma, dus kan een near miss fout 00030 inruilen voor een breedteconsistentiefout, en in het slechtste geval slaat hij door de validatie terwijl hij net anders rendert dan de auteur bedoelde. Liever melden we een overgeslagen font dan dat we een gok archiveren

De opzoeking leest geïnstalleerde fonts via Windows GDI. Op Linux- of macOS-builds geeft het systeempad niets terug, en de op bestanden gebaseerde aanroep in de volgende sectie is de manier om programma's aan te leveren

Wat gebeurt er als het font niet is geïnstalleerd?

De returnwaarde vertelt het. Meldt EmbedMissingFonts minder fonts dan u weet dat er ontbreken, dan bestaat het verschil uit fonts die de machine niet heeft, of niet in de juiste stijl. Voor die gevallen koppelt EmbedFontProgramFromFile(FontName, FileName) een programma vanuit een .ttf- of .otf-bestand dat u aanlevert, zodat een pipeline de bedrijfsfaces kan meesturen die hij verwacht tegen te komen en er bewust op terugvalt

Beslissingsstroom van PDF Library voor Delphi die elk fontwoordenboek opsomt, BaseFont-namen tegen het geïnstalleerde systeem normaliseert, gevonden programma's insluit met EmbedFontProgram of terugvalt op EmbedFontProgramFromFile, en het gerepareerde aantal meldt
Naamnormalisatie maakt de systeemopzoeking vergevingsgezind, en het retouraantal houdt overgeslagen faces zichtbaar

Het patroon dat in de praktijk het best werkt is twee passes. Draai EmbedMissingFonts en sla op, laad daarna het resultaat, som op wat nog niet is ingesloten en bied elke resterende naam aan uw eigen fontmap aan. Het opnieuw laden telt mee: de ingesloten-vlag die GetFontIsEmbedded meldt voor een opgesomd font weerspiegelt het bestand zoals het was toen FindFonts draaide, dus opsommen in dezelfde sessie als de reparatie zou verouderde antwoorden tonen

function FontFileFor(const BaseFont: string): string;
begin
  // Uw eigen helper (geen deel van de bibliotheek): breng document-
  // fontnamen in kaart naar fontbestanden die de app meestuurt.
  // Een leeg resultaat laat EmbedFontProgramFromFile 0 teruggeven
  // zonder het bestandssysteem aan te raken.
  if Pos('CorporateSans', BaseFont) > 0 then
    Result := ExtractFilePath(ParamStr(0)) + 'fonts\CorporateSans.ttf'
  else
    Result := '';
end;

procedure EmbedFromShippedFonts(const InFile, OutFile: string);
var
  PDF: TPDFlib;
  I, FontID: Integer;
  Name: string;
begin
  PDF := TPDFlib.Create;
  try
    if PDF.LoadFromFile(InFile, '') <> 1 then
      Exit;
    PDF.FindFonts;
    for I := 1 to PDF.FontCount do
    begin
      FontID := PDF.GetFontID(I);
      if (FontID > 0) and (PDF.SelectFont(FontID) = 1) and
         (PDF.GetFontIsEmbedded = 0) then
      begin
        // Geef de naam precies door zoals opgeslagen, subsetprefix inbegrepen
        Name := PDF.FontName;
        if PDF.EmbedFontProgramFromFile(Name, FontFileFor(Name)) = 0 then
          Writeln('Still not embedded: ', Name);
      end;
    end;
    PDF.SaveToFile(OutFile);
  finally
    PDF.Free;
  end;
end;

Drie details bepalen of die lus slaagt. De aanroepen op naam, EmbedFontProgram voor het geïnstalleerde font en EmbedFontProgramFromFile voor een bestand, vergelijken met de BaseFont precies zoals het document hem bewaart en werken op het eerste Font-woordenboek dat die naam draagt, wat verklaart waarom de lus PDF.FontName rechtstreeks doorgeeft in plaats van een opgeschoonde familienaam. Het programmaformaat moet bij het fonttype passen: glyph-contour-TrueType-data voor een TrueType- of CIDFontType2-font, een OpenType CFF-programma (één dat met de tag OTTO begint) voor een CIDFontType0-font, dat dan als /FontFile3 met subtype OpenType wordt weggeschreven. Een CFF-bestand aan een TrueType-font geven laat de aanroep 0 teruggeven. En het reparatiepad dekt TrueType- en CID-fonts; de /FontFile van een Type1-font heeft de driesegments-PFB-layout met expliciete lengtesleutels nodig, dus Type1-verwijzingen worden overgeslagen en aan het retouraantal overgelaten om te vlaggen. Standard 14-verwijzingen worden meestal als Type1 geschreven, dus reken erop ze in die restlijst tegen te komen

Er is ook een vraag die de bibliotheek niet voor u kan beantwoorden. De insluitingsrechten van een TrueType-font behoren aan zijn foundry, en een pipeline die gelicentieerde programma's in documenten wegschrijft die de organisatie verlaten heeft iemand nodig die bevestigt dat de licenties het toestaan. De code sluit in wat u er ook naar laat wijzen. Of het mag is een juridische vraag

De kring sluiten met CreatePreflightReport

De audit die het bestand weigerde zou ook de zijn die hem vrijgeeft. CreatePreflightReport met ComplianceTests = 1 draait de PDF/A-controles, en bevinding 00030 wordt één keer voor het hele bestand gemeld, dus één over het hoofd gezien font houdt hem in het rapport. Draai hem op de bron, repareer en sla op, en draai hem daarna opnieuw op de uitvoer

PDF Library voor Delphi: gesloten reparatiekring waarin CreatePreflightReport foutcode 00030 vlagt, EmbedMissingFonts de gevlagde fonts insluit, SaveToFile de gerepareerde PDF wegschrijft en een tweede rapportrun bevestigt dat de batch slaagt
Draai eerst het preflight-rapport, laat het de reparatie sturen, en laat dezelfde audit de uitvoer certificeren
function HasFontEmbeddingViolation(PDF: TPDFlib;
  const FileName: string): Boolean;
var
  Report: string;
begin
  // ComplianceTests = 1 kiest de PDF/A-controles
  Report := PDF.CreatePreflightReport(FileName, '', 1, 0);
  Result := Pos('00030', Report) > 0;
end;

Eén resultaat verrast mensen de eerste keer. De fontcontrole negeert fonts die inhoud alleen ooit onzichtbaar tekent, in tekstrenderingsmodus 3, de manier waarop de meeste OCR-engines een doorzoekbare tekstlaag over een gescande afbeelding leggen. Een gescand bestand kan daarom door 00030 komen terwijl FindFonts nog steeds een niet-ingesloten face noemt. Dat is consistent met hoe PDF/A met onzichtbare tekst omgaat, en het betekent dat een opsomming per font en het oordeel per bestand legitiem van elkaar kunnen verschillen op hetzelfde document

Voor batchlogs die precies moeten noemen welke face in welk bestand niet is ingesloten is de opsomming per font het betere gereedschap: laad de uitvoer, roep FindFonts aan, daarna SelectFont en GetFontIsEmbedded voor elke entry. Het artikel over het extraheren van tekst, afbeeldingen en fonts uit geladen PDF's gebruikt dezelfde opsomming om extractie in plaats van reparatie te voeden

Insluiten ruimt één bevinding op, en uw eigen uitvoer zou hem nooit nodig moeten hebben

Fonts insluiten ruimt fout 00030 op en niets verder. Een bestand dat ook zakt op encryptie, ontbrekende XMP-metadata, een apparaatafhankelijke kleurruimte zonder OutputIntent, of fonts zonder ToUnicode-maps zal nog steeds zakken nadat elk programma op zijn plek staat, dus hoort de reparatie thuis binnen de preflight-lus en werkt hij af op wat het rapport noemt. Grootte is de andere kost. Een volledig CJK-fontprogramma kan tot meerdere megabytes oplopen, en een paar daarvan insluiten kan van een eenpaginafactuur een veelvoud van zijn oorspronkelijke grootte maken; het artikel over optimalisatie van PDF-bestandsgrootte en font-subsetting behandelt het inkorten van elk ingesloten programma tot de glyphs die de pagina's werkelijk gebruiken

Aan de schrijfkant voorkomt SetEmbedAllFonts(1) dat uw eigen code de bestanden produceert die dit artikel repareert. Hij past dezelfde promotie toe die PDF/A-modus gebruikt op een gewoon document: elke latere AddTrueTypeFont-aanroep met Embed=0 sluit het volledige programma in. De instelling hoort bij het geselecteerde document en raakt fonts die na de aanroep worden toegevoegd, dus zet hem direct na NewDocument. Ons advies is hem aan te zetten voor alles wat in een archief kan belanden, PDF/A of niet, want de bestanden die u vandaag maakt zijn de geërfde bestanden van wie ze later leest

PDF.NewDocument;
PDF.SetEmbedAllFonts(1);
// Vanaf hier sluit AddTrueTypeFont('Segoe UI', 0) het
// volledige programma in, precies zoals AddTrueTypeFont('Segoe UI', 1)
PDF.AddTrueTypeFont('Segoe UI', 0);

Het pad laden-repareer-opslaan, de op bestanden gebaseerde fallback en de bewaking aan de schrijfkant worden allemaal geleverd in losLab PDF Library voor Delphi, C# en VB.NET, samen met de preflight-engine die hierboven het resultaat bevestigt; de productpagina documenteert de rest van de font-API, inclusief inspectie per font en subsetting