PDF/A-Validierung

PDF/A (ISO 19005) ist der internationale Standard für die Langzeitarchivierung elektronischer Dokumente. PDF Oxide validiert alle wichtigen PDF/A-Stufen und kann nicht konforme Dokumente in Richtung Konformität konvertieren.

Unterstützte Stufen

Level	Standard	Structure	Unicode	Transparency	Embedded Files
1a	ISO 19005-1	Required	Required	No	No
1b	ISO 19005-1	No	No	No	No
2a	ISO 19005-2	Required	Required	Yes	No
2b	ISO 19005-2	No	No	Yes	No
2u	ISO 19005-2	No	Required	Yes	No
3a	ISO 19005-3	Required	Required	Yes	Yes
3b	ISO 19005-3	No	No	Yes	Yes
3u	ISO 19005-3	No	Required	Yes	Yes

Stufe “a” (zugänglich) erfordert einen getaggten Strukturbaum und Unicode-Zeichenzuordnung. Stufe “b” (grundlegend) erfordert nur visuelle Reproduzierbarkeit. Stufe “u” (Unicode) erfordert Unicode-Textzuordnung ohne den vollständigen Strukturbaum.

Schnellvalidierung

Verwenden Sie die Komfortfunktion für eine einmalige Prüfung:

from pdf_oxide import PdfDocument

doc = PdfDocument("document.pdf")
result = doc.validate_pdf_a("2b")
print(f"Valid: {result.valid}")
print(f"Level: {result.level}")
for error in result.errors:
    print(f"  Error: {error}")

const doc = new WasmPdfDocument(bytes);
const result = doc.validatePdfA("2b");
console.log(`Valid: ${result.valid}`);
console.log(`Errors: ${result.errors.length}`);
doc.free();

use pdf_oxide::PdfDocument;
use pdf_oxide::compliance::{validate_pdf_a, PdfALevel};

let mut doc = PdfDocument::open("archive.pdf")?;
let result = validate_pdf_a(&mut doc, PdfALevel::A1b)?;

if result.has_errors() {
    println!("Not PDF/A-1b compliant:");
    for error in &result.errors {
        println!("  [{}] {} (clause {})",
            error.code, error.message,
            error.clause.as_deref().unwrap_or("n/a"));
    }
} else {
    println!("Document is PDF/A-1b compliant");
}

Validator-API

Der PdfAValidator bietet ein Builder-Pattern für feinkörnige Kontrolle:

use pdf_oxide::PdfDocument;
use pdf_oxide::compliance::{PdfAValidator, PdfALevel};

let mut doc = PdfDocument::open("report.pdf")?;

let result = PdfAValidator::new()
    .stop_on_first_error(false)
    .include_warnings(true)
    .validate(&mut doc, PdfALevel::A2b)?;

println!("Errors: {}", result.errors.len());
println!("Warnings: {}", result.warnings.len());

Gezielte Prüfungen

Einzelne Validierungskategorien anstelle der vollständigen Suite ausführen:

use pdf_oxide::PdfDocument;
use pdf_oxide::compliance::{PdfAValidator, PdfALevel};

let mut doc = PdfDocument::open("report.pdf")?;
let validator = PdfAValidator::new();

// Check only metadata
let result = validator.check_metadata(&mut doc, PdfALevel::A1b)?;

// Check only fonts
let result = validator.check_fonts(&mut doc, PdfALevel::A1b)?;

// Check only color spaces
let result = validator.check_colors(&mut doc, PdfALevel::A1b)?;

// Check only transparency
let result = validator.check_transparency(&mut doc, PdfALevel::A2b)?;

// Check only structure tags
let result = validator.check_structure(&mut doc, PdfALevel::A1a)?;

Eigenständige Validatoren

Jede Validierungskategorie ist auch als eigenständige Funktion für maximale Flexibilität verfügbar:

