Technisch artikel

Hoe een PDF werkt: van startxref tot pixels op het scherm

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

  1. Zoek naar het einde van het bestand en lees de byte-offset die na het trefwoord startxref staat
  2. Laad de kruisverwijzingsdata op die offset, die elk objectnummer aan een positie in het bestand koppelt
  3. Lees de trailer en volg /Root naar de documentcatalogus
  4. Volg de /Pages-entry van de catalogus door de paginaboom naar het gevraagde paginaobject
  5. Decodeer de content stream van de pagina en interpreteer zijn operators in volgorde
  6. Resolveer de fonts, afbeeldingen en Form XObjects die die operators noemen via /Resources
  7. 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

Hoe een PDF werkt: verticale anatomie van een PDF-bestand, van header en objectbody via de kruisverwijzingstabel naar de trailer
De kruisverwijzingstabel zet objectnummers om in byte-offsets, zodat een lezer rechtstreeks naar elke pagina kan zoeken zonder de rest te scannen

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
Hoe een PDF een pagina tekent: fragment uit een content stream waarin de operators BT, Tf, Td en Tj leiden tot de marken die ze schilderen
Operanden landen vóór operators en q/Q-paren hekken statuswijzigingen af, zodat lokale transformaties niet lekken naar buurcontent

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

Hoe PDF-incrementele updates werken: gestapelde save-generaties met toegevoegde objecten, verfreste trailers en het byterebied dat een digitale handtekening dekt
Opslagen voegen toe in plaats van te herschrijven, waardoor validators elke wijziging na ondertekening blootleggen en toegestane bewerkingen handtekeningen levend houden

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