v4.0.7

Ghostscript dev advised against. It appears that this is for
creating target for a device that colors in a particular format.

.git_archival.txt

@@ -0,0 +1 @@
+ref-names: $Format:%D$

.gitattributes

@@ -5,4 +5,6 @@
 # (binary is a macro for -text -diff)
 *.jar	binary
 *.pdf	binary
-*.PDF	binary
+*.PDF	binary
+
+.git_archival.txt  export-subst

.gitignore

@@ -10,6 +10,7 @@ pyvenv.cfg
 .eggs/
 build/
 dist/
+wheelhouse/
 
 # Automatically generated files
 ocrmypdf/lib/_*.py

Dockerfile

@@ -23,11 +23,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 
 RUN apt-get install -y --no-install-recommends \
   unpaper \
-  ghostscript \
   qpdf \
-  poppler-utils
-
-RUN apt-get install -y --no-install-recommends \
+  poppler-utils \
   tesseract-ocr \
   tesseract-ocr-deu tesseract-ocr-spa tesseract-ocr-eng tesseract-ocr-fra
 
@@ -36,6 +33,14 @@ RUN apt-get install -qy --no-install-recommends \
   libpython3-dev \
   gcc
 
+# Install Ghostscript from Debian sid to work around JPEG 2000 issue in
+# Debian stretch libgs9 or gs 9.16~dfsg-2.1
+
+COPY ./share/etc-apt-sources.list /etc/apt/sources.list
+
+RUN apt-get update && apt-get install -y ghostscript/sid
+
+
 # Enforce UTF-8
 # Borrowed from https://index.docker.io/u/crosbymichael/python/ 
 RUN dpkg-reconfigure locales && \
@@ -63,9 +68,11 @@ RUN chmod 644 /usr/share/tesseract-ocr/tessdata/pdf.ttf
 
 # Install application and dependencies
 # In this arrangement Pillow and reportlab will be provided by the system
+# Even though ocrmypdf is locally present, pull from PyPI because
+# Dockerhub and setuptools_scm clash
 RUN . /appenv/bin/activate; \
   pip install --upgrade pip \
-  && pip install /application \
+  && pip install ocrmypdf \
   && pip install --no-cache-dir -r /application/test_requirements.txt
 
 # Remove the junk
@@ -77,7 +84,6 @@ USER docker
 WORKDIR /home/docker
 
 ENV OCRMYPDF_TEST_OUTPUT=/tmp/test-output
-ENV OCRMYPDF_IN_DOCKER=1
 ENV OCRMYPDF_SHARP_TTF=1
 
 # Must use array form of ENTRYPOINT

README.rst

@@ -116,8 +116,8 @@ Install or upgrade the required Homebrew packages, if any are missing::
    brew install qpdf
    brew install ghostscript
    brew install python3
-   brew install libxml2
-   brew install leptonica
+   brew install libxml2 libffi leptonica
+   brew install unpaper    # optional
    brew install tesseract
    
 Update the homebrew pip and install Pillow::
@@ -252,11 +252,11 @@ In case you detect an issue, please:
 Press & Media
 -------------
 
--  `c't 1-2014, page 59 <http://www.heise.de/ct/inhalt/2014/1/58/>`__:
+-  `c't 1-2014, page 59 <http://heise.de/-2279695>`__:
    Detailed presentation of OCRmyPDF v1.0 in the leading German IT
    magazine c't
 -  `heise Open Source, 09/2014: Texterkennung mit
-   OCRmyPDF <http://www.heise.de/-2356670>`__
+   OCRmyPDF <http://heise.de/-2356670>`__
 
 Disclaimer
 ----------

RELEASE_NOTES.rst

@@ -6,6 +6,75 @@ Please always read this file before installing the package
 Download software here: https://github.com/jbarlow83/OCRmyPDF/tags
 
 
+v4.0.7:
+=======
+
+-  Minor correction to Ghostscript output settings
+
+
+v4.0.6:
+=======
+
+-  Update install instructions
+-  Provide a sRGB profile instead of using Ghostscript's
+
+
+v4.0.5:
+=======
+
+Fixes
+-----
+
+-  Remove some verbose debug messages from v4.0.4
+-  Fixed temporary that wasn't being deleted
+-  DPI is now calculated correctly for cropped images, along with other image transformations
+-  Inline images are now checked during DPI calculation instead of rejecting the image
+
+v4.0.4:
+=======
+
+Released with verbose debug message turned on. Do not use. Skip to v4.0.5.
+
+
+v4.0.3:
+=======
+
+New features
+------------
+
+-  Page orientations detected are now reported in a summary comment
+
+
+Fixes
+-----
+
+-  Show stack trace if unexpect errors occur
+-  Treat "too few characters" error message from Tesseract as a reason to skip that page rather than
+   abort the file
+-  Docker: fix blank JPEG2000 issue by insisting on Ghostscript versions that have this fixed
+
+
+v4.0.2:
+=======
+
+Fixes
+-----
+
+-  Fixed compatibility with Tesseract 3.04.01 release, particularly its different way of outputting
+   orientation information
+-  Improved handling of Tesseract errors and crashes
+-  Fixed use of chmod on Docker that broke most test cases
+
+
+v4.0.1:
+=======
+
+Fixes
+-----
+
+-  Fixed a KeyError if tesseract fails to find page orientation information
+
+
 v4.0:
 =====
 
