sticker-convert 2.7.13__tar.gz → 2.8.0__tar.gz

{sticker-convert-2.7.13/src/sticker_convert.egg-info → sticker-convert-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sticker-convert
-Version: 2.7.13
+Version: 2.8.0
 Summary: Convert (animated) stickers to/from WhatsApp, Telegram, Signal, Line, Kakao, iMessage. Written in Python.
 Author-email: laggykiller <chaudominic2@gmail.com>
 Maintainer-email: laggykiller <chaudominic2@gmail.com>

{sticker-convert-2.7.13 → sticker-convert-2.8.0}/pyproject.toml

@@ -40,7 +40,7 @@ Repository = "https://github.com/laggykiller/sticker-convert"
 sticker-convert = "sticker_convert.__main__:main"
 
 [build-system]
-requires = ["setuptools>=61.0.0", "wheel"]
+requires = ["setuptools>=61.0.0"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools.packages.find]

{sticker-convert-2.7.13 → sticker-convert-2.8.0}/src/sticker_convert/converter.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
 import os
-from decimal import ROUND_HALF_UP, Decimal
 from fractions import Fraction
 from io import BytesIO
 from math import ceil, floor
@@ -15,7 +14,7 @@ from PIL import __version__ as PillowVersion
 from sticker_convert.job_option import CompOption
 from sticker_convert.utils.callback import Callback, CallbackReturn, CbQueueItemType
 from sticker_convert.utils.files.cache_store import CacheStore
-from sticker_convert.utils.media.codec_info import CodecInfo
+from sticker_convert.utils.media.codec_info import CodecInfo, rounding
 from sticker_convert.utils.media.format_verify import FormatVerify
 
 if TYPE_CHECKING:
@@ -44,10 +43,6 @@ YUV_RGB_MATRIX = np.array(
 )
 
 
-def rounding(value: float) -> Decimal:
-    return Decimal(value).quantize(0, ROUND_HALF_UP)
-
-
 def get_step_value(
     max_step: Optional[int],
     min_step: Optional[int],
@@ -426,10 +421,24 @@ class StickerConvert:
     def _frames_import_pillow(self) -> None:
         with Image.open(self.in_f) as im:
             # Note: im.convert("RGBA") would return rgba image of current frame only
-            if "n_frames" in dir(im):
-                for i in range(im.n_frames):
-                    im.seek(i)
+            if (
+                "n_frames" in dir(im)
+                and im.n_frames != 0
+                and self.codec_info_orig.fps != 0.0
+            ):
+                duration_ptr = 0.0
+                duration_inc = 1 / self.codec_info_orig.fps * 1000
+                next_frame_start_duration = im.info.get("duration", 1000)
+                frame = 0
+                while True:
                     self.frames_raw.append(np.asarray(im.convert("RGBA")))
+                    duration_ptr += duration_inc
+                    if duration_ptr >= next_frame_start_duration:
+                        if frame == im.n_frames:
+                            break
+                        im.seek(frame)
+                        next_frame_start_duration += im.info.get("duration", 1000)
+                        frame += 1
             else:
                 self.frames_raw.append(np.asarray(im.convert("RGBA")))
 
@@ -480,10 +489,12 @@ class StickerConvert:
                         graph.configure()
 
                         graph.push(frame)
-                        frame = cast(VideoFrame, graph.pull())
+                        frame_resized = cast(VideoFrame, graph.pull())
+                    else:
+                        frame_resized = frame
 
-                    if frame.format.name == "yuv420p":
-                        rgb_array = frame.to_ndarray(format="rgb24")
+                    if frame_resized.format.name == "yuv420p":
+                        rgb_array = frame_resized.to_ndarray(format="rgb24")
                         rgba_array = np.dstack(
                             (
                                 rgb_array,
@@ -494,11 +505,11 @@ class StickerConvert:
                         # yuva420p may cause crash
                         # Not safe to directly call frame.to_ndarray(format="rgba")
                         # https://github.com/laggykiller/sticker-convert/issues/114
-                        frame = frame.reformat(
+                        frame_resized = frame_resized.reformat(
                             format="yuva420p",
                             dst_colorspace=1,
                         )
-                        rgba_array = yuva_to_rgba(frame)
+                        rgba_array = yuva_to_rgba(frame_resized)
 
                     # Remove pixels that was added to make dimensions even
                     rgba_array = rgba_array[0:width_orig, 0:height_orig]
@@ -534,25 +545,25 @@ class StickerConvert:
         anim.lottie_animation_destroy()
 
     def determine_bg_color(self) -> Tuple[int, int, int, int]:
+        mean_total = 0.0
         # Calculate average color of all frames for selecting background color
-        frames_raw_np = np.array(self.frames_raw)
-        s = frames_raw_np.shape
-        colors = frames_raw_np.reshape((-1, s[3]))  # type: ignore
-        # Do not count in alpha=0
-        # If alpha > 0, use alpha as weight
-        colors = colors[colors[:, 3] != 0]
-        if colors.shape[0] == 0:
-            return (0, 0, 0, 0)
+        for frame in self.frames_raw:
+            s = frame.shape
+            colors = frame.reshape((-1, s[2]))  # type: ignore
+            # Do not count in alpha=0
+            # If alpha > 0, use alpha as weight
+            colors = colors[colors[:, 3] != 0]
+            if colors.shape[0] != 0:
+                alphas = colors[:, 3] / 255
+                r_mean = np.mean(colors[:, 0] * alphas)
+                g_mean = np.mean(colors[:, 1] * alphas)
+                b_mean = np.mean(colors[:, 2] * alphas)
+                mean_total += (r_mean + g_mean + b_mean) / 3
+
+        if mean_total / len(self.frames_raw) < 128:
+            return (255, 255, 255, 0)
         else:
-            alphas = colors[:, 3] / 255
-            r_mean = np.mean(colors[:, 0] * alphas)
-            g_mean = np.mean(colors[:, 1] * alphas)
-            b_mean = np.mean(colors[:, 2] * alphas)
-            mean = (r_mean + g_mean + b_mean) / 3
-            if mean < 128:
-                return (255, 255, 255, 0)
-            else:
-                return (0, 0, 0, 0)
+            return (0, 0, 0, 0)
 
     def frames_resize(
         self, frames_in: "List[np.ndarray[Any, Any]]"
@@ -647,8 +658,6 @@ class StickerConvert:
         frame_current = 0
         frame_current_float = 0.0
         while True:
-            frame_current_float += frame_increment
-            frame_current = int(rounding(frame_current_float))
             if frame_current <= len(frames_in) - 1 and not (
                 frames_out_max and len(frames_out) == frames_out_max
             ):
@@ -659,6 +668,8 @@ class StickerConvert:
                 ):
                     frames_out.append(frames_in[-1])
                 return frames_out
+            frame_current_float += frame_increment
+            frame_current = int(rounding(frame_current_float))
 
     def frames_export(self) -> None:
         is_animated = len(self.frames_processed) > 1 and self.fps
@@ -775,10 +786,25 @@ class StickerConvert:
         config = webp.WebPConfig.new(quality=self.quality)  # type: ignore
         enc = webp.WebPAnimEncoder.new(self.res_w, self.res_h)  # type: ignore
         timestamp_ms = 0
-        for frame in self.frames_processed:
-            pic = webp.WebPPicture.from_numpy(frame)  # type: ignore
+        timestamp_inc = int(1000 / self.fps)
+
+        pic = webp.WebPPicture.from_numpy(self.frames_processed[0])  # type: ignore
+        enc.encode_frame(pic, 0, config=config)  # type: ignore
+
+        frame_num = 1
+        frame_num_prev = 1
+        frame_total = len(self.frames_processed)
+        while frame_num < frame_total - 1:
+            while frame_num < frame_total - 1 and np.array_equal(
+                self.frames_processed[frame_num_prev],
+                self.frames_processed[frame_num],
+            ):
+                timestamp_ms += timestamp_inc
+                frame_num += 1
+            pic = webp.WebPPicture.from_numpy(self.frames_processed[frame_num])  # type: ignore
             enc.encode_frame(pic, timestamp_ms, config=config)  # type: ignore
-            timestamp_ms += int(1000 / self.fps)
+            frame_num_prev = frame_num
+
         anim_data = enc.assemble(timestamp_ms)  # type: ignore
         self.tmp_f.write(anim_data.buffer())  # type: ignore
 

{sticker-convert-2.7.13 → sticker-convert-2.8.0}/src/sticker_convert/utils/media/codec_info.py

@@ -3,13 +3,64 @@ from __future__ import annotations
 
 import mmap
 from decimal import ROUND_HALF_UP, Decimal
+from fractions import Fraction
 from io import BytesIO
+from math import gcd
 from pathlib import Path
-from typing import BinaryIO, Optional, Tuple, Union, cast
+from typing import BinaryIO, List, Optional, Tuple, Union, cast
 
 from PIL import Image, UnidentifiedImageError
 
 
+def lcm(a: int, b: int):
+    return abs(a * b) // gcd(a, b)
+
+
+def rounding(value: float) -> Decimal:
+    return Decimal(value).quantize(0, ROUND_HALF_UP)
+
+
+def fraction_gcd(x: Fraction, y: Fraction) -> Fraction:
+    a = x.numerator
+    b = x.denominator
+    c = y.numerator
+    d = y.denominator
+    return Fraction(gcd(a, c), lcm(b, d))
+
+
+def fractions_gcd(*fractions: Fraction) -> Fraction:
+    fractions_list = list(fractions)
+    gcd = fractions_list.pop(0)
+    for fraction in fractions_list:
+        gcd = fraction_gcd(gcd, fraction)
+
+    return gcd
+
+
+def get_five_dec_place(value: float) -> str:
+    return str(value).split(".")[1][:5].ljust(5, "0")
+
+
+def likely_int(value: float) -> bool:
+    if isinstance(value, int):
+        return True
+    return True if get_five_dec_place(value) in ("99999", "00000") else False
+
+
+def durations_gcd(*durations: Union[int, float]) -> Union[float, Fraction]:
+    if any(i for i in durations if isinstance(i, float)):
+        if all(i for i in durations if likely_int(i)):
+            return Fraction(gcd(*(int(rounding(i)) for i in durations)), 1)
+        # Test for denominators that can produce recurring decimal
+        for x in (3, 6, 7, 9, 11, 13):
+            if all(likely_int(i * x) for i in durations):
+                return Fraction(gcd(*(int(rounding(i * x)) for i in durations)), x)
+        else:
+            return min(durations)
+    else:
+        return Fraction(gcd(*durations), 1)  # type: ignore
+
+
 class CodecInfo:
     def __init__(
         self, file: Union[Path, bytes], file_ext: Optional[str] = None
@@ -29,8 +80,9 @@ class CodecInfo:
     @staticmethod
     def get_file_fps_frames_duration(
         file: Union[Path, bytes], file_ext: Optional[str] = None
-    ) -> Tuple[float, int, int]:
+    ) -> Tuple[float, int, float]:
         fps: float
+        duration: float
 
         if not file_ext and isinstance(file, Path):
             file_ext = CodecInfo.get_file_ext(file)
@@ -41,13 +93,12 @@ class CodecInfo:
                 duration = int(frames / fps * 1000)
             else:
                 duration = 0
+        elif file_ext == ".webp":
+            fps, frames, duration = CodecInfo._get_file_fps_frames_duration_webp(file)
+        elif file_ext in (".gif", ".apng", ".png"):
+            fps, frames, duration = CodecInfo._get_file_fps_frames_duration_pillow(file)
         else:
-            if file_ext == ".webp":
-                frames, duration = CodecInfo._get_file_frames_duration_webp(file)
-            elif file_ext in (".gif", ".apng", ".png"):
-                frames, duration = CodecInfo._get_file_frames_duration_pillow(file)
-            else:
-                frames, duration = CodecInfo._get_file_frames_duration_av(file)
+            frames, duration = CodecInfo._get_file_frames_duration_av(file)
 
             if duration > 0:
                 fps = frames / duration * 1000
@@ -63,14 +114,16 @@ class CodecInfo:
 
         if file_ext == ".tgs":
             return CodecInfo._get_file_fps_tgs(file)
-        if file_ext == ".webp":
-            frames, duration = CodecInfo._get_file_frames_duration_webp(file)
+        elif file_ext == ".webp":
+            fps, _, _ = CodecInfo._get_file_fps_frames_duration_webp(file)
+            return fps
         elif file_ext in (".gif", ".apng", ".png"):
-            frames, duration = CodecInfo._get_file_frames_duration_pillow(file)
-        else:
-            frames, duration = CodecInfo._get_file_frames_duration_av(
-                file, frames_to_iterate=10
-            )
+            fps, _, _ = CodecInfo._get_file_fps_frames_duration_pillow(file)
+            return fps
+
+        frames, duration = CodecInfo._get_file_frames_duration_av(
+            file, frames_to_iterate=10
+        )
 
         if duration > 0:
             return frames / duration * 1000
@@ -89,7 +142,7 @@ class CodecInfo:
         if file_ext == ".tgs":
             return CodecInfo._get_file_frames_tgs(file)
         if file_ext in (".gif", ".webp", ".png", ".apng"):
-            frames, _ = CodecInfo._get_file_frames_duration_pillow(
+            _, frames, _ = CodecInfo._get_file_fps_frames_duration_pillow(
                 file, frames_only=True
             )
         else:
@@ -106,7 +159,9 @@ class CodecInfo:
     @staticmethod
     def get_file_duration(
         file: Union[Path, bytes], file_ext: Optional[str] = None
-    ) -> int:
+    ) -> float:
+        duration: float
+
         # Return duration in miliseconds
         if not file_ext and isinstance(file, Path):
             file_ext = CodecInfo.get_file_ext(file)
@@ -118,9 +173,9 @@ class CodecInfo:
             else:
                 duration = 0
         elif file_ext == ".webp":
-            _, duration = CodecInfo._get_file_frames_duration_webp(file)
+            _, _, duration = CodecInfo._get_file_fps_frames_duration_webp(file)
         elif file_ext in (".gif", ".png", ".apng"):
-            _, duration = CodecInfo._get_file_frames_duration_pillow(file)
+            _, _, duration = CodecInfo._get_file_fps_frames_duration_pillow(file)
         else:
             _, duration = CodecInfo._get_file_frames_duration_av(file)
 
@@ -176,29 +231,46 @@ class CodecInfo:
         return fps, frames
 
     @staticmethod
-    def _get_file_frames_duration_pillow(
+    def _get_file_fps_frames_duration_pillow(
         file: Union[Path, bytes], frames_only: bool = False
-    ) -> Tuple[int, int]:
-        total_duration = 0
+    ) -> Tuple[float, int, float]:
+        total_duration = 0.0
+        durations: List[float] = []
 
         with Image.open(file) as im:
             if "n_frames" in dir(im):
                 frames = im.n_frames
                 if frames_only is True:
-                    return frames, 1
+                    return 0.0, frames, 1
                 for i in range(im.n_frames):
                     im.seek(i)
-                    total_duration += im.info.get("duration", 1000)
-                return frames, total_duration
-
-        return 1, 0
+                    frame_duration = cast(float, im.info.get("duration", 1000))
+                    if frame_duration not in durations and frame_duration != 0:
+                        durations.append(frame_duration)
+                    total_duration += frame_duration
+                if im.n_frames == 0 or total_duration == 0:
+                    fps = 0.0
+                elif len(durations) == 1:
+                    fps = frames / total_duration * 1000
+                else:
+                    duration_gcd = durations_gcd(*durations)
+                    frames_apparent = total_duration / duration_gcd
+                    fps = frames_apparent / total_duration * 1000
+                return fps, frames, total_duration
+
+        return (
+            0.0,
+            1,
+            0,
+        )
 
     @staticmethod
-    def _get_file_frames_duration_webp(
+    def _get_file_fps_frames_duration_webp(
         file: Union[Path, bytes],
-    ) -> Tuple[int, int]:
+    ) -> Tuple[float, int, int]:
         total_duration = 0
         frames = 0
+        durations: List[int] = []
 
         def _open_f(file: Union[Path, bytes]) -> BinaryIO:
             if isinstance(file, Path):
@@ -213,16 +285,26 @@ class CodecInfo:
                         break
                     mm.seek(anmf_pos + 20)
                     frame_duration_32 = mm.read(4)
-                    frame_duration = frame_duration_32[:-1] + bytes(
+                    frame_duration_bytes = frame_duration_32[:-1] + bytes(
                         int(frame_duration_32[-1]) & 0b11111100
                     )
-                    total_duration += int.from_bytes(frame_duration, "little")
+                    frame_duration = int.from_bytes(frame_duration_bytes, "little")
+                    if frame_duration not in durations and frame_duration != 0:
+                        durations.append(frame_duration)
+                    total_duration += frame_duration
                     frames += 1
 
         if frames == 0:
-            return 1, 0
+            return 0.0, 0, 0
+
+        if len(durations) == 1:
+            fps = frames / total_duration * 1000
+        else:
+            duration_gcd = durations_gcd(*durations)
+            frames_apparent = total_duration / duration_gcd
+            fps = float(frames_apparent / total_duration * 1000)
 
-        return frames, total_duration
+        return fps, frames, total_duration
 
     @staticmethod
     def _get_file_frames_duration_av(
@@ -246,9 +328,7 @@ class CodecInfo:
             container = cast(InputContainer, container)
             stream = container.streams.video[0]
             if container.duration:
-                duration_metadata = int(
-                    Decimal(container.duration / 1000).quantize(0, ROUND_HALF_UP)
-                )
+                duration_metadata = int(rounding(container.duration / 1000))
             else:
                 duration_metadata = 0
 
@@ -273,7 +353,7 @@ class CodecInfo:
             duration_n_minus_one = last_frame.pts * time_base_ms
             ms_per_frame = duration_n_minus_one / (frame_count - 1)
             duration = frame_count * ms_per_frame
-            return frame_count, int(Decimal(duration).quantize(0, ROUND_HALF_UP))
+            return frame_count, int(rounding(duration))
 
         return 0, 0
 

{sticker-convert-2.7.13 → sticker-convert-2.8.0}/src/sticker_convert/version.py

@@ -1,3 +1,3 @@
 #!/usr/bin/env python3
 
-__version__ = "2.7.13"
+__version__ = "2.8.0"

{sticker-convert-2.7.13 → sticker-convert-2.8.0/src/sticker_convert.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sticker-convert
-Version: 2.7.13
+Version: 2.8.0
 Summary: Convert (animated) stickers to/from WhatsApp, Telegram, Signal, Line, Kakao, iMessage. Written in Python.
 Author-email: laggykiller <chaudominic2@gmail.com>
 Maintainer-email: laggykiller <chaudominic2@gmail.com>