IDOL and KeyView OEM 26.2.0
26.2 OEM Release Notes

# Filter SDK

## 26.2.0

### New in this Release

- Format detection has been extended, with support for 54 additional file formats. By identifying a larger range of formats present in the enterprise, decisions can be made on how to route, filter, or alert on such documents.

  New detected formats

  - Internet_Shortcut_Fmt

  - MS_Windows_Registry_5_Fmt

  - MS_Windows_Registry_95_Fmt

  - MS_Windows_Registry_3_Fmt

  - MS_NET_RESX_Fmt

  - MS_NET_Resource_Binary_Fmt

  - VHDX_Fmt

  - JSPX_Fmt

  - Windows_Provisioning_Package_Fmt

  - PowerShell_Formatting_Fmt

  - PowerShell_Module_Manifest_Fmt

  - Visual_Studio_Extension_Fmt

  - SOAP_Message_Fmt

  - WCF_Service_Fmt

  - Carl_Zeiss_Image_Fmt

  - DSD_Audio_Fmt

  - MacOS_ASIF_Fmt

  - HTML_Application_Fmt

  - HTML_Help_Project_Fmt

  - ArcGIS_MapX_Fmt

  - ArcGIS_Pro_Project_Fmt

  - ArcGIS_Pro_Mobile_Map_Fmt

  - ArcGIS_Pro_Layer_Fmt

  - ArcGIS_Map_Package_Fmt

  - ArcGIS_Pro_Layer_Package_Fmt

  - ArcGIS_Pro_Map_Package_Fmt

  - ArcGIS_Pro_Project_Package_Fmt

  - DrawPlus_OLE_Fmt

  - DrawPlus_Zip_Fmt

  - PagePlus_Zip_Fmt

  - PhotoPlus_OLE_Fmt

  - PhotoPlus_Zip_Fmt

  - XMP_Fmt

  - Digital_Speech_Standard_Fmt

  - Minolta_Raw_Fmt

  - Lytro_Fmt

  - SPSS_Viewer_Fmt

  - Khronos_SPIRV_Fmt

  - Extended_MIDI_Fmt

  - BigTIFF_Fmt

  - Windows_Gadget_CAB_Fmt

  - Windows_Gadget_Zip_Fmt

  - Progressive_Graphics_Fmt

  - MS_Management_Console_Fmt

  - KCells_XML_Fmt

  - ArcGIS_Vector_Tile_Package_Fmt

  - InDesign_INX_Fmt

  - Adobe_Catalog_Index_Fmt

  - KWord_XML_Fmt

  - Kivio_XML_Fmt

  - Kivio_Fmt

  - ClickOnce_Application_Manifest_Fmt

  - ClickOnce_Deployment_Manifest_Fmt

  - PowerShell_Console_Fmt

- Metadata and/or content extraction is now available for an additional 30 formats.

  Formats that now support metadata and/or content extraction

  - CAB_Fmt

  - PostScript_Font_Fmt

  - MS_InfoPath_Fmt

  - MS_Access_Snapshot_Fmt

  - OneNote_Package_Fmt

  - JSON_Lines_Fmt

  - MachO_Universal_Fmt

  - Corel_Color_Palette_Fmt

  - TrueSpace_Object_Fmt

  - Modo_3D_Fmt

  - Nendo_Fmt

  - Animation_Works_Fmt

  - Disney_CFAST_Fmt

  - DK_Animation_Fmt

  - Indeo_IVF_Fmt

  - Magix_MXV_Fmt

  - ILDA_Fmt

  - Internet_Shortcut_Fmt

  - MS_NET_RESX_Fmt

  - JSPX_Fmt

  - PowerShell_Formatting_Fmt

  - SOAP_Message_Fmt

  - DrawPlus_OLE_Fmt

  - PhotoPlus_OLE_Fmt

  - Windows_Gadget_CAB_Fmt

  - Progressive_Graphics_Fmt

  - KCells_XML_Fmt

  - KWord_XML_Fmt

  - Kivio_XML_Fmt

  - PowerShell_Console_Fmt

- File Content Extraction now supports merged cells in OpenDocument Spreadsheet (.ods) format documents, including vertical and two-dimensional merges.

- File Content Extraction now supports merged cells in Opendocument Text (.odt) format documents.

- File Content Extraction supports "modern comments" in Microsoft PowerPoint (pptx) files. Modern comments are a new type of comment, available in recent versions of PowerPoint. File Content Extraction can filter and export modern comments.

- File Content Extraction can now reconstruct an MSIPLabel with the required fields from files that have an XrML, but which do not include explicit Label metadata.

- File Content Extraction can use Microsoft APIs to resolve a human-readable name for an MSIPLabel, in cases where only the label ID and site ID are stored in the document.

- The C++, Python and .NET APIs have been improved to expose some subfile information that is only available after the subfile has been extracted, which was previously only available through the C API:

  - The information returned from opening or extracting a subfile now reports the subfile name.

  - The new `allow_external_subfiles` (C++ and Python) or `allowExternalSubfiles` (.NET) option has been added. This option allows you to extract an external subfile without throwing an error, which might be useful in cases where the subfile name stored in the file can be retrieved only while performing the extraction.

- You can now run the C sample programs `filtertest` and `extracttest` from working directories other than the File Content Extraction bin directory.

- Performance has been significantly improved when filtering Apple iWork Pages files.

- Performance has been improved for detecting PDF files, with increased speed and reduced reads, especially for large PDF files or files where the internal objects are stored in an inefficient order.

- JSON Lines documents (.jsonl) are now routed to the plain text reader (afsr) in the default configuration.

- The third-party ICU library has been upgraded to version 78.2.

### Resolved Issues

- (Security update) The third-party libpng library has been upgraded to version 1.6.55 to resolve known vulnerabilities, including CVE-2026-22801, CVE-2025-66293, CVE-2025-65018, CVE-2025-64720, CVE-2025-64506 and CVE-2025-64505.

- (Security update) The third-party libheif library has been upgraded to version 1.21.2 to resolve known vulnerabilities, including CVE-2025-68431.

- (Security update) The third-party libtiff library has been upgraded to version 4.7.1 to resolve known vulnerabilities, including CVE-2025-9900.

- (Security update) The third-party rapidjson library has been upgraded to the latest code as of 2026-02-16 to resolve known vulnerabilities, including CVE-2024-39684 and CVE-2024-38517.

- (Security update) The third-party openssl library has been upgraded to version 3.6.1 to resolve known vulnerabilities, including CVE-2025-11187, CVE-2025-15467, CVE-2025-15468, CVE-2025-15469, CVE-2025-66199, CVE-2025-68160, CVE-2025-69418, CVE-2025-69419, CVE-2025-69420, CVE-2025-69421, CVE-2026-22795, and CVE-2026-22796.

- (Security update) File Content Extraction could exit unexpectedly when processing invalid Microsoft Word documents (.docx).

- (Security update) File Content Extraction could perform out-of-bounds writes when processing some Microsoft Excel documents (.xlsx).

- File Content Extraction could leak resources if filter kvoop was refreshed while a stream was open.

- When calling `fpGetMainFileInfo`, the `KVMainFileInfoFlag_HasContent` flag was not set for HTML files.

- Empty cells did not properly appear in tab-delimited output for OpenDocument Spreadsheet (.ods) files, resulting in misaligned columns.

- File Content Extraction failed to extract subfiles from ZIP files more than 4GB in size.

  On Windows platform, the 4GB limit still applies.

- On MacOS platforms, repeatedly initializing and shutting down a File Content Extraction session could cause increases in memory usage.

- When exporting to HTML, external subfile links were displayed in the table of contents, even though the subfiles could not be displayed.

- File Content Extraction could not extract OpenOffice files from inside OpenOffice Presentation Format (.opf) files.

- In PDF documents that were originally created by Microsoft Word and filtered using pdfsr, the positioning of accented characters in Thai text was sometimes incorrect.

### Notes

- The C API `fpOpenSubFile()` function, and the related `fpCloseSubFile`, `fpExtractInfo`, and `fpExtractStatus` functions have been deprecated. For more information, see Deprecated Features.

## 26.1.0

### New in this Release

- Format detection has been extended, with support for 11 additional file formats. By identifying a larger range of formats present in the enterprise, decisions can be made on how to route, filter, or alert on such documents. For the full list, refer to the Filter SDK Programming Guides.

- When using the pdfsr reader, space detection has been improved for some PDF files.

- The Extract API now allows you to open a Document object from a subfile. This makes recursive processing of a file and all its subfiles considerably easier as it is no longer necessary to explicitly extract, store and pass back in the bytes of a subfile in order to process it further. This functionality is available in the C, C++, .NET and Python APIs.

  In the C API, use the `fpOpenDocumentFromSubFile()` function. In the C++ API, use the `Subfile::open` method. In the Python API, use the `Subfile.open` method. In the .NET API, use the `Subfile.Open` method.

- The `filtertest` and `extracttest` sample programs now report `KVMetadataSource` values by their name, not numerical value.

- The `filtertest` and `extracttest` sample programs now report error names in addition to error numbers.

- The Python API is now available on Linux ARM platforms.

- The third-party freetype library has been upgraded to version 2.14.1.

- The third-party zlib-ng library has been upgraded to version 2.2.5.

### Resolved Issues

- (Security update) The third-party libwebp library has been upgraded to version 1.6.0.
- (Security update) The third-party arrow library has been upgraded to version 21.0.0.
- The third-party Apache ORC library has been upgraded to version 2.2.1.

- (Security update) The third-party expat library has been upgraded to version 2.7.3 to resolve known vulnerabilities including CVE-2025-59375.

- (Security update) The third-party libxml2 library has been upgraded to version 2.15.1 to resolve known vulnerabilities including CVE-2025-6021.

- (Security update) The third-party openssl library has been upgraded to version 3.5.4 to resolve known vulnerabilities, including CVE-2025-9230 and CVE-2025-9231.

- (Security update) The third-party openssl library used by cryptographyservices has been upgraded to version 3.4.1 to resolve known vulnerabilities.

- (Security update) The third-party sqlite library has been upgraded to version 3.51.0 to resolve known vulnerabilities, including CVE-2025-6965, CVE-2025-3277 and CVE-2025-29087.

- (Security update) The third-party 7zip library has been upgraded to version 25.01 to resolve known vulnerabilities, including CVE-2025-53816 and CVE-2025-53817.

- (Security update) The third-party ODA library has been upgraded to version 2026.10. This change upgrades its FreeType version to 2.13.3 to resolve CVE-2025-27363.

- File Content Extraction could output header and footer text from Microsoft PowerPoint documents (.ppt) when not configured to do so.

- Text from Microsoft Word (docx) Addins, such as the XML associated with the EndNote Citation plugin was output when Show Hidden Text was not enabled.

- When processing any spreadsheet format (such as .xlsx, .csv, .ods), File Content Extraction output an unnecessary tab character at the end of each row of output. This change applies whether or not you configure tab-delimited output.

- Some characters were missing from the output of certain PDFs.

- File Content Extraction could report incorrect metadata for bitmap (`BMP_Fmt`) images.

- When using `fpOpenSubfile`, processing for some subfiles in a zip container could become unresponsive (in-process), or cause a timeout out-of-process. This change has also improved performance for some files.

- Zip bomb detection did not correctly flag some smaller files.

- File Content Extraction could not retrieve metadata from some files that contained an unusually large amount of metadata.

- The `filtertest` sample program would incorrectly output the name for the diagnostic format `KeyView_Poison_Fmt`.

- File Content Extraction could use a large amount of memory when filtering some large Microsoft Word (.docx) files.

- The C++ API could cause the calling application to terminate unexpectedly when certain types of error occurred, or throw a keyview_error with the wrong exception message. Updated source is provided to resolve this issue.

- The Python API could cause the calling application to terminate unexpectedly when certain types of error occurred, or raise an exception with the wrong message. Updated wheels are provided to resolve this issue.

- The .NET API could cause the calling application to terminate unexpectedly when certain types of error occurred, or raise an exception with the wrong message.

### Notes

- File Content Extraction no longer supports Python versions 3.8 and 3.9.
- The legacy Filter .NET API (`FilterDotNet.dll`), that was deprecated in File Content Extraction version 24.3, has been removed. The new Filter .NET API, included in versions 24.3 and later, exposes a greater proportion of File Content Extraction functionality. The new API provides features that were first introduced in the C and C++ APIs, such as the `Document` class and metadata field standardization.

## 25.4.0

### New in this Release

- Format detection has been extended, with support for one additional file format. By identifying a larger range of formats present in the enterprise, decisions can be made on how to route, filter, or alert on such documents. For the full list, refer to the Filter SDK Programming Guides.

- File Content Extraction now outputs standardized ImageBitsPerPixel and ImageChannelCount metadata elements for JPEG_File_Interchange_Fmt images.

- Support has been improved for ISO-8859-2 and ISO-8859-7 encodings in HTML files and in PST subfiles.

- Metadata is now reported for Apple_Icon_Fmt, CDA_Fmt, Enhanced_Metafile_Fmt, MS_DirectDraw_Surface_Fmt, OpenType_Fmt, Westwood_Studios_Audio_Fmt, Windows_Metafile_Fmt and Windows_Palette_Fmt.

- The C++ API now uses fixed width integer types for timeout durations and format versions, which means the types used are predictable and identical across all supported platforms.

- The .NET API binaries provided for Linux_X86_64 and Windows_X86_64 now use identical types across the two platforms. This change means that you do not need to build separate platform specific versions of your .NET application to use File Content Extraction.

- To make the same features available regardless of the programming language you choose, the ability to export files to HTML has been added to the C++, Python, and .NET APIs. This feature allows you to view supported file formats in a web browser without requiring the native application that created them. To use this feature, your license must enable HTML Export.

- The C, C++, .NET, and Python APIs provide a way to obtain information about a license key, including its validity and expiry date.

- You can now export HTML from Documents that were created from a stream.

- File Content Extraction now returns more detailed errors codes when OCR fails.

- The `filter_tutorial` sample program can now output document text to stdout.

- Performance has been significantly improved when filtering the Microsoft PPT and VSDX formats.

- Performance has been significantly improved when filtering Open Document Format files.

- Advanced Character Set detect is now available on MacOS x64 platforms.

- The avrosr reader, and associated Avro_Fmt, is now available on all supported platforms.

- The parquetsr reader (and associated Apache_Arrow_Feather_v1_Fmt, Apache_Arrow_Feather_v2_Fmt, and Apache_Parquet_Fmt formats) is now available on the Linux ARM, MacOS M1 and MacOS x86 64 platforms, in addition to the Linux x86 64 and Windows x86 64 platforms on which it was already supported.

- The OCR engine has been updated to 25.2.

- (Security update)The third-party OpenSSL library has been upgraded to version 3.5.1.

- The third-party ICU library has been upgraded to version 77.1.

- The third-party libpng library has been upgraded to version 1.6.50.

### Resolved Issues

- (Security update) The third-party libtiff library has been upgraded to version 4.7.0 to resolve known vulnerabilities, including CVE-2024-7006.

- (Security update) The third-party XMP Toolkit library has been upgraded to version 2025.03 to resolve known vulnerabilities, including CVE-2025-30305, CVE-2025-30306, CVE-2025-30307, CVE-2025-30308, and CVE-2025-30309.

- (Security update)A potential use-after-free could occur when using `fpOpenSubFile`.

- A small amount of memory could be leaked when processing a MS_PPT_2007_Fmt (PPTX) file.

- A potential memory leak could occur when using `fpOpenSubFile`.

- A memory leak occurred when obtaining metadata from PKZIP_Fmt, MHT_Fmt, MPEG_Audio_Fmt or Open_eBook_Fmt files.

- A small memory leak could occur when decrypting RMS encrypted documents.

- Microsoft Application Verifier reported a heap allocation leak when calling `fpShutdown`. The memory was being deallocated, but improvements have been made to remove the reported error.

- In File Content Extraction version 25.3.0, performance was degraded for format detection for some document types when running in file mode.

- Metadata extraction for JPEG2000 formats (ISO_JPEG2000_JP2_Fmt, ISO_JPEG2000_JPX_Fmt, JPEG_2000_JP2_File_Fmt, JPEG_2000_PGX_Fmt) could take multiple seconds. As a result of this change, some duplicate metadata is no longer output for these formats.

- Performance had degraded for the uncommon case where the majority of the text in a PDF file was not stored in Unicode encoding and the text was not absolutely positioned.

- In some cases, File Content Extraction did not respect configuration in formats.ini that specified that a format must be processed by using `unzip`.

- In File Content Extraction version 25.3.0, the use of `KVDocument` resulted in a format detection happening in-process even if it was configured to run out-of-process. This issue occurred only when the legacy out-of-process method was configured in `formats.ini` (that is, when `oop_method` was set to legacy).

- Some formats returned a `KVError_ReaderInitError` error, rather than `KVError_FormatNotSupported`, if they were present in `formats.ini` but were not supported for text filtering. The main examples were files being sent to the olesr and multiarcsr readers.

- Sometimes the `fpCanFilter` API function returned false if File Content Extraction could get only metadata for a file.

- File Content Extraction did not extract text from some XLSX spreadsheet files that were generated by Apache POI.

- File Content Extraction returned a `KVError_PasswordProtected` error for some PDFs that required a password for editing, but not for viewing.

- File Content Extraction could return a `KVError_BadInputStream` error for RSS files in some encodings.

- For RTF files that had multiple values for string-based metadata keys, File Content Extraction only returned one of the values. Multiple values are now returned as a single semicolon-delimited string.

- Space detection in PDF files sometimes produced inaccurate spaces in the output.

- File Content Extraction could not retrieve XMP metadata from Encapsulated Postscript (EPS) documents.

## 25.3.0

### New in this Release

- Format detection has been extended, with support for 28 additional file formats. By identifying a larger range of formats present in the enterprise, decisions can be made on how to route, filter, or alert on such documents. For the full list, refer to the Filter SDK Programming Guides.

- Format detection has been improved for the following formats:

  - Microsoft Excel Workbooks (versions 4 and 5) (effectively .xlw files) were previously detected as `Excel_Fmt`, but are now detected as the more precise `Excel_Workbook_Fmt`. Microsoft Excel Spreadsheets (up to version 5) (effectively .xls files) are still detected as `Excel_Fmt`. File Content Extraction continues to filter both types of file in exactly the same way.

  - JPEG-LS files were previously detected as `JPEG_File_Interchange_Fmt`, but are now detected as a separate format.

- File Content Extraction extracts metadata from a number of formats (for example `MS_GraphEdit_Fmt`) that use the Microsoft OLE (COM) container format. The metadata is extracted by using the reader `olesr`. If you are upgrading from an earlier version of File Content Extraction, update your `formats.ini` configuration file to enable this feature.

- File Content Extraction can now filter text from Apache Feather Version 1 and Version 2 files, and retrieve metadata from Apache Feather Version 2 files.

- File Content Extraction now supports CSV files that use semi-colons as the delimiting character.

- File Content Extraction can now extract MIP labels from Microsoft Power BI files.

- Improved performance of character set detection, resulting in faster processing for some formats such as UTF-8 and ASCII encoded plain-text files.
- Significantly improved performance when extracting content from file formats that compress data using the DEFLATE algorithm. File Content Extraction now uses a faster implementation of this algorithm. DEFLATE is used in many common file formats including zip files and Microsoft Office formats (`.docx`, `.xlsx`, `.pptx`).

