Open dezelfde factuur-PDF op Windows en op een telefoon, en de regeleinden, fonts en het logo landen op identieke plekken. Een PDF-bestand is een set genummerde objecten plus een index van byte-offsets, en een lezer zoals de PDFium-engine binnen PDFium Component opent hem vanaf het einde: startxref, xref-tabel, catalogus, paginaboom, content streams, daarna pixels
Dus wat is een PDF-bestand, en waarom ziet hij er overal hetzelfde uit? Word- en RTF-documenten bewaren tekst en stijlen en laten de layout over aan de machine die ze opent, dus een ontbrekend font of een andere printerdriver laat de pagina's opnieuw doorlopen. PDF bewaart in plaats daarvan het eindresultaat. Elke glyph en regel heeft een absolute positie in een coördinaatruimte gemeten in punten, de fontprogramma's reizen mee in het bestand, en afbeeldingen dragen hun eigen kleurdata en compressiefilters. Er wordt niets gezet op het moment van bekijken, en daarom schildert elke conformerende renderer op elk besturingssysteem dezelfde pagina. Het formaat begon als PDF 1.0 met Acrobat in 1993, gebouwd op het PostScript-beeldmodel, en elke revisie voegde een deel van de machinerie hieronder toe:
- PDF 1.1 tot 1.4 bracht versleuteling, interactieve formulieren, digitale handtekeningen met logische structuur en transparantie
- PDF 1.5 voegde object streams en cross-reference streams toe; PDF 1.6 voegde AES-versleuteling toe
- PDF 1.7 werd ISO 32000-1:2008, en PDF 2.0 werd ISO 32000-2:2017, herzien in 2020
- PDF/A (ISO 19005), PDF/X (ISO 15930) en PDF/UA (ISO 14289) beperken die basis voor archivering, printproductie en toegankelijkheid
Wat gebeurt er wanneer een lezer een PDF-bestand opent?
Een PDF openen is een keten van opzoekingen die bij de laatste bytes van het bestand begint en eindigt bij een bitmap. Bijna elke schakel in die keten is een woordenboek, één van de basisobjecttypen uit ISO 32000-1 §7.3, en woordenboeken wijzen met indirecte verwijzingen zoals 7 0 R (object 7, generatie 0) naar elkaar. Het bestand gedraagt zich daardoor als een graaf van objecten in plaats van een reeks pagina's. De header, body, kruisverwijzingstabel en trailer staan beschreven in het overzicht van de PDF-bestandsstructuur, en een minimale PDF regel voor regel van commentaar voorzien laat zien hoe obj, endobj en stream er in een teksteditor uitzien. Dit is de volgorde die elke lezer volgt
- Zoek naar het einde van het bestand en lees de byte-offset die na het trefwoord
startxrefstaat - Laad de kruisverwijzingsdata op die offset, die elk objectnummer aan een positie in het bestand koppelt
- Lees de trailer en volg
/Rootnaar de documentcatalogus - Volg de
/Pages-entry van de catalogus door de paginaboom naar het gevraagde paginaobject - Decodeer de content stream van de pagina en interpreteer zijn operators in volgorde
- Resolveer de fonts, afbeeldingen en Form XObjects die die operators noemen via
/Resources - Rasteriseer paden, glyph-contours en afbeeldingen naar pixels op de apparaatresolutie
Stap één: startxref en de kruisverwijzingstabel
Een lezer scant een PDF nooit van bovenaf. Een welgevormd bestand eindigt op het trefwoord startxref, een decimaal getal zoals 48211, en %%EOF, en dat getal is de byte-offset van de kruisverwijzingsdata. Een naïeve achterwaartse zoektocht naar xref stopt binnen startxref, dus zoek naar het volledige trefwoord. De klassieke tabel gebruikt entries met vaste breedte (§7.5.4), zodat een lezer naar de entry van elk objectnummer kan springen zonder de anderen te parsen; de byte-layout van elke entry staat in het structuuroverzicht. De trailer na de tabel noemt /Size, /Root en optioneel /Encrypt, /ID en /Prev
Elke entry is een absolute bytepositie, dus alles dat bytes verschuift, zoals een editor die regeleinden herschrijft, laat de index naar de verkeerde plekken wijzen. Lezers met een reparatiedoorgang herbouwen hem door naar obj-trefwoorden te scannen; lezers zonder zo'n doorgang weigeren het bestand, en daarom kan een beschadigde PDF in de ene viewer openen en in de andere falen. Wat op de startxref-offset staat, vertelt u in welk geval u verkeert: het trefwoord xref voor een klassieke tabel, een N 0 obj-header voor een cross-reference stream uit PDF 1.5, en al het andere voor een verlopen offset. De helper hieronder is uw eigen code, gebouwd op kale RTL-streams
uses
System.SysUtils, System.Classes;
// Eigen helper: Offset is het getal dat na startxref staat.
// Classificeert wat de lezer op die positie zal aantreffen
function DescribeXrefAt(const FileName: string; Offset: Int64): string;
var
FS: TFileStream;
Buf: TBytes;
Head: string;
begin
FS := TFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
try
if Offset >= FS.Size then
Exit('offset beyond end of file: the file needs a repair pass');
FS.Position := Offset;
SetLength(Buf, 32);
SetLength(Buf, FS.Read(Buf[0], Length(Buf)));
finally
FS.Free;
end;
Head := TEncoding.ASCII.GetString(Buf);
if Head.StartsWith('xref') then
Result := 'classic cross-reference table'
else if Head.Contains(' obj') then
Result := 'cross-reference stream (PDF 1.5 or later)'
else
Result := 'stale offset: the file needs a repair pass';
end;
Een cross-reference stream (§7.5.8) is een gecomprimeerd object met /Type /XRef, een /W-array die de bytebreedte van elke kolom geeft, en binaire rijen die ofwel naar een byte-offset wijzen ofwel naar binnen een object stream (§7.5.7). De trailer-sleutels verhuizen naar zijn woordenboek, dus het bestand heeft het trefwoord trailer helemaal niet. HotPDF schrijft deze vorm wanneer UseXRefStream op THotPDF staat gezet. Voor bestanden die uw controle ontstijgen, zoals mailbijlagen of uploads naar een drukkerij, blijft de klassieke tabel de veiligere keuze, omdat readers van vóór PDF 1.5 haar nog steeds parsen. PDF/A-1 beslist de vraag voor archieven: ISO 19005-1 bouwt op PDF 1.4, en zijn §6.1.4 stelt dat cross-reference streams niet gebruikt mogen worden, dus HotPDF schrijft een klassieke tabel zodra een PDF/A-1-profiel actief is
48 0 obj
<< /Type /XRef /Size 49 /Root 1 0 R
/W [1 3 1] /Index [0 49]
/Filter /FlateDecode /Length 162 >>
stream
...binary rows: 1 + 3 + 1 bytes each...
endstream
endobj
startxref
48211
%%EOF
Van /Root naar de juiste pagina: catalogus en paginaboom
De /Root van de trailer wijst naar de documentcatalogus, en de /Pages van de catalogus wijst naar de wortel van de paginaboom. Elke tussenliggende /Pages-knoop draagt een /Count van de bladpagina's eronder, dus een lezer die pagina 5000 zoekt trekt tijdens zijn afdaling counts af en slaat hele deelbomen ongeopend over. ISO 32000-1 §7.7.3 eist geen gebalanceerde boom; een enkele /Kids-array met 10.000 entries is legaal, alleen trager om door te zoeken. Code die alleen het blad leest valt in één valkuil. /Resources, /MediaBox, /CropBox en /Rotate zijn overerfbaar (§7.7.3.4), dus een pagina zonder eigen /MediaBox is nog steeds geldig omdat de waarde op een voorouder woont
12 0 obj
<< /Type /Page
/Parent 3 0 R
/MediaBox [0 0 612 792]
/Resources << /Font << /F1 7 0 R >> >>
/Contents 13 0 R
>>
endobj
De media box zet de coördinaatruimte vast voor alles dat op de pagina wordt getekend: oorsprong linksonder, Y omhoog lopend, één gelijk aan 1/72 inch tenzij een /UserUnit uit PDF 1.6 dat schaalt. PDFium Component verricht de hele afdaling wanneer u een pagina op nummer vraagt. TPdf.PageMetrics geeft de paginagrootte in punten terug met overgeërfde boxen al resolved, plus de paginarotatie, dus de opsomming hieronder meldt correcte groottes zelfs voor bestanden waarvan de bladpagina's geen eigen box dragen
uses
System.SysUtils, PDFium;
// Drukt het paginaaantal en de grootte van elke pagina in punten af
procedure ListPages(const FileName: string);
const
Degrees: array[TRotation] of Integer = (0, 90, 180, 270);
var
Pdf: TPdf;
I: Integer;
M: TPdfPageMetrics;
begin
Pdf := TPdf.Create(nil);
try
Pdf.FileName := FileName;
Pdf.Active := True; // parst de xref-data, trailer en catalogus
if not Pdf.Active then // een mislukte load laat Active = False
raise Exception.Create('Cannot open ' + FileName);
Writeln(Pdf.PageCount, ' pages');
for I := 1 to Pdf.PageCount do
begin
M := Pdf.PageMetrics[I]; // 1-based; laadt de pagina via de boom
Writeln(Format('Page %d: %.1f x %.1f pt, /Rotate %d',
[I, M.Width, M.Height, Degrees[M.Rotation]]));
end;
finally
Pdf.Free;
end;
end;
Hoe tekent een PDF een pagina op het scherm?
De zichtbare content van een pagina is een klein programma: postfix-operators in één of meer content streams, in volgorde geïnterpreteerd nadat de lezer de decoder heeft gedraaid die in /Filter staat genoemd, meestal /FlateDecode. BT opent een tekstobject, Tf kiest een fontresource en grootte, Td verschuift de tekstpositie, Tj schildert een string en ET sluit het object af. Paden worden gebouwd met m, l, c en re, daarna gevuld met f of van contour voorzien met S. De graphics state (§8.4) bewaart wat die operators impliciet lezen, zoals de transformatiematrix, kleuren en het clipping pad. q duwt een kopie op de stapel en Q haalt haar eraf, dus een transformatie die binnen het paar wordt gezet kan niet lekken naar latere content
q
1 0 0 1 72 700 cm % verplaatst de oorsprong naar (72, 700)
BT
/F1 12 Tf % fontresource F1 op 12 punten
0 0 Td
(Invoice 2026-0417) Tj
ET
0.2 0.2 0.8 RG % contourkleur, begrensd door q/Q
0 -6 m 140 -6 l S
Q
Names zoals /F1 zijn sleutels in de /Resources van de pagina. Een font-woordenboek loopt via zijn fontdescriptor (§9.8) naar het ingesloten fontprogramma, en een afbeelding wordt met één enkele Do geschilderd zodra zijn JPEG- of Flate-data is gedecodeerd. Rasteriseren komt als laatste. De renderer past de transformatiematrix toe op elk pad en elke glyph-contour, mapt punten op apparaatpixels en vult het resultaat met anti-aliasing. Omdat de pagina op dat punt nog vectordata is, draait inzoomen naar 400 procent de content stream opnieuw op een grotere schaal in plaats van een bitmap uit te rekken. De doelresolutie wordt door de aanroeper gekozen: 96 of 150 pixels per inch voor een scherm, 300 of meer voor print. In PDFium Component is die fase TPdf.RenderPage, die de uitvoergrootte in pixels neemt
uses
System.SysUtils, Vcl.Graphics, PDFium;
// Rendert pagina 1 van FileName op Dpi pixels per inch en slaat hem op als BMP
procedure RenderFirstPage(const FileName: string; Dpi: Integer);
var
Pdf: TPdf;
Bmp: TBitmap;
W, H: Integer;
begin
Pdf := TPdf.Create(nil);
try
Pdf.FileName := FileName;
Pdf.Active := True;
if not Pdf.Active then
raise Exception.Create('Cannot open ' + FileName);
Pdf.PageNumber := 1; // 1-based
// PageWidth en PageHeight zijn in punten (1/72 inch)
W := Round(Pdf.PageWidth * Dpi / 72);
H := Round(Pdf.PageHeight * Dpi / 72);
Bmp := Pdf.RenderPage(0, 0, W, H, ro0, [reAnnotations]);
try
Bmp.SaveToFile(ChangeFileExt(FileName, '-p1.bmp'));
finally
Bmp.Free; // de functievorm geeft een nieuwe bitmap terug
end;
finally
Pdf.Free;
end;
end;
Waarom geeft kopiëren en plakken rommel terug terwijl de pagina er prima uitziet?
Kopiëren en plakken faalt wanneer het bestand vastlegt welke glyph getekend moet worden, maar niet welk teken hij vertegenwoordigt. Renderen heeft alleen glyphvormen uit het ingesloten fontprogramma nodig. Extractie heeft Unicode nodig, en die komt uit een standaardencoding of een /ToUnicode-CMap op het font-woordenboek (§9.10.3). Een composietfont met /Encoding /Identity-H schrijft rauwe glyph-ID's in de content stream, en zonder een ToUnicode-map hebben die ID's geen gedefinieerde relatie met welk teken dan ook. Het scherm ziet er perfect uit terwijl het klembord vol symbolen loopt. Subsetfonts maken dit waarschijnlijker, want ze houden alleen de glyphs bij die het document gebruikt en zijn te herkennen aan het prefix van zes letters in namen zoals /BaseFont /AAAAAA+ArialMT (§9.6.4). De gids voor PDF-fonthandling gaat diep in op CJK-fonts en kapotte extractie
Incrementele updates en het byterebied van de handtekening
Handtekeningen hangen aan de append-only manier waarop PDFs worden bewerkt: een incrementele update (§7.5.6) voegt objecten en een nieuwe kruisverwijzingssectie toe na de laatste %%EOF, en het structuuroverzicht legt de /Prev-keten uit en waarom verwijderde content in eerdere revisies overleeft. De /ByteRange van een handtekening-woordenboek, geschreven als [0 a b c], hash alles behalve de /Contents-hexstring die de CMS-handtekening draagt, dus de ondertekende revisie eindigt op byte b + c en een validator herbouwt haar door het bestand daar af te kappen. Latere revisies landen na dat punt, terwijl een volledige herschrijving, een linearizer of een optimize-pass bytes verplaatst die de ondertekenaar hashte en elke bestaande handtekening in één keer ongeldig maakt
Wanneer een Delphi- of Lazarus-applicatie deze hele pijplijn nodig heeft, van het parsen van de kruisverwijzingsdata en het doorlopen van de paginaboom tot rendering en tekstextractie, wikkelt de PDFium Component for Delphi and Lazarus haar in het TPdf-documentcomponent dat in de opsommingen hierboven wordt gebruikt en de TPdfView-viewercontrol voor weergave op het scherm