Artículo técnico

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

veraPDF rechaza un informe trimestral etiquetado por el ISO 14289-1 §7.21.8 porque un único operador Tj muestra los bytes <0000>, que bajo Identity-H significa CID 0, el glifo .notdef. Esa cláusula y su vecina §7.21.6, que limita los nombres de glifo que un array /Differences TrueType puede usar, aparecen en Delphi como flags separados en el resultado de TPdf.ValidatePdfUa de PDFium Component

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

Todo operador que muestra texto cuyo operando mapea al glifo 0 lo hace. En una fuente simple, .notdef es un nombre de glifo. En una fuente CID-keyed el mismo papel corresponde al CID 0, y el ISO 32000-2 §9.7.4.2 exige que toda CIDFont contenga una descripción de glifo para el CID 0 «análoga al nombre de carácter .notdef en las fuentes simples». Con la codificación habitual Identity-H, código de carácter y CID son los mismos dos bytes, así que un flujo de contenido que muestra <0000> con Tj, o dentro de un array TJ, está dibujando el CID 0. El ISO 14289-1 §7.21.8 prohíbe que cualquier operador de texto lo haga, y PDF/UA-2 enuncia el mismo requisito en el §8.4.5.9. El modo de renderizado de texto es irrelevante. El texto invisible en modo 3, como la capa OCR sobre una página escaneada, cuenta también. En pantalla el resultado suele ser una caja vacía de unos pocos puntos de ancho, o ninguna marca, y nada de eso dice a un corrector vidente que un carácter se perdió

La fuente habitual es un generador que se encontró con un carácter ausente de su fuente subset y escribió el código 0 donde debía cambiar a una fuente de respaldo. Eso hace la comprobación a nivel de bytes agradablemente precisa. Decodifica solo los flujos referenciados por el /Contents de cada página, busca <0000> alimentando a Tj o TJ en un documento que use fuentes Type 0, y deja las imágenes, los perfiles ICC y las CMaps comprimidos. Un detalle de parseo decide si encuentras las páginas siquiera. El 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 de la forma con espacio /Type /Page se lo salta. Nombrar /.notdef dentro de un array 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 PDFium Component informa en Delphi
todo operador de texto que alimenta el código 0 a una fuente Identity-H dibuja el CID 0, así que el test de bytes lo informa aunque el texto sea invisible

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

Los que aparecen en la Adobe Glyph List, siempre que el programa de fuente incrustada contenga también una subtabla cmap (3,1). El trasfondo es el ISO 32000-2 §9.6.5.4, que recomienda que una fuente TrueType no simbólica use MacRomanEncoding o WinAnsiEncoding sin array Differences; PDF/UA convierte ese consejo en requisito con una trampilla de escape. Las dos partes de PDF/UA enuncian el test 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 array /Differences o bien cada nombre de ese array es conforme a Unicode. La condición (3,1) se sigue del orden de selección de glifos que el §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 a Unicode por la Adobe Glyph List, y Unicode a glifo por la subtabla (3,1). Un nombre fuera de la lista rompe el paso del medio, y una fuente sin la subtabla nunca toma ese camino. La regla de la fuente simbólica apunta al otro lado: una fuente TrueType simbólica no debe llevar entrada /Encoding alguna

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

La segunda fila es donde las listas de glifos caseras se equivocan. La lista que veraPDF embarca con su código de fuentes, font/AdobeGlyphList.txt, tiene 4.282 entradas, y su primera línea es .notdef 0000. Las tablas montadas a mano o tomadas de otras fuentes a menudo carecen de esa entrada, porque .notdef no representa ningún carácter real. Un comprobador construido sobre tal tabla informa toda fuente cuyo array Differences mencione /.notdef, un nombre que aparece con regularidad en fuentes subset que rellenan con él las ranuras sin usar. La coincidencia es por nombre entero. Una búsqueda de subcadena aceptaría /grav solo porque /grave está en la lista. Rellena las ranuras Differences sin usar con .notdef sin miedo; un comprobador que sigue a veraPDF lo acepta

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