- File Content Extraction now writes fewer temporary files to disk when processing .docx, .xlsx and .pptx files. This change can improve performance significantly on Windows when you use a virus scanner that scans each temporary file as it is written.

- Performance has been improved for HTML and RSS files.

- When diagnostic logging is turned on, each log entry now includes the time to millisecond precision.

### Resolved Issues

- (Security update) File Content Extraction could terminate unexpectedly (in-process) or return an error (out-of-process) when processing some spreadsheet files with hidden text enabled.

- (Security update)The third-party expat library has been upgraded to version 2.7.1 to resolve known vulnerabilities, including CVE-2024-8176.

- (Security update)The third-party 7zip library has been upgraded to version 24.09 to resolve known vulnerabilities, including CVE-2024-11612.

- (Security update)The third-party libheif library has been upgraded to version 1.19.8 to resolve known vulnerabilities, including CVE-2024-4131, CVE-2025-43967 and CVE-2025-43967.

- (Security update)The third-party libxml2 library has been upgraded to 2.13.8 to resolve known vulnerabilities, including CVE-2024-56171 and CVE-2025-24928.

- File Content Extraction could terminate unexpectedly (in-process) or return an error (out-of-process) when processing certain RTF files.

- For iWork Numbers files, File Content Extraction would output some numbers with insufficient precision.

- In rare cases, `fpGetSubFileMetadataList()` returned `KVError_Success` and output a null `KVMetadataList`. It now outputs a null `KVMetadataList` only when the error code is not `KVError_Success`.

- When running out-of-process, File Content Extraction could cause the calling application to exit unexpectedly during a call to the deprecated `fpGetOLESummaryInfo()` API function.

- When running in process, File Content Extraction could exit unexpectedly when processing some corrupt Microsoft Excel documents (.xls).

- Processing PDFs with pdfsr was on average slower than in 25.1.0.

- When the bin directory was specified as `./` diagnostic logging did not work.

- Some metadata values from MP3 files were truncated when the output character set was `KVCS_UNICODE`.

- File Content Extraction output was missing spaces for some PDF documents.

- File Content Extraction could output misencoded newlines when filtering Presentation Graphics documents to KVCS_UNICODE.

- File Content Extraction could split multibyte characters across successive calls to `fpFilter()` or `fpFilterStream()` when filtering RMS protected documents.

- File Content Extraction could terminate unexpectedly (in-process) or return an error (out-of-process) when parsing Microsoft Excel (.xlsx) files if the underlying stream failed to read data.

- File Content Extraction could output partial OLE summary string values if language detection had failed for a previous filter operation.

## 25.2.0

### New in this Release

- Format detection has been extended, with support for 63 additional file formats. By identifying a larger range of formats present in the enterprise, decisions can be made on how to route, filter, or alert on such documents. For the full list, refer to the Filter SDK Programming Guides.

- The new interface method, `fpExportHTMLToFile`, has been added to allow you to create a HTML representation of the input file. To use this option, you require a license for HTML Export.

- You can now configure File Content Extraction to produce log messages to help you diagnose issues.

- Metadata elements now report the storage mechanism used to store the data in the file. This change allows you to determine which elements were stored in the XMP packet.

- To make the same features available regardless of the programming language you choose, the following file extraction features are now exposed in the C++, Python, and .NET APIs:

  - Extract as MSG. File Content Extraction can construct MSG files from the messages and attachments in an Outlook Personal Folders (PST) container. This option is useful when your application already has support for handling MSG files. By default, File Content Extraction extracts e-mail messages in `KV_Mail_Subfile_Fmt` and attachments are exposed as separate subfiles, which is the best option for ensuring you obtain all available data.
  - Exclude mail headers. When you extract an e-mail message, File Content Extraction (by default) includes the header fields ("From", "Sent", "To", "CC", "Subject", and so on) even though this information is stored in the container and not the message. This behavior is for convenience as many users might expect to see the header fields and message body together. However, you can disable this feature. You might prefer to do this if you have already processed the header fields, for example through the metadata API.
  - Target encoding. In the C++ API, the `Configuration::target_encoding` method sets the target encoding for extracted e-mail messages (`.mail` subfiles). In earlier versions of the Filter C++ API, the messages were output in their original encoding. In the Python and .NET APIs, this option is not available and all extracted messages are encoded in UTF-8.

- When using the C API, you can configure File Content Extraction to include or exclude header and footer text during the lifetime of a session using the `KVFLT_HEADERFOOTER` flag with `fpSetConfig`. This change deprecates the `KVF_HEADERFOOTER KVFilterInitOptions` flag.

- File Content Extraction can now filter text from Design_Web_Format_Fmt (.dwf) files.

- Metadata is now supported for Open Packaging Format (.opf) files. This support is provided through a new reader opfsr.

- Text output is now supported for ActiveMime_Fmt documents.

- File Content Extraction can now extract the subfiles of `NuGet_Package_Fmt` files.

- File Content Extraction can extract more text from PDF XFA forms.

- File Content Extraction can now retrieve metadata from password-protected iWork 2013 files.

- When processing PDF files using the default pdfsr reader, File Content Extraction now extracts the replacement text from ActualText marked-content sequences, instead of the text enclosed by the sequence.

- The Outlook Personal Folders File (PST) reader `pstxsr` is now available on all supported platforms. The reader `pstnsr` is no longer available and OpenText recommends using `pstxsr` instead.

- Advanced character set detection is now supported on Windows ARM64.

- The Filter Python API now supports Python 3.13.

- If the parent process crashes, `filter_kvoop` now cleans up temporary files before it exits.

- The ODA third-party library has been upgraded to version 2024.12.

- The libxml2 third-party library has been upgraded to version 2.13.5.

- The size of the installation directory has been reduced by about 7% on Windows platforms, and 10% on Linux platforms.

### Resolved Issues

- (Security update) File Content Extraction could perform an invalid memory read when processing some PDF files.

- (Security update)File Content Extraction could perform an invalid memory read when processing some MSG files.

- (Security update)File Content Extraction could perform an invalid memory write when processing certain MS_Works_Win_WP_Fmt files.

- (Security update) File Content Extraction could perform an invalid memory write when processing some multi-page TIFF files.

- (Security update)For some crafted input files, kwAD could perform a division by zero.

- (Security update)For some crafted input files, kvfilter had invalid memcpys when filtering spreadsheet formats.

- (Security update)For some crafted input files of XML-based formats, the reader could perform an out-of-bounds read.

- (Security update)For some crafted input files, kpP97rdr had a memory leak, invalid free and out-of-bounds read.

- (Security update)For some crafted input files, mw6sr had out-of-bounds reads.

- (Security update)For some crafted input files, mw8sr had null dereferences, out-of-bounds reads, an overlapping memcpy, a use-after-free, and an infinite recursion.

- (Security update)For some crafted input files, xlssr had an invalid strtoul, a null dereference, and out-of-bounds reads.

- (Security update)File Content Extraction could terminate unexpectedly (in-process) or return an error (out-of-process) when filtering some DOCX files containing images in the header or footer.

- (Security update)The `fpConfig` function did not take a copy of the string passed in when you set `KVFLT_SETOOPSRCFILE`, which could result in a use after free if you freed the string before it was used.

- File Content Extraction could leak memory when processing some RSS files with embedded HTML.
- File Content Extraction would only filter the first page of some multi-page TIFF files.

- When filtering with the pdf2sr reader, File Content Extraction could run together text from different pages.

- Older versions of Valgrind could falsely report a conditional jump on uninitialized memory when processing some files, and a change has been made to avoid this.

- Text in PDF XFA forms would be incorrectly encoded if the target character set was set to `KVCS_UNICODE`.

- File Content Extraction returned `KVError_BadInputStream` for a small number of valid PDFs.

- File Content Extraction output incorrect values for Microsoft Excel (xlsx) pivot table caches that contained date, Boolean, error, or empty value types.

- File Content Extraction did not correctly output Eduction table delimiters when the character set of the input file was not ASCII-based.

- If an error was encountered when filtering a chunk of text with `fpFilter`, sometimes the error was reported before all available text had been returned to the caller.

- File Content Extraction could potentially perform an overlapping memcpy when processing some GIF files.

- When performing some operations File Content Extraction could read uninitialized memory in a way that did not adversely impact behavior.

- Certain Apple iWork Numbers files could cause File Content Extraction to hang indefinitely in-process, or exit with a timeout out-of-process.

- File Content Extraction could leak memory when processing some PDF files.

- File Content Extraction could leak memory when processing some VSD files.

- File Content Extraction could miss text from some VSD files.

- File Content Extraction could leak memory when processing some MSG files.

- File Content Extraction could leak memory when extracting PST subfiles to MSG.

- File Content Extraction could leak memory when processing metadata from some RTF files.

- File Content Extraction did not handle escaped new lines in vCard (.vcf) files.

- When processing a corrupt EPUB file, File Content Extraction could stop responding in-process, or exit with a timeout out-of-process.

- File Content Extraction did not output the correct text for date/time field codes in Microsoft PowerPoint files. File Content Extraction now handles these correctly. The output now contains the cached time when available and `KVFLT_SHOWDATEFIELDCODE` is false, and the field code when `KVFLT_SHOWDATEFIELDCODE` is true.

- RMS decryption would occasionally fail due to a sporadic SSL error when contacting the Microsoft server. When this occurs, File Content Extraction now automatically waits for one second and retries.

- File Content Extraction produced header and footer text output for Microsoft PowerPoint documents (.pptx) even when configured not to.

  NOTE: If your File Content Extraction session is not configured to output header and footer text, this change results in File Content Extraction outputting less text.

### Notes

