Artigo Técnico

HotPDF CompressDocument: font subsets compactos no Delphi

Dois caracteres chineses definidos em SimSun e passados por um subsetter TrueType comum ainda deixam cerca de 25 KB de dados de fonte embutida no PDF. Os contornos desses dois ideógrafos são uma fração mínima disso. O resto é contabilidade de slots: o subset manteve a numeração original de glyphs, então ele ainda carrega uma entrada de localização e uma entrada de largura para cada glyph ID até o mais alto que reteve, e em uma face CJK os ideógrafos ficam fundo em uma tabela muito grande. Renumere os sobreviventes a partir de zero, deixe um stream /CIDToGIDMap traduzir, e os mesmos dois caracteres cabem em cerca de 3 KB

Para onde vão os bytes num font subset esparso

Um subset esparso continua pesado porque se recusa a mover qualquer glyph. O HotPDF grava texto Unicode como uma fonte Type 0 sobre um descendente CIDFontType2, e o content stream mostra cada glyph pelo glyph ID original dele usado como CID. Com /CIDToGIDMap /Identity, a ISO 32000-1 §9.7.4.2 diz ao visualizador para tratar aquele CID diretamente como o índice de glyph. Renumere os glyphs dentro do programa de fonte e deixe todo o resto em paz, e cada caractere na página aponta para o contorno errado. Manter a numeração é a resposta barata e segura. O preço dela é que loca e hmtx precisam cobrir todo slot até o GID mais alto mantido, vazio ou não

Suponha uma face CJK que declara 28,000 glyphs e um dos seus dois caracteres fica perto do fim. Uma tabela loca em formato longo gasta 4 bytes por slot, cerca de 112 KB, e métricas horizontais completas gastam outros 4 bytes por slot. São mais de 200 KB de tabelas antes da compressão, quase tudo zeros e offsets repetidos. O Flate encolhe sequências assim muito bem, mas não consegue fazê-las desaparecer, e é dali que vem a maior parte daqueles 25 KB. Uma face latina com alguns milhares de glyphs carrega a mesma estrutura em um décimo da escala, então o custo realmente cai sobre documentos que misturam texto em chinês, japonês ou coreano

Quais glyphs sobrevivem em primeiro lugar (componentes compostos, alternatas puxadas por shaping) é decidido antes, pelas regras de closure de font subset para glyphs com shaping. A compactação só muda o que os sobreviventes custam depois que esse conjunto está fixado

Font subsets compactos atrás de um stream CIDToGIDMap

O THotPDF.CompactFontSubsetting renumera os glyphs mantidos em uma faixa densa começando em zero, reconstrói as tabelas de glyphs só para esses glyphs e grava um stream /CIDToGIDMap explícito no CIDFont. A ISO 32000-1 §9.7.4.2 define esse stream como um array de glyph IDs de dois bytes, big-endian, indexado por CID: o GID do CID n fica no offset de byte 2n. Content streams, o array de larguras /W e o CMap ToUnicode todos mantêm os números originais como CIDs. Só o passo de CID para glyph se move para dentro do mapa, então nada do que já foi gravado em uma página precisa ser tocado

A propriedade funciona por conta própria. Você não precisa do resto da maquinaria de compressão para ter fontes menores, e para um relatório que é majoritariamente texto CJK esse par de configurações faz a maior parte do trabalho:

