PDF rendering with Chinese fonts extremely slow when SubsetFonts=true in Docker deployment

Aspose.PDF Product Family
1

Hello, I’m encountering a performance issue when rendering a PDF using the Aspose.PDF library.
When the document contains Chinese Simplified (zh-CN) or Chinese Traditional (zh-TW) text, I set:

pdfDocument.OptimizeResources(new OptimizationOptions()
{
    SubsetFonts = true
});

On my local machine, calling:

pdfDocument.Save(_request.ResultFile);

takes only about 3 seconds.
However, when I deploy the same code to Docker (Linux-based container) or our test environment, the Save() call takes about 6 minutes under the same conditions.
Some notes:

  • The issue happens only when SubsetFonts = true and the document contains Chinese text.
  • English documents, or Chinese documents with SubsetFonts = false, save quickly.
  • The Docker container already includes required fonts (fonts-noto-cjk, fontconfig, etc.).
  • Local environment: Windows, .NET 6, Aspose.PDF latest version.
  • Docker: Debian-based image, .NET 6, Aspose.PDF same version.

Question:
I would like to keep SubsetFonts = true (to reduce PDF size) but still have the same fast performance as my local environment.

  • Is there any known cause for such a big performance difference in Linux/Docker?
  • Are there recommended font settings, caching, or configuration to speed up SubsetFonts processing for Chinese text in Docker?
  • Could this be related to font file access speed, font fallback resolution, or encoding handling in Linux?

Any advice or best practices to avoid this delay would be greatly appreciated.

Thank you,

2

@tuantran3012

It sounds like you’re experiencing a significant performance issue when rendering PDFs with Chinese text in a Docker environment, particularly when using the SubsetFonts option. Here are some potential causes and actionable steps to improve performance:

Diagnosis & Next Steps

  1. Font Configuration: Ensure that the required Chinese fonts are correctly installed and accessible in your Docker container. Font configuration can differ between environments, leading to performance issues.

  2. Font Caching: Implement font caching mechanisms to reduce the time taken to access and load fonts during PDF rendering.

  3. Resource Optimization: Review your resource optimization settings. While SubsetFonts is beneficial for reducing file size, it may introduce overhead in certain environments. Experiment with different optimization settings to find a balance between performance and file size.

  4. Docker Resource Allocation: Check the resource allocation for your Docker container. Ensure it has sufficient CPU and memory resources, as limited resources can lead to slower processing times.

  5. Testing with Different Images: If possible, try using a different base image for your Docker container. Some images may have better performance characteristics for font handling.

  6. Logging and Monitoring: Implement logging to monitor the performance of the PDF rendering process. This can help identify specific bottlenecks or issues related to font handling.

Example Code Snippet

Here’s a simple example of how you might set up your PDF optimization:

var pdfDocument = new Document("input.pdf");
var optimizationOptions = new OptimizationOptions
{
    SubsetFonts = true,
    CompressImages = true,
    RemoveUnusedObjects = true
};

pdfDocument.OptimizeResources(optimizationOptions);
pdfDocument.Save("output.pdf");

Additional Considerations

  • Font Fallback: Ensure that any fallback fonts your application relies on are also available in the Docker environment.
  • Encoding Handling: Verify that the encoding settings in your application are consistent with those used in your local environment.

Please implement these suggestions and monitor the performance. If you continue to experience issues or have further questions, feel free to reach out for additional assistance!

3

I’ve tried it in many ways, but it still doesn’t work. One thing to note is that when using the NotoSansTC font (or NotoSansTC) and setting SubsetFonts = false, the rendered text comes out incorrect, some parts are missing or displayed wrong.
image.png (3.1 KB)
I also tried another font that supports Chinese well - HanSans Font, but if SubsetFonts = true, it renders text with errors similar to NotoSans with SubsetFonts = false. However, if I set it to true, it renders correctly, but the file size increases significantly. It seems this is an issue related to the library.

4

@tuantran3012
Could you specify what version & library you are using?
In case of Linux it’s common to use Aspose.Pdf Drawing version of library as more adapted to Linux environment, maybe that’s the case in this situation
Also, could you provide file and code you used to investigate issue in our environment?