- The following readers have been replaced by a single, new, reader (`wpsr`) that is capable of handling multiple word processor formats.

  - `afmsr` - Adobe Font Metrics
  - `axsr` - Applix Asterix
  - `cdsr` - Convergent Technologies DEF Comm. Format
  - `lyxsr` - LyX Word Processor
  - `nnsr` - NBI OASys Net Archive
  - `pfasr` - ASCII Printer and PostScript fonts
  - `pwsr` - PRIMEWORD
  - `swsr` - Informix SmartWare II Word Processor

  When you upgrade, update your `formats.ini` configuration file and replace any usage of these readers with `wpsr`.

## 25.1.0

### New in this Release

- Format detection has been extended, with support for 94 additional file formats. By identifying a larger range of formats present in the enterprise, decisions can be made on how to route, filter, or alert on such documents. For the full list, refer to the Filter SDK Programming Guides.

- To make the same features available regardless of the programming language you choose, the following file extraction features are now exposed in the C++, Python, and .NET APIs:

  - Credentials other than passwords can be supplied for opening container files, and multiple credentials can be set at the same time. In the C++, Python, and .NET APIs, credentials are set through the session configuration.
  - When extracting subfiles from a container, you can choose to create an artificial root node at the top of the subfile hierarchy. This option is available through the session configuration.
  - The `Subfile` class in each API has additional members to provide more information about a subfile (information that is available before extraction).
  - Extracting a subfile now returns a `SubfileExtractInfo` object that contains information about the extracted subfile.

- You can now configure the unit of the kvoop timeout in milliseconds.

  The default unit is seconds. To change the timeout unit to milliseconds, set the `KvoopTimeOutUnit` parameter to millisecond in `[FilterSDK_Config]` section of the formats.ini file.

- To improve ease-of-use, configuration parameter names in `formats``.ini` have been made case-insensitive. In earlier versions of File Content Extraction, the parameter names were case-sensitive so setting (for example) `kvooprefresh` rather than `kvoopRefresh` would have no effect. The values of Boolean parameters ("True" or "False") are now case-insensitive, and a positive integer such as "1" is accepted instead of "True".

- In the Filter C++ API, the `MetadataElement` class has methods that allow you to access an element's value directly, without implementing a visitor. These methods might be more convenient when you want to process a specific standard field and know the data type.

- The C sample programs include makefiles for all supported platforms.

- The C SDK now includes a new sample program called `filter_tutorial`, which demonstrates how to use the File Extraction, Filter, and Metadata APIs together. Both source code and a prebuilt executable are provided.

- The C SDK now includes a new test program called `extracttest` that you can use to try out various options related to the File Extraction API.

- File Content Extraction can extract comments from ZIP files. ZIP files contain two types of optional comments. The ".ZIP file comment" is associated with the ZIP as a whole, and "file comments" are associated with individual subfiles. In the Filter SDK, document metadata for a ZIP file now includes the .ZIP file comment in the Comments standard field. In the Extract API, subfile metadata for a subfile of a ZIP now includes the file comment for that subfile in the Comments standard field.

- File Content Extraction can output tabular data in a form that can be understood by Eduction for files with the formats `Apache_ORC_Fmt`, `Apache_Parquet_Fmt`, and `Avro_Fmt`.

- File Content Extraction extracts subfiles from RAR5 containers even when the calculated checksum for a subfile does not match the checksum stored in the container. This is to ensure that subfiles cannot be hidden by maliciously editing the file.

- Improved support for Microsoft Excel Binary (XLSB) files. File Content Extraction now supports XLSB files created using the beta version of Microsoft Excel.

- The third-party Freetype library has been upgraded to version 2.13.3.
- The third-party ICU library has been upgraded to version 76.1.
- The third-party libpng library has been upgraded to version 1.6.44.

### Resolved Issues

- (Security update) The third-party OpenSSL library has been upgraded to version 3.4.0 to resolve known vulnerabilities, including CVE-2024-6119 and CVE-2024-5535.
- (Security update) The third-party expat library has been upgraded to version 2.6.4 to resolve known vulnerabilities CVE-2024-45492, CVE-2024-45491, CVE-2024-45490 and CVE-2024-50602.
- (Security update) File Content Extraction could return an error (when running out-of-process) or crash (when running in-process) when processing some `OPML_Fmt` files.
- (Security update) There were potential out-of-bounds reads and writes when performing character encoding detection and conversion.
- (Security update) There was a potential out-of-bounds read when processing specially crafted `XFDL_Fmt` files.
- (Security update) There was a potential out-of-bounds read when processing specially crafted `CGM_Binary_Fmt`, `CGM_Character_Fmt`, or `CGM_ClearText_Fmt` files.
- File Content Extraction failed to filter some PDF files that could be opened successfully in Adobe Acrobat.
- Metadata for .MSG files no longer includes the `PR_BODY` field, because it duplicates the filtered or exported text.
- File Content Extraction could fail to extract text from some cells in ODF Spreadsheet files.
- File Content Extraction could output the metadata of some UTF-8 encoded EML files in the wrong encoding.

- When the default out-of-process mechanism was used, extraction would use the system temporary directory instead of the temporary directory configured through the API.

- Temporary files created during extraction could be left on disk, when the default out-of-process mechanism was used and the out-of-process server crashed or timed out.

- Some text from XPS files could be output without whitespace. This has been resolved on platforms other than MACOS_M1, MACOS_X86_64, and WINDOWS_ARM64.

- When a PDF file contained XFA forms with images in them, File Content Extraction could put base64-encoded image data in the output.

- In the Extract API, when running `fpGetMainFileInfo`, `fpGetSubFileInfo` or `fpExtractSubFile` out-of-process, the output structure would be allocated (and need freeing by `fpFreeStruct`) even if the operation failed.

- When processing an encrypted PDF (where printing was restricted), File Content Extraction would decrypt the document but did not decrypt the names of some form fields.

- File Content Extraction would cause the calling application to terminate unexpectedly when attempting to retrieve subfile metadata from an MSG file that had a double-precision floating point field value.

- File Content Extraction could cause the calling application to terminate unexpectedly when accessing metadata out-of-process.

- File Content Extraction could cause the calling application to terminate unexpectedly when out-of-process communication failed while opening or closing a stream or document.

- The out-of-process Filter process could crash during initialization in rare error cases.

- When extracting a zero-byte subfile of a `PKZIP_Fmt` file to a `KVOutputStream`, File Content Extraction did not open and close the `KVOutputStream`.

- File Content Extraction could terminate unexpectedly when processing some TIFF images with bottom-to-top orientation and uneven strip sizes.

- Some potential issues reported by the ASAN and TSAN analysis tools were resolved.

- When using the legacy kvoop method, KeyView could sometimes leak memory when obtaining metadata.

- When using the legacy kvoop method, KeyView would leak a small amount of memory for each document opened from an input filename, and filtered with `fpFilter()`.

- The filter sample program failed to demonstrate correct freeing of resources in some error cases. In those error cases it failed to call `fpCloseDocument`. This would result in the memory being allocated for the document being leaked.

### Notes

- The ability to use custom readers has been deprecated. For more information, see Deprecated Features.

## 24.4.0

### New in this Release

- KeyView format detection has been extended, with support for 93 additional file formats. By identifying a larger range of formats present in the enterprise, decisions can be made on how to route, filter, or alert on such documents. For the full list, refer to the KeyView Filter SDK Programming Guides.

- To make the same features available regardless of the programming language you choose, the following options are now exposed in the C++, Python, and .NET APIs: logical ordering (for PowerPoint); skip phonetic guides; standardize cell formats; source code identification; table detection; unexpected zip detection; filtering of Excel formulas; setting the out-of-process user.
- To simplify application packaging, you can now redistribute all of the files in the KeyView `PLATFORM/bin` folder. All non-redistributable files, such as compiled sample programs, have been moved to other directories.

- You can now configure the XML elements to extract with the C++, Python, and .NET APIs.

- Several changes have been made to make the Filter SDK easier to use:

  - You can now configure whether to show formulas by using a new `KVFLT_SHOWFORMULAS` option, rather than the more complex `KVFLT_SetConfigurableArguments` option.

    DEPRECATED: The `KVFLT_SetConfigurableArguments` option is now deprecated.

  - Makefiles for the `filter` and `tstxtract` sample programs are now available for all supported platforms.

  - The Windows sample program makefiles now report an error if the wrong command prompt is used.

  - The `filter` sample program now outputs autodet attributes as a human-readable list of fields that have been set.

  - The Python SDK includes a new sample script, `filter_text.py`.

  - The .NET metadata API now allows you to process metadata elements by writing a visitor class that inherits from `MetadataOperationBase`. This change makes it easier to handle metadata elements because you do not need to check the data type of each element and can instead call the `ApplyTo` method of your class, regardless of the data type.

- KeyView now supports Metadata output for .mht files.

- A new reader, `codesr`, filters code comments (but not the code itself) from a selection of source code file formats. This reader is now the default reader for the formats that it supports. To filter both comments and source code, modify `formats.ini` and use the reader `afsr` instead - this will provide the same behavior as earlier versions of KeyView.

- A new reader, `poisonsr`, has been provided for testing error handling and recovery. This reader is not for distribution, but you can use it in your testing of your application.

- XMP metadata can now be extracted from more QuickTime (.mov) files.

- Performance has been improved when filtering a large quantity of text from a single file.

  NOTE: For some files this change significantly increases the amount of text returned by each call to `fpFilter` (or the deprecated `fpFilterStream`function), from a few KB to a few MB.

- KeyView now returns a specific error message when the out-of-process terminates unexpectedly or crashes. On Linux platforms, you can also enable a dump file to troubleshoot issues.

- When KeyView detects a zip bomb, it now returns a more descriptive error code.

- Target encodings have been simplified, and target encodings other than UTF-8 and UTF-16 are now deprecated. See Deprecated Features

- The libxml2 third-party library has been upgraded to version 2.13.3.

- The Expat third-party library has been upgraded to version 2.6.2.

- The OpenSSL third-party library has been upgraded to 3.3.1 in most components. The optional cryptographyServices components (which is used for RMS decryption) uses OpenSSL 3.0.8.

