PyTurboJPEG 2.2.0__tar.gz → 2.4.0__tar.gz

{pyturbojpeg-2.2.0 → pyturbojpeg-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyTurboJPEG
-Version: 2.2.0
+Version: 2.4.0
 Summary: A Python wrapper of libjpeg-turbo for decoding and encoding JPEG image.
 Home-page: https://github.com/lilohuang/PyTurboJPEG
 Author: Lilo Huang
@@ -179,6 +179,13 @@ with open('input.jpg', 'rb') as f:
     cropped_data = jpeg.crop(f.read(), 8, 8, 320, 240)
 with open('cropped_output.jpg', 'wb') as f:
     f.write(cropped_data)
+
+# Lossless Huffman table optimization (re-encodes with optimal tables,
+# identical pixels; typically smaller unless already optimized)
+with open('input.jpg', 'rb') as f:
+    optimized_data = jpeg.optimize(f.read())
+with open('optimized_output.jpg', 'wb') as f:
+    f.write(optimized_data)
 ```
 
 ### In-Place Operations

{pyturbojpeg-2.2.0 → pyturbojpeg-2.4.0}/PyTurboJPEG.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyTurboJPEG
-Version: 2.2.0
+Version: 2.4.0
 Summary: A Python wrapper of libjpeg-turbo for decoding and encoding JPEG image.
 Home-page: https://github.com/lilohuang/PyTurboJPEG
 Author: Lilo Huang
@@ -179,6 +179,13 @@ with open('input.jpg', 'rb') as f:
     cropped_data = jpeg.crop(f.read(), 8, 8, 320, 240)
 with open('cropped_output.jpg', 'wb') as f:
     f.write(cropped_data)
+
+# Lossless Huffman table optimization (re-encodes with optimal tables,
+# identical pixels; typically smaller unless already optimized)
+with open('input.jpg', 'rb') as f:
+    optimized_data = jpeg.optimize(f.read())
+with open('optimized_output.jpg', 'wb') as f:
+    f.write(optimized_data)
 ```
 
 ### In-Place Operations

{pyturbojpeg-2.2.0 → pyturbojpeg-2.4.0}/README.md

@@ -155,6 +155,13 @@ with open('input.jpg', 'rb') as f:
     cropped_data = jpeg.crop(f.read(), 8, 8, 320, 240)
 with open('cropped_output.jpg', 'wb') as f:
     f.write(cropped_data)
+
+# Lossless Huffman table optimization (re-encodes with optimal tables,
+# identical pixels; typically smaller unless already optimized)
+with open('input.jpg', 'rb') as f:
+    optimized_data = jpeg.optimize(f.read())
+with open('optimized_output.jpg', 'wb') as f:
+    f.write(optimized_data)
 ```
 
 ### In-Place Operations

{pyturbojpeg-2.2.0 → pyturbojpeg-2.4.0}/setup.py

@@ -2,7 +2,7 @@ import io
 from setuptools import setup, find_packages
 setup(
     name='PyTurboJPEG',
-    version='2.2.0',
+    version='2.4.0',
     description='A Python wrapper of libjpeg-turbo for decoding and encoding JPEG image.',
     author='Lilo Huang',
     author_email='kuso.cc@gmail.com',

{pyturbojpeg-2.2.0 → pyturbojpeg-2.4.0}/tests/test_turbojpeg.py

@@ -513,6 +513,17 @@ class TestCropMultiple:
         assert subsample == TJSAMP_GRAY
 
 
+class TestOptimize:
+    """Test optimize function."""
+
+    def test_optimize_is_lossless(self, jpeg_instance, encoded_sample_jpeg):
+        """Test optimization returns a valid JPEG with unchanged pixels."""
+        optimized = jpeg_instance.optimize(encoded_sample_jpeg)
+        original_pixels = jpeg_instance.decode(encoded_sample_jpeg)
+        optimized_pixels = jpeg_instance.decode(optimized)
+        assert np.array_equal(original_pixels, optimized_pixels)
+
+
 class TestBufferSize:
     """Test buffer_size function."""
     

{pyturbojpeg-2.2.0 → pyturbojpeg-2.4.0}/turbojpeg.py

@@ -23,7 +23,7 @@
 # SOFTWARE.
 
 __author__ = 'Lilo Huang <kuso.cc@gmail.com>'
-__version__ = '2.2.0'
+__version__ = '2.4.0'
 
 from ctypes import *
 from ctypes.util import find_library
@@ -125,6 +125,7 @@ TJXOPT_GRAY = 8
 TJXOPT_NOOUTPUT = 16
 TJXOPT_PROGRESSIVE = 32
 TJXOPT_COPYNONE = 64
+TJXOPT_OPTIMIZE = 256  # Huffman table optimization
 
 # pixel size
 # see details in https://github.com/libjpeg-turbo/libjpeg-turbo/blob/main/src/turbojpeg.h
@@ -305,12 +306,12 @@ def fill_background(coeffs_ptr, arrayRegion, planeRegion, componentID, transform
             min(arrayRegion.y+arrayRegion.h, background_data.h)
             - arrayRegion.y
         )
-        for x in range(background_data.w//MCU_WIDTH, planeRegion.w//MCU_WIDTH):
-            for y in range(
-                left_start_row//MCU_HEIGHT,
-                left_end_row//MCU_HEIGHT
-            ):
-                coeffs[y][x][0] = background_data.lum
+        y_start = left_start_row // MCU_HEIGHT
+        y_end = left_end_row // MCU_HEIGHT
+        x_start = background_data.w // MCU_WIDTH
+        x_end = planeRegion.w // MCU_WIDTH
+        if y_end > y_start and x_end > x_start:
+            coeffs[y_start:y_end, x_start:x_end, 0] = background_data.lum
 
         # fill mcus under image
         bottom_start_row = (
@@ -320,12 +321,11 @@ def fill_background(coeffs_ptr, arrayRegion, planeRegion, componentID, transform
             max(arrayRegion.y+arrayRegion.h, background_data.h)
             - arrayRegion.y
         )
-        for x in range(0, planeRegion.w//MCU_WIDTH):
-            for y in range(
-                bottom_start_row//MCU_HEIGHT,
-                bottom_end_row//MCU_HEIGHT
-            ):
-                coeffs[y][x][0] = background_data.lum
+        y_start = bottom_start_row // MCU_HEIGHT
+        y_end = bottom_end_row // MCU_HEIGHT
+        x_end = planeRegion.w // MCU_WIDTH
+        if y_end > y_start and x_end > 0:
+            coeffs[y_start:y_end, 0:x_end, 0] = background_data.lum
 
     return 1
 
@@ -1311,6 +1311,8 @@ class TurboJPEG(object):
 
             # Define crop transforms from cropping_regions
             crop_transforms = (TransformStruct * number_of_operations)()
+            # Pre-compute luminance coefficient once for all crops
+            lum_coefficient = None
             for i, crop_region in enumerate(crop_regions):
                 # The fill_background callback is slow, only use it if needed
                 if self.__need_fill_background(
@@ -1318,14 +1320,16 @@ class TurboJPEG(object):
                     (image_width, image_height),
                     background_luminance
                 ):
+                    if lum_coefficient is None:
+                        lum_coefficient = self.__map_luminance_to_dc_dct_coefficient(
+                            bytearray(jpeg_buf),
+                            background_luminance
+                        )
                     # Use callback to fill in background post-transform
                     callback_data = BackgroundStruct(
                         image_width,
                         image_height,
-                        self.__map_luminance_to_dc_dct_coefficient(
-                            bytearray(jpeg_buf),
-                            background_luminance
-                        )
+                        lum_coefficient
                     )
                     callback = CUSTOMFILTER(fill_background)
                     crop_transforms[i] = TransformStruct(
@@ -1348,9 +1352,45 @@ class TurboJPEG(object):
         finally:
             self.__destroy(handle)
 
+    def optimize(self, jpeg_buf, copynone=False):
+        """Losslessly optimize the Huffman tables of a jpeg image.
+
+        Re-encodes the entropy-coded data with optimal Huffman tables
+        (equivalent to ``jpegtran -optimize``) without any loss in image
+        quality. Typically reduces file size, unless the input is already
+        optimized.
+
+        Parameters
+        ----------
+        jpeg_buf: bytes
+            Input jpeg image.
+        copynone: bool
+            True = do not copy EXIF data (False by default)
+
+        Returns
+        ----------
+        bytes
+            Huffman-optimized jpeg image.
+        """
+        handle = self.__init(TJINIT_TRANSFORM)
+        try:
+            jpeg_array = np.frombuffer(jpeg_buf, dtype=np.uint8)
+            src_addr = self.__getaddr(jpeg_array)
+            status = self.__decompress_header(handle, src_addr, jpeg_array.size)
+            if status != 0:
+                self.__report_error(handle)
+            # Without TJXOPT_CROP the cropping region is ignored and the whole
+            # image is transformed, so the (zeroed) region needs no setup.
+            transforms = (TransformStruct * 1)()
+            transforms[0].op = TJXOP_NONE
+            transforms[0].options = TJXOPT_OPTIMIZE | (copynone and TJXOPT_COPYNONE)
+            return self.__do_transform(handle, src_addr, jpeg_array.size, 1, transforms)[0]
+
+        finally:
+            self.__destroy(handle)
+
     def buffer_size(self, img_array, jpeg_subsample=TJSAMP_422):
         """Get maximum number of bytes of compressed jpeg data"""
-        img_array = np.ascontiguousarray(img_array)
         height, width = img_array.shape[:2]
         return self.__buffer_size(width, height, jpeg_subsample)