VAPS picture starting and switching acceleration method and system based on font pre-resolving cache
By adopting a font pre-parsing caching mechanism in the aircraft cockpit display system, the problem of excessive CPU resource consumption during font parsing is solved, improving startup speed and screen switching performance, and making it suitable for embedded platforms.
Patent Information
- Application Number
- CN202610381226.3
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-03-26
- Publication Date
- 2026-07-31
AI Technical Summary
In aircraft cockpit display systems, the font parsing process consumes a large amount of CPU resources, resulting in slow screen startup and lag, which affects the pilot's operating experience and mission execution efficiency.
A font pre-parsing and caching mechanism is adopted. By pre-parsing and caching font information in local persistent storage, redundant calculations are avoided. Font metrics and texture data are directly read from the cache for rendering, and real-time parsing and updates are only performed when the cache is missing.
It significantly improves the startup speed and screen switching performance of VAPS display and control applications, reduces CPU utilization, is suitable for embedded platforms with frequent startups, and meets real-time requirements.
Smart Images
Figure CN122489144A_ABST
Abstract
Description
Technical Field
[0001] This invention belongs to the field of airborne cockpit display technology, specifically relating to a method and system for accelerating VAPS screen startup and switching based on font pre-parsing caching, which is used to improve the startup speed and screen switching response performance of VAPS display and control applications under embedded platforms. Background Technology
[0002] In aircraft cockpit display systems, VAPS, as a mainstream human-computer interaction design framework, is widely used in the development of display and control applications. When VAPS display and control applications start up and switch screens for the first time, their underlying font rendering mechanism needs to load and parse TrueType font files through the FreeType open-source development library to generate bitmaps for each glyph that needs to be rendered, and calculate the glyph's metric values, including character width, height, offset, forward displacement, and other information.
[0003] Due to limitations in the computing performance and real-time requirements of embedded platforms, the aforementioned font parsing process consumes significant CPU resources, resulting in noticeable stuttering during screen transitions and slow screen startup. This is particularly problematic in applications like aircraft cockpit displays, where real-time performance and reliability are extremely critical. Display latency and stuttering directly impact the pilot's operational experience and mission efficiency, and may even pose safety hazards.
[0004] Traditional optimization methods mainly focus on simplifying the font file itself or adjusting rendering parameters, but they cannot fundamentally solve the repetitive computational overhead caused by the font parsing process. Every time an application starts or accesses a font size for the first time, the entire font parsing process needs to be executed repeatedly, resulting in wasted computing resources and accumulated response latency. Summary of the Invention
[0005] The purpose of this invention is to overcome the shortcomings of the prior art and provide a method and system for accelerating VAPS screen startup and switching based on font pre-parsing caching. By using font information pre-parsing and local persistent caching mechanism, repeated font parsing calculations are avoided, thereby significantly improving the startup speed and screen switching performance of VAPS display and control applications.
[0006] To solve the above-mentioned technical problems, the present invention adopts the following technical solution:
[0007] A method for accelerating VAPS screen startup and switching based on font pre-parsing caching includes the following steps: In the font rendering interface of the VAPS framework, based on the font information and font size information of the font to be rendered, it queries whether there is a corresponding pre-parsed font cache file in the local persistent storage; If present, font metric information and character texture data are read directly from the pre-parsed font cache file and loaded into video memory for rendering, without needing to call the FreeType font parsing library for real-time parsing; If it does not exist, the font file is parsed using the FreeType font parsing library to obtain font measurement information and character texture data. The parsed data is serialized according to a predefined binary format and stored in local persistent storage to form the pre-parsed font cache file. The font measurement information and character texture data are then loaded into video memory for rendering.
[0008] Furthermore, the pre-parsed font cache file includes a description cache file and a bitmap cache file; the description cache file is used to store font measurement information, and the bitmap cache file is used to store character texture data; each combination of font and font size corresponds to an independent description cache file and bitmap cache file, named with the font name plus the font size plus an identifier.
[0009] Furthermore, the format of the description cache file includes: a file header and a character data portion; the file header contains font name, font size, number of textures and version number information; the character data portion records the Unicode code, texture width, texture height, horizontal offset (bearingX), vertical offset (bearingY) and advance displacement of each character in the order of character storage.
[0010] Furthermore, the bitmap cache file is formatted as follows: each character's Unicode code and its corresponding texture bitmap data are recorded sequentially according to the character's storage order; the length of the texture bitmap data is determined by the character's texture width and height.
[0011] Furthermore, the font rendering interface includes the vxtPLTrueTypeFont::FreeTypeFont::pGetOutlinedFont function and the vxtPLTrueTypeFont::FreeTypeFont::pGetFilledFont function in the VAPS PORT Display layer; the functions perform query and read operations on the pre-parsed font cache file, maintaining compatibility with the original VAPS framework interface.
[0012] Furthermore, the step of loading the text into video memory for rendering includes: in the vxtPLTrueTypeFont::vRenderText function of VAPS, obtaining the text string to be rendered, traversing each character in the string, obtaining the corresponding font metric information and character texture data from the pre-parsed font cache file, and performing texture mapping to complete the rendering.
[0013] Furthermore, it also includes an incremental update step: when the character to be rendered does not exist in the description cache file, the FreeType font parsing library is called to parse the character in real time, obtain its font metric information and character texture data, and append the parsed data to the corresponding description cache file and bitmap cache file. At the same time, the number of textures in the description cache file is updated to realize the dynamic expansion of the cache file.
[0014] This invention also provides a VAPS screen startup and switching acceleration system based on font pre-parsing caching, comprising: The cache query module is used in the VAPS font rendering interface to query whether the corresponding pre-parsed font cache file exists in the local persistent storage based on the font information and font size information; The cache reading module is used to directly read font measurement information and character texture data from the file when the pre-parsed font cache file exists; The font parsing module is used to parse the font file using the FreeType font parsing library to obtain font measurement information and character texture data when the pre-parsed font cache file does not exist. The cache generation module is used to serialize the parsed data according to a predefined binary format and store it in local persistent storage to form the pre-parsed font cache file; The rendering module is used to load font measurement information and character texture data into video memory for texture mapping rendering.
[0015] Furthermore, the pre-parsed font cache file generated by the cache generation module includes a description cache file and a bitmap cache file; the description cache file stores font measurement information, and its format includes a file header containing the font name, font size, number of textures and version number, as well as the character Unicode code, texture width, texture height, horizontal offset, vertical offset and forward displacement arranged in storage order; the bitmap cache file stores character texture data, and records the Unicode code of each character and its corresponding texture bitmap data in the order of character storage.
[0016] Furthermore, the cache generation module is also used to trigger the font parsing module to parse the character in real time when the character to be rendered does not exist in the description cache file, and to append the parsed data to the corresponding description cache file, while updating the texture count of the description cache file.
[0017] Beneficial effects: Compared with the prior art, the beneficial effects of the present invention are as follows: 1. By persistently storing the FreeType font parsing results in the local file system, the VAPS application can directly read the cached data during subsequent startup and screen switching, completely skipping the font parsing process, thus fundamentally solving the performance bottleneck caused by repeated calculations.
[0018] 2. This invention uses persistent caching instead of runtime memory caching. The cached files still exist after the application exits and can be reused upon subsequent startups, making it particularly suitable for scenarios with frequent startups on embedded platforms.
[0019] 3. This invention embeds caching logic into the native font rendering interface of the VAPS framework, which is completely transparent to upper-layer applications and requires no modification to existing application code, thus exhibiting good integrability and maintainability.
[0020] 4. The custom binary cache file format supports fast location and reading. The design of separating the description file and bitmap file facilitates on-demand loading and supports incremental updates, balancing storage efficiency and access performance.
[0021] 5. Actual tests on embedded platforms show that after adopting this invention, the second startup time of VAPS applications is reduced to 1.6% of the original time, the screen switching time is reduced to 3.0% of the original time, and the CPU utilization rate is significantly reduced, reserving more computing resources for other real-time tasks. Attached Figure Description
[0022] Figure 1 This is a flowchart of the VAPS screen startup and switching acceleration method based on font pre-parsing caching in an embodiment of the present invention. Detailed Implementation
[0023] The embodiments of this application will now be described in detail with reference to the accompanying drawings.
[0024] The following specific examples illustrate the implementation of this application. Those skilled in the art can easily understand other advantages and effects of this application from the content disclosed in this specification. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. This application can also be implemented or applied through other different specific embodiments, and the details in this specification can also be modified or changed based on different viewpoints and applications without departing from the spirit of this application. It should be noted that, in the absence of conflict, the following embodiments and features in the embodiments can be combined with each other. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.
[0025] Example 1: Method Example This embodiment provides a method for accelerating VAPS screen startup and switching based on font pre-parsing caching. This method integrates cache query and generation logic into the font rendering interface of the VAPS framework to achieve persistent caching and reuse of font parsing results.
[0026] like Figure 1 As shown, the method includes the following steps: Step S101: Cache Query In this step, within the VAPS framework's font rendering interface, the system queries the local persistent storage to determine if a corresponding pre-parsed font cache file exists, based on the font and size information of the font to be rendered.
[0027] Specifically, in the pGetOutlinedFont and pGetFilledFont member functions of the vxtPLTrueTypeFont::FreeTypeFont class related to VAPS XT font rendering, the corresponding pre-parsed font cache file is searched in the .cache folder of the local file system based on the font name and font size information of the font to be rendered.
[0028] The pre-parsed font cache files include description cache files (describe files) and bitmap cache files (bitmap files). Each combination of font and font size corresponds to an independent description cache file and bitmap cache file. The files are named using the font name + font size + identifier, specifically: font name + font size + "_describe" and font name + font size + "_bitmap". For example, for the font "SimHei" and font size 16, the corresponding cache files are "SimHei16_describe" and "SimHei16_bitmap".
[0029] Step S102: Determine if the cache file exists. Specifically, determine if the cache file exists. If it exists, proceed to step S103 to execute the cache reading branch; if it does not exist, proceed to step S106 to execute the font parsing and cache generation branch.
[0030] Cache read branch (cache hit): Step S103: Character Traversal and Data Reading In the `vRenderText` function of the `vxtPLTrueTypeFont` class, which is related to VAPS XT font rendering, the text string to be rendered is obtained. All characters in the string are iterated through, and for each character, the corresponding character record is searched in the description cache file based on its Unicode code.
[0031] The binary format of the cache file is defined as follows:
[0032] The binary format definition of a bitmap cache file is as follows:
[0033] The storage order of character records in the description cache file and the bitmap cache file remains consistent. The starting position of the i-th character record in the description cache file is: file header length + (i-1) × length of a single character record; the starting position of the corresponding texture data in the bitmap cache file is: the sum of the texture data lengths of the first i-1 characters plus the space occupied by the i Unicode codes (i×4 bytes).
[0034] Step S104: Obtain character data If the current character exists in the description cache file, the font measurement information (texture width, texture height, bearingX, bearingY, advance, etc.) of the character is directly read from the description cache file. Based on the storage order of the character in the description cache file, its offset in the bitmap cache file is calculated, and the corresponding character texture bitmap data is directly read from the bitmap cache file.
[0035] Step S105: Render the characters The acquired font measurement information and character texture bitmap data are loaded into video memory, and OpenGL texture mapping functions (such as glTexImage2D, glBindTexture, glDrawArrays, etc.) are called to complete the rendering of the characters.
[0036] Cache generation branch (cache miss): Step S106: Create cache file In the pGetOutlinedFont and pGetFilledFont functions, based on the font name and size information of the font to be rendered, corresponding description cache files and bitmap cache files are created in the local .cache folder. Following the format defined in step S103, the font name, font size, initial texture quantity (initially 0), and version number are written to the header of the description cache file.
[0037] Step S107: Initialize FreeType Initialize the FreeType library by calling FT_Init_FreeType, load the font file by calling FT_New_Face, and set the font size by calling FT_Set_Pixel_Sizes.
[0038] Step S108: Character parsing The font file is parsed using the FreeType font parsing library. Specifically, in the `vRenderText` function, the text string to be rendered is obtained, and all characters in the string are iterated through. For each character, the character index is obtained using the FreeType library's `FT_Get_Char_Index` function, the glyph image is loaded using the `FT_Load_Glyph` function, and the outline is rendered into bitmap data using the `FT_Render_Glyph` function.
[0039] Step S109: Extract character information Font metric information and character texture data are obtained from the FreeType parsing results. Specifically, the following character information is extracted: Unicode code: The Unicode encoding of the current character; Texture width: face->glyph->bitmap.width; Texture height: face->glyph->bitmap.rows; bearingX: face->glyph->bitmap_left; bearingY: face->glyph->bitmap_top; advance: face->glyph->advance.x>>6 (convert to pixels); Texture bitmap data: face->glyph->bitmap.buffer.
[0040] Step S110: Write to the cache file The parsed data is serialized according to a predefined binary format and stored in local persistent storage to form a pre-parsed font cache file. Specifically, the character information is written to the corresponding cache file according to the format defined in step S103: Append the Unicode code and font measurement information (texture width, texture height, bearingX, bearingY, advance) to the character data area of the description cache file; increment the texture count in the file header of the description cache file by 1; append the Unicode code and texture bitmap data to the bitmap cache file; Step S111: Render the characters The acquired font measurement information and character texture bitmap data are loaded into video memory, and the OpenGL texture mapping function is called to complete the character rendering.
[0041] By following the steps above, when the VAPS application is launched for the first time and renders text of a specific font size, a complete FreeType parsing process is executed, and the parsing results are persistently stored in a local cache file. Subsequent launches of the application or rendering of text of the same font size can directly read the required data from the cache file, completely skipping the FreeType parsing process, thus significantly improving startup speed and screen transition responsiveness.
[0042] Example 2: Incremental Update Mechanism Example This embodiment further optimizes the dynamic update mechanism of cache files based on embodiment 1.
[0043] In real-world applications, the set of characters that may need to be rendered for a particular font size may dynamically expand as the interface content changes. To address this requirement, this embodiment enhances the cache generation branch: When a cache file already exists but the character to be rendered is not present in the description cache file, the complete font parsing is not re-executed. Instead, incremental parsing and appending are performed only for the missing characters.
[0044] Specifically, in step S103 of Example 1, during character traversal, if the current character does not exist in the description cache file, the FreeType font parsing library is temporarily invoked to parse the single character, obtain its font metric information and character texture bitmap data, and then the parsed character data is appended to the corresponding description cache file and bitmap cache file, while updating the texture count in the description cache file header. After the appending is completed, the character data is loaded into video memory for rendering.
[0045] This incremental update mechanism avoids repeated full parsing due to incomplete initial caching, while supporting dynamically expanding character sets to adapt to changes in interface content and maintaining the integrity of cached files without the need for periodic rebuilding.
[0046] Example 3: System Example This embodiment provides a VAPS screen startup and switching acceleration system based on font pre-parsing caching. This system can be integrated into the existing VAPS framework to achieve transparent optimization of upper-layer applications.
[0047] The system includes the following modules: The cache query module is used in the VAPS font rendering interface to query whether the corresponding pre-parsed font cache file exists in the local persistent storage based on font information and font size information.
[0048] In the specific implementation, query logic is embedded in the vxtPLTrueTypeFont::FreeTypeFont::pGetOutlinedFont and pGetFilledFont functions. The cache file path is concatenated based on the font name and font size, and the file system API (such as access or fopen) is called to check if the file exists.
[0049] The cache reading module is used to directly read font metric information and character texture data from the file when the pre-parsed font cache file exists.
[0050] This module parses and describes cache files and bitmap cache files according to the cache file format defined in Example 1. To improve read efficiency, memory-mapped file technology can be used to map the cache file to the process address space, achieving zero-copy access.
[0051] The font parsing module is used to parse font files using the FreeType font parsing library when the pre-parsed font cache file does not exist, in order to obtain font metric information and character texture data.
[0052] This module encapsulates the complete parsing process of the FreeType font parsing library, including steps such as initialization, loading the font, setting the font size, parsing characters, obtaining measurement information and bitmap data.
[0053] The cache generation module is used to serialize the parsed data according to a predefined binary format and store it in local persistent storage, forming a pre-parsed font cache file.
[0054] This module is responsible for the following two types of operations: Initial Generation: If the cache file does not exist, create the corresponding description cache file and bitmap cache file. Write the file header according to the predefined format (including font name, font size, initial texture count, and version number), and append the parsed character data (Unicode code, font measurement information, and texture bitmap data) to the corresponding cache file. Update the texture count in the description cache file header after each write.
[0055] Incremental Update: When a character to be rendered does not exist in the description cache file, the font parsing module is triggered to parse the character in real time. Then, the character's Unicode code and font measurement information (texture width, texture height, bearingX, bearingY, advance) are appended to the character data area of the description cache file. The texture count in the description cache file header is updated, and the character's Unicode code and texture bitmap data are appended to the bitmap cache file. To ensure data consistency, a file locking mechanism is used during the write process to prevent concurrent write conflicts.
[0056] The cached files are stored in binary format, and the design of separating the description file and bitmap file facilitates on-demand loading and supports fast location and reading. The incremental update mechanism avoids repeated full parsing due to incomplete initial caching, and supports dynamically expanding character sets to adapt to changes in interface content.
[0057] The rendering module is used to load font measurement information and character texture data into video memory for texture mapping rendering.
[0058] This module encapsulates OpenGL texture operations, including texture creation, texture binding, texture parameter setting, texture uploading, and texture mapping. To improve rendering efficiency, texture atlas technology can be used to package multiple character textures into a single large texture, reducing texture switching overhead.
[0059] The system's workflow corresponds to the method described in Example 1: The cache query module receives the font name and font size and checks whether the cache file exists. If the cache exists, the cache reading module reads the font measurement information and character texture data, and then hands them over to the rendering module for rendering. If the cache does not exist, the font parsing module parses the font file, the cache generation module performs the first generation operation, writes the parsing result to the cache file, and then hands it over to the rendering module for rendering; During the rendering process, if the current character is not present in the existing cache (i.e., the cache file exists but the character is missing), the cache generation module triggers an incremental update operation: it calls the font parsing module to parse the character, then appends the new character data to the cache file, and simultaneously hands it over to the rendering module for rendering.
[0060] Example 4: Performance Testing Example This embodiment performs performance tests on the present invention on a typical embedded avionics display platform to verify its technical effectiveness.
[0061] Test environment: Processor: PowerPC e500v2, 1GHz; Memory: 2GB DDR3; Storage: Onboard Flash, FAT32 file system; Operating System: VxWorks 6.9; Graphics Library: OpenGL ES 2.0; VAPS Version: XT 4.1; Font File: SimHei.ttf, containing 21,000+ Chinese characters.
[0062] Test cases: The test interface contains 5 fonts (Heiti, Songti, Kaiti, Fangsong, and Lishu); each font contains 3 font sizes (12px, 16px, and 24px); a total of approximately 450 characters need to be rendered (covering commonly used Chinese characters, numbers, and symbols).
[0063] The test scenarios include: first launch of the application, second launch of the application, first screen switch, and subsequent screen switches.
[0064] Test results:
[0065] CPU utilization comparison:
[0066] Cache file size:
[0067] Results analysis: Startup performance: After optimization, the application's secondary startup time is reduced to 1.5% of the original, achieving "second-level startup". Compared with runtime memory caching solutions, the persistent caching solution of this invention can still maintain high performance after the application restarts.
[0068] Switching performance: The optimized screen switching time is reduced to 2.6% of the original time, and the screen switching is smooth and lag-free, meeting the real-time requirements of the avionics system.
[0069] Resource consumption: CPU utilization was significantly reduced, with peak utilization during startup and screen switching phases decreasing by 70.5% and 66.3% respectively, freeing up valuable computing resources for other real-time tasks.
[0070] Storage overhead: The total cache file size is approximately 2.27MB, which is relatively small and within an acceptable range for embedded systems. If storage space is limited, the bitmap data can be further compressed (e.g., using RLE compression), or a cache of frequently used characters can be generated as needed.
[0071] Test results show that the solution of the present invention can significantly improve the startup speed and screen switching performance of VAPS display and control applications, while reducing CPU resource consumption, and is particularly suitable for aviation cockpit display systems with high real-time requirements under embedded platforms.
[0072] In summary, this embodiment of the invention persistently stores the FreeType font parsing results in a custom format on the local file system and implements cache query and read logic in the VAPS native interface, so that subsequent startups and switches can directly read the cache, completely eliminating the overhead of repeated parsing.
[0073] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention. For those skilled in the art, various modifications and variations can be made to the embodiments of the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.
Claims
1. A font pre-resolving cache based VAPS picture initiation and switching acceleration method, characterized in that, Includes the following steps: In the font rendering interface of the VAPS framework, based on the font information and font size information of the font to be rendered, it queries whether there is a corresponding pre-parsed font cache file in the local persistent storage; If present, font metric information and character texture data are read directly from the pre-parsed font cache file and loaded into video memory for rendering, without needing to call the FreeType font parsing library for real-time parsing; If it does not exist, the font file is parsed using the FreeType font parsing library to obtain font measurement information and character texture data. The parsed data is serialized according to a predefined binary format and stored in local persistent storage to form the pre-parsed font cache file. The font measurement information and character texture data are then loaded into video memory for rendering.
2. The method of claim 1, wherein, The pre-parsed font cache file includes a description cache file and a bitmap cache file; the description cache file is used to store font measurement information, and the bitmap cache file is used to store character texture data; each combination of font and font size corresponds to an independent description cache file and bitmap cache file, named with the font name plus the font size plus an identifier.
3. The method of claim 2, wherein, The format of the description cache file includes: The file header contains information such as font name, font size, number of textures, and version number. Character data section: In accordance with the storage order of characters, the Unicode code, texture width, texture height, horizontal offset, vertical offset, and forward displacement of each character are recorded sequentially.
4. The method of claim 2, wherein, The bitmap cache file is formatted as follows: each character's Unicode code and its corresponding texture bitmap data are recorded sequentially according to the character's storage order; the length of the texture bitmap data is determined by the character's texture width and height.
5. The method of claim 1, wherein, The font rendering interface includes the vxtPLTrueTypeFont::FreeTypeFont::pGetOutlinedFont function and the vxtPLTrueTypeFont::FreeTypeFont::pGetFilledFont function in the VAPS PORTDisplay layer; the functions perform query and read operations on the pre-parsed font cache file, maintaining compatibility with the original VAPS framework interface.
6. The method according to claim 1, characterized in that, The steps of loading the text into video memory for rendering include: in the vxtPLTrueTypeFont::vRenderText function of VAPS, obtaining the text string to be rendered, traversing each character in the string, obtaining the corresponding font metric information and character texture data from the pre-parsed font cache file, and performing texture mapping to complete the rendering.
7. The method according to claim 3, characterized in that, It also includes an incremental update step: when the character to be rendered does not exist in the description cache file, the FreeType font parsing library is called to parse the character in real time, obtain its font measurement information and character texture data, and append the parsed data to the corresponding description cache file and bitmap cache file. At the same time, the number of textures in the description cache file is updated to realize the dynamic expansion of the cache file.
8. A VAPS screen startup and switching acceleration system based on font pre-parsing caching, characterized in that, include: The cache query module is used in the VAPS font rendering interface to query whether the corresponding pre-parsed font cache file exists in the local persistent storage based on the font information and font size information; The cache reading module is used to directly read font measurement information and character texture data from the file when the pre-parsed font cache file exists; The font parsing module is used to parse the font file using the FreeType font parsing library to obtain font measurement information and character texture data when the pre-parsed font cache file does not exist. The cache generation module is used to serialize the parsed data according to a predefined binary format and store it in local persistent storage to form the pre-parsed font cache file; The rendering module is used to load font measurement information and character texture data into video memory for texture mapping rendering.
9. The system according to claim 8, characterized in that, The pre-parsed font cache file generated by the cache generation module includes a description cache file and a bitmap cache file. The description cache file stores font measurement information, and its format includes a file header containing the font name, font size, number of textures and version number, as well as the character Unicode code, texture width, texture height, horizontal offset, vertical offset and forward displacement arranged in storage order. The bitmap cache file stores character texture data, and records the Unicode code of each character and its corresponding texture bitmap data in the order of character storage.
10. The system according to claim 8, characterized in that, The cache generation module is also used to trigger the font parsing module to parse the character in real time when the character to be rendered does not exist in the description cache file, and to append the parsed data to the corresponding description cache file, while updating the texture count of the description cache file.