### Resolved Issues

- (Security update) The `kvfilter` component had a potential out-of-bounds read when filtering Microsoft Excel (xls) files.

- (Security update) Several potential issues with readers were resolved:

  - The `kwAD`, `kpAGrdr`, `xmlsh`, and `kpP40rdr` readers had potential out-of-bounds reads.

  - The `kpP40rdr`, and `mwsr` readers had potential out-of-bounds writes.

  - The `kpAGrdr` and `xlssr` readers had potential memory leaks.

  - The `kpAGrdr` and `kpP40rdr` readers had potential issues that might have led to an interruption of service, or becoming unresponsive.

- (Security update) When using two sessions in a single process, and running in-process, KeyView could read from deallocated memory.

- When processing multiple files of unknown character set in a single session, KeyView could fail to perform character set detection, resulting in incorrectly encoded output.

- For some Microsoft Word 95 files that were created using a later version of Microsoft Word, KeyView could return the `KVError_FormatNotSupported` error.

- When doing table detection on PDF files, KeyView sometimes missed some text from the output.

- When `KV_SS_SHOWFORMULAS` was set via the API, KeyView did not show formulas for .xlsx files.

- When text in a PDF file was added by editing the PDF with Firefox, KeyView could miss the text.

- When KeyView encountered an OLE_Fmt file that did not contain metadata, it could return an error.

- The KeyView Filter C++ API did not declare the destructor for `ContainerImplementationBase` as virtual.

- The KeyView Filter C++ and Python APIs could output subfile metadata in the wrong encoding.

- In subfile metadata output, KeyView set incorrect values of `is_superseded` and `has_standard_alternative` for some documents of format MS_OEDBX_Fmt, Lotus_Domino_DXL_Fmt, ENT_Fmt, GWFS_Email_Fmt, Lotus_Notes_NSF_Fmt, MS_OutlookOLM_Fmt, Legato_Extender_ONM_Fmt, or TNEF_Fmt.

- During file format detection, KeyView could mark some PDFs as encrypted when a password was only required to edit, but not to read, the file contents.

- On the MacOS x86 64 platform, the 7z, libheif, and libde265 libraries did not have the correct minimum operating system version set.

- Detection would still run out-of-process if only `KVFLT_DETECT_INPROCESS` was used.

- For MP3 files, KeyView did not always convert the metadata strings to the target encoding correctly.

- When using `fpGetOLESummaryInfo`, MIP Label metadata could be misencoded.

## 24.3.0

### New in this Release

- KeyView format detection has been extended, with support for 30 additional file formats. By identifying a larger range of formats present in the enterprise, decisions can be made on how to route, filter, or alert on such documents. For the full list, refer to the KeyView Filter SDK Programming Guides.

- KeyView includes a new Filter .NET API. The new API is based on the C++ API, making it easier to use. It also includes features that were not previously available in .NET, for example: simplified session configuration, document objects that can represent files or streams, and easier access to document and subfile metadata. The new .NET API requires .NET 6 and works on Linux as well as Windows. To use the new API, reference `filter_dotnet.dll` from your project.

- The Filter Python API supports Python 3.12.

- In the Python API, the `FilterSession` and `Document` objects now have close methods, and you can use these objects as a context manager.

- The metadata API provides more information about metadata elements, so that you can identify non-standard elements that have a standardized alternative, and "superseded" elements that exist for backwards compatibility. Using this information, you can avoid processing the same metadata field more than once.

- When using the pdfsr reader, the detection of spaces between words in PDF documents has been improved.

- The third-party Lib ICU library has been upgraded to version 73.2.

- The third-party libpng library has been upgraded from version 1.6.37 to version 1.6.40.

- The third-party zlib library has been upgraded from version 1.2.13 to version 1.3.

### Resolved Issues

- (Security update) A maliciously crafted TIFF file could cause KeyView to temporarily allocate a large amount of memory (CVE-2023-52355).

- (Security update) The third-party libtiff library has been upgraded to version 4.6.0 to resolve security vulnerabilities (CVE-2023-40745, CVE-2023-3618, CVE-2023-2908, CVE-2023-26966, CVE-2023-3618 and CVE-2023-3316).

- (Security update) The third-party freetype library has been upgraded to version 2.13.1.

- (Security update) The third-party JasPer library has been upgraded to version 4.2.1 to resolve CVE-2023-51257.

- (Security update) The third-party ODA library has been upgraded to version 2025.1 to resolve CVE-2023-5179, CVE-2023-5180.

- (Security update) A jump on uninitialized value could potentially occur when processing some PDF files.

- (Security update) The third-party 7zip library has been upgraded to 23.01. This upgrade addresses CVE-2023-31102, and resolves a memory issue in the xz decoder, as well as a number of other issues. It also has potential speed improvements.

- (Security update) When processing some EML files, KeyView could sometimes perform an invalid write.

- (Security update) When processing DWG files, a memory leak could occur.

- (Security update) When using the pstsr reader, the subfile metadata for items within a PST included the PR_STORE_ENTRYID which was set to the location of the PST on disk at the time it was processed by KeyView.

- (Security update) A jump on uninitialized value could occur when processing some files that contained an embedded WMF or EMF file.

- (Security update) A resource leak could occur when processing Microsoft Word documents that contained charts.

- (Security update) When performing OCR on Windows, if the `libopenblas.dll` library was not present in the bin folder but was present in one of the folders on the PATH, KeyView loaded it from the folder on PATH.

- KeyView extracted the subfiles of some CAB files as empty files.

- A jump on uninitialized value could occur when processing some LZH files.

- A jump on uninitialized value could potentially occur when performing format detection on some zip-based files.

- KeyView could not extract subfiles from certain ZIP files that contained inconsistent specified lengths for those subfiles.

- PDF Table Detection sometimes produced invalid output, especially for rotated pages.

- KeyView occasionally output an inaccurate error message when shutting down the out-of-process executable `kvoop.exe`.

- When showing hidden text from Open Document Spreadsheet (ODS) documents, KeyView missed some non-hidden text.

- KeyView sometimes exited unexpectedly (in-process) or returned an error (out-of-process) when extracting some self-extracting archives.

- KeyView did not correctly identify the source character set for some Microsoft Powerpoint (PPTX) files, resulting in non-valid metadata.

- When extracting metadata from Microsoft Word documents (DOCX), KeyView missed properties that belonged to a namespace that contained a space.

- When filtering text from text boxes in Microsoft PowerPoint presentations (PPT), KeyView did not convert non-ASCII characters to the requested output encoding.

- The new RSS reader did not process some media:content XML elements in the RSS feed XML, resulting in a KVError_BadInputStream error.

- KeyView reported a different subfile time during daylight savings time for zip-based formats when using the multiarcsr reader.

- When KeyView was configured to do detection in-process, if the first session was shut down and a new session started, detecting some iWork files could cause the calling application to exit unexpectedly.

### Notes

- KeyView is no longer available for Linux x86 (32-bit).
- KeyView no longer supports Java 7. The Filter and Export Java APIs require Java 8 to 17. KeyView Export also requires Java 8 to 17 for converting vector graphics to raster images on non-Windows platforms.

## 24.2.0

### New in this Release

- KeyView format detection has been extended, with support for 51 additional file formats. KeyView can now identify more than 2000 unique file formats. By identifying a larger range of formats present in the enterprise, decisions can be made on how to route, filter, or alert on such documents. For the full list, refer to the KeyView Filter SDK Programming Guides.

- When running out-of-process, KeyView now communicates with the out-of-process server using shared memory, which results in faster processing times for nearly all operations. This feature is enabled by default.

  This feature provides the benefits of pipe-streaming, without the downside of taking longer to process some files. For example:

  - your application can be more responsive because each block of output is available before the next has been produced.

  - it reduces the disk space used for temporary files.

  - it reduces the file I/O for partial filtering because KeyView might not need to read the whole file if you choose to stop filtering before all the text has returned.

  - for many formats it reduces the amount of the input file that is read during extraction, especially if you extract only a subset of the files.

  NOTE: This change also resolves an issue where KeyView set the detected format of a subfile when extracting to a stream out-of-process, contrary to the documented behavior.

  When you extract a subfile, the intended behavior is that the result of extraction (`KVSubFileExtractInfo` (C API), `ExtSubFileExtractInfo` (Java API), or `ExtractSubFileExtractInfo` (.NET API)) provides the detected format of the subfile if you extract to a file, but not if you extract to a stream. In version 24.1 and earlier, with the default configuration, KeyView was doing additional work to set the detected format of the subfile when running out-of-process.

  With version 24.2.0, the benefits of extracting to a stream are available even when running out-of-process, and as a result, the detected format is no longer provided.

  If you were relying on this undocumented behavior, you must update your code to either extract to a file, or detect the format of the file after extraction by using `fpGetDocInfo()`.

- Performance has been improved for large Rich-Text Format (RTF) files.

- Performance has been improved for Source Code Detection.

- Keyview can now filter tabular data from OneNote files in a way that allows Eduction to make use of the table structure.

- KeyView can now filter tabular data from Pipe_Separated_Fmt files in a way that allows Eduction to make use of the table structure.

- The Python API now exposes the `header_and_footer` configuration option.

- Optical Character Recognition (OCR) is now available on MacOS x86-64 platforms.

- The third-party libxml2 library has been updated to version 2.12.0.

- The third-party zStandard library has been upgraded to version 1.5.5.

### Resolved Issues

- (Security update) The third-party openssl library has been upgraded to version 3.2.1 to resolve security potential vulnerabilities including CVE-2023-4807,CVE-2023-5363, CVE-2023-5678, CVE-2023-6237, CVE-2024-0727.

- (Security update) The third-party sqlite library has been upgraded to version 3.45.1 to resolve known vulnerabilities, including CVE-2023-7104.

