> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Frequently Asked Questions

> Frequently asked questions about ABBYY FineReader Engine licensing, distribution, image processing, recognition accuracy, and supported formats.

## Licensing and distribution

<Accordion title="Is there a special installation program for distribution ABBYY FineReader Engine on a workstation (Linux and Windows)?">
  ABBYY FineReader Engine 12 provides a special installation utility for distribution. Using this utility you can install the ABBYY FineReader Engine library on a workstation in automatic mode from the command line. You can also install the library manually by copying the necessary files. See [Distribution of Applications Which Use the ABBYY FineReader Engine Library](/fine-reader/engine/distribution).
</Accordion>

<Accordion title="What license is required for compiling an application?">
  All the licenses in one project share the same [Customer Project ID](/fine-reader/engine/api-reference/functions/initializeengine-function#customerprojectid) which is required by the functions that initialize the library. The end user's Runtime License and the software developer's Developer License should correspond to the Customer Project ID passed to these functions.

  See also [Distribution of Applications Which Use the ABBYY FineReader Engine Library](/fine-reader/engine/distribution).
</Accordion>

<Accordion title="What license is required for activating ABBYY FineReader Engine on a workstation?">
  You should activate a Runtime License on the workstation. See [Activating the ABBYY FineReader Engine Library with the Runtime License](/fine-reader/engine/distribution/distribution-windows/activating-the-library-windows).
</Accordion>

<Accordion title="What ABBYY FineReader Engine files should be copied on a workstation?">
  * Files for the functioning of the modules that your application will support.
  * Files marked as "mandatory" in the table of the [ABBYY FineReader Engine Distribution Kit](/fine-reader/engine/distribution/distribution-windows/distribution-kit) section. They are system modules and main recognition databases.
  * Recognition databases for handwritten/handprinted text, if needed.
  * Resource files for interface languages that will be used in your application.
  * Dictionary support files for recognition languages that your application will support. If the recognition languages include languages with the Latin alphabet, make sure that you copy the Univers.amd and Univers.amm files.
  * Windows canning modules, scanning-specific resources and Twain modules if your application will perform scanning via the ABBYY FineReader Engine interface.
  * Windows Visual Components modules and corresponding specific resources, if your application uses ABBYY FineReader Engine Visual Components. Register VisualComponents\_dll using regsvr32.exe.

  You can also use the [FREngineDistribution.csv](/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file) file to automatically create a list of files required for your application to function.

  See

  * [Installing the ABBYY FineReader Engine Library in Manual Mode](/fine-reader/engine/distribution/distribution-linux/installing-the-library-linux/installing-the-library-in-manual-mode) (Linux)

  * [Installing the ABBYY FineReader Engine Library](/fine-reader/engine/distribution/distribution-macos/installing-the-library-macos) (Mac)

  * [Installing the ABBYY FineReader Engine Library in Manual Mode](/fine-reader/engine/distribution/distribution-windows/installing-the-library-windows/installing-the-library-in-manual-mode)(Windows)
</Accordion>

<Accordion title="Is it necessary to have write or even full control permissions to a folder with the Licensing Service executable for 'Everyone' group?">
  No, it is not necessary, and it is a proper way to limit full access for 'Everyone' so an unauthorized user is not allowed to modify. It is enough to have 'Read' access only for 'Everyone' group.
</Accordion>

<Accordion title="Which folders should be accessible from the Windows workstation?">
  Full control permissions for the following folders are required:

  * %TEMP% folder
  * folder %ProgramData%\ABBYY\SDK\12\FineReader Engine
  * folder %ProgramData%\ABBYY\SDK\12\Licenses (required for license server, optional for workstations)

  All users running your application should have read\&execute and write permissions to:

  * %ProgramData%\ABBYY folder.

  The following registry branches should be accessible from the workstation:

  * "HKEY\_CURRENT\_USER\Software\ABBYY\SDK\12\FineReader Engine" — full control
  * "HKEY\_CURRENT\_USER\Software\ABBYY\SDK\12" — full control for installation only
  * "HKEY\_LOCAL\_MACHINE\Software\ABBYY\SDK\12" — full control for installation only

  See [Installing the ABBYY FineReader Engine Library](/fine-reader/engine/distribution/distribution-windows/installing-the-library-windows).
</Accordion>

<Accordion title="The application is run on a workstation with an activated Runtime License. The message saying &#x22;ABBYY FineReader Engine is not licensed&#x22; is displayed. What should I do?">
  Please make sure that the [Runtime License](/fine-reader/engine/licensing#developer_runtime) corresponds to the Customer Project ID with which the application was compiled. If the license does not match the Customer Project ID, the application will not work.

  Customer Project ID is passed to the methods which load FineReader Engine as one of the input parameters. Make sure that the Customer Project ID used by the methods is correct.

  See also [Licensing](/fine-reader/engine/licensing), [Distribution of Applications Which Use the ABBYY FineReader Engine Library](/fine-reader/engine/distribution).
</Accordion>

<Accordion title="I had activated my license in Linux, but during initialization I got the message saying &#x22;There are no licenses on 127.0.0.1&#x22;. What should I do?">
  Please check the permissions granted to the folder %ProgramData%\ABBYY\SDK\12\Licenses with the following command line:

  ```
  ls -l /var/lib/ABBYY/SDK/12 | grep Licenses
  chmod 777 /var/lib/ABBYY/SDK/12/Licenses
  ```

  If the command line returns a value other than drwxrwxrwx, the folder %ProgramData%\ABBYY\SDK\12\Licenses lacks several permissions.

  To grant full access permissions to the folder %ProgramData%\ABBYY\SDK\12\Licenses, perform the following command line:
</Accordion>

<Accordion title="My license supports barcode recognition. Why cannot I use processing methods?">
  To be able to use processing methods such as [IFRDocument::Process](/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method), you need a license which includes [Processing](/fine-reader/engine/licensing/modules#processing) module. If your license does not support it, you can recognize only barcodes; use the [IFRPage::ExtractBarcodes](/fine-reader/engine/api-reference/document-related-objects/frpage/extractbarcodes-method) method.
</Accordion>

<Accordion title="My license supports barcode recognition and/or optical mark recognition (OMR). Why cannot I use processing methods?">
  To be able to use processing methods such as [IFRDocument::Process](/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method), you need a license which includes [Processing](/fine-reader/engine/licensing/modules#processing) module. If your license does not support it, you still can recognize barcodes and/or checkmarks using other methods:

  * for barcode recognition, you can use the [IFRPage::ExtractBarcodes](/fine-reader/engine/api-reference/document-related-objects/frpage/extractbarcodes-method) method;
  * an OMR license will generally also include [Recognition](/fine-reader/engine/licensing/modules#recognition) module, which allows you to call such methods as [IFRDocument::Recognize](/fine-reader/engine/api-reference/document-related-objects/frdocument/recognize-method), [IFRDocument::RecognizePages](/fine-reader/engine/api-reference/document-related-objects/frdocument/recognizepages-method), [IFRPage::Recognize](/fine-reader/engine/api-reference/document-related-objects/frpage/recognize-method), [IFRPage::RecognizeBlocks](/fine-reader/engine/api-reference/document-related-objects/frpage/recognizeblocks-method).
</Accordion>

<Accordion title="What should I do if I want to run ABBYY FineReader Engine for Windows or Linux inside a Docker container?">
  To run ABBYY FineReader Engine in a Docker container, use two separate containers with ABBYY FineReader Engine and the Licensing Service inside.

  See the instructions for this scenario in [Running ABBYY FineReader Engine 12 inside a Docker container](/fine-reader/engine/distribution/distribution-windows/running-abbyy-finereader-engine-12-inside-a-docker-container).
</Accordion>

<Accordion title="How can I run my Windows application in Azure Services?">
  You may run your ABBYY FineReader Engine-based application in Azure Cloud Service or Azure App Service. Use the instructions provided in [Running ABBYY FineReader Engine in Azure Services](/fine-reader/engine/distribution/distribution-windows/running-abbyy-finereader-engine-inside-azure-services).
</Accordion>

## Image-related questions

<Accordion title="How can I remove background noise from each block separately?">
  Use the methods of the [ImageDocument](/fine-reader/engine/api-reference/image-related-objects/imagedocument) object that improve image quality. These methods allow you to select an image region to work with.
</Accordion>

<Accordion title="What is the difference between various methods of changing the image resolution?">
  ABBYY FineReader Engine provides several ways of correcting the image resolution:

  1. After the image is opened, using the [ChangeResolution](/fine-reader/engine/api-reference/image-related-objects/imagedocument/changeresolution-method) method of the [ImageDocument](/fine-reader/engine/api-reference/image-related-objects/imagedocument) object.<br />You may use the [DetectResolution](/fine-reader/engine/api-reference/document-related-objects/frpage/detectresolution-method) method of the [FRPage](/fine-reader/engine/api-reference/document-related-objects/frpage) object to determine the optimal resolution value.
  2. During image preprocessing stage (which will, by default, be included in the call to any of the methods which perform full processing of the image), managed by the [OverwriteResolutionMode](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pagepreprocessingparams#overwriteresolutionmode) property of the [PagePreprocessingParams](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageprocessingparams) object. The resolution can be corrected automatically or set to the value specified in the [ResolutionToOverwrite](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pagepreprocessingparams#resolutiontooverwrite) property.
</Accordion>

<Accordion title="I am working with a screenshot image. Are there any special recommendations for screenshot processing?">
  For the images obtained by capturing the computer screen we recommend using settings intended for text extraction. Call the [LoadPredefinedProfile](/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/loadpredefinedprofile-method) method of the [Engine](/fine-reader/engine/api-reference/engine-object-iengine-interface) object to load one of the predefined profiles:

  * TextExtraction\_Accuracy — for extracting text from documents, optimized for accuracy
  * TextExtraction\_Speed — for extracting text from documents, optimized for speed

  The resolution of the image that was received from the screenshot must be set to 72 or 96 dpi (depending on the screen resolution).

  <Note>
    These recommendations concern digital images which were created using the operating system or software running on the computer. Resolution of the screen photo made by any additional device (i.e., camera) should be from 200 to 300 dpi.
  </Note>

  See also [Working with Profiles](/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles).
</Accordion>

## Using the Engine object

<Accordion title="What should I do if I have problems creating the Engine object in C# .NET?">
  If you use the [InitializeEngine](/fine-reader/engine/api-reference/functions/initializeengine-function) function for initialization, make sure to specify \[STAThread] (single-thread apartment model) as an attribute on your application's main function:

  ```csharp theme={null}
  [STAThread]
  public static void Main()
  {
    ...
  }
  ```
</Accordion>

<Accordion title="How to work with read-only object properties?">
  Certain ABBYY FineReader Engine objects (for example, [ILayout::Blocks](/fine-reader/engine/api-reference/layout-related-objects/layout#blocks)) have read-only object properties. This does not mean that such properties cannot be changed, it only means that they cannot be changed directly. In C++ (C++ raw if Linux), if you want to change such a property, you need to pass a reference to the property object to a new variable, and then use this variable to change it. Below you can see a C++ sample for the ILayout::Blocks property which is represented by a read-only collection:

  ```
  ILayout* pLayout = 0;
  ILayoutBlocks* pLayoutBlocks = 0;
  int blockIndex = 0;
  // Receive the layout from the previously opened FRPage
  pFRPage->get_Layout( &pLayout );
  // The pLayoutBlocks variable receives a reference to the blocks collection from Layout
  pLayout->get_Blocks( &pLayoutBlocks );
  // Remove an element from the block collection
  pLayoutBlocks->DeleteAt( blockIndex );
  // Work with modified layout
  ...
  // Release the objects
  pLayoutBlocks->Release();
  pLayout->Release();
  ```
</Accordion>

<Accordion title="Is it possible to run and use Engine object in several threads (Windows)?">
  Yes, it is possible. You should use the [InprocLoader](/fine-reader/engine/api-reference/engine-loaders/inprocloader) or [OutprocLoader](/fine-reader/engine/api-reference/engine-loaders/outprocloader) object when creating the [Engine](/fine-reader/engine/api-reference/engine-object-iengine-interface) object. See [Different Ways to Load the Engine Object](/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine) for details.

  If you use the [InitializeEngine](/fine-reader/engine/api-reference/functions/initializeengine-function) function for loading, using Engine object in several threads is impossible. In this case, the methods of all FineReader Engine objects should be called only from the thread in which Engine object was created.
</Accordion>

<Accordion title="Is it possible to create and run the Engine object on a multi-processor system (Windows)?">
  Yes, it is possible. See [Different Ways to Load the Engine Object](/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine) for details.
</Accordion>

<Accordion title="What should I do if the &#x22;Engine deinitialization failed&#x22; exception is thrown during deinitialization of the Engine object?">
  This exception is thrown if not all the objects which were created and used by the application have been deleted before the deinitialization of the [Engine](/fine-reader/engine/api-reference/engine-object-iengine-interface) object. If all the objects have been deleted the exception may be caused by the garbage collector operation.

  <Note>
    If the application is developed in Windows using Visual Basic .NET:  All objects with the Nothing value are not deleted, they are only marked for deletion. The exact moment when the garbage collector deletes the object is not known. Therefore, you should call the following methods before deinitializing the Engine object so that the garbage collector deletes the object:
  </Note>

  ```
      GC.Collect()
      GC.WaitForPendingFinalizers()
  ```

  If you are using the log (it can be turned on with the [StartLogging](/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/startlogging-method) method of the Engine object), the message "Warning: DeinitializeEngine() has detected external references to FREngine objects. It can indicate a leak if programming platform without automatic garbage collection is used." can also appear in this situation. Even if you are explicitly calling the garbage collector (GC.Collect), it does not always mean that the objects are deleted immediately. When working in the environments with garbage collectors, you can disregard this message.

  When working in the environments without garbage collection (such as C++), these exception and message can indicate a problem in your source code. Some objects can be incorrectly handled, causing a memory leak. However, after Engine deinitialization all FineReader Engine objects will be deleted in any case, so the memory leak can occur in the client part of the code, i.e., if you create your own wrappers for the FineReader Engine objects and fail to release them before the deinitialization.

  Consider using the [TotalObjectsCount](/fine-reader/engine/api-reference/engine-object-iengine-interface/properties#totalobjectscount) property of the Engine object which returns the number of unreleased objects and can help you track down the memory leak.
</Accordion>

<Accordion title="How can I create a log file to keep track of all errors, warnings and method calls of ABBYY FineReader Engine?">
  To do this, you need to call the [StartLogging](/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/startlogging-method) method of the [Engine](/fine-reader/engine/api-reference/engine-object-iengine-interface) object. As input parameters, specify the log file name and the Boolean variable which determines whether method call messages should be logged or not. Once you have called this method, all messages will be logged. To stop logging, call the [StopLogging](/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/stoplogging-method) method of the Engine object.
</Accordion>

<Accordion title="Do I need to register the Windows FREngine.dll?">
  Normally, you do not need to register FREngine.dll. The library is registered automatically during the Developer installation or the Runtime installation with the default parameters.

  However, if for some reason you need to register FREngine.dll after installation (during the Runtime installation you have specified RegisterCOM=No), use the following command line:

  ```csharp theme={null}
  regsvr32 /s /n /i:"<path to the Inc folder>" "<path to FREngine.dll>"
  ```
</Accordion>

## Recognition-related questions

<Accordion title="What recognition language is used by default?">
  English is the default recognition language. If you want to change the default recognition language, you must use the [SetPredefinedTextLanguage](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams/setpredefinedtextlanguage-method) method of the [RecognizerParams](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams) object.
</Accordion>

<Accordion title="How can I improve the quality of recognition of blocks which contain different types of text?">
  If a block contains text of different types, ABBYY FineReader Engine will still treat it as text of the same type. To improve the quality of OCR, draw a separate block for text of each type.

  See also [Using Text Type Autodetection](/fine-reader/engine/guided-tour/advanced-techniques/using-text-type-autodetection).
</Accordion>

<Accordion title="How can I quickly obtain the information about document structure?">
  After recognizing the target document, you may export it to XML format. The [XML schema](/fine-reader/engine/specifications/export-formats/xml-schema-description) using in ABBYY FineReader Engine allows you to receive all needed information about the processed text and its structure, attributes, and recognition variants.
</Accordion>

<Accordion title="Why italic fonts and superscript or subscript are not recognized by autodetection?">
  If the [TextTypes](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams#texttypes) property of the [RecognizerParams](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams) object contains any combination of TT\_Matrix, TT\_Typewriter, TT\_OCR\_A, and TT\_OCR\_B, then italic fonts and superscript/subscript will not be recognized, regardless of the values of the [ProhibitItalic](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams#prohibititalic), [ProhibitSubscript](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams#prohibitsubscript) and [ProhibitSuperscript](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams#prohibitsuperscript) properties of the RecognizerParams object.

  See also [Using Text Type Autodetection](/fine-reader/engine/guided-tour/advanced-techniques/using-text-type-autodetection).
</Accordion>

<Accordion title="What is the difference between CharConfidence, ErrorProbability, and IsSuspicious?">
  To find out if a character was recognized unreliably and needs verification, use the IsSuspicious property of the [PlainText](/fine-reader/engine/api-reference/text-related-objects/plaintext/issuspicious-property) or [CharParams](/fine-reader/engine/api-reference/text-related-objects/charparams#issuspicious) objects for the given character. It is calculated based on ErrorProbability.

  To implement more fine-grained distinctions, you can use the ErrorProbability property of the [PlainText](/fine-reader/engine/api-reference/text-related-objects/plaintext/errorprobability-property) or [CharParams](/fine-reader/engine/api-reference/text-related-objects/charparams#errorprobability) objects, which returns the estimated probability (in range from 0 to 100) that the character was recognized incorrectly. It takes into account the context in which the character is found, for example, whether the word with this character is found in the dictionary.

  You can also get the character confidence, both for a recognized character (the CharConfidence property of the [PlainText](/fine-reader/engine/api-reference/text-related-objects/plaintext/charconfidence-property) object) and for all recognition variants (the CharConfidence property of the [CharacterRecognitionVariant](/fine-reader/engine/api-reference/text-related-objects/characterrecognitionvariant#charconfidence) object). The confidence provides an accuracy estimate based only on the image of one character, without considering the context. Confidence estimates for different characters are incomparable, and the only safe use of confidence is for comparing several recognition variants of the same image (character).

  None of these properties make sense for symbols obtained without recognition, for example, those taken directly from the source PDF file.
</Accordion>

<Accordion title="Why cannot I receive recognized words in paragraphs and recognition variants for the words and characters?">
  Make sure that you have set the SaveCharacterRecognitionVariants or SaveWordRecognitionVariants properties of the [RecognizerParams](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams) object to TRUE. These properties specify whether the variants of characters or words recognition must be saved. See also [Using Voting API](/fine-reader/engine/guided-tour/advanced-techniques/using-voting-api).
</Accordion>

<Accordion title="I am using macOS 10.15 Catalina. During document processing I got the message saying &#x22;No fonts are specified for document synthesis&#x22;. What should I do?">
  If your operating system is macOS 10.15 Catalina or above, do the following steps (in this instruction we use the Font Book application):

  1. Find the folder with the fonts (right-click the desired font - Show in Finder).
  2. Install the local fonts from the found folder:

  * Open the application settings (Preferences).
  * Set the Default install location property to Computer.
  * Click the '+' button on the toolbar (or use File - Add fonts).
  * Select the folder from step 1.
  * Click the 'Open' button. Note, that during fonts installation you need to enter the user password.

  Alternatively, you may copy the fonts from the folder in step 1 to /Library/Fonts folder.

  If you do not plan to install the fonts, but want to use them in ABBYY FineReader Engine, set the [Folder](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/customfontset#folder) property of the [CustomFontSet](/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/customfontset) Object.
</Accordion>

<Accordion title="Where are the scan log files located?">
  There are two scan log files: scantwain.txt and scanwia.txt. They are stored in the %userprofile%\AppData\Local\ABBYY\ScanManager\12.00 folder.

  <Note>
    Scan is currently implemented only in Windows.
  </Note>
</Accordion>

<Accordion title="How to change scanning settings?">
  You can use the ScanSettings property of the [ScanSource](/fine-reader/engine/api-reference/mechanism-objects/scansource) object to access to the [ScanSourceSettings](/fine-reader/engine/api-reference/mechanism-objects/scansourcesettings) object. This object provides access to the scanning settings of a source.

  See details in the description of the [Scanning](/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/scanning) scenario.

  <Note>
    Scan is currently implemented only in Windows.
  </Note>
</Accordion>

<Accordion title="Which PDF versions can recognized text be exported to?">
  PDF versions supported for export are enumerated by the [PDFVersionEnum](/fine-reader/engine/api-reference/enumerations/pdfversionenum).

  Note that the version should not conflict with the specified export parameters. The earliest version of the PDF file which matches the specified parameters of export should be selected as the version of the PDF file:

  * The earliest file version available is 1.3.
  * The PDF file version should be 1.4, if:
    * the [PDFAComplianceMode](/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#pdfacompliancemode) property of the PDFExportParams object is PCM\_Pdfa\_1a or PCM\_Pdfa\_1b
  * The PDF file version should be 1.4 or higher, if:
    * at least one of the [PermissionFillFormFields](/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfencryptioninfo#permissionfillformfields), [PermissionExtractTextAndGraphicsExt](/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfencryptioninfo#permissionextracttextandgraphicsext), [PermissionAssembleDoc](/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfencryptioninfo#permissionassembledoc), [PermissionPrintExt](/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfencryptioninfo#permissionprintext) properties of the PDFEncryptionInfo object is TRUE, or
    * the encryption key length exceeds 40 bits (see the [KeyLength](/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfencryptioninfo#keylength) property of the PDFEncryptionInfo object), or
    * the WriteTaggedPDF property is TSPV\_Yes, or
    * the WriteXmpMetadata property is TSPV\_Yes, or
    * the [BwPictureFormats](/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfpicturecompressionparams#bwpictureformats) property of the PDFPictureCompressionParams is BWPF\_JBIG2 or BWPF\_JBIG2Lossless.
  * The version should be 1.5 or higher, if
    * the [ColorPictureFormats](/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfpicturecompressionparams#colorpictureformats) property of the PDFPictureCompressionParams is CPF\_J2K, or
    * the [GrayPictureFormats](/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfpicturecompressionparams#graypictureformats) property of the PDFPictureCompressionParams is GPF\_J2K.
  * The version should be 1.6 or higher, if:
    * the [EncryptionAlgorithm](/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfencryptioninfo#encryptionalgorithm) property of the PDFEncryptionInfo object is PDFEA\_AES128, or
    * OpenType fonts are used in output PDF file.
  * The version should be 1.7 or higher, if:
    * the [EncryptionAlgorithm](/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfencryptioninfo#encryptionalgorithm) property of the PDFEncryptionInfo object is PDFEA\_AES256.
  * The latest file version available is 2.0.

  See also [PDFExportFeatures](/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportfeatures).
</Accordion>

<Accordion title="Linux: I got the output file with fonts significantly different from fonts in a source file. How can I customize the fonts?">
  Depending on how you intend to use the fonts, you need to register them in the operating system or add to your application before launching it using one of the following methods:

  * copy the fonts manually into the Data/Resources/Font folder in your ABBYY FineReader Engine-based application.
  * copy the fonts manually into /usr/share/fonts system folder.
  * install the package for the installation of the fonts, depending on your operating system.

  See [Working with Fonts](/fine-reader/engine/guided-tour/advanced-techniques/working-with-fonts) for details.
</Accordion>

If you cannot find the answer to your question, please contact the [ABBYY Technical Support](/fine-reader/engine/contact-abbyy/technical-support).