6

I’m using Aspose.PDF Version=“24.12.0” and I using Aspose.Pdf Drawing version of library
Example my code:

private void Execute()
{
    try
    {
        using var pdfDocument = new Document(_request.ResultFile, true);

        if (pdfDocument == null)
            return;

        var titles = new List<(string Title, int PageNumber)>();
        for (var pageNumber = 2; pageNumber <= pdfDocument.Pages.Count; pageNumber++)
        {
            var page = pdfDocument.Pages[pageNumber];

            page.AddStamp(_logoImageStamp);
            page.AddStamp(_footerImageStamp);

            AddTextStampToPage(page, new TextStamp(pageNumber.ToString(), new()
            {
                Font = _fontsRepository.Weight400,
                FontSize = 12,
                ForegroundColor = Color.Black,
            })
            {
                LeftMargin = PageWidth - RightMargin,
                BottomMargin = InToPoints(0.3),
                HorizontalAlignment = HorizontalAlignment.Left,
                VerticalAlignment = VerticalAlignment.Bottom,
                TextAlignment = HorizontalAlignment.Left,
            });

            var titleRegex = new Regex(@"\[TITLE:(.+)\]");
            var titleAbsorber = new TextFragmentAbsorber(titleRegex);
            titleAbsorber.Visit(page);
            if (titleAbsorber.TextFragments.Any())
            {
                var textFragment = titleAbsorber.TextFragments.First();
                var title = titleRegex.Match(textFragment.Text).Groups[1].Value;
                titles.Add((title, pageNumber));
                textFragment.Text = string.Empty;
                textFragment.TextState.Invisible = true;
            }
        }

        pdfDocument.OptimizeResources(new()
        {
            SubsetFonts = _request.Publication.Language.Code is "ct" or "cs",
            RemoveUnusedObjects = true,
            RemoveUnusedStreams = true,
        });
        pdfDocument.Save(_request.ResultFile);
        pdfDocument.FreeMemory();
    }
    catch
    {
        throw;
    }
}
internal class FontsRepository
{
    public Font Weight300 => _languageCode switch
    {
        "ct" => LoadFont(Path.Combine(_fontsFolder, "NotoSansTC-Light.otf")),
        "cs" => LoadFont(Path.Combine(_fontsFolder, "NotoSansSC-Light.otf")),
        _ => LoadFont(Path.Combine(_fontsFolder, "OpenSans-Light.ttf")),
    };

    public Font Weight400 => _languageCode switch
    {
        "ct" => LoadFont(Path.Combine(_fontsFolder, "NotoSansTC-DemiLight.otf")),
        "cs" => LoadFont(Path.Combine(_fontsFolder, "NotoSansSC-DemiLight.otf")),
        _ => LoadFont(Path.Combine(_fontsFolder, "OpenSans-Regular.ttf")),
    };
    public Font Weight700 => _languageCode switch
    {
        "ct" => LoadFont(Path.Combine(_fontsFolder, "NotoSansTC-Medium.otf")),
        "cs" => LoadFont(Path.Combine(_fontsFolder, "NotoSansSC-Medium.otf")),
        _ => LoadFont(Path.Combine(_fontsFolder, "OpenSans-Bold.ttf")),
    };

    private readonly string _fontsFolder;
    private readonly string _languageCode;

    public FontsRepository(string fontsFolder, string languageCode)
    {
        _fontsFolder = fontsFolder;
        _languageCode = languageCode;
    }

    private static Font LoadFont(string path)
    {
        if (!File.Exists(path))
            throw new FileNotFoundException(path);

        return FontRepository.OpenFont(path);
    }
}

If I change its setting to subsetFont = false for Chinese, the rendering becomes very fast, but the PDF file size becomes much larger, sometimes up to 20 times bigger depending on the content.

7

@tuantran3012
Thank you for the details, I’ll investigate this issue
Could you also provide file you used as input in your code if that’s possible?

8

Due to the project’s security requirements, I am unable to share any additional personalized files.

9

@tuantran3012
Is it possible to remove sensitive information and provide document without it?
Some errors could be document specific and we may face difficulties reproducing this issue without input file