- (Security update) The third-party libde265 library has been upgraded to version 1.0.15 to resolve known vulnerabilities, including CVE-2023-27102, CVE-2023-27103, CVE-49465, CVE-49467, and CVE-49468.

- (Security update) The third-party libheif library has been upgraded to version 1.17.6 to resolve known vulnerabilities, including CVE-2023-49462, and CVE-2023-49463.

- (Security update) The third-party XMPToolkit library has been upgraded to version 2023.12 to resolve known vulnerabilities.

- (Security update) The third-party expat library has been upgraded to version 2.6.0 to resolve known vulnerabilities, including CVE-2023-52425 and CVE-2023-52426.

- When attempting to extract images using the pdf2sr reader, Keyview sometimes returned an error (out-of-process), or exited unexpectedly (in-process).

- When processing Microsoft Word (docx) files that contained charts, KeyView sometimes left files in the temporary directory when running in-process.

- KeyView sometimes output some nonsense text when processing the headers and footers of Microsoft Word documents (.doc).

- KeyView sometimes returned KVError_Success when attempting to process unsupported PSD documents. It now returns KVError_FormatNotSupported.

- When using the `tstextract.exe` program with the pstx reader, KeyView sometimes failed to extract any content from a PST file when one of the message-type attachments was not valid.

- When a PDF had an non-valid subform, it could lead to a bad input stream error for the whole file. KeyView now skips the non-valid subform and attempts to retrieve information from the rest of the file.

- For some fields output in KeyView versions earlier than 23.2, KeyView did not output a non-standard metadata element. To aid backwards compatibility, KeyView now outputs a non-standardized field for each field that was present before standardization was introduced in 23.2.

- For some mail formats, some metadata elements were output twice.

- KeyView refreshed the out-of-process process for Extraction even if `kvoopRefresh` was set to zero.

- When filtering formulae from some non-valid spreadsheet files, KeyView could return an error (out-of-process), or exit unexpectedly (in-process).

- When processing some RSS feed XML files to filter hidden text, KeyView could time out (out-of-process), or stop responding (in-process).

- When using the C++ API, the `header_and_footer` configuration option did not work correctly when it was set after initializing a session.

- Filtering very small text files (less than 16 bytes) could result in a memory leak.

- KeyView failed to process XFA forms in PDF files when the entry was a direct XFA object (that is, it processed XFA forms only when the entry pointed elsewhere in the PDF).

### Notes

- The KeyView macOS support has changed so that KeyView 24.2 supports macOS (x86-64) version 10.15 or later.

- KeyView 24.2 no longer includes the deprecated cebsr and lwpsr readers.

## 24.1.0

### New in this Release

- KeyView format detection has been extended, with support for 40 additional file formats. By identifying a larger range of formats present in the enterprise, decisions can be made on how to route, filter, or alert on such documents. For the full list, refer to the KeyView Filter SDK Programming Guides.

- KeyView can extract embedded media files from PDF_Fmt documents.

- When filtering a PDF file using the pdfsr reader with hidden text shown, KeyView now outputs the labels for the outline bookmarks.

- Metadata parsing has been improved for PDF documents to handle some additional non-standard methods of storing metadata.

- When processing a PDF file using the pdfsr reader, the annotations (also known as comments) output between each page of the document now include the title, author and modification date of the comment as a heading line.

- KeyView now outputs annotations from PDF files when using the pdf2 reader. You can disable this option by using the `KVFLT_NOCOMMENTS` configuration flag.

- KeyView can now extract text from the pivot table cache in Microsoft Excel XLS and XLSX files. The pivot table cache might contain data that was deleted from the worksheet. To output this information, enable hidden text for Microsoft Excel documents.

- KeyView now gets text from SmartArt when filtering PPT (PowerPoint 97-2004) files.

- When you enable extract images, KeyView now extracts images that are embedded in HTML files using base64 encoding.

- KeyView now treats TSV files as spreadsheet files, resulting in tab delimited output that can be parsed by Eduction (when you have enabled tab delimited output and table delimiters).

- KeyView output now includes URLs in OpenDocument Spreadsheet (.ODS) documents and outputs them as hidden text.

- KeyView can filter the RSS syndication XML format (RSS_Fmt).

- When configured to display formula strings, KeyView now supports many more formulas from Microsoft Excel (.xls) files.

- KeyView supports OCR on the Linux ARM and MacOS M1 platforms.

- The C++ and Python APIs now expose options for configuring OCR.

- Error reporting has been improved when KeyView is reading from the text member of a Document object and the child process times out. It now raises a `child_timeout_error` (in the C++ API) or `ChildTimeoutError` (in the Python API).

- In the C API, you can now configure the out-of-process error log after session initialization by using `fpSetConfig`.

- In the Python API, you can now enable the out-of-process error log.

- When KeyView cannot start the out-of-process executable, `kvoop.exe`, it returns the error code `KVError_CreateProcessFailed` instead of `KVError_General`.

- The third-party `libpng` library was upgraded from version 1.6.37 to version 1.6.40.

- The third-party Lib ICU library was upgraded to version 73.2.

- The third-party zlib library was upgraded from version 1.2.13 to version 1.3.

### Resolved Issues

- (Security update) The third-party OpenSSL library was updated to version 3.1.4.

- (Security update) A potential security vulnerability was resolved for processing `WebP_Fmt` files or `TIFF_Fmt` files that use webp compression in the Filter SDK. This change addresses CVE-2023-4863.

- (Security update) The `assr`, `awsr`, `kpcgmrdr`, and `orcsr` readers had potential buffer overruns.

- The Java API could leak memory when filtering from an input stream.

- The sample program for the C++ Extract API could return a `KVError_BadInputStream` error when extracting a password-protected subfile from a 7Z without the correct password, rather than a `KVError_PasswordProtected` error.

- KeyView did not filter URLs that were associated with embedded images in Microsoft Excel (XLSX) documents. These URLs are now output as hidden text.

- In the C++ API, the configuration option `out_of_process_log` did not work after session initialization.

- For some PDF files with particular font encodings, the PDF reader (pdfsr) would output some special characters incorrectly.

- In the .NET API, subfile extraction failed with `KVError_InvalidArgsExtraction` when extracting to a file rather than a stream.

- KeyView failed to detect spaces between words in some PDF documents.

- Processing some valid ODS files failed with the error `KVError_ArchiveFatalError`.

- The KeyView sample program `tstxtract` did not generate sufficient subdirectories when doing recursive extraction.

- KeyView did not use consistent naming conventions for mail subfiles across different file formats.

- On non-windows platforms, KeyView reported invalid bytes at the end of subfiles names for some ZIP-based formats, such as JAR files.

- MBox (.mbx) files that were signed but not encrypted returned `KVError_PasswordProtected`.

- Attempting to retrieve metadata from MSG files returned a `KVError_General`, rather than `KVError_FormatNotSupported`.

- KeyView could identify some files of type GDSII as MacWrite format.

- KeyView missed the content of some pages in PDF documents when they contained certain character encodings.

### Notes

- The Filter .NET API requires the Microsoft .NET Framework version 4.6.2 or later.

- On the Linux x86-64 platform, KeyView 24.1 requires `libstdc++.so.6` and `libgcc_s.so.1` from at least GCC 12.2 if you are using OCR or RMS decryption.

## 23.4.0

### New in this Release

- KeyView format detection has been extended, with support for 48 additional file formats. By identifying a larger range of formats present in the enterprise, decisions can be made on how to route, filter, or alert on such documents. For the full list, refer to the KeyView Filter SDK Programming Guides.

- Handling of XLSX file has been improved when the same image data is referenced multiple times in the same input file. The extract images functionality now detects multiple references and outputs each image only once.

- KeyView now supports extraction of subfiles from iWork13 Pages, Numbers and Keynote files.

- KeyView now supports metadata extraction for current (2013 to the present day) Apple iWork Pages, Numbers and Keynote files.

- Filter support has been added for the ZIP variant of Uniform Office Format word processor files (Uniform_Office_Text_Zip_Fmt).

- When filtering PDF files with the pdfsr reader, Unicode private use area characters are now output as-is, rather than being translated to the configured replacement character (usually a question mark).

- KeyView can now filter Yozosoft Yozo Office (Yozo_Office_Fmt) files.

- The Python API is now available for MacOS (x86 64 and M1).

- The readability of metadata output from the `filtertest` sample program has been improved.

- The PDF reader (pdfsr) has been improved for Arabic text in some circumstances.

  When you use Microsoft Print to PDF to convert Word documents that contain Arabic text in certain fonts to PDF, the resulting file is often incomplete, missing character mapping information that is required to interpret the text content. The pdfsr reader was previously able to reconstruct this missing information for most cases where the text was in Calibri font. The pdfsr reader can now also reconstruct the information for Sakkal Majalla font, and for additional Calibri cases.

  Furthermore, pdfsr now attempts to reconstruct the information when a character is mapped to the Unicode replacement character codepoint, rather than only when a character's mapping information is missing entirely.

- KeyView can now extract text from some PDF documents that contain Type 3 fonts without unicode character mapping information, rather than always converting all characters in those fonts to the configured replacement character. This process is not guaranteed to result in readable output for all such files.

- The Python API now raises an `ExternalSubfileError` when you attempt to extract an external subfile.

- In the Python API, the `Document.filter` and `Subfile.extract` methods have been added. The existing `Document.filter_to_file` and `Subfile.extract_to_file` methods are now deprecated aliases of these methods.

- In the Python API, enum value names now match those in the C++ API.

- The third-party openssl library has been upgraded to version 3.1.2.

- (Security update) The third-party libwebp library has been upgraded to version 1.3.1.

- (Security update) The third-party libxml2 library has been upgraded to version 2.11.4.

- (Security update) The third-party freetype library has been upgraded to version 2.13.1.

- The third-party libheif library has been upgraded to version 1.16.2.

### Resolved Issues