use pdf_oxide::PdfDocument;
use pdf_oxide::compliance::validators::*;
use pdf_oxide::compliance::{PdfALevel, ValidationResult};

let mut doc = PdfDocument::open("document.pdf")?;
let mut result = ValidationResult::new(PdfALevel::A1b);

// Run each validator independently
validate_xmp_metadata(&mut doc, PdfALevel::A1b, &mut result)?;
validate_fonts(&mut doc, PdfALevel::A1b, &mut result)?;
validate_colors(&mut doc, PdfALevel::A1b, &mut result)?;
validate_encryption(&mut doc, PdfALevel::A1b, &mut result)?;
validate_transparency(&mut doc, PdfALevel::A1b, &mut result)?;
validate_structure(&mut doc, PdfALevel::A1b, &mut result)?;
validate_javascript(&mut doc, PdfALevel::A1b, &mut result)?;
validate_embedded_files(&mut doc, PdfALevel::A1b, &mut result)?;
validate_annotations(&mut doc, PdfALevel::A1b, &mut result)?;

println!("Total errors: {}", result.errors.len());

Validator-Zusammenfassung

Funktion	Was geprüft wird
validate_xmp_metadata()	XMP-Stream vorhanden, pdfaid:part- und pdfaid:conformance-Einträge vorhanden, Metadaten-Konsistenz
validate_fonts()	Alle Schriften eingebettet, Glyphenbreiten vorhanden, Unicode-Zuordnung verfügbar (für Stufe “a” und “u”)
validate_colors()	Keine geräteabhängigen Farboperatoren (rg, RG, k, K, g, G) ohne Ausgabeabsicht
validate_encryption()	Keine Verschlüsselung in PDF/A-Dokumenten erlaubt
validate_transparency()	Keine Transparenz in PDF/A-1; erlaubt in PDF/A-2 und später
validate_structure()	Getaggter Strukturbaum mit gültiger Rollenzuordnung vorhanden (erforderlich für Stufe “a”)
validate_javascript()	Keine JavaScript-Aktionen oder -Trigger vorhanden
validate_embedded_files()	Nicht erlaubt in PDF/A-1 oder PDF/A-2; PDF/A-3 erfordert AFRelationship-Schlüssel bei jeder Dateispezifikation
validate_annotations()	Anmerkungstypen eingeschränkt gemäß dem relevanten ISO-19005-Teil

ValidationResult

Die ValidationResult-Struktur enthält das vollständige Ergebnis eines Validierungslaufs:

pub struct ValidationResult {
    pub level: PdfALevel,
    pub errors: Vec<ComplianceError>,
    pub warnings: Vec<ComplianceWarning>,
    pub stats: ValidationStats,
}

Feld	Typ	Beschreibung
level	PdfALevel	Die Ziel-Konformitätsstufe
errors	Vec<ComplianceError>	Blockierende Verstöße, die Konformität verhindern
warnings	Vec<ComplianceWarning>	Nicht blockierende Probleme, die die Qualität beeinträchtigen können
stats	ValidationStats	Anzahl geprüfter Seiten, Schriften und Objekte

ComplianceError

pub struct ComplianceError {
    pub code: ErrorCode,
    pub message: String,
    pub location: Option<String>,
    pub clause: Option<String>,
}

Das code-Feld verwendet das ErrorCode-Enum with categories like MissingXmpMetadata, FontNotEmbedded, DeviceDependentColor, VerschlüsselungPresent, TransparencyNotAllowed, MissingStructureTree, JavaScriptPresent, and InvalidEmbeddedFile.

ComplianceWarning

pub struct ComplianceWarning {
    pub code: WarningCode,
    pub message: String,
    pub location: Option<String>,
}

PDF/A-Konvertierung

Ein nicht konformes Dokument in Richtung PDF/A-Konformität konvertieren:

use pdf_oxide::PdfDocument;
use pdf_oxide::compliance::{convert_to_pdf_a, PdfALevel};

