Artículo técnico

PDF/UA rechaza .notdef y nombres Differences fuera de lista

veraPDF falla un reporte trimestral con tags por ISO 14289-1 §7.21.8 porque un solo operador Tj muestra los bytes <0000>, que bajo Identity-H significan CID 0, el glifo .notdef. Esa cláusula y su vecina §7.21.6, que limita los nombres de glifo que un arreglo /Differences de TrueType puede usar, aparecen en Delphi como flags separados en el resultado del TPdf.ValidatePdfUa de PDFium Component

¿Qué operadores de texto referencian el glifo .notdef?

Todos los operadores que muestran texto cuyo operando mapea al glifo 0. En una fuente simple, .notdef es un nombre de glifo. En una fuente con clave CID el mismo papel le toca al CID 0, e ISO 32000-2 §9.7.4.2 exige que cada CIDFont contenga una descripción de glifo para el CID 0 "analogous to the .notdef character name in simple fonts". Con la codificación Identity-H de siempre, el código de carácter y el CID son los mismos dos bytes, así que un content stream que muestra <0000> con Tj, o dentro de un arreglo TJ, está dibujando el CID 0. ISO 14289-1 §7.21.8 prohíbe que cualquier operador que muestra texto lo haga, y PDF/UA-2 enuncia el mismo requisito en §8.4.5.9. El modo de renderización del texto da igual. El texto invisible en modo 3, como la capa OCR sobre una página escaneada, también cuenta. En pantalla el resultado suele ser una caja vacía de unos puntos de ancho, o ninguna marca, y ninguno de los dos le dice a un corrector con vista que un carácter se perdió

La fuente habitual es un generador que se encontró un carácter ausente de su fuente de subconjunto y escribió el código 0 donde debía cambiar a una fuente de respaldo. Eso hace la revisión a nivel de bytes agradablemente precisa. Decodifique solo los streams que referencian los /Contents de cada página, busque <0000> alimentando a Tj o TJ en un documento que usa fuentes Type 0, y deje imágenes, perfiles ICC y CMaps comprimidos. Un detalle de parseo decide si encuentra las páginas o no. ISO 32000-1 §7.3.5 termina un token de nombre en el siguiente delimitador, así que /Type/Page sin espacio es un diccionario de página válido, y una búsqueda por la forma espaciada /Type /Page se lo salta. Nombrar /.notdef dentro de un arreglo Differences no dispara esta regla por sí mismo; solo mostrar un código que caiga en esa ranura lo hace

Flujo que muestra un operando 0000 bajo Identity-H llegando al CID 0 y al glifo .notdef, con la cláusula ISO 14289 que reporta PDFium Component en Delphi
cualquier operador que muestra texto y alimenta el código 0 a una fuente Identity-H dibuja el CID 0, así que la prueba de bytes lo reporta incluso cuando el texto es invisible

¿Qué nombres de glifo /Differences cuentan como Unicode compliant?

Los nombres que aparecen en el Adobe Glyph List sí, siempre que el programa de fuente embebido también contenga una subtabla cmap (3,1). El trasfondo es ISO 32000-2 §9.6.5.4, que recomienda que una fuente TrueType no simbólica use MacRomanEncoding o WinAnsiEncoding sin arreglo Differences; PDF/UA convierte ese consejo en requisito con una única puerta de escape. Ambas partes de PDF/UA enuncian la prueba en la misma forma que aplica veraPDF: la fuente es simbólica, o su codificación es MacRoman o WinAnsi y o bien no tiene arreglo /Differences o cada nombre en ese arreglo es Unicode compliant. La condición (3,1) se sigue del orden de selección de glifos que §9.6.5.4 prescribe cuando esa subtabla (plataforma Microsoft, Unicode BMP) está presente. El código de carácter va a nombre de glifo por la codificación, el nombre de glifo va a Unicode por el Adobe Glyph List, y Unicode va a glifo por la subtabla (3,1). Un nombre fuera de la lista rompe el paso de en medio, y una fuente sin la subtabla nunca toma ese camino. La regla de fuente simbólica apunta al otro lado: una fuente TrueType simbólica no debe cargar entrada /Encoding alguna

Cadena de selección de glifos desde el código de carácter por el Adobe Glyph List hasta una subtabla cmap (3,1), la prueba TrueType que aplica PDFium Component en Delphi
un nombre Differences solo llega a un glifo cuando se sostiene la cadena de codificación, Adobe Glyph List y subtabla cmap (3,1), que es donde falla la prueba de nombres PDF/UA en PDFium Component para Delphi
Diccionario de fuenteResultado
No simbólico, /Encoding /WinAnsiEncoding, sin DifferencesPasa
No simbólico, base WinAnsi, Differences con /Euro /bullet /.notdef, la fuente tiene cmap (3,1)Pasa
No simbólico, Differences con /g123 o /glyph57Falla: nombres fuera de la lista de glifos
No simbólico, Differences válidos, la fuente embebida solo tiene cmap Mac (1,0)Falla: sin subtabla (3,1)
No simbólico, base WinAnsi con Differences, sin FontFile2 embebidoEsta regla no lo decide; la regla de embebido (§7.21.4) lo falla
No simbólico, sin entrada /EncodingFalla
Simbólico, cualquier entrada /EncodingFalla la regla simbólica

La segunda fila es donde las listas de glifos hechas en casa se equivocan. La lista que veraPDF manda con su código de fuentes, font/AdobeGlyphList.txt, tiene 4,282 entradas, y su primera línea es .notdef 0000. Las tablas armadas a mano o tomadas de otras fuentes a menudo carecen de esa entrada, porque .notdef no representa carácter real alguno. Un checker construido sobre una tabla así reporta toda fuente cuyo arreglo Differences mencione /.notdef, un nombre que aparece con regularidad en fuentes de subconjunto que rellenan las ranuras sin uso con él. El emparejamiento es por nombre completo. Una búsqueda de subcadena aceptaría /grav solo porque /grave está en la lista. Rellene las ranuras Differences sin uso con .notdef con toda libertad; un checker que sigue a veraPDF lo acepta

Las reglas de fuentes se juzgan sobre los bytes que escribió el productor

Un atajo natural es guardar una copia normalizada del documento y escanear esa, porque un archivo reescrito es más fácil de parsear. Para las reglas de fuentes, eso falla. Cualquier herramienta que re-serializa un PDF es libre de reconstruir diccionarios de fuente: doblar un arreglo Differences dentro de una codificación fresca, renombrar glifos, renumerar objetos. Una regla de codificación entonces hay que revisarla contra los bytes que escribió el productor. TPdf.ValidatePdfUa corre sus pruebas de fuentes sobre el archivo o buffer de memoria que cargó y decodifica los streams FontFile2 directo para llegar al directorio de tablas TrueType. La prueba a nivel de carácter (¿un carácter dibujado mapea a Unicode 0?) usa el texto que la página renderiza y se salta el contenido marcado como Artifact o cubierto por /ActualText; la prueba de bytes del CID 0 no hace tal excepción. Los hallazgos llegan como valores separados en el issue set, así que un reporte puede decir qué regla disparó:

uses
  SysUtils, PDFium, FPdfPdfua;

procedure ReportFontFindings(const FileName: string);
const
  FontIssues: TPdfUaValidationIssues = [pvuaiPdfiumNotDefGlyph,
    pvuaiTrueTypeEncodingInvalid, pvuaiSymbolicTrueTypeEncoding,
    pvuaiFontNotEmbedded, pvuaiFontMissingToUnicode];
var
  Pdf: TPdf;
  Report: TPdfUaValidationResult;
  Found: TPdfUaValidationIssues;
  Coverage: TPdfUaUnicodeCoverageReport;
  I: Integer;
begin
  Pdf := TPdf.Create(nil);
  try
    Pdf.FileName := FileName;
    Pdf.Active := True;
    if not Pdf.Active then
      raise Exception.CreateFmt('Cannot open %s', [FileName]);
    Report := Pdf.ValidatePdfUa;
    Found := Report.Issues * FontIssues;
    if pvuaiPdfiumNotDefGlyph in Found then
    begin
      Writeln('Text references .notdef / CID 0 (7.21.8, 8.4.5.9)');
      // Localice los caracteres renderizados que no mapean a ningún valor Unicode
      Coverage := Pdf.InspectPdfUaUnicodeCoverage;
      for I := 0 to High(Coverage.Objects) do
        if Coverage.Objects[I].MissingUnicodeCharacterCount > 0 then
          Writeln(Format('  page %d, object %d: %d character(s)',
            [Coverage.Objects[I].PageNumber,
             Coverage.Objects[I].PageObjectIndex,
             Coverage.Objects[I].MissingUnicodeCharacterCount]));
    end;
    if pvuaiTrueTypeEncodingInvalid in Found then
      Writeln('Non-symbolic TrueType encoding or Differences (7.21.6, 8.4.5.7)');
    if pvuaiSymbolicTrueTypeEncoding in Found then
      Writeln('Symbolic TrueType font carries an /Encoding entry');
    if pvuaiFontNotEmbedded in Found then
      Writeln('A font program is not embedded (7.21.4)');
    if pvuaiFontMissingToUnicode in Found then
      Writeln('A font has no usable Unicode mapping (7.21.7)');
    if Found = [] then
      Writeln('No font findings');
    // Esperado para un archivo cuya única falla es /g123 en un arreglo Differences:
    // la única línea de 7.21.6
  finally
    Pdf.Free;
  end;
end;

Las reparaciones pertenecen al programa que escribió el archivo

Ninguno de los dos hallazgos se repara con seguridad después editando un diccionario. Una referencia al CID 0 significa que un carácter no tenía glifo en la fuente que se usó, así que el generador necesita una fuente de respaldo para ese carácter. Reescribir <0000> a otro código dibujaría un glifo arbitrario y le pegaría el valor Unicode equivocado. Un arreglo Differences con nombres como /g123 suele venir de subconjuntar una fuente cuyos glifos no cargan nombres estándar. La reparación limpia es embeber esa cara como fuente TrueType con clave CID, el montaje que se usa para el embebido de fuentes CID Type 2, con Identity-H y un CMap /ToUnicode. Eso saca de juego la regla de codificación de fuente simple

Poner la bandera Symbolic para que §7.21.6 desaparezca es el movimiento equivocado. Una fuente TrueType simbólica no puede cargar /Encoding para nada. Los nombres Differences que le decían a un screen reader qué carácter representa cada código desaparecen con ella, y cada visor entonces elige glifos por código crudo por la subtabla (3,0) o (1,0). La bandera se limpia. El significado del texto se va con ella

¿El programa de fuente embebido tiene un cmap (3,1)?

Pregúntele al programa de fuente directamente, porque la bandera de codificación cubre las dos mitades de la prueba y no puede decir cuál falló. Cuando dispara y cada nombre Differences está en la lista, el programa es el siguiente sospechoso. Un archivo TrueType abre con un encabezado de 12 bytes cuyos bytes 4–5 cargan el número de tablas, seguido de registros de tabla de 16 bytes (tag, checksum, offset, longitud). La tabla cmap abre con una versión y un conteo de subtablas, seguidos de registros de 8 bytes de platform ID, encoding ID y offset, todo big-endian. No hace falta librería de fuentes. TPdf.GetFontData devuelve el programa embebido de la fuente que usa un objeto de página, así que el helper puede correr sobre cada objeto de texto de una página:

Caminata por bytes dentro de un programa TrueType embebido: encabezado, registros de tabla y registros cmap que deciden la subtabla (3,1), leídos por PDFium Component en Delphi
la respuesta (3,1) sale del propio programa de fuente: los registros de tabla localizan el cmap, y sus registros de 8 bytes de plataforma y codificación deciden si el camino Unicode existe
function BE16(const B: TBytes; P: Integer): Integer;
begin
  Result := (B[P] shl 8) or B[P + 1];
end;

function BE32(const B: TBytes; P: Integer): Cardinal;
begin
  Result := (Cardinal(B[P]) shl 24) or (Cardinal(B[P + 1]) shl 16) or
    (Cardinal(B[P + 2]) shl 8) or B[P + 3];
end;

// True cuando un programa TrueType tiene una subtabla cmap para (Platform, Encoding)
function HasCmapSubtable(const Font: TBytes; Platform, Encoding: Integer): Boolean;
var
  Tables, I, Rec, CmapOfs, Count: Integer;
begin
  Result := False;
  if Length(Font) < 12 then
    Exit;
  Tables := BE16(Font, 4);
  CmapOfs := -1;
  for I := 0 to Tables - 1 do
  begin
    Rec := 12 + I * 16;
    if Rec + 16 > Length(Font) then
      Exit;
    if (Font[Rec] = Ord('c')) and (Font[Rec + 1] = Ord('m')) and
       (Font[Rec + 2] = Ord('a')) and (Font[Rec + 3] = Ord('p')) then
      CmapOfs := Integer(BE32(Font, Rec + 8));
  end;
  if (CmapOfs < 0) or (CmapOfs + 4 > Length(Font)) then
    Exit;
  Count := BE16(Font, CmapOfs + 2);
  for I := 0 to Count - 1 do
  begin
    Rec := CmapOfs + 4 + I * 8;
    if Rec + 8 > Length(Font) then
      Exit;
    if (BE16(Font, Rec) = Platform) and (BE16(Font, Rec + 2) = Encoding) then
      Exit(True);
  end;
end;

// Una cara con solo un cmap Mac Roman (1,0) imprime cmap(3,1)=False
procedure ListTextFonts(Pdf: TPdf; PageNo: Integer);
var
  I: Integer;
begin
  Pdf.PageNumber := PageNo;
  for I := 0 to Pdf.ObjectCount - 1 do
    if Pdf.ObjectType[I] = otText then
      Writeln(Format('%-32s embedded=%-5s cmap(3,1)=%s', [
        string(Pdf.GetFontBaseName(I)),
        BoolToStr(Pdf.GetFontIsEmbedded(I), True),
        BoolToStr(HasCmapSubtable(Pdf.GetFontData(I), 3, 1), True)]));
end;

Los objetos de texto que comparten fuente imprimen la misma línea repetida. Eso es inofensivo aquí. Un programa CFF desnudo (FontFile3 con /Type1C o /CIDFontType0C) no tiene directorio de tablas, así que el helper responde False para él, y como la regla concierne a fuentes TrueType esa respuesta nunca decide nada aquí. Las fuentes OpenType con outlines CFF son distintas: cargan un directorio sfnt bajo el tag OTTO y pueden incluir un cmap, que el mismo bucle encuentra. Mientras el programa está en memoria, sus anchos de avance de hmtx también valen la pena compararlos con los /Widths del diccionario de fuente, porque PDF/UA tiene una regla separada de consistencia de anchos, y auditar anchos de glifo, CharSet y CIDSet la aplica desde el lado de PDFlibPas

Si HasCmapSubtable devuelve False para la cara detrás de una bandera §7.21.6, ninguna edición a su arreglo Differences limpiará el hallazgo, y el generador necesita embeber esa cara como fuente Type 0 con un CMap ToUnicode. Corra otra vez la validación del PDFium Component para Delphi sobre el archivo regenerado y espere que pvuaiTrueTypeEncodingInvalid esté ausente de Report.Issues