- The KeyView sample program `tstxtract` could not extract subfiles with names that include certain characters.

- On macOS, KeyView included a version of `libxml2.dylib`, which could make it difficult for calling applications to use their own or the system version of `libxml2.dylib`.

- KeyView did not set the `KVMainFileInfoFlag_HasContent` flag for `pFiles` (`RMS_Protected_Fmt`).

- When extracting subfiles from a PDF with extracted images configured to true, KeyView could output duplicate images.

- KeyView could incorrectly process some images in PDF files resulting in distorted images.

- KeyView sometimes failed to output the text from some cells in tables in current (2013 to the present day) Apple iWork Numbers and KeyNote files.

- KeyView did not correctly enclose footer text from Microsoft PowerPoint Windows XML 2007 and 2010 (.pptx) files in custom footer tags when `LogicalOrder` was set to 1.

- When PDF Logical Reading Order was enabled using the `format.ini` file, processing PDFs would result in a `KVError_ReaderInitError`.

- KeyView could exit unexpectedly (in-process) or return an error (out-of-process) when extracting from certain MIME email files.

- KeyView could exit unexpectedly (in-process) or return an error (out-of-process) when processing certain PDF and ODS files.

- When running KeyView out-of-process, processing streams in pipe mode, kvoop memory usage would increase until the process is shut down.

- When filtering PDFs with `pdfsr`, with logical ordering turned on, hyphens following a number at the end of a line were deleted. Deleting the hyphens is correct behavior when words are split over line endings, but not desirable for numbers in which hyphens tend to be deliberate (for example in social security numbers).

- When outputting URLs from certain ODT files, the URL was sometimes concatenated to the preceding text.

- (Security update) The third-party ODA library was upgraded to 2024.7 on Windows and Linux platforms, and 2024.1 on Mac platforms to resolve known vulnerability CVE-2023-26495.

- KeyView leaked memory when using the text member of Document objects in the C++ and Python APIs.

- KeyView returned an error when retrieving headers and footers from certain MS Word (docx) documents.

- KeyView returned an error when processing PDF documents containing encrypted forms.

- KeyView returned an error when processing certain PDF documents.

- KeyView sometimes included duplicate text in the output when PDF documents contained the same text multiple times in the same location.

- In the Python API, the `Subfile.time` member gave a valid but incorrect value if the document does not store a timestamp for that subfile. It now gives a value of None in this case.

## 23.3.0

### New in this Release

- KeyView format detection has been extended, with support for 61 additional file formats. By identifying a larger range of formats present in the enterprise, decisions can be made on how to route, filter, or alert on such documents. For the full list, refer to the KeyView Filter SDK Programming Guides.

- KeyView 23.3 introduces a Python API for the Filter SDK. The Python API is currently in beta. It is not recommended for production use, and might not be released in this way in the future.

- KeyView 23.3 introduces a `Document` class to the C++ API. OpenText recommends that you create a `Document` object for each file that you want to process. You can obtain a document object by calling the new method `open()` on your KeyView `Session`. The use of document objects allows caching of data between calls to KeyView for the same file, and might allow performance improvements in future versions of KeyView.
- The KeyView Filter C API is supported on Windows 11 ARM64.

- You can now enable the output of Eduction table delimiters by using the Java API. You can configure this option by using the new `Filter.setOutputTableDelimiters` method.

- KeyView 23.3 expands support for the new metadata API that was introduced in KeyView 23.2. The new API has now been exposed through the Java API for Filter. You can also use the new API in the Java API for KeyView Export, but only when extracting subfile metadata.
- Source code identification is available on all KeyView supported platforms.
- KeyView can extract XMP metadata from additional formats on the `LINUX_ARM` platform. This change means that support for XMP metadata is the same across all supported platforms.

- The third-party sqlite library was upgraded to version 3.42.0.

### Resolved Issues

- (Security update) KeyView depended on outdated LZMA code for detection of 7z encryption. This dependence has been removed.

- When running out of process on Windows platforms, `kvoop.exe` did not close the file handles it had inherited from the parent process.

- When using the pdfsr reader to process PDFs that contained fonts with certain predefined encodings, spaces sometimes appeared in the wrong places in output text.

- When using the pdfsr reader to process PDFs, output text was sometimes broken onto additional new lines or missed characters.

- Attempting to get XMP metadata from supported file types with no associated reader failed with a `KVError_FormatNotSupported` error.

- KeyView leaked memory when filtering some Apple iWork Keynote (.key) (IWPG_Fmt) files.

- KeyView used large amounts of memory when filtering large CSV files.

- KeyView incorrectly identified some attachments to Outlook .msg files as being inline pictures rather than non-inline attachments.

- Changing the global locale could cause KeyView to fail to process some file formats.

- When attempting to filter NIST_ITL_Fmt files, KeyView returned KVERR_FormatNotSupported.

- Extracting metadata or summary information from invalid OLE-based files could cause memory inconsistencies.

- When filtering files in stream mode using the pipe-streaming method, KeyView leaked memory in the worker process `kvoop.exe`.

- KeyView could produce an unreadable subfile from PST files if no target character set was specified.

- When processing HTML files that specify an ISO-2022 character encoding, KeyView output some entities as unprocessed strings, rather than the correct unicode character.

### Notes

- In the C++ metadata API, the `Metadatum` class has been renamed `MetadataElement`. The following methods of that class have also been renamed:

  - The method `is_standard_field()` has been renamed `is_standard()`.
  - The method `name()` has been renamed `key()`.
  - The method `standard_field_type()` has been renamed `standard_key()`.

  OpenText recommends that you use the new class and method names because the old names are deprecated and might be removed in future.

- In the C++ metadata API, functions that provide access to metadata return a new `Metadata` class. The same functions in KeyView 23.2 returned a `std::multimap<std::string, Metadatum>`. If your code stores metadata in a variable declared using `auto`, it will compile and run without any changes, provided that you do not call any `std::multimap` functions that are not implemented in `Metadata`. If your code stores metadata in a variable explicitly declared `std::multimap`, it will compile and run without any changes, but OpenText recommends that you use the new class instead, because conversion to `std::multimap` is deprecated and might be removed in future.

## 23.2.0

### New in this Release

- KeyView format detection has been extended, with support for 56 additional file formats. By identifying a larger range of formats present in the enterprise, decisions can be made on how to route, filter, or alert on such documents. For the full list, refer to the KeyView Filter SDK Programming Guides.

- KeyView 23.2 introduces a new metadata API. The new API:

  - reduces the number of function calls you need to make to retrieve all metadata.
  - performs field standardization. Field standardization returns metadata using a standard set of field names, so that the same metadata is returned in the same field regardless of the source file format. The new metadata API allows for the introduction of further standardization, in future releases, without breaking backwards compatibility.

  The new metadata API is available in KeyView Filter (C and C++). The new metadata API can also be used through KeyView Export (C), but only when extracting subfile metadata.

- KeyView 23.2 introduces the concept of a `KVDocument` to the C API. The Filter C API has new functions that accept a `KVDocument` instead of a file path or input stream. This simplifies the API because a `KVDocument` stores information about the source, and a `KVDocument` created from a file or stream can be passed into the same function. For example, `fpGetDocInfoFile()` and `fpGetDocInfoStream()` can be replaced with the new function `fpGetDocInfo()`. The introduction of `KVDocument` is also intended to support future performance enhancements, because KeyView will be able to cache information about a document instead of repeating some work in cases where you call several functions that operate on the same input.

- In the Filter C API, the `fpFilterConfig()` function has been replaced with the new `fpSetConfig()`. This function allows you to set the same configuration options, and it returns a `KVErrorCode`, rather than using extended errors. The `fpFilterConfig()` function is now deprecated.

- In the Filter C API, KeyView now defines a `KVFilterSession` type which can be used instead of a void* for holding the session object provided by `fpInit` and passed to the other Filter API functions.

- Error reporting has been simplified in the C API. In earlier versions of KeyView, some functions could return the error code `KVERR_General`. You could then call `fpGetKvErrorCodeEx()` to obtain an "extended" error code. In KeyView 23.2 the error codes have been unified such that all error codes are included in the `KVErrorCode`enumeration. If a function returns an error code, there is no need to call a second function to obtain more information. This makes it easier to handle errors when an operation fails.

- The `fpGetXMPInfo*` functions now return appropriate error codes on failure.

- KeyView has been simplified so that it is much easier to map file formats to readers. File formats no longer have an associated "category". The KeyView configuration files such as `formats.ini`, `formats_e.ini`, and `kvsdk.ini` now identify file formats using the same file format numbers that are returned by format detection.

  For example, when KeyView detects an Adobe PDF file it returns format number `230`. Imagine that you want to process PDF files with the reader `pdf2sr`.

  In previous versions of KeyView you had to find the associated format category (`200`) and use this to configure KeyView:

      200=pdf2

  In KeyView 23.2, this is no longer necessary and you instead use the same format number that is returned from format detection:

      230=pdf2

- You can now remove certain third-party libraries that handle file formats you do not need to process. For a full list of these optional third-party components, and the changes you must make to exclude them, refer to the KeyView Filter SDK Programming Guide.

- KeyView can now extract all platform-specific embedded files from `PDF_Fmt` documents.

- KeyView can now filter WordPerfect Graphics (`WordPerfect_Graphics_Fmt`) files of `adVECTORGRAPHIC` class.

- When you enable 'show hidden text', KeyView can now output author names for comments in Rich Text Format (`MS_RTF_Fmt`) documents.

- When you enable 'show hidden text', KeyView can now output the value of the href attribute in HTML (`HTML_Fmt`) files.

- KeyView can now process certain OpenOffice Text files that it would previously reject, and it can process image alt text in OpenOffice Text as hidden text. KeyView can also now filter text from the master slide in OpenOffice Presentations as hidden text.

- When getting mail metadata from EML subfiles, KeyView now reports the sent date as a date instead of a string.