let mut doc = PdfDocument::open("input.pdf")?;
let result = convert_to_pdf_a(&mut doc, PdfALevel::A1b)?;

println!("Conversion actions taken:");
for action in &result.actions {
    println!("  - {}: {}", action.action_type, action.description);
}

if result.remaining_errors.is_empty() {
    println!("Document is now PDF/A-1b compliant");
} else {
    println!("{} issues could not be resolved automatically",
        result.remaining_errors.len());
}

Konvertierung Config

Den Konvertierungsprozess fein abstimmen:

use pdf_oxide::PdfDocument;
use pdf_oxide::compliance::{PdfAConverter, PdfALevel, ConversionConfig};

let mut doc = PdfDocument::open("input.pdf")?;

let config = ConversionConfig::new()
    .embed_fonts(true)
    .remove_javascript(true)
    .flatten_transparency(true)
    .add_structure(true);

let result = PdfAConverter::new(PdfALevel::A2b)
    .with_config(config)
    .convert(&mut doc)?;

Der Konverter führt diese Aktionen automatisch aus:

1. XMP-Metadaten-Injektion – adds pdfaid:part and pdfaid:conformance entries
2. Schrifteinbettung – embeds any referenced but non-embedded fonts
3. JavaScript-Entfernung – strips JavaScript actions and triggers
4. Transparenz-Einbettung – renders transparent elements to opaque (PDF/A-1 only)
5. ICC-Profil-Konvertierung – converts device-dependent colors to ICC-based color spaces
6. Struktur-Tagging – adds basic structure tags (for level “a” targets)

Arbeitsablauf: Validieren, Beheben, Erneut validieren

Ein typischer Archivierungs-Arbeitsablauf validiert, versucht automatische Konvertierung und validiert dann erneut:

use pdf_oxide::PdfDocument;
use pdf_oxide::compliance::{validate_pdf_a, convert_to_pdf_a, PdfALevel};

let level = PdfALevel::A2b;
let mut doc = PdfDocument::open("input.pdf")?;

// Step 1: Initial validation
let result = validate_pdf_a(&mut doc, level)?;
if !result.has_errors() {
    println!("Already compliant");
    return Ok(());
}

println!("{} errors found, attempting conversion...", result.errors.len());

// Step 2: Automatic conversion
let conversion = convert_to_pdf_a(&mut doc, level)?;
println!("{} actions taken", conversion.actions.len());

// Step 3: Re-validate
let result = validate_pdf_a(&mut doc, level)?;
if result.has_errors() {
    println!("{} errors remain after conversion:", result.errors.len());
    for e in &result.errors {
        println!("  {} -- {}", e.code, e.message);
    }
} else {
    println!("Document is now PDF/A-2b compliant");
}

PdfALevel-Methoden

Das PdfALevel-Enum enthält Hilfsmethoden zum Abfragen der Stufenfähigkeiten:

Methode	Rückgabe	Beschreibung
part()	PdfAPart	ISO-19005-Teil (Part1, Part2, Part3)
conformance()	char	Konformitätsbuchstabe (‘a’, ‘b’ oder ‘u’)
requires_structure()	bool	Ob getaggter Strukturbaum obligatorisch ist
requires_unicode()	bool	Ob Unicode-Zuordnung obligatorisch ist
allows_transparency()	bool	Ob Transparenz erlaubt ist
allows_jpeg2000()	bool	Ob JPEG-2000-Bilder erlaubt sind
allows_embedded_files()	bool	Ob Dateianhänge erlaubt sind
xmp_part()	&str	XMP pdfaid:part value
xmp_conformance()	&str	XMP pdfaid:conformance value
from_xmp(part, conformance)	Option<Self>	Stufe aus XMP-Metadatenwerten parsen

Nächste Schritte

• PDF/UA-Barrierefreiheit – Barrierefreiheitsvalidierung
• PDF/X-Druckproduktion – Druckproduktionsvalidierung
• API-Referenz – vollständige Rust-API