PyTurboJPEG 1.7.7__tar.gz → 1.8.2__tar.gz

{PyTurboJPEG-1.7.7 → PyTurboJPEG-1.8.2}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018-2024 Lilo Huang <kuso.cc@gmail.com>
+Copyright (c) 2018-2025 Lilo Huang <kuso.cc@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{PyTurboJPEG-1.7.7 → PyTurboJPEG-1.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyTurboJPEG
-Version: 1.7.7
+Version: 1.8.2
 Summary: A Python wrapper of libjpeg-turbo for decoding and encoding JPEG image.
 Home-page: https://github.com/lilohuang/PyTurboJPEG
 Author: Lilo Huang
@@ -108,6 +108,33 @@ in_file.close()
 out_file = open('lossless_cropped_output.jpg', 'wb')
 out_file.write(jpeg.crop(open('input.jpg', 'rb').read(), 8, 8, 320, 240))
 out_file.close()
+
+# in-place decoding input.jpg to BGR array
+# here I use a 640x480 example (in practise, read the dimensions)
+in_file = open('input.jpg', 'rb')
+img_array = np.empty((640, 480, 3), dtype=np.uint8)
+result = jpeg.decode(in_file.read(), dst=img_array)
+in_file.close()
+
+# return value is the img_array argument value
+id(result) == id(img_array)
+# True
+
+# Optional: display the in-place array
+# cv2.imshow('img_array', img_array)
+# cv2.waitKey(0)
+
+# in-place encoding with default settings.
+buffer_size = jpeg.buffer_size(img_array)
+dest_buf = bytearray(buffer_size)
+result, n_byte = jpeg.encode(img_array, dst=dest_buf)
+
+# return value is the dest_buf argument value
+id(result) == id(dest_buf)
+
+out_file = open('output.jpg', 'wb')
+out_file.write(dest_buf[:n_byte])
+out_file.close()
 ```
 
 ```python

{PyTurboJPEG-1.7.7 → PyTurboJPEG-1.8.2}/PyTurboJPEG.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyTurboJPEG
-Version: 1.7.7
+Version: 1.8.2
 Summary: A Python wrapper of libjpeg-turbo for decoding and encoding JPEG image.
 Home-page: https://github.com/lilohuang/PyTurboJPEG
 Author: Lilo Huang
@@ -108,6 +108,33 @@ in_file.close()
 out_file = open('lossless_cropped_output.jpg', 'wb')
 out_file.write(jpeg.crop(open('input.jpg', 'rb').read(), 8, 8, 320, 240))
 out_file.close()
+
+# in-place decoding input.jpg to BGR array
+# here I use a 640x480 example (in practise, read the dimensions)
+in_file = open('input.jpg', 'rb')
+img_array = np.empty((640, 480, 3), dtype=np.uint8)
+result = jpeg.decode(in_file.read(), dst=img_array)
+in_file.close()
+
+# return value is the img_array argument value
+id(result) == id(img_array)
+# True
+
+# Optional: display the in-place array
+# cv2.imshow('img_array', img_array)
+# cv2.waitKey(0)
+
+# in-place encoding with default settings.
+buffer_size = jpeg.buffer_size(img_array)
+dest_buf = bytearray(buffer_size)
+result, n_byte = jpeg.encode(img_array, dst=dest_buf)
+
+# return value is the dest_buf argument value
+id(result) == id(dest_buf)
+
+out_file = open('output.jpg', 'wb')
+out_file.write(dest_buf[:n_byte])
+out_file.close()
 ```
 
 ```python

{PyTurboJPEG-1.7.7 → PyTurboJPEG-1.8.2}/README.md

@@ -96,6 +96,33 @@ in_file.close()
 out_file = open('lossless_cropped_output.jpg', 'wb')
 out_file.write(jpeg.crop(open('input.jpg', 'rb').read(), 8, 8, 320, 240))
 out_file.close()
+
+# in-place decoding input.jpg to BGR array
+# here I use a 640x480 example (in practise, read the dimensions)
+in_file = open('input.jpg', 'rb')
+img_array = np.empty((640, 480, 3), dtype=np.uint8)
+result = jpeg.decode(in_file.read(), dst=img_array)
+in_file.close()
+
+# return value is the img_array argument value
+id(result) == id(img_array)
+# True
+
+# Optional: display the in-place array
+# cv2.imshow('img_array', img_array)
+# cv2.waitKey(0)
+
+# in-place encoding with default settings.
+buffer_size = jpeg.buffer_size(img_array)
+dest_buf = bytearray(buffer_size)
+result, n_byte = jpeg.encode(img_array, dst=dest_buf)
+
+# return value is the dest_buf argument value
+id(result) == id(dest_buf)
+
+out_file = open('output.jpg', 'wb')
+out_file.write(dest_buf[:n_byte])
+out_file.close()
 ```
 
 ```python

{PyTurboJPEG-1.7.7 → PyTurboJPEG-1.8.2}/setup.py

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

{PyTurboJPEG-1.7.7 → PyTurboJPEG-1.8.2}/turbojpeg.py

@@ -2,7 +2,7 @@
 #
 # PyTurboJPEG - A Python wrapper of libjpeg-turbo for decoding and encoding JPEG image.
 #
-# Copyright (c) 2018-2024, Lilo Huang. All rights reserved.
+# Copyright (c) 2018-2025, Lilo Huang. All rights reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -23,7 +23,7 @@
 # SOFTWARE.
 
 __author__ = 'Lilo Huang <kuso.cc@gmail.com>'
-__version__ = '1.7.7'
+__version__ = '1.8.2'
 
 from ctypes import *
 from ctypes.util import find_library
@@ -408,7 +408,7 @@ class TurboJPEG(object):
         finally:
             self.__destroy(handle)
 
-    def decode(self, jpeg_buf, pixel_format=TJPF_BGR, scaling_factor=None, flags=0):
+    def decode(self, jpeg_buf, pixel_format=TJPF_BGR, scaling_factor=None, flags=0, dst=None):
         """decodes JPEG memory buffer to numpy array."""
         handle = self.__init_decompress()
         try:
@@ -416,9 +416,14 @@ class TurboJPEG(object):
             src_addr = self.__getaddr(jpeg_array)
             scaled_width, scaled_height, _, _ = \
                 self.__get_header_and_dimensions(handle, jpeg_array.size, src_addr, scaling_factor)
-            img_array = np.empty(
-                [scaled_height, scaled_width, tjPixelSize[pixel_format]],
-                dtype=np.uint8)
+            if ((type(dst) == np.ndarray) and
+                (dst.shape == (scaled_height, scaled_width, tjPixelSize[pixel_format])) and
+                (dst.dtype == np.uint8)):
+                img_array = dst
+            else:
+                img_array = np.empty(
+                    [scaled_height, scaled_width, tjPixelSize[pixel_format]],
+                    dtype=np.uint8)
             dest_addr = self.__getaddr(img_array)
             status = self.__decompress(
                 handle, src_addr, jpeg_array.size, dest_addr, scaled_width,
@@ -486,13 +491,22 @@ class TurboJPEG(object):
         finally:
             self.__destroy(handle)
 
-    def encode(self, img_array, quality=85, pixel_format=TJPF_BGR, jpeg_subsample=TJSAMP_422, flags=0):
+    def encode(self, img_array, quality=85, pixel_format=TJPF_BGR, jpeg_subsample=TJSAMP_422, flags=0, dst=None):
         """encodes numpy array to JPEG memory buffer."""
         handle = self.__init_compress()
         try:
-            jpeg_buf = c_void_p()
-            jpeg_size = c_ulong()
             img_array = np.ascontiguousarray(img_array)
+            if dst is not None and not self.__is_buffer(dst):
+                raise TypeError('\'dst\' argument must support buffer protocol')
+            if (dst is not None and
+                (len(dst) >= self.buffer_size(img_array, jpeg_subsample))):
+                dst_array = np.frombuffer(dst, dtype=np.uint8)
+                jpeg_buf = dst_array.ctypes.data_as(c_void_p)
+                jpeg_size = c_ulong(len(dst))
+            else:
+                dst_array = None
+                jpeg_buf = c_void_p()
+                jpeg_size = c_ulong()
             height, width = img_array.shape[:2]
             channel = tjPixelSize[pixel_format]
             if channel > 1 and (len(img_array.shape) < 3 or img_array.shape[2] != channel):
@@ -503,10 +517,12 @@ class TurboJPEG(object):
                 byref(jpeg_buf), byref(jpeg_size), jpeg_subsample, quality, flags)
             if status != 0:
                 self.__report_error(handle)
-            dest_buf = create_string_buffer(jpeg_size.value)
-            memmove(dest_buf, jpeg_buf.value, jpeg_size.value)
-            self.__free(jpeg_buf)
-            return dest_buf.raw
+            if dst_array is None or jpeg_buf.value != dst_array.ctypes.data:
+                result = self.__copy_from_buffer(jpeg_buf.value, jpeg_size.value)
+                self.__free(jpeg_buf)
+            else:
+                result = dst
+            return result if dst is None else (result, jpeg_size.value)
         finally:
             self.__destroy(handle)
 
@@ -539,7 +555,7 @@ class TurboJPEG(object):
             scaled_width, scaled_height, jpeg_subsample, _ = self.__get_header_and_dimensions(
                 handle, jpeg_array.size, src_addr, scaling_factor)
             buffer_YUV_size = self.__buffer_size_YUV2(
-                scaled_height, 4, scaled_width, jpeg_subsample)
+                scaled_width, 4, scaled_height, jpeg_subsample)
             img_array = np.empty([buffer_YUV_size])
             dest_addr = self.__getaddr(img_array)
             status = self.__decompressToYUV2(
@@ -680,6 +696,12 @@ class TurboJPEG(object):
         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)
+
     def __do_transform(self, handle, src_buf, src_size, number_of_transforms, transforms):
         """Do transform.
 
@@ -774,16 +796,22 @@ class TurboJPEG(object):
         return scaled_width, scaled_height, jpeg_subsample, jpeg_colorspace
 
     def __axis_to_image_boundaries(self, a, b, img_boundary, preserve, mcuBlock):
-        img_b = img_boundary - (img_boundary % mcuBlock)
-        delta_a = a % mcuBlock
-        if a > img_b:
-            a = img_b
+        if preserve:
+            original_a = a
+            a = int(math.ceil(float(original_a) / mcuBlock) * mcuBlock)
+            b -= (a - original_a)
+            if (a + b) > img_boundary:
+                b = img_boundary - a
         else:
-            a = a - delta_a
-        if not preserve:
+            img_b = img_boundary - (img_boundary % mcuBlock)
+            delta_a = a % mcuBlock
+            if a > img_b:
+                a = img_b
+            else:
+                a = a - delta_a
             b = b + delta_a
-        if (a + b) > img_b:
-            b = img_b - a
+            if (a + b) > img_b:
+                b = img_b - a
         return a, b
 
     @staticmethod
@@ -974,6 +1002,14 @@ class TurboJPEG(object):
         """returns the memory address for a given ndarray"""
         return cast(nda.__array_interface__['data'][0], POINTER(c_ubyte))
 
+    def __is_buffer(self, x):
+        result = True
+        try:
+            memoryview(x)
+        except Exception:
+            result = False
+        return result
+
     @property
     def scaling_factors(self):
         return self.__scaling_factors