Pdf.EnableFontSubsetting := True;
Pdf.CompactFontSubsetting := True;   // utilizável sem CompressDocument
Pdf.BeginDoc;
Pdf.CurrentPage.SetFont('SimSun', [], 12);
Pdf.CurrentPage.TextOut(40, 40, 0, WideString('Total: '#$4E2D#$6587));
Pdf.EndDoc;
Comparação entre um font subset esparso do HotPDF, que retém entradas de loca e hmtx para todo glyph ID original até o GID retido mais alto, e a saída do CompactFontSubsetting, que renumera os glyphs mantidos densamente a partir de zero e mapeia CIDs por um stream CIDToGIDMap enquanto content streams, /W e ToUnicode ficam inalterados
A renumeração move o custo para fora do programa de fonte e para dentro de um pequeno stream de mapa — dois caracteres SimSun caem de cerca de 25 KB para cerca de 3 KB sem tocar um byte de conteúdo já gravado

A compactação se aplica a um tipo específico de fonte. O HotPDF constrói subsets compactos para faces Type 0 TrueType: as definidas por meio de SetFont com o EnableFontSubsetting ligado, e a face registrada por meio de RegisterUnicodeTTF. Uma fonte TrueType simples é localizada pelo cmap dentro do próprio programa de fonte dela, e a renumeração deixaria esse cmap apontando para os glyphs errados, então fontes simples mantêm o subset esparso. Faces OpenType-CFF também mantêm. Se a construção compacta falha para uma fonte em particular, o HotPDF grava o subset esparso para essa fonte e segue com o documento. A propriedade é desligada por padrão, então a saída existente continua idêntica byte a byte até você optar por entrar; sob PDF/A, a face Unicode registrada sempre recebe um subset compacto

Uma armadilha fica do lado da leitura. Um stream /CIDToGIDMap parece pertencer ao lado dos CMaps, mas ele é binário bruto sem blocos begincidchar, e entregá-lo a um tokenizador de CMap rende um mapeamento vazio sem erro nenhum. Se a sua própria ferramenta extrai texto ou mede glyphs desses arquivos, leia o mapa como pares de 16 bits simples

O que o CompressDocument muda para um documento?

O THotPDF.CompressDocument toma emprestadas seis configurações do writer mais o teto de object streams no BeginDoc e devolve todas no EndDoc. Antes de a versão do PDF se fixar, o HotPDF registra os seus valores e então define:

  • Compression como cmFlateDecode e CompressionLevel como clMaximum
  • EnableFontSubsetting e CompactFontSubsetting como True
  • UseXRefStream e UseObjectStreams como True, pela ISO 32000-1 §7.5.7 e §7.5.8
  • O teto de objetos por contêiner para 250 em vez dos 100 usuais, a menos que você já tenha definido o seu por meio do ConfigureAdaptiveObjectStreamPacking

Object streams precisam de PDF 1.5, então uma Version mais velha é elevada a 1.5 quando a versão não está travada. O PDF/A-1 proíbe cross-reference streams e object streams de forma absoluta, então um documento PDF/A-1 mantém a tabela de cross-reference clássica e recebe só o trabalho de Flate e de fontes. Imagens são gravadas exatamente como você as embutiu; nada é reamostrado ou recomprimido com perda

Diagrama do ciclo de vida do CompressDocument do HotPDF em Delphi: o BeginDoc registra os valores próprios do gravador, sobrepõe seis configurações incluindo Compression e UseObjectStreams por um documento, e o EndDoc restaura todo valor emprestado no finally mais externo dele enquanto a propriedade CompressDocument em si fica True
Seis configurações de gravação e o teto de object streams são emprestados por exatamente um documento e devolvidos quando o EndDoc roda, então um relatório que falha nunca deixa o componente preso na compressão máxima
var
  Pdf: THotPDF;
begin
  Pdf := THotPDF.Create(nil);
  try
    Pdf.AutoLaunch := False;
    Pdf.FileName := 'invoice-2026-1042.pdf';
    Pdf.CompressDocument := True;    // aplicado pelo BeginDoc, desfeito pelo EndDoc
    Pdf.BeginDoc;
    Pdf.CurrentPage.SetFont('Arial', [], 12);
    Pdf.CurrentPage.TextOut(40, 40, 0, 'Invoice 2026-1042');
    Pdf.CurrentPage.SetFont('SimSun', [], 12);
    Pdf.CurrentPage.TextOut(40, 60, 0, WideString(#$5408#$8BA1));
    Pdf.EndDoc;
  finally
    Pdf.Free;
  end;
end;

A restauração roda no finally mais externo do EndDoc. Isso importa para um componente que vive em um data module e grava centenas de relatórios por dia: uma exceção no meio de um relatório não deixa o próximo job rodando na compressão máxima com subsetting forçado. A propriedade CompressDocument em si continua True, então o próximo documento recebe o mesmo tratamento, e só as configurações emprestadas voltam

A versão recebe um tratamento mais cuidadoso. O HotPDF desfaz a própria elevação para 1.5 só se o documento ainda termina em 1.5. Quando outro recurso empurra o arquivo para cima durante a execução (uma fonte OpenType embutida que precisa de 1.6, digamos), a versão maior fica, que é exatamente o resultado que você teria sem compressão. Para um componente de vida longa, isso é um design mais seguro do que definir as seis propriedades à mão uma vez na inicialização, porque valores definidos à mão ficam colados em todo job seguinte, incluindo os editáveis

Aparando sintaxe, offsets e empacotamento de object streams

Quando fontes e streams já estão pequenos, os dicionários e os dados de cross-reference viram o maior custo restante, e o gravador de object streams usado pelo CompressDocument enxuga isso também. O formato de contêiner em si é coberto no guia de object streams e incremental updates. Por cima dele, o caminho de compressão adiciona quatro refinamentos:

  • Sintaxe compacta pela ISO 32000-1 §7.2.2: um espaço é gravado só onde dois tokens caso contrário correriam juntos como caracteres regulares, então /Type /Page vira /Type/Page
  • Os campos do cross-reference stream usam qualquer largura que a §7.5.8.2 permite, então um arquivo abaixo de 16 MB guarda cada offset em 3 bytes em vez de 4
  • Até 250 objetos entram em cada object stream; menos contêineres maiores dão ao Flate mais repetição para trabalhar
  • Em um arquivo não criptografado, o Catalog e o dicionário Info também são empacotados em object streams, enquanto a saída criptografada os mantém no nível de topo

A sintaxe compacta esbarra em qualquer coisa que aplique patch em um arquivo buscando no texto dele. Assinatura é o caso óbvio. O valor da assinatura é preenchido depois de o arquivo ser gravado, localizando os placeholders literais /ByteRange ( e /Contents < nos bytes de saída. Grafados de forma compacta, eles viram /ByteRange( e /Contents<, e uma busca literal nunca os encontra. O HotPDF portanto grava dicionários de assinatura (Type Sig ou DocTimeStamp, ou FT Sig) e o dicionário de criptografia com o layout espaçado. Qualquer script pós-save seu que faça grep por /Type /Page ou tokens espaçados parecidos precisa de um padrão que tolere o espaço ausente

Dá para comprimir um PDF que já está carregado?

Sim. O overload de opções CompressLoadedDocument(Options, AInfo) roda os mesmos passos sem perdas sobre um arquivo existente. Com THPDFLoadedDocumentCompressionOptions.Default, ele remove recursos de página não usados, mescla fontes e form XObjects idênticos, faz subsetting de fontes embutidas com subsets compactos ligados, recomprime streams sem filtro, Flate, LZW, ASCII85, ASCIIHex e RunLength com Flate sempre que o resultado é menor, e faz o próximo save usar object streams. O HighRatioFlate fica desligado por padrão, e object streams são pulados para PDF/A-1 e para saves incrementais. O overload sem parâmetros do CompressLoadedDocument é a chamada mais estreita: ele só comprime com Flate streams que estão armazenados sem compressão

var
  Doc: THotPDF;
  Options: THPDFLoadedDocumentCompressionOptions;
  Info: THPDFLoadedDocumentCompressionInfo;
begin
  Doc := THotPDF.Create(nil);
  try
    Doc.AutoLaunch := False;
    Doc.LoadFromFile('quarterly-report.pdf');
    Options := THPDFLoadedDocumentCompressionOptions.Default;
    // Options.AllowSignatureInvalidation := True;  // só se perder assinaturas for aceitável
    Doc.CompressLoadedDocument(Options, Info);
    if Info.RefusedBySignaturePolicy then
      Writeln(Format('Left untouched: %d signature fields', [Info.SignatureCount]))
    else
    begin
      Writeln(Format('Compact fonts: %d, bytes saved before object streams: %d',
        [Info.Fonts.CompactSubsetFontCount, Info.BytesSaved]));
      Doc.SaveLoadedDocument('quarterly-report-compact.pdf');
    end;
  finally
    Doc.Free;
  end;
end;

Arquivos assinados são tratados como uma decisão única. Cada passo reescreve bytes que uma assinatura cobre, então um documento com signature fields é recusado como um todo: a chamada retorna 0, define RefusedBySignaturePolicy e não muda nada. Definir AllowSignatureInvalidation deixa o trabalho seguir, e o Info.SignaturesInvalidated então registra que as assinaturas não verificam mais. Deixe essa opção desligada em jobs em lote. Uma pasta de contratos comprimida durante a noite é um lugar ruim para descobrir que metade deles carregava assinaturas

Fluxo do CompressLoadedDocument do HotPDF em Delphi: a chamada remove recursos de página não usados, mescla fontes e forms idênticos, faz subsetting de fontes embutidas com subsets compactos, recomprime streams com Flate só quando o resultado é menor, e liga object streams para o próximo save, enquanto signature fields disparam RefusedBySignaturePolicy e deixam o arquivo intocado
Cada passo reescreve bytes que uma assinatura cobre, então o documento inteiro é recusado a menos que você permita invalidação explicitamente — o Info.BytesSaved então soma só o trabalho de recursos, fontes e streams

A compactação no caminho carregado é mais estrita que no caminho de criação, por um motivo que vem direto do formato de arquivo. Quando as fontes são submetidas a subsetting, o decodificador já transformou todo CID em um GID por meio do /CIDToGIDMap que o arquivo carregava, mas um mapa compacto novo precisa ser indexado por CID. Os dois só se alinham quando CID é igual a GID. O HotPDF portanto compacta um programa de fonte só quando toda fonte que o usa é uma CIDFontType2 com /CIDToGIDMap Identity. Programas que já têm um stream de mapa, fontes TrueType simples e fontes com um /CIDSet recebem o subset esparso. O mesmo vale para faces com tabelas de glyphs de cor (COLR, sbix, CBDT ou SVG), porque a reconstrução compacta mantém só tabelas de contorno e descartaria as camadas de cor

Leia o Info.BytesSaved pelo que ele é. Ele soma os passos de recursos, fontes e streams, enquanto o ganho de object streams aparece só quando o SaveLoadedDocument grava o arquivo, então compare os tamanhos de arquivo no disco para o número completo

Cópias finais versus documentos que ainda mudam

Os ganhos acompanham quanto do arquivo é estrutura sem compressão e dados de fonte acima do tamanho, e a contagem de páginas tem pouco a ver com isso. Para um documento de três páginas com texto misto em inglês e chinês em Arial e SimSun com as duas fontes totalmente embutidas, o arquivo sem compressão fica em cerca de 10 MB; gerado com CompressDocument, ele chega a aproximadamente 20 KB, com a maior parte da queda vindo do font subsetting, e o CompressLoadedDocument para no mesmo intervalo com o original sem compressão. Um PDF que já é compacto mal se move. Arquivos pesados em fotos ganham pouco, porque nenhum dos caminhos toca dados de imagem

O custo é a editabilidade. Uma fonte subset só consegue mostrar os caracteres que o documento já usa, então um AcroForm que alguém preenche depois, ou uma edição incremental que adiciona texto novo na mesma fonte, pode esbarrar em glyphs ausentes. Object streams empacotados também deixam de ser legíveis em um editor de texto, o que atrasa qualquer sessão de debug que começa abrindo o PDF no Notepad. Ligue o CompressDocument para cópias finais: faturas arquivadas, extratos, qualquer coisa gerada uma vez e só lida depois. Para templates e formulários que alguém a jusante vai preencher, deixe desligado e mantenha as fontes completas

Se você gera os mesmos relatórios CJK toda noite, emparelhe subsets compactos com o cache persistente de font subsets em disco para o trabalho de subsetting não ser refeito a cada execução. E quando você compara duas saídas noturnas, faça o diff pelo conteúdo de objeto. Um campo alterado re-Flate o object stream inteiro dele, então um diff de bytes mostra muito mais mudança do que realmente aconteceu

Detalhes de propriedades, records e opções para tudo acima estão na referência na página de produto do componente HotPDF Delphi PDF