- When getting subfile information from EML subfiles, KeyView now converts the file time to UTC, rather than an unspecified time zone.

- For Microsoft Visio 2013 (.VSDX) files, KeyView now reports solution properties in the metadata.

- KeyView now supports TIFF (`TIFF_Fmt`) files that use WebP compression.

- Handling of Arabic diacritics (tashkil) has been significantly improved when using the pdfsr reader to process PDFs.

- Text ordering has been improved when using the pdfsr reader to process PDFs.

- In the C++ API, `Session::subfiles` now throws a `keyview::password_protected_error` if the container is protected and the session has not been configured with the correct password.

- For the .NET API, the `FilterTextDotNet` sample program now includes a C# Project file `FilterTestDotNet.csproj` to make it easier to use.

- In the C++ API, you can now enable tab delimiters for tables by using the tab_delimited and output_table_delimiters functions in the Configuration class.

- The FreeType third-party library has been upgraded to version 2.12.1.

- The ODA third-party library has been upgraded to version 2023.12.

- The zlib third-party library has been upgraded to version 1.2.13.

- The libxml2 third-party library has been upgraded to version 2.10.3.

- The expat third-party library has been upgraded to version 2.5.0.

- The ICU third-party library has been upgraded to version 72.1.

- The openssl third-party library has been upgraded to version 3.0.8.

- The libde265 third-party library has been upgraded to version 1.0.11.

- The XMP-Toolkit third-party library has been upgraded to version 2022.06.

- The wavpack third-party library has been upgraded to version 5.6.0.

- The sqlite third-party library has been upgraded to version 3.41.0.

- The third-party libical library was upgraded to version 3.0.16.

- The third-party Apache Arrow library was upgraded to version 11.0.0. This change includes upgrades to the following dependencies:

  - boost was upgraded to version 1.75.0

  - brotli was upgraded to version1.0.9

  - jemalloc was upgraded to version 5.3.0

  - re2 was upgraded to version 2022-06-01

  - thrift was upgraded to version 0.16.0

  - utf8proc was upgraded to version 2.7.0

  - zStandard was upgraded to version 1.5.2

### Resolved Issues

- (Security update) The third-party libtiff library has been upgraded to version 4.5.0 to resolve known vulnerabilities, including CVE-2022-2056, CVE-2022-2057, CVE-2022-2058, CVE-2022-3452, CVE-2022-3570, CVE-2022-3597, CVE-2022-3598, CVE-2022-3599, CVE-2022-3626, and CVE-2022-3627.

- (Security update) The third-party protobuf library has been upgraded to version 3.21.12 to resolve known vulnerabilities, including CVE-2022-1941.

- (Security update) The libjpeg third-party library has been upgraded to version 9e to resolve potential vulnerabilities.

- (Security update) The libwebp third-party library has been upgraded to version 1.3.0.

- When running out-of-process in stream mode, KeyView used a lot of pipe operations when detecting the format of some files, which could negatively impact the performance of the system.
- KeyView could pause for up to a minute while trying to shut down an out-of-process process.

- For password protected OpenOffice files (ODS, ODT and ODP), `fpOpenFile` did not return `KVERR_PasswordProtected`. Continuing with extraction could then result in invalid extracted files.

- When attempting to get summary info from some password protected Office formats (DOCX, PPTX, XLSX, ODS, ODT and ODP), KeyView could return `KVERR_General` instead of `KVERR_PasswordProtected`.

- KeyView could truncate long sections of text in `PDF_Fmt` documents.

- KeyView did not retrieve the Image Width, Image Height and Bits Per Pixel in summary information from Tagged Image File Format (TIFF) `TIFF_Fmt` files.

- For some Microsft Excel (XLSX) files with a lot of cells using Rich Data Types, KeyView output the names of those types incorrectly, using a number instead of a type name.

- KeyView could skip some user defined properties in summary information for some OLE-based files like `MS_Project_2007_Fmt`.

- KeyView did not perform OCR on animated PNG (`APNG_Fmt`) images.

- KeyView could fail to extract some images from Rich Text Format (`MS_RTF_Fmt`) documents.

- KeyView did not extract all the images from some Rich Text Format (`MS_RTF_Fmt`) documents.

- The extraction API `fpGetSubFileInfo` function did not correctly report the sizes of subfiles when they were larger than 2GB.

- Some PDF files took longer to process in version 12.13.0 of the SDK than in version 12.12.0.

- Heic and Heif format documents could not be processed on macOS.

- When Extract Images was enabled, filtering certain Word documents could cause KeyView to exit unexpectedly (in-process), or return an error (out-of-process).

- The `fpGetMainFileInfo` function did not respect the source code detection option when KeyView was running out-of-process.

- KeyView could return an error (out-of-process), or exit unexpectedly (in-process) when processing some Microsoft Visio (.vsd) files.

- KeyView missed text from some Microsoft Visio (.vsd) files.

- Some base-64 encoded attachments to ICS files were extracted incorrectly.

- KeyView could fail to extract bzip2 files if Unexpected Zip Detection was enabled.

- KeyView could report duplicate metadata from Tagged Image File Format (TIFF) files with multiple pages.

- KeyView could output incorrect metadata names for some PDF files.

- KeyView could omit metadata entries for some PDF files.

- When using the pdfsr reader to process PDFs that contained right-to-left (RTL) text, some text at the top of the file was not included in the output.

- KeyView could process some CSV files incorrectly, meaning fields were output in the wrong columns.

### Notes

KeyView 23.2 is a new major version of IDOL, released in the second quarter of 2023. It is the first new major version since KeyView 12.0 was released in June 2018. KeyView 23.2 includes some changes that require you to update your license and application code. For more information about how to upgrade, see the KeyView upgrade guide.

## Deprecated Features

The following features are deprecated and might be removed in a future release.

Category | Deprecated Feature | Deprecated Since
--- | --- | ---
C API | The `fpOpenSubFile` function, and the related `fpCloseSubFile`, `fpExtractInfo`, and `fpExtractStatus` functions have been deprecated. Use `fpOpenDocumentFromSubFile` (Filter-only) or `fpOpenFile` instead. | 26.2.0
Custom readers | The ability to use custom readers has been deprecated. In a future version, File Content Extraction will no longer be able to call new custom readers, or those that have already been developed. If you need to process file formats that are not supported out-of-the-box, OpenText recommends that you contact OpenText support. | 25.1.0
C API | In the `fpSetConfig` function, `KVFLT_SetConfigurableArguments` has been deprecated. Use the `KVFLT_SHOWHIDDENDATA` and `KVFLT_SHOWFORMULAS` options instead. | 24.4.0
Target Encodings | Target encodings other than KVCS_UTF8 and KVCS_UTF16 are now deprecated. OpenText recommends that you use the common UTF-8 and UTF-16 encodings. | 24.4.0
C API | In `KVFilterInitOptions`, the `KVF_OOPLOGON` and `KVF_OOPLOGOFF` flags have been deprecated. Use the `fpSetConfig()` function to turn the out-of-process error log on or off. | 24.1.0
C++ API | The `Configuration::out_of_process_log` function has been deprecated. Use `Configuration:oop_error_log` instead. | 24.1.0
C++ API | The following functions have been deprecated: Session::detect Session::filter Session::get_metadata Session::get_restrictions Session::metadata_map Session::subfiles KeyView 23.3 introduces a `Document` class to the C++ API. OpenText recommends that you create a `Document` object for each document and use the methods on that object instead. For example, call `Document::info` rather than `Session::detect`. | 23.3.0
C++ Metadata API | In KeyView 23.3, the `Metadatum` class was renamed `MetadataElement`, and some of its methods were renamed. The old names are deprecated. OpenText recommends using the new class and method names. | 23.3.0
C API | The following functions have been deprecated. OpenText recommends that you create a `KVDocument` to represent each document, by calling `fpOpenDocumentFromFile()` or `fpOpenDocumentFromStream()`. You can then use the new Filter API functions that accept a `KVDocument`. fpCanFilterFile() fpCanFilterStream() fpCloseStream() fpFileToInputStreamCreate() fpFileToInputStreamFree() fpFilterFile() fpFilterStream() fpGetDocInfoFile() fpGetDocInfoStream() fpGetRestrictionsFile() fpGetRestrictionsStream() fpOpenStream() fpOpenStreamEx2() | 23.2.0
C API | As part of the improvements to simplify error handling, the following functions have been deprecated: `fpFilterConfig()`. OpenText recommends that you use the function `fpSetConfig()` instead. This sets the same configuration options, and returns a `KVErrorCode` rather than a Boolean value. `fpGetKvErrorCodeEx()`. You only need to call this if you use the deprecated functions `fpGetDocInfoFile`, `fpGetDocInfoStream`, and `fpFilterConfig` which return `FALSE` to indicate an error, rather than returning an error code. | 23.2.0
C API | The following functions have been deprecated. OpenText recommends that you access metadata through the new metadata API, by calling `fpGetMetadataList()`. fpFreeOLESummaryInfo() fpFreeXmpInfo() fpGetOLESummaryInfo() fpGetOLESummaryInfoFile() fpGetXmpInfo() fpGetXmpInfoFile() | 23.2.0
C++ API | The following have been deprecated: The `Session::get_summary_information` function. The `Subfile::mail_metadata` function. The `SummaryInfoItem` class. The `SummaryInfoVisitorBase` class. The `SummaryInfoType` enumeration. OpenText recommends that you access metadata using the new metadata API. | 23.2.0

Copyright 2026 Open Text
Version 26.2.0 | Last updated April 2026

Send documentation feedback

Close

Send documentation feedback

To send feedback using your default email client, open an email window.

Otherwise, send your feedback and the information below to MFI-swpdl.idoldocsfeedback@opentext.com.

We appreciate your feedback!

Product: IDOL and KeyView OEM 26.2.0

Topic Title: Filter SDK