@@ -15,15 +84,15 @@ New features
 -  Automatic page rotation (``-r``) is now available. It uses ignores any prior rotation information
    on PDFs and sets rotation based on the dominant orientation of detectable text. This feature is
    fairly reliable but some false positives occur especially if there is not much text to work with. (#4) 
--  Deskewing is now performed using Leptonica instead of unpaper. Leptonica deskews images faster and
-   more reliably than unpaper.
+-  Deskewing is now performed using Leptonica instead of unpaper. Leptonica is faster and more reliable
+   at image deskewing than unpaper.
 
 
 Fixes
 -----
 
 -  Fixed an issue where lossless reconstruction could cause some pages to be appear incorrectly
-   rotated in the page had a /Rotate tag applied (#50)
+   if the page was rotated by the user in Acrobat after being scanned (specifically if it a /Rotate tag)
 -  Fixed an issue where lossless reconstruction could misalign the graphics layer with respect to
    text layer if the page had been cropped such that its origin is not (0, 0) (#49)
 
@@ -31,7 +100,7 @@ Fixes
 Changes
 -------
 
--  Logging output much is now better
+-  Logging output is now much easier to read
 -  ``--deskew`` is now performed by Leptonica instead of unpaper (#25)
 -  libffi is now required
 -  Some changes were made to the Docker and Travis build environments to support libffi

ocrmypdf/__init__.py

@@ -10,6 +10,7 @@ class ExitCode(IntEnum):
     invalid_output_pdfa = 4
     file_access_error = 5
     already_done_ocr = 6
+    child_process_error = 7
     other_error = 15
 
 

ocrmypdf/ghostscript.py

@@ -5,6 +5,7 @@ from tempfile import NamedTemporaryFile
 from subprocess import Popen, PIPE, check_call
 from shutil import copy
 from . import get_program
+from .pdfa import SRGB_ICC_PROFILE
 
 
 def rasterize_pdf(input_file, output_file, xres, yres, raster_device, log,
@@ -52,7 +53,6 @@ def generate_pdfa(pdf_pages, output_file, threads=1):
             "-dJPEGQ=95",
             "-dPDFA=2",
             "-sPDFACompatibilityPolicy=2",
-            "-sOutputICCProfile=srgb.icc",
             "-sOutputFile=" + gs_pdf.name,
         ]
         args_gs.extend(pdf_pages)

ocrmypdf/leptonica.py

@@ -84,6 +84,20 @@ class LeptonicaIOError(LeptonicaError):
 
 
 class Pix:
+    """Wrapper around leptonica's PIX object.
+
+    Leptonica uses referencing counting on PIX objects. Also, many Leptonica
+    functions return the original object with an increased reference count
+    if the operation had no effect (for example, image skew was found to be 0).
+    This has complications for memory management in Python. Whenever Leptonica
+    returns a PIX object (new or old), we wrap it in this class, which
+    registers it with the FFI garbage collector. pixDestroy() decrements the
+    reference count and only destroys when the last reference is removed.
+
+    Leptonica's reference counting is not threadsafe. This class can be used
+    in a threadsafe manner if a Python threading.Lock protects the data.
+    """
+
     def __init__(self, cpix):
         self.cpix = ffi.gc(cpix, Pix._pix_destroy)
 
@@ -95,6 +109,34 @@ class Pix:
         else:
             return "<leptonica.Pix image NULL>"
 
+    def __getstate__(self):
+        data = ffi.new('l_uint32 **')
+        size = ffi.new('size_t *')
+
+        err = lept.pixSerializeToMemory(self.cpix, data, size)
+        if err != 0:
+            raise LeptonicaIOError("pixSerializeToMemory")
+
+        char_data = ffi.cast('char *', data[0])
+        data_bytes = ffi.buffer(char_data, size[0])[:]
+        lept.lept_free(char_data)
+        return dict(data=data_bytes)
+
+    def __setstate__(self, state):
+        cdata_bytes = ffi.new('char[]', state['data'])
+        cdata_uint32 = ffi.cast('l_uint32 *', cdata_bytes)
+
+        self.cpix = lept.pixDeserializeFromMemory(
+            cdata_uint32, len(state['data']))
+
+    @property
+    def width(self):
+        return self.cpix.w
+
+    @property
+    def height(self):
+        return self.cpix.h
+
     @classmethod
     def read(cls, filename):
         """Load an image file into a PIX object.
@@ -113,23 +155,11 @@ class Pix:
         jpeg_quality -- quality (iff JPEG; 1 - 100, 0 for default)
         jpeg_progressive -- (iff JPEG; 0 for baseline seq., 1 for progressive)
         """
-        fileroot, extension = os.path.splitext(filename)
-        fix_pnm = False
-        if extension.lower() in ('.pbm', '.pgm', '.ppm'):
-            # Leptonica does not process handle these extensions correctly, but
-            # does handle .pnm correctly.  Add another .pnm suffix.
-            filename += '.pnm'
-            fix_pnm = True
-
         with LeptonicaErrorTrap():
             lept.pixWriteImpliedFormat(
                 filename.encode(sys.getfilesystemencoding()),
                 self.cpix, jpeg_quality, jpeg_progressive)
 
-        if fix_pnm:
-            from shutil import move
-            move(filename, filename[:-4])   # Remove .pnm suffix
-
     def deskew(self, reduction_factor=0):
         """Returns the deskewed pix object.
 
@@ -165,16 +195,21 @@ class Pix:
             else:
                 return (None, None)
 
+    @staticmethod
+    @lru_cache(maxsize=1)
+    def make_pixel_sum_tab8():
+        return lept.makePixelSumTab8()
+
     @staticmethod
     def correlation_binary(pix1, pix2):
-        if getLeptonicaVersion() < 'leptonica-1.72':
+        if get_leptonica_version() < 'leptonica-1.72':
             # Older versions of Leptonica (pre-1.72) have a buggy
             # implementation of pixCorrelationBinary that overflows on larger
             # images.
-            pix1_count = ffi.new('l_int32 *', 0)
-            pix2_count = ffi.new('l_int32 *', 0)
-            pixn_count = ffi.new('l_int32 *', 0)
-            tab8 = lept.makePixelSumTab8()  # Small memory leak on each call
+            pix1_count = ffi.new('l_int32 *')
+            pix2_count = ffi.new('l_int32 *')
+            pixn_count = ffi.new('l_int32 *')
+            tab8 = Pix.make_pixel_sum_tab8()
 
             lept.pixCountPixels(pix1.cpix, pix1_count, tab8)
             lept.pixCountPixels(pix2.cpix, pix2_count, tab8)
@@ -204,7 +239,7 @@ class Pix:
 
 
 @lru_cache(maxsize=1)
-def getLeptonicaVersion():
+def get_leptonica_version():
     """Get Leptonica version string.
 
     Caveat: Leptonica expects the caller to free this memory.  We don't,
@@ -248,39 +283,12 @@ if __name__ == '__main__':
 
     args = parser.parse_args()
 
-    if getLeptonicaVersion() != u'leptonica-1.69':
+    if get_leptonica_version() != u'leptonica-1.69':
         print("Unexpected leptonica version: %s" % getLeptonicaVersion())
 
     args.func(args)
 
 
-def _test_output(mode, extension, im_format):
-    from PIL import Image
-    from tempfile import NamedTemporaryFile
-
-    with NamedTemporaryFile(prefix='test-lept-pnm', suffix=extension, delete=True) as tmpfile:
-        im = Image.new(mode=mode, size=(100, 100))
-        im.save(tmpfile)
-
-        pix = pixRead(tmpfile.name)
-        pixWriteImpliedFormat(tmpfile.name, pix)
-        pixDestroy(pix)
-
-        im_roundtrip = Image.open(tmpfile.name)
-        assert im_roundtrip.mode == im.mode, "leptonica mode differs"
-        assert im_roundtrip.format == im_format, \
-            "{0}: leptonica produced a {1}".format(
-                extension,
-                im_roundtrip.format)
-
-
-def test_pnm_output():
-    params = [['1', '.pbm', 'PPM'], ['L', '.pgm', 'PPM'],
-              ['RGB', '.ppm', 'PPM']]
-    for param in params:
-        _test_output(*param)
-
-
 def test_skew_angle():
     from PIL import Image, ImageDraw
     from tempfile import NamedTemporaryFile

ocrmypdf/lib/compile_leptonica.py

@@ -58,7 +58,13 @@ PIX *pixRotate180(PIX *pixd, PIX *pixs);
 l_int32 pixCountPixels ( PIX *pix, l_int32 *pcount, l_int32 *tab8 );
 PIX * pixAnd ( PIX *pixd, PIX *pixs1, PIX *pixs2 );
 l_int32 * makePixelSumTab8 ( void );
+
+PIX * pixDeserializeFromMemory ( const l_uint32 *data, size_t nbytes );
+l_int32 pixSerializeToMemory ( PIX *pixs, l_uint32 **pdata, size_t *pnbytes );
+
+void lept_free(void *ptr);
 """)
 
+
 if __name__ == '__main__':
     ffi.compile()

ocrmypdf/main.py

@@ -378,7 +378,7 @@ def cleanup_working_files(*args):
 @transform(
     input=options.input_file,
     filter=formatter('(?i)\.pdf'),
-    output=work_folder + '{basename[0]}.repaired.pdf',
+    output=os.path.join(work_folder, '{basename[0]}.repaired.pdf'),
     extras=[_log, _pdfinfo, _pdfinfo_lock])
 def repair_pdf(
         input_file,
@@ -524,9 +524,9 @@ def orient_page(
 
     direction = {
         0: '⇧',
-        90: '⇦',
+        90: '⇨',
         180: '⇩',
-        270: '⇨'
+        270: '⇦'
     }
 
     log.info(
@@ -544,12 +544,18 @@ def orient_page(
         reader = pypdf.PdfFileReader(page_pdf)
         page = reader.pages[0]
 
-        # Rotate opposite of orientation
-        rotated_page = page.rotateClockwise(orient_conf.angle)
+        # angle is a clockwise angle, so rotating ccw will correct the error
+        rotated_page = page.rotateCounterClockwise(orient_conf.angle)
         writer.addPage(rotated_page)
         with open(output_file, 'wb') as out:
             writer.write(out)
 
+        with pdfinfo_lock:
+            pageno = int(os.path.basename(page_pdf)[0:6]) - 1
+            pageinfo = pdfinfo[pageno].copy()
+            pageinfo['rotated'] = orient_conf.angle
+            pdfinfo[pageno] = pageinfo
+
 
 @transform(
     input=orient_page,
@@ -788,11 +794,12 @@ def add_text_layer(
 
     page_text = pdf_text.getPage(0)
 
-    # The text page always will be oriented up
+    # The text page always will be oriented up by this stage
     # but if lossless_reconstruction, pdf_image may have a rotation applied
-    # we can't just merge the pages, because a page can only have one /Rotate
-    # tag, so the differential rotation must be corrected.
-    # Also, pdf_image may not have its mediabox nailed to (0, 0)
+    # We have to eliminate the /Rotate tag (because it applies to the whole
+    # page) and rotate the image layer to match the text page
+    # Also, pdf_image may not have its mediabox nailed to (0, 0), so may need
+    # translation
     page_image = pdf_image.getPage(0)
     rotation = page_image.get('/Rotate', 0)
 
@@ -1011,10 +1018,17 @@ def run_pipeline():
         cmdline.run(options)
     except ruffus_exceptions.RethrownJobError as e:
         if options.verbose:
-            print(e)
+            _log.debug(e)
 
         # Yuck. Hunt through the ruffus exception to find out what the
         # return code is supposed to be.
+        # Ruffus flattens the exception to a string, throwing away all kinds
+        # of helpful details
+        # task_name, job_name - ruffus status
+        # exc_name - class name of exception
+        # exc_value - irritating string that makes impossible to recover
+        #   exception object
+        # exc_stack - string that contains traceback of exception
         for exc in e.args:
             task_name, job_name, exc_name, exc_value, exc_stack = exc
             if exc_name == 'builtins.SystemExit':
@@ -1023,22 +1037,46 @@ def run_pipeline():
                 exit_code = getattr(ExitCode, exit_code_name, 'other_error')
                 return exit_code
             elif exc_name == 'ruffus.ruffus_exceptions.MissingInputFileError':
-                print(cleanup_ruffus_error_message(exc_value))
+                _log.error(cleanup_ruffus_error_message(exc_value))
                 return ExitCode.input_file
             elif exc_name == 'builtins.TypeError':
                 # Even though repair_pdf will fail, ruffus will still try
                 # to call split_pages with no input files, likely due to a bug
                 if task_name == 'split_pages':
-                    print("Input file '{0}' is not a valid PDF".format(
+                    _log.error("Input file '{0}' is not a valid PDF".format(
                         options.input_file))
                     return ExitCode.input_file
+            elif exc_name == 'subprocess.CalledProcessError':
+                # It's up to the subprocess handler to report something useful
+                msg = "Error occurred while running this command:"
+                _log.error(msg + '\n' + exc_value)
+                return ExitCode.child_process_error
+            elif not options.verbose:
+                _log.error(e)
 
         return ExitCode.other_error
+    except Exception as e:
+        _log.error(e)
+        return ExitCode.other_error
 
     if not validate_pdfa(options.output_file, _log):
         _log.warning('Output file: The generated PDF/A file is INVALID')
         return ExitCode.invalid_output_pdfa
 
+    with _pdfinfo_lock:
+        _log.debug(_pdfinfo)
+        direction = {0: 'n', 90: 'e',
+                     180: 's', 270: 'w'}
+        orientations = []
+        for n, page in enumerate(_pdfinfo):
+            angle = _pdfinfo[n].get('rotated', 0)
+            if angle != 0:
+                orientations.append('{0}{1}'.format(
+                    n + 1,
+                    direction.get(angle, '')))
+        if orientations:
+            _log.info('Page orientations detected: ' + ' '.join(orientations))
+
     return ExitCode.ok
 
 

ocrmypdf/pageinfo.py

@@ -6,7 +6,9 @@ from decimal import Decimal, getcontext
 import re
 import sys
 import PyPDF2 as pypdf
+from collections import namedtuple
 
+matrix_mult = pypdf.pdf.utils.matrixMultiply
 
 FRIENDLY_COLORSPACE = {
     '/DeviceGray': 'gray',
@@ -19,7 +21,11 @@ FRIENDLY_COLORSPACE = {
     '/Indexed': 'index',
     '/Separation': 'sep',
     '/DeviceN': 'devn',
-    '/Pattern': '-'
+    '/Pattern': '-',
+    '/G': 'gray',  # Abbreviations permitted in inline images
+    '/RGB': 'rgb',
+    '/CMYK': 'cmyk',
+    '/I': 'index',
 }
 
 FRIENDLY_ENCODING = {
@@ -27,6 +33,8 @@ FRIENDLY_ENCODING = {
     '/DCTDecode': 'jpeg',
     '/JPXDecode': 'jpx',
     '/JBIG2Decode': 'jbig2',
+    '/CCF': 'ccitt',  # Abbreviations permitted in inline images
+    '/DCT': 'jpeg'
 }
 
 FRIENDLY_COMP = {
@@ -38,38 +46,159 @@ FRIENDLY_COMP = {
 }
 
 
-def _page_has_inline_images(page):
-    # PDF always uses \r\n for separator regardless of platform
-    # Really basic heuristic that might trigger the odd false positive
-    # This is only finds the first image and is not quite spec compliant
-    try:
-        contents = page.getContents()
-        data = contents.getData()
-    except AttributeError:
-        # If we can't access the contents or data (empty page?) then there
-        # are no inline images
-        return False
+def _matrix_from_shorthand(shorthand):
+    """Convert from PDF matrix shorthand to full matrix
 
-    begin_image, image_data, end_image = False, False, False
-    for data in re.split(b'\s+', data):
-        if data == b'BI':
-            begin_image = True
-        elif data == b'ID':
-            image_data = True
-        elif data == b'EI':
-            end_image = True
-        if all((begin_image, image_data, end_image)):
-            return True
-    return False
+    PDF 1.7 spec defines a shorthand for describing the entries of a matrix
+    since the last column is always (0, 0, 1).
+    """
+
+    a, b, c, d, e, f = map(float, shorthand)
+    return ((a, b, 0),
+            (c, d, 0),
+            (e, f, 1))
 
 
-def _find_page_images(page, pageinfo):
+def _shorthand_from_matrix(matrix):
+    """Convert from transformation matrix to PDF shorthand."""
+    a, b = matrix[0][0], matrix[0][1]
+    c, d = matrix[1][0], matrix[1][1]
+    e, f = matrix[2][0], matrix[2][1]
+    return tuple(map(float, (a, b, c, d, e, f)))
+
+
+def euclidean_distance(rowvec1, rowvec2):
+    return ((rowvec1[0] - rowvec2[0]) ** 2
+        + (rowvec1[1] - rowvec2[1]) ** 2) ** 0.5
+
+
+ContentsInfo = namedtuple('ContentsInfo',
+    ['raster_settings', 'inline_images'])
+
+def _interpret_contents(contentstream):
+    operations = contentstream.operations
+    stack = []
+    ctm = _matrix_from_shorthand((1, 0, 0, 1, 0, 0))
+    image_raster_settings = []
+    inline_images = []
+
+    for op in operations:
+        operands, command = op
+        if command == b'q':
+            stack.append(ctm)
+        elif command == b'Q':
+            ctm = stack.pop()
+        elif command == b'cm':
+            ctm = matrix_mult(
+                ctm, _matrix_from_shorthand(operands))
+        elif command == b'Do':
+            image_name = operands[0]
+            image_raster_settings.append(
+                (image_name, _shorthand_from_matrix(ctm)))
+        elif command == b'INLINE IMAGE':
+            settings = operands['settings']
+            inline_images.append(
+                (settings, _shorthand_from_matrix(ctm)))
+
+    return ContentsInfo(
+        raster_settings=image_raster_settings,
+        inline_images=inline_images)
+
+
+def _get_dpi(ctm_shorthand, image_size):
+    """Given the transformation matrix and image size, find the image DPI.
+
+    PDFs do not include image resolution information within image data.
+    Instead, the PDF page content stream describes the location where the
+    image will be rasterized, and the effective resolution is the ratio of the
+    pixel size to raster target size.
+
+    Normally a scanned PDF has the paper size set appropriately but this is
+    not guaranteed. The most common case is a cropped image will change the
+    page size (/CropBox) without altering the page content stream. That means
+    it is not sufficient to assume that the image fills the page, even though
+    that is the most common case.
+
+    This code solves the general case where the image may be scaled (always),
+    cropped, translated (often), and rotated in place (occasionally) to an
+    arbitrary angle (rare). It will work as long as the image is a
+    parallelogram from the perspective of a rectilinear coordinate system.
+    It does not work for arbitrarily quadrilaterals that might be produced
+    by shearing, but by that point DPI becomes a linear gradient rather than
+    constant over the image.
+
+    The transformation matrix describes the coordinate system at the time of
+    rendering. We transform the image corner locations into the coordinate
+    system and measure the width and height within the system, expressed in
+    PDF units. From there we can compare to the actual image dimensions.
+
+    pdfimages -list does calculate the DPI in some way that is not completely
+    naive, but it does not the DPI of rotated images right, so cannot be
+    used anymore to validate this. Photoshop works, or using Acrobat to
+    rotate the image back to normal.
+
+    It does not matter if the image is partially cropped, or even out of the
+    /MediaBox.
+
+    """
+    matrix = _matrix_from_shorthand(ctm_shorthand)
+
+    # Corners of the image in untransformed unit space; last
+    # column is a dummy to assist matrix math
+    corners = [[0, 0, 1],
+               [1, 0, 1],
+               [0, 1, 1],
+               [1, 1, 1]]
+
+    # Rotate/translate/scale the corners into PDF coords (1/72")
+    # ordering of points may change, e.g. if rotation is 180 then
+    # the point (0, 0) may become the top right
+    # The row vectors can all be transformed together here by building
+    # a matrix of them
+    page_unit_corners = matrix_mult(corners, matrix)
+
+    # Calculate the width and height of the rotated image
+    # the transformation matrix so the corner that was originally
+    # (1, 1) can be ignored
+    image_drawn_width = euclidean_distance(
+        page_unit_corners[0], page_unit_corners[1])
+    image_drawn_height = euclidean_distance(
+        page_unit_corners[0], page_unit_corners[2])
+
+    # print((image_drawn_width, image_drawn_height))
+
+    # The scale of the image is pixels per PDF unit (1/72")
+    scale_w = image_size[0] / image_drawn_width
+    scale_h = image_size[1] / image_drawn_height
+
+    # DPI = scale * 72
+    dpi_w = scale_w * 72.0
+    dpi_h = scale_h * 72.0
+
+    return (dpi_w, dpi_h)
+
+
+def _find_page_images(page, pageinfo, contentsinfo):
+
+    for n, im in enumerate(contentsinfo.inline_images):
+        settings, shorthand = im
+        image = {}
+        image['name'] = str('inline-%02d' % n)
+        image['width'] = settings['/W']
+        image['height'] = settings['/H']
+        image['bpc'] = settings['/BPC']
+        image['color'] = FRIENDLY_COLORSPACE.get(settings['/CS'], '-')
+        image['comp'] = FRIENDLY_COMP.get(image['color'], '?')
+
+        dpi_w, dpi_h = _get_dpi(shorthand, (image['width'], image['height']))
+        image['dpi_w'], image['dpi_h'] = Decimal(dpi_w), Decimal(dpi_h)
+        yield image
+
+    # Look for XObject (out of line images)
     try:
         page['/Resources']['/XObject']
     except KeyError:
         return
-
-    # Look for XObject (out of line images)
     for xobj in page['/Resources']['/XObject']:
         # PyPDF2 returns the keys as an iterator
         pdfimage = page['/Resources']['/XObject'][xobj]
@@ -79,6 +208,7 @@ def _find_page_images(page, pageinfo):
             if pdfimage['/ImageMask']:
                 continue
         image = {}
+        image['name'] = str(xobj)
         image['width'] = pdfimage['/Width']
         image['height'] = pdfimage['/Height']
         image['bpc'] = pdfimage['/BitsPerComponent']
@@ -98,8 +228,24 @@ def _find_page_images(page, pageinfo):
             image['color'] = 'jpx' if image['enc'] == 'jpx' else '?'
 
         image['comp'] = FRIENDLY_COMP.get(image['color'], '?')
-        image['dpi_w'] = image['width'] / pageinfo['width_inches']
-        image['dpi_h'] = image['height'] / pageinfo['height_inches']
+        image['dpi_w'] = image['dpi_h'] = 0
+
+        for raster in contentsinfo.raster_settings:
+            # Loop in case the same image is display multiple times on a page
+            if raster[0] != image['name']:
+                continue
+            shorthand = raster[1]
+
+            dpi_w, dpi_h = _get_dpi(
+                shorthand, (image['width'], image['height']))
+
+            # When image is used multiple times take the highest DPI it is
+            # rendered at
+            image['dpi_w'] = max(dpi_w, image.get('dpi_w', 0))
+            image['dpi_h'] = max(dpi_h, image.get('dpi_h', 0))
+
+        image['dpi_w'] = Decimal(image['dpi_w'])
+        image['dpi_h'] = Decimal(image['dpi_h'])
         image['dpi'] = (image['dpi_w'] * image['dpi_h']) ** Decimal(0.5)
         yield image
 
@@ -141,12 +287,14 @@ def _pdf_get_pageinfo(infile, pageno: int):
     pageinfo['width_inches'] = width_pt / Decimal(72.0)
     pageinfo['height_inches'] = height_pt / Decimal(72.0)
 
-    pageinfo['images'] = [im for im in _find_page_images(page, pageinfo)]
+    try:
+        contentstream = pypdf.pdf.ContentStream(page.getContents(), pdf)
+    except AttributeError as e:
+        return pageinfo
 
-    # Look for inline images
-    if _page_has_inline_images(page):
-        raise NotImplementedError(
-            "Warning: input PDF contains inline images - not supported")
+    contentsinfo = _interpret_contents(contentstream)
+    pageinfo['images'] = [im for im in _find_page_images(
+                                page, pageinfo, contentsinfo)]
 
     if pageinfo['images']:
         xres = max(image['dpi_w'] for image in pageinfo['images'])
@@ -164,3 +312,17 @@ def pdf_get_all_pageinfo(infile):
     pdf = pypdf.PdfFileReader(infile)
     getcontext().prec = 6
     return [_pdf_get_pageinfo(infile, n) for n in range(pdf.numPages)]
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('infile')
+    args = parser.parse_args()
+    info = pdf_get_all_pageinfo(args.infile)
+    from pprint import pprint
+    pprint(info)
+
+
+if __name__ == '__main__':
+    main()

ocrmypdf/pdfa.py

@@ -5,10 +5,13 @@
 
 from __future__ import print_function, absolute_import, division
 from string import Template
-from subprocess import Popen, PIPE
-import os
 import codecs
-from . import get_program
+import pkg_resources
+
+ICC_PROFILE_RELPATH = 'data/sRGB_IEC61966-2-1_black_scaled.icc'
+
+SRGB_ICC_PROFILE = pkg_resources.resource_filename(
+    'ocrmypdf', ICC_PROFILE_RELPATH)
 
 
 # This is a template written in PostScript which is needed to create PDF/A
@@ -93,38 +96,9 @@ def _get_pdfa_def(icc_profile, icc_identifier, pdfmark):
     return result
 
 
-def _get_postscript_icc_path():
-    "Parse Ghostscript's help message to find where iccprofiles are stored"
-
-    p_gs = Popen([get_program('gs'), '--help'], close_fds=True,
-                 universal_newlines=True,
-                 stdout=PIPE, stderr=PIPE)
-    out, _ = p_gs.communicate()
-    lines = out.splitlines()
-
-    def search_paths(lines):
-        seeking = True
-        for line in lines:
-            if seeking:
-                if line.startswith('Search path'):
-                    seeking = False
-                    continue
-            else:
-                if line.strip().startswith('/'):
-                    yield from (
-                        path.strip() for path in line.split(':')
-                        if path.strip() != '')
-    for root in search_paths(lines):
-        path = os.path.realpath(os.path.join(root, '../iccprofiles'))
-        if os.path.exists(path):
-            return path
-
-    raise FileNotFoundError("Could not find Ghostscript's iccprofiles")
-
-
 def generate_pdfa_def(target_filename, pdfmark, icc='sRGB'):
     if icc == 'sRGB':
-        icc_profile = os.path.join(_get_postscript_icc_path(), 'srgb.icc')
+        icc_profile = SRGB_ICC_PROFILE
     else:
         raise NotImplementedError("Only supporting sRGB")
 

ocrmypdf/tesseract.py

@@ -90,14 +90,18 @@ def get_orientation(input_file, language: list, timeout: float, log):
         'stdout'
     ]
 
-    p = Popen(args_tesseract, close_fds=True, stdout=PIPE, stderr=STDOUT,
-              universal_newlines=True)
     try:
-        stdout, _ = p.communicate(timeout=timeout)
+        stdout = check_output(
+            args_tesseract, close_fds=True, stderr=STDOUT,
+            universal_newlines=True, timeout=timeout)
     except TimeoutExpired:
-        p.kill()
-        stdout, _ = p.communicate()
         return OrientationConfidence(angle=0, confidence=0.0)
+    except CalledProcessError as e:
+        tesseract_log_output(log, e.output, input_file)
+        if ('Too few characters. Skipping this page' in e.output or
+                'Image too large' in e.output):
+            return OrientationConfidence(0, 0)
+        raise e from e
     else:
         osd = {}
         for line in stdout.splitlines():
@@ -106,9 +110,21 @@ def get_orientation(input_file, language: list, timeout: float, log):
             if len(parts) == 2:
                 osd[parts[0].strip()] = parts[1].strip()
 
+        angle = int(osd.get('Orientation in degrees', 0))
+        if 'Orientation' in osd:
+            # Tesseract < 3.04.01
+            # reports "Orientation in degrees" as a counterclockwise angle
+            # We keep it clockwise
+            assert 'Rotate' not in osd
+            angle = -angle % 360
+        else:
+            # Tesseract == 3.04.01, hopefully also Tesseract > 3.04.01
+            # reports "Orientation in degrees" as a clockwise angle
+            assert 'Rotate' in osd
+
         oc = OrientationConfidence(
-            angle=int(osd['Orientation in degrees']),
-            confidence=float(osd['Orientation confidence']))
+            angle=angle,
+            confidence=float(osd.get('Orientation confidence', 0)))
         return oc
 
 
@@ -124,10 +140,24 @@ def tesseract_log_output(log, stdout, input_file):
             log.warning(prefix + "lots of diacritics - possibly poor OCR")
         elif line.startswith('OSD: Weak margin'):
             log.warning(prefix + "unsure about page orientation")
+        elif 'error' in line.lower() or 'exception' in line.lower():
+            log.error(prefix + line.strip())
         else:
             log.info(prefix + line.strip())
 
 
+def page_timedout(log, input_file):
+    prefix = "{0:4d}: [tesseract] ".format(page_number(input_file))
+    log.warning(prefix + " took too long to OCR - skipping")
+
+
+def _generate_null_hocr(output_hocr, pageinfo):
+    with open(output_hocr, 'w', encoding="utf-8") as f:
+        f.write(HOCR_TEMPLATE.format(
+            pageinfo['width_pixels'],
+            pageinfo['height_pixels']))
+
+
 def generate_hocr(input_file, output_hocr, language: list, tessconfig: list,
                   timeout: float, pageinfo_getter, pagesegmode: int, log):
 
@@ -146,26 +176,25 @@ def generate_hocr(input_file, output_hocr, language: list, tessconfig: list,
         badxml,
         'hocr'
     ] + tessconfig)
-    p = Popen(args_tesseract, close_fds=True, stdout=PIPE, stderr=STDOUT,
-              universal_newlines=True)
     try:
-        stdout, _ = p.communicate(timeout=timeout)
+        stdout = check_output(
+            args_tesseract, close_fds=True, stderr=STDOUT,
+            universal_newlines=True, timeout=timeout)
     except TimeoutExpired:
-        p.kill()
-        stdout, _ = p.communicate()
         # Generate a HOCR file with no recognized text if tesseract times out
         # Temporary workaround to hocrTransform not being able to function if
         # it does not have a valid hOCR file.
-        with open(output_hocr, 'w', encoding="utf-8") as f:
-            pageinfo = pageinfo_getter()
-            f.write(HOCR_TEMPLATE.format(
-                pageinfo['width_pixels'],
-                pageinfo['height_pixels']))
+        page_timedout(log, input_file)
+        _generate_null_hocr(output_hocr, pageinfo_getter())
+    except CalledProcessError as e:
+        tesseract_log_output(log, e.output, input_file)
+        if 'Image too large' in e.output:
+            _generate_null_hocr(output_hocr, pageinfo_getter())
+            return
+
+        raise e from e
     else:
         tesseract_log_output(log, stdout, input_file)
-        if p.returncode != 0:
-            raise CalledProcessError(p.returncode, args_tesseract)
-
         if os.path.exists(badxml + '.html'):
             # Tesseract 3.02 appends suffix ".html" on its own (.badxml.html)
             shutil.move(badxml + '.html', badxml)
@@ -213,14 +242,19 @@ def generate_pdf(input_image, skip_pdf, output_pdf, language: list,
         os.path.splitext(output_pdf)[0],  # Tesseract appends suffix
         'pdf'
     ] + tessconfig)
-    p = Popen(args_tesseract, close_fds=True, stdout=PIPE, stderr=STDOUT,
-              universal_newlines=True)
 
     try:
-        stdout, _ = p.communicate()
+        stdout = check_output(
+            args_tesseract, close_fds=True, stderr=STDOUT,
+            universal_newlines=True, timeout=timeout)
     except TimeoutExpired:
-        p.kill()
-        log.info("Tesseract - page timed out")
+        page_timedout(log, input_image)
         shutil.copy(skip_pdf, output_pdf)
+    except CalledProcessError as e:
+        tesseract_log_output(log, e.output, input_image)
+        if 'Image too large' in e.output:
+            shutil.copy(skip_pdf, output_pdf)
+            return
+        raise e from e
     else:
         tesseract_log_output(log, stdout, input_image)

setup.py

@@ -209,7 +209,6 @@ setup(
         ],
     setup_requires=[
         'setuptools_scm',
-        'setuptools_scm_git_archive',
         'cffi>=1.5.0',
         'pytest-runner'
     ],
@@ -231,5 +230,6 @@ setup(
             'ocrmypdf = ocrmypdf.main:run_pipeline'
         ],
     },
+    package_data={'ocrmypdf': ['data/sRGB_IEC61966-2-1_black_scaled.icc']},
     include_package_data=True,
     zip_safe=False)

share/etc-apt-sources.list

@@ -0,0 +1,4 @@
+deb http://httpredir.debian.org/debian stretch main
+deb http://httpredir.debian.org/debian stretch-updates main
+deb http://security.debian.org stretch/updates main
+deb http://ftp.de.debian.org/debian sid main contrib non-free

tests/resources/README.rst

@@ -18,9 +18,12 @@ In some cases they were converted from one image format to another without other
 +---------------------+--------------------------------------------------------------------------------+
 | graph.pdf           | `Wikimedia: Pandas text analysis.png`_                                         |
 +---------------------+--------------------------------------------------------------------------------+
-| LinnSequencer.jpg   | `Wikimedia: LinnSequencer`_ (Creative Commons Attribution-ShareAlike 3.0)      |
+| lichtenstein.pdf    | `Wikimedia: JPEG2000 Lichtenstein`_ (Creative Commons BY-SA 3.0)               |
 +---------------------+--------------------------------------------------------------------------------+
-
+| LinnSequencer.jpg,  | `Wikimedia: LinnSequencer`_ (Creative Commons Attribution-ShareAlike 3.0)      |
+| linn.pdf, linn.txt  |                                                                                |
++---------------------+--------------------------------------------------------------------------------+
+ 
 
 Files generated for this project
 ================================
@@ -32,6 +35,7 @@ under the terms of the license in LICENSE.rst.
 - cmyk.pdf (a CMYK image created in Photoshop)
 - enormous.pdf (a very lage page)
 - francais.pdf (a page containing French accented characters)
+- hugemono.pdf (large monochrome JBIG2 page with pixel dimensions of 35000x35000)
 - invalid.pdf (a PDF file header followed by EOF marker)
 - missing_docinfo.pdf (PDF file with no /DocumentInfo section)
 
@@ -57,4 +61,6 @@ These test resources are assemblies from other previously mentioned files, relea
 
 .. _`US Congressional Records`: http://www.baxleystamps.com/litho/meiji/courts_1871.jpg
 
-.. _`Wikimedia: Pandas text analysis.png`: https://en.wikipedia.org/wiki/File:Pandas_text_analysis.png
+.. _`Wikimedia: Pandas text analysis.png`: https://en.wikipedia.org/wiki/File:Pandas_text_analysis.png
+
+.. _`Wikimedia: JPEG2000 Lichtenstein`: https://en.wikipedia.org/wiki/JPEG_2000#/media/File:Jpeg2000_2-level_wavelet_transform-lichtenstein.png

tests/resources/linn.txt

@@ -0,0 +1,123 @@
+The LinnSequencer
+32 Track MIDI Sequence Recorder
+
+The LinnSequencer is a state—of—the-art composition and performance tool for the professional musician. It is
+
+extremely powerful, yet amazingly simple to learn and use. It’s many remarkable features include:
+
+0 Operation is similar to multi-track tape recorder with PLAY, STOP, RECORD, FAST
+FORWARD, REWIND, and LOCATE controls.
+
+0 Each of the 100 sequences contains 32 simultaneous, polyphonic tracks. Each track may
+be assigned to one of 16 MIDI channels. Simultaneously plays up to 16 polyphonic
+
+synthesizers !
+
+0 Ultra-fast 3 1/2 ” disk drive stores complex songs in seconds and holds over 110,000 notes
+
+per disk!
+
+0 One or all tracks may be TRANSPOSED at the touch of a key.
+0 Exclusive real—time ERASE function makes editing FAST.
+0 Exclusive REPEAT function automatically repeats any held notes at a pre-selected
+
+rhythmic value.
+
+0 TIMING CORRECTION works during playback and operates without ‘chopping’ notes.
+
+0 Optional SMPTE time code synchronization.
+
+0 Optional remote control.
+
+Recording a Sequence
+
+To record a sequence, simply press RECORD and PLAY,
+then play your MIDI keyboard in time to the Sequencer’s
+click track. When the sequence loops back around to bar 1,
+you’ll hear what you played—only all timing errors will be
+
+corrected! (Timing correction may be adjusted 0r defeated).
+
+Any additional notes played will be added into the track
+—existing notes are not erased while recording!
+
+FAST FORWARD, REWIND, and LOCATE controls
+may be used at any time to quickly access any location in
+your sequence for spot-recording. To overdub a new part,
+select a different track and start recording—while you
+record, the first‘track will play in perfect sync (unless you
+MUTE it, or SOLO another track). In this way, up to 32
+tracks may be overdubbed! All MIDI effects are recorded
+including pitch bend, modulation, velocity, aftertouch,
+sustain pedal, and program changes!
+
+Editing
+
+To erase a wrong note, simply hold ERASE and press
+the note to be erased just before it plays in the sequence-—
+when played back, it will be gone. Notes may also be
+
+added, erased, or changed using the SINGLE STEP func-
+tion. To overdub notes at specific points within a sequence,
+
+Additional Features
+
+simply use LOCATE, FAST FORWARD, or REWIND to
+find the desired bar number, then start recording.
+
+The INSERT/ COPY function allows you to move bars
+from one location to another—in the same sequence or a
+different one. For example, you might insert a copy of the
+first verse between the second chorus and the bridge.
+DELETE BARS operates the same way to remove
+unwanted sections.
+
+Creating a Song
+
+One way to create a song is to record each track all the
+way through (up to 999 bars). Another way is to record
+each basic section (verse, chorus, etc.) in individual
+sequences, then use the CREATE SONG function to “chain”
+them together. CREATE SONG will then automatically
+copy all the parts into a new sequence. If desired, you can
+even set the last few bars to repeat infinitely, for a fadeout.
+
+Composition Without Compromise
+
+The technology you use should never be so complex that
+it interferes with the creative process. That’s precisely why
+the LinnSequencer is designed to let you compose, record
+and edit while devoting your undivided attention to your
+music. See your Linn dealer today for a demonstration!
+
+0 Simple, easy to learn operation—the 32 character LCD display clearly guides you through all operations. If needed, the
+
+HELP button displays additional explanations.
+
+0 Non-destructive recording—existing notes are not erased while recording.
+0 Two FOOTSWIT CH INPUTS may be assigned to remotely control many of the commonly used functions, including
+
+ERASE, REPEAT, PLAY/ STOP, or LOCATE.
+
+0 Two TRIGGER OUTPUTS may be programmed to output pulses at any selected note value.
+
+0 Will sync to standard LinnDrum or Linn 9000 sync tone.
+
+0 Utilizes ultra high—speed, 8 MHZ 80186 16 bit computer internally for FAST operation.
+0 TEMPO may be specified in BEATS-PER—MINUTE or FRAMES-PER—BEAT at 24, 25, or 30 frames per second,
+
+(even drop frame!)
+
+0 TEMPO may be entered numerically, adjustable in tenths of a Beat-Per-Minute increments, or by tapping quarter notes
+
+on the TAP TEMPO button.
+
+0 TEMPO CHANGES may be programmed into a sequence, with smooth transitions if desired.
+0 Any TIME SIGNATURE may be used, and may be changed within a song.
+
+EDI]
+Linn Electronics, Inc.
+
+18720 Oxnard Street, Tarzana, CA 91356
+(818) 708-8131 TELEX #298949 LINN UR
+

tests/spoof/tesseract_big_image_error.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+import sys
+
+
+VERSION_STRING = '''tesseract 3.04.00
+ leptonica-1.72
+  libjpeg 8d : libpng 1.6.19 : libtiff 4.0.6 : zlib 1.2.5
+SPOOFED: return error claiming image too big
+'''
+
+"""Simulates a Tesseract crash
+
+It isn't strictly necessary to crash the process and that has unwanted
+side effects like triggering core dumps or error reporting, logging and such.
+It's enough to dump some text to stderr and return an error code.
+
+Follows the POSIX? convention of returning 128 + signal number.
+
+"""
+
+
+def main():
+    if sys.argv[1] == '--version':
+        print(VERSION_STRING, file=sys.stderr)
+        sys.exit(0)
+    elif sys.argv[1] == '--list-langs':
+        print('List of available languages (1):\neng', file=sys.stderr)
+        sys.exit(0)
+    elif sys.argv[-1] == 'hocr':
+        print("Image too large: (33830, 14959)\n"
+              "Error during processing.", file=sys.stderr)
+        sys.exit(1)
+    elif sys.argv[-1] == 'pdf':
+        print("Image too large: (33830, 14959)\n"
+              "Error during processing.", file=sys.stderr)
+        sys.exit(1)
+    elif sys.argv[-1] == 'stdout':
+        print("Image too large: (33830, 14959)\n"
+              "Error during processing.", file=sys.stderr)
+        sys.exit(1)
+    else:
+        print("Spoof doesn't understand arguments", file=sys.stderr)
+        print(sys.argv, file=sys.stderr)
+        sys.exit(1)
+
+    sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()

tests/spoof/tesseract_cache.py

@@ -90,6 +90,13 @@ def main():
             universal_newlines=True)
     stdout, stderr = p.communicate()
 
+    if p.returncode != 0:
+        # Do not cache errors or crashes
+        print("Tesseract error", file=sys.stderr)
+        print(stdout, end='')
+        print(stderr, end='', file=sys.stderr)
+        return p.returncode
+
     with open(cache_name + '.stdout', 'w') as f:
         f.write(stdout)
     with open(cache_name + '.stderr', 'w') as f:

tests/spoof/tesseract_crash.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+import sys
+import os
+import signal
+
+
+VERSION_STRING = '''tesseract 3.04.00
+ leptonica-1.72
+  libjpeg 8d : libpng 1.6.19 : libtiff 4.0.6 : zlib 1.2.5
+SPOOFED: CRASH ON OCR or -psm 0
+'''
+
+"""Simulates a Tesseract crash
+
+It isn't strictly necessary to crash the process and that has unwanted
+side effects like triggering core dumps or error reporting, logging and such.
+It's enough to dump some text to stderr and return an error code.
+
+Follows the POSIX? convention of returning 128 + signal number.
+
+"""
+
+
+def main():
+    if sys.argv[1] == '--version':
+        print(VERSION_STRING, file=sys.stderr)
+        sys.exit(0)
+    elif sys.argv[1] == '--list-langs':
+        print('List of available languages (1):\neng', file=sys.stderr)
+        sys.exit(0)
+    elif sys.argv[-1] == 'hocr':
+        print("KABOOM! Tesseract failed for some reason", file=sys.stderr)
+        sys.exit(128 + signal.SIGSEGV)
+    elif sys.argv[-1] == 'pdf':
+        print("KABOOM! Tesseract failed for some reason", file=sys.stderr)
+        sys.exit(128 + signal.SIGSEGV)
+    elif sys.argv[-1] == 'stdout':
+        print("libc++abi.dylib: terminating with uncaught exception of type "
+              "std::bad_alloc: std::bad_alloc", file=sys.stderr)
+        sys.exit(128 + signal.SIGABRT)
+    else:
+        print("Spoof doesn't understand arguments", file=sys.stderr)
+        print(sys.argv, file=sys.stderr)
+        sys.exit(1)
+
+    sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()

tests/test_main.py

@@ -28,6 +28,11 @@ TEST_OUTPUT = os.environ.get(
     default=os.path.join(PROJECT_ROOT, 'tests', 'output', 'main'))
 
 
+def running_in_docker():
+    # Docker creates a file named /.dockerinit
+    return os.path.exists('/.dockerinit')
+
+
 def setup_module():
     with suppress(FileNotFoundError):
         shutil.rmtree(TEST_OUTPUT)
@@ -83,22 +88,41 @@ def run_ocrmypdf_env(input_basename, output_basename, *args, env=None):
     return p, out, err
 
 
+def spoof(replace_program, with_spoof):
+    """Modify environment variables to override subprocess executables
+
+    Before running any executable, ocrmypdf checks the environment variable
+    OCRMYPDF_PROGRAMNAME to override default program name/location, e.g.
+    OCRMYPDF_GS redirects from the system path Ghostscript ("gs") to elsewhere.
+    """
+    env = os.environ.copy()
+    spoofer = os.path.join(SPOOF_PATH, with_spoof)
+    if not os.access(spoofer, os.X_OK):
+        os.chmod(spoofer, 0o755)
+    env['OCRMYPDF_' + replace_program.upper()] = spoofer
+    return env
+
+
 @pytest.fixture
 def spoof_tesseract_noop():
-    env = os.environ.copy()
-    program = os.path.join(SPOOF_PATH, 'tesseract_noop.py')
-    check_call(['chmod', "+x", program])
-    env['OCRMYPDF_TESSERACT'] = program
-    return env
+    return spoof('tesseract', 'tesseract_noop.py')
 
 
 @pytest.fixture
 def spoof_tesseract_cache():
-    env = os.environ.copy()
-    program = os.path.join(SPOOF_PATH, "tesseract_cache.py")
-    check_call(['chmod', '+x', program])
-    env['OCRMYPDF_TESSERACT'] = program
-    return env
+    if running_in_docker():
+        return os.environ.copy()
+    return spoof('tesseract', "tesseract_cache.py")
+
+
+@pytest.fixture
+def spoof_tesseract_crash():
+    return spoof('tesseract', 'tesseract_crash.py')
+
+
+@pytest.fixture
+def spoof_tesseract_big_image_error():
+    return spoof('tesseract', 'tesseract_big_image_error.py')
 
 
 def test_quick(spoof_tesseract_noop):
@@ -146,7 +170,9 @@ def test_clean(spoof_tesseract_noop):
     ('ccitt.pdf', 'hocr'),
     ('ccitt.pdf', 'tesseract'),
     ('jbig2.pdf', 'hocr'),
-    ('jbig2.pdf', 'tesseract')
+    ('jbig2.pdf', 'tesseract'),
+    ('lichtenstein.pdf', 'hocr'),
+    ('lichtenstein.pdf', 'tesseract')
 ])
 def test_exotic_image(spoof_tesseract_cache, pdf, renderer):
     check_ocrmypdf(
@@ -285,6 +311,13 @@ def test_monochrome_correlation():
         test_pageno=3,  # south facing page
         )
     assert corr < 0.10
+    corr = check_monochrome_correlation(
+        reference_pdf=_infile('cardinal.pdf'),
+        reference_pageno=2,
+        test_pdf=_infile('cardinal.pdf'),
+        test_pageno=2,
+        )
+    assert corr > 0.90
 
 
 @pytest.mark.parametrize('renderer', [
@@ -382,6 +415,8 @@ def test_missing_docinfo(spoof_tesseract_noop):
     assert p.returncode == ExitCode.ok, err
 
 
+@pytest.mark.skipif(running_in_docker(),
+                    reason="writes to tests/resources")
 def test_uppercase_extension(spoof_tesseract_noop):
     shutil.copy(_infile("skew.pdf"), _infile("UPPERCASE.PDF"))
     try:
@@ -438,4 +473,33 @@ def test_pagesegmode(renderer, spoof_tesseract_cache):
         '--pdf-renderer', renderer, env=spoof_tesseract_cache)
 
 
+@pytest.mark.parametrize('renderer', [
+    'hocr',
+    'tesseract',
+    ])
+def test_tesseract_crash(renderer, spoof_tesseract_crash):
+    sh, out, err = run_ocrmypdf_env(
+        'ccitt.pdf', 'wontwork.pdf', '-v', '1',
+        '--pdf-renderer', renderer, env=spoof_tesseract_crash)
+    assert sh.returncode == ExitCode.child_process_error
+    assert not os.path.exists(_outfile('wontwork.pdf'))
+    assert "ERROR" in err
 
+
+def test_tesseract_crash_autorotate(spoof_tesseract_crash):
+    sh, out, err = run_ocrmypdf_env(
+        'ccitt.pdf', 'wontwork.pdf',
+        '-r', env=spoof_tesseract_crash)
+    assert sh.returncode == ExitCode.child_process_error
+    assert not os.path.exists(_outfile('wontwork.pdf'))
+    assert "ERROR" in err
+
+
+@pytest.mark.parametrize('renderer', [
+    'hocr',
+    'tesseract',
+    ])
+def test_tesseract_image_too_big(renderer, spoof_tesseract_big_image_error):
+    check_ocrmypdf(
+        'hugemono.pdf', 'hugemono_%s.pdf' % renderer, '-r',
+        '--pdf-renderer', renderer, env=spoof_tesseract_big_image_error)

tests/test_pageinfo.py

@@ -103,8 +103,8 @@ def test_single_page_image():
     assert pdfimage['bpc'] == 8
 
     # DPI in a 1"x1" is the image width
-    assert pdfimage['dpi_w'] == 8
-    assert pdfimage['dpi_h'] == 8
+    assert abs(pdfimage['dpi_w'] - 8) < 1e-5
+    assert abs(pdfimage['dpi_h'] - 8) < 1e-5
 
 
 def test_single_page_inline_image():
@@ -120,8 +120,12 @@ def test_single_page_inline_image():
         pdf.showPage()
         pdf.save()
 
-    with pytest.raises(NotImplementedError):
-        pageinfo.pdf_get_all_pageinfo(filename)
+    pdfinfo = pageinfo.pdf_get_all_pageinfo(filename)
+    print(pdfinfo)
+    pdfimage = pdfinfo[0]['images'][0]
+    assert (pdfimage['dpi_w'] - 8) < 1e-5
+    assert pdfimage['color'] != '-'
+    assert pdfimage['width'] == 8
 
 
 def test_jpeg():
@@ -131,4 +135,5 @@ def test_jpeg():
 
     pdfimage = pdfinfo[0]['images'][0]
     assert pdfimage['enc'] == 'jpeg'
+    assert (pdfimage['dpi_w'] - 150) < 1e-5