Un atajo natural es guardar una copia normalizada del documento y escanear esa, porque un archivo reescrito se parsea más fácil. Para las reglas de fuentes, eso falla. Cualquier herramienta que reserialice un PDF puede reconstruir diccionarios de fuentes: plegar un array Differences en una codificación nueva, renombrar glifos, renumerar objetos. Una regla de codificación tiene por tanto que comprobarse contra los bytes que el productor escribió. TPdf.ValidatePdfUa ejecuta sus tests de fuentes sobre el archivo o buffer de memoria que cargó y decodifica los flujos FontFile2 directamente para llegar al directorio de tablas TrueType. El test 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; el test de bytes del CID 0 no hace tal excepción. Los hallazgos llegan como valores separados en el conjunto de issues, así que un informe 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)');
      // Localiza 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 cuyo único fallo es /g123 en un array Differences:
    // la única línea del 7.21.6
  finally
    Pdf.Free;
  end;
end;

Las reparaciones pertenecen al programa que escribió el archivo

Ninguno de los dos hallazgos se puede reparar con seguridad después editando un diccionario. Una referencia al CID 0 significa que un carácter no tenía glifo en la fuente usada, 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 array Differences con nombres como /g123 suele venir de hacer un subset de una fuente cuyos glifos no llevan nombres estándar. La reparación limpia es incrustar esa cara como fuente TrueType CID-keyed, la configuración usada para la incrustación de fuentes CID Type 2, con Identity-H y una CMap /ToUnicode. Eso saca de juego la regla de codificación de fuente simple

Poner el flag Symbolic para que el §7.21.6 desaparezca es el movimiento equivocado. Una fuente TrueType simbólica no puede llevar /Encoding en absoluto. Los nombres Differences que decían a un lector de pantalla qué carácter representa cada código desaparecen con él, y cada visor pasa a elegir glifos por código crudo vía la subtabla (3,0) o (1,0). El flag se limpia. El significado del texto se va con él

¿Tiene el programa de fuente incrustado una subtabla cmap (3,1)?

Pregúntale al programa de fuente directamente, porque el flag de codificación cubre ambas mitades del test y no puede decir cuál falló. Cuando dispara y todos los nombres Differences están en la lista, el programa es el siguiente sospechoso. Un archivo TrueType empieza con una cabecera de 12 bytes cuyos bytes 4–5 guardan el número de tablas, seguida de registros de tabla de 16 bytes (tag, checksum, offset, longitud). La tabla cmap empieza con una versión y un recuento de subtablas, seguidos de registros de 8 bytes de ID de plataforma, ID de codificación y offset, todo big-endian. No hace falta ninguna biblioteca de fuentes. TPdf.GetFontData devuelve el programa incrustado de la fuente que usa un objeto de página, así que el ayudante puede correr sobre cada objeto de texto de una página:

Recorrido de bytes por un programa TrueType incrustado: cabecera, registros de tabla y registros cmap que deciden la subtabla (3,1), leído 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 existe el camino Unicode
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 repetidas veces. Eso es inofensivo aquí. Un programa CFF desnudo (FontFile3 con /Type1C o /CIDFontType0C) no tiene directorio de tablas, así que el ayudante responde False para él, y como la regla se refiere a fuentes TrueType esa respuesta nunca decide nada aquí. Las fuentes OpenType con contornos CFF difieren: llevan un directorio sfnt bajo el tag OTTO y pueden incluir un cmap, que el mismo bucle encuentra. Mientras el programa está en memoria, merece la pena comparar sus anchos de avance del hmtx 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 un flag del §7.21.6, ninguna edición de su array Differences limpiará el hallazgo, y el generador necesita incrustar esa cara como fuente Type 0 con una CMap ToUnicode. Ejecuta de nuevo la validación del PDFium Component para Delphi sobre el archivo regenerado y espera que pvuaiTrueTypeEncodingInvalid esté ausente de Report.Issues