do not convert "L" mode to "RGB" during save #26

Author: bigcat88

pillow_heif/heif.py

@@ -48,8 +48,11 @@ def __init__(self, heif_ctx: Union[LibHeifCtx, HeifCtxAsDict], handle):
         else:
             self._handle = None
             self.size = heif_ctx.size
+            if heif_ctx.mode == "L":
+                self._colorspace = HeifColorspace.MONOCHROME
             if heif_ctx.data:
-                _img = create_image(self.size, self.chroma, self.bit_depth, heif_ctx.data, stride=heif_ctx.stride)
+                chroma_color = (self.chroma, self._colorspace)
+                _img = create_image(self.size, chroma_color, self.bit_depth, heif_ctx.data, heif_ctx.stride)
                 self._img_to_img_data_dict(_img)
 
     @property
@@ -88,10 +91,14 @@ def has_alpha(self):
 
     @property
     def mode(self):
-        """Returns “RGBA” for images with alpha channel, and “RGB” for images without.
+        """Returns “L“ for Greyscale images, “RGBA” for images with alpha channel and “RGB” for other cases.
 
-        :returns: "RGB" or "RGBA" """
+        .. note:: Images with "L" mode currently only possible to get when adding from Pillow.
 
+        :returns: "RGB", "RGBA" or "L" """
+
+        if self.color == HeifColorspace.MONOCHROME:
+            return "L"
         return "RGBA" if self.has_alpha else "RGB"  # noqa
 
     @property
@@ -123,6 +130,8 @@ def chroma(self):
 
         :returns: Value from :py:class:`~pillow_heif.HeifChroma`"""
 
+        if self.mode == "L":
+            return HeifChroma.MONOCHROME
         if self.bit_depth <= 8:
             return HeifChroma.INTERLEAVED_RGBA if self.has_alpha else HeifChroma.INTERLEAVED_RGB
         return HeifChroma.INTERLEAVED_RRGGBBAA_BE if self.has_alpha else HeifChroma.INTERLEAVED_RRGGBB_BE
@@ -186,7 +195,8 @@ def _load_if_not(self):
 
     def _img_to_img_data_dict(self, heif_img):
         p_stride = ffi.new("int *")
-        p_data = lib.heif_image_get_plane(heif_img, HeifChannel.INTERLEAVED, p_stride)
+        channel = HeifChannel.Y if self.color == HeifColorspace.MONOCHROME else HeifChannel.INTERLEAVED
+        p_data = lib.heif_image_get_plane(heif_img, channel, p_stride)
         stride = p_stride[0]
         data_length = self.size[1] * stride
         data_buffer = ffi.buffer(p_data, data_length)
@@ -575,8 +585,6 @@ def __add_frame_from_pillow(self, frame: Image.Image, ignore_primary: bool, **kw
             frame = frame.convert(mode=mode)
         elif frame.mode == "LA":
             frame = frame.convert(mode="RGBA")
-        elif frame.mode == "L":
-            frame = frame.convert(mode="RGB")
 
         if original_orientation is not None and original_orientation != 1:
             frame = ImageOps.exif_transpose(frame)

pillow_heif/private.py

@@ -2,14 +2,21 @@
 Undocumented private functions for other code to look better.
 """
 
-from typing import Union
+from typing import Tuple, Union
 
 from _pillow_heif_cffi import ffi, lib
 
 from ._libheif_ctx import LibHeifCtxWrite
 from .constants import HeifChannel, HeifChroma, HeifColorProfileType, HeifColorspace
 from .error import check_libheif_error
 
+MODE_CHANNELS = {
+    "RGBA": 4,
+    "RGB": 3,
+    "L": 1,
+    "": 0,
+}
+
 
 # from dataclasses import dataclass
 # @dataclass                # Avalaible from Python 3.7
@@ -20,7 +27,7 @@ def __init__(self, bit_depth: int, mode: str, size: tuple, data, **kwargs):
         stride = kwargs.get("stride", None)
         if stride is None:
             factor = 1 if bit_depth == 8 else 2
-            stride = size[0] * 3 * factor if mode == "RGB" else size[0] * 4 * factor
+            stride = size[0] * MODE_CHANNELS[mode] * factor
         self.bit_depth = bit_depth
         self.mode = mode
         self.size = size
@@ -29,16 +36,18 @@ def __init__(self, bit_depth: int, mode: str, size: tuple, data, **kwargs):
         self.additional_info = kwargs.get("add_info", {})
 
 
-def create_image(size: tuple, chroma: HeifChroma, bit_depth: int, data, stride: int, **kwargs):
+def create_image(size: tuple, chroma_color: Tuple[HeifChroma, HeifColorspace], bit_depth: int, data, stride: int):
     width, height = size
+    chroma, color = chroma_color
     p_new_img = ffi.new("struct heif_image **")
-    error = lib.heif_image_create(width, height, kwargs.get("color", HeifColorspace.RGB), chroma, p_new_img)
+    error = lib.heif_image_create(width, height, color, chroma, p_new_img)
     check_libheif_error(error)
     new_img = ffi.gc(p_new_img[0], lib.heif_image_release)
-    error = lib.heif_image_add_plane(new_img, HeifChannel.INTERLEAVED, width, height, bit_depth)
+    channel = HeifChannel.Y if color == HeifColorspace.MONOCHROME else HeifChannel.INTERLEAVED
+    error = lib.heif_image_add_plane(new_img, channel, width, height, bit_depth)
     check_libheif_error(error)
     p_dest_stride = ffi.new("int *")
-    p_data = lib.heif_image_get_plane(new_img, HeifChannel.INTERLEAVED, p_dest_stride)
+    p_data = lib.heif_image_get_plane(new_img, channel, p_dest_stride)
     dest_stride = p_dest_stride[0]
     copy_image_data(p_data, data, dest_stride, stride, height)
     return new_img

tests/opener_test.py

@@ -13,6 +13,7 @@
 
 import pillow_heif.HeifImagePlugin  # noqa
 from pillow_heif import (
+    HeifChroma,
     HeifError,
     HeifFile,
     HeifImage,
@@ -56,6 +57,17 @@ def test_corrupted_open(img_path):
             Image.open(BytesIO(f.read()))
 
 
+def test_add_L_mode():
+    img = Image.open(Path("images/jpeg_gif_png/L_color_mode_image.png"))
+    img = img.convert(mode="L")
+    heif_file = HeifFile().add_from_pillow(img)
+    assert heif_file.mode == "L"
+    assert heif_file.chroma == HeifChroma.MONOCHROME
+    img2 = heif_file[0].to_pillow()
+    assert img2.mode == "L"
+    assert img.tobytes() == img2.tobytes()
+
+
 @pytest.mark.parametrize("img_path", dataset.MINIMAL_DATASET)
 def test_inputs(img_path):
     with builtins.open(img_path, "rb") as fh: