sticker-convert 2.3.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

sticker_convert/__init__.py

@@ -1,3 +1,3 @@
 #!/usr/bin/env python3
 '''sticker-convert'''
-__version__ = '2.3.0'
+__version__ = '2.4.0'

sticker_convert/cli.py

@@ -67,11 +67,14 @@ class CLI:
                     'color_min', 'color_max',
                     'duration_min', 'duration_max',
                     'vid_size_max', 'img_size_max')
-        flags_str = ('vid_format', 'img_format', 'cache_dir', 'scale_filter')
+        flags_float = ('fps_power', 'res_power', 'quality_power', 'color_power')
+        flags_str = ('vid_format', 'img_format', 'cache_dir', 'scale_filter', 'quantize_method')
         flags_bool = ('fake_vid')
         for k, v in self.help['comp'].items():
             if k in flags_int:
                 keyword_args = {'type': int, 'default': None}
+            elif k in flags_float:
+                keyword_args = {'type': float, 'default': None}
             elif k in flags_str:
                 keyword_args = {'default': None}
             elif k in flags_bool:
@@ -202,7 +205,8 @@ class CLI:
             },
             'fps': {
                 'min': self.compression_presets[preset]['fps']['min'] if args.fps_min == None else args.fps_min,
-                'max': self.compression_presets[preset]['fps']['max'] if args.fps_max == None else args.fps_max
+                'max': self.compression_presets[preset]['fps']['max'] if args.fps_max == None else args.fps_max,
+                'power': self.compression_presets[preset]['fps']['power'] if args.fps_power == None else args.fps_power,
             },
             'res': {
                 'w': {
@@ -212,15 +216,18 @@ class CLI:
                 'h': {
                     'min': self.compression_presets[preset]['res']['h']['min'] if args.res_h_min == None else args.res_h_min,
                     'max': self.compression_presets[preset]['res']['h']['max'] if args.res_h_max == None else args.res_h_max
-                }
+                },
+                'power': self.compression_presets[preset]['res']['power'] if args.res_power == None else args.res_power,
             },
             'quality': {
                 'min': self.compression_presets[preset]['quality']['min'] if args.quality_min == None else args.quality_min,
-                'max': self.compression_presets[preset]['quality']['max'] if args.quality_max == None else args.quality_max
+                'max': self.compression_presets[preset]['quality']['max'] if args.quality_max == None else args.quality_max,
+                'power': self.compression_presets[preset]['quality']['power'] if args.quality_power == None else args.quality_power,
             },
             'color': {
                 'min': self.compression_presets[preset]['color']['min'] if args.color_min == None else args.color_min,
-                'max': self.compression_presets[preset]['color']['max'] if args.color_max == None else args.color_max
+                'max': self.compression_presets[preset]['color']['max'] if args.color_max == None else args.color_max,
+                'power': self.compression_presets[preset]['color']['power'] if args.color_power == None else args.color_power,
             },
             'duration': {
                 'min': self.compression_presets[preset]['duration']['min'] if args.duration_min == None else args.duration_min,
@@ -229,8 +236,9 @@ class CLI:
             'steps': self.compression_presets[preset]['steps'] if args.steps == None else args.steps,
             'fake_vid': self.compression_presets[preset]['fake_vid'] if args.fake_vid == None else args.fake_vid,
             'cache_dir': args.cache_dir,
-            'scale_filter': args.scale_filter,
-            'default_emoji': args.default_emoji,
+            'scale_filter': self.compression_presets[preset]['scale_filter'] if args.scale_filter == None else args.scale_filter,
+            'quantize_method': self.compression_presets[preset]['quantize_method'] if args.quantize_method == None else args.quantize_method,
+            'default_emoji': self.compression_presets[preset]['default_emoji'] if args.default_emoji == None else args.default_emoji,
             'no_compress': args.no_compress,
             'processes': args.processes if args.processes else math.ceil(cpu_count() / 2)
         }

sticker_convert/converter.py

@@ -4,15 +4,8 @@ import io
 from multiprocessing.queues import Queue as QueueType
 from typing import Optional, Union
 
-import imageio.v3 as iio
-from rlottie_python import LottieAnimation # type: ignore
-from apngasm_python._apngasm_python import APNGAsm, create_frame_from_rgba
 import numpy as np
 from PIL import Image
-import av # type: ignore
-from av.codec.context import CodecContext # type: ignore
-import webp # type: ignore
-import oxipng
 
 from .utils.media.codec_info import CodecInfo # type: ignore
 from .utils.files.cache_store import CacheStore # type: ignore
@@ -22,11 +15,26 @@ from .job_option import CompOption
 
 def get_step_value(
         max: Optional[int], min: Optional[int],
-        step: int, steps: int
-        ) -> Optional[int]:
+        step: int, steps: int,
+        power: int = 1,
+        even: bool = False
+    ) -> Optional[int]:
+    # Power should be between -1 and positive infinity
+    # Smaller power = More 'importance' of the parameter
+    # Power of 1 is linear relationship
+    # e.g. fps has lower power -> Try not to reduce it early on
+
+    if step > 0:
+        factor = pow(step / steps, power)
+    else:
+        factor = 0
     
-    if max and min:
-        return round((max - min) * step / steps + min)
+    if max != None and min != None:
+        v = round((max - min) * step / steps * factor + min)
+        if even == True and v % 2 == 1:
+            return v + 1
+        else:
+            return v
     else:
         return None
 
@@ -89,23 +97,21 @@ class StickerConvert:
         self.fps = None
         self.color = None
 
-        self.frames_orig = CodecInfo.get_file_frames(self.in_f)
-        self.fps_orig = CodecInfo.get_file_fps(self.in_f)
-        self.duration_orig = self.frames_orig / self.fps_orig * 1000
+        self.codec_info_orig = CodecInfo(self.in_f)
 
         self.tmp_f = None
         self.result = None
         self.result_size = 0
         self.result_step = None
 
-        self.apngasm = APNGAsm() # type: ignore[call-arg]
+        self.apngasm = None
 
     def convert(self) -> tuple[bool, str, Union[None, bytes, str], int]:
-        if (FormatVerify.check_format(self.in_f, fmt=self.out_f_ext) and
-            FormatVerify.check_file_res(self.in_f, res=self.opt_comp.res) and
-            FormatVerify.check_file_fps(self.in_f, fps=self.opt_comp.fps) and
-            FormatVerify.check_file_size(self.in_f, size=self.opt_comp.size_max) and
-            FormatVerify.check_duration(self.in_f, duration=self.opt_comp.duration)):
+        if (FormatVerify.check_format(self.in_f, fmt=self.out_f_ext, file_info=self.codec_info_orig) and
+            FormatVerify.check_file_res(self.in_f, res=self.opt_comp.res, file_info=self.codec_info_orig) and
+            FormatVerify.check_file_fps(self.in_f, fps=self.opt_comp.fps, file_info=self.codec_info_orig) and
+            FormatVerify.check_file_size(self.in_f, size=self.opt_comp.size_max, file_info=self.codec_info_orig) and
+            FormatVerify.check_file_duration(self.in_f, duration=self.opt_comp.duration, file_info=self.codec_info_orig)):
             self.cb_msg.put(self.MSG_SKIP_COMP.format(self.in_f_name, self.out_f_name))
 
             with open(self.in_f, 'rb') as f:
@@ -119,11 +125,11 @@ class StickerConvert:
         steps_list = []
         for step in range(self.opt_comp.steps, -1, -1):
             steps_list.append((
-                get_step_value(self.opt_comp.res_w_max, self.opt_comp.res_w_min, step, self.opt_comp.steps),
-                get_step_value(self.opt_comp.res_h_max, self.opt_comp.res_h_min, step, self.opt_comp.steps),
-                get_step_value(self.opt_comp.quality_max, self.opt_comp.quality_min, step, self.opt_comp.steps),
-                get_step_value(self.opt_comp.fps_max, self.opt_comp.fps_min, step, self.opt_comp.steps),
-                get_step_value(self.opt_comp.color_max, self.opt_comp.color_min, step, self.opt_comp.steps)
+                get_step_value(self.opt_comp.res_w_max, self.opt_comp.res_w_min, step, self.opt_comp.steps, self.opt_comp.res_power, True),
+                get_step_value(self.opt_comp.res_h_max, self.opt_comp.res_h_min, step, self.opt_comp.steps, self.opt_comp.res_power, True),
+                get_step_value(self.opt_comp.quality_max, self.opt_comp.quality_min, step, self.opt_comp.steps, self.opt_comp.quality_power),
+                get_step_value(self.opt_comp.fps_max, self.opt_comp.fps_min, step, self.opt_comp.steps, self.opt_comp.fps_power),
+                get_step_value(self.opt_comp.color_max, self.opt_comp.color_min, step, self.opt_comp.steps, self.opt_comp.color_power)
             ))
 
         step_lower = 0
@@ -141,14 +147,14 @@ class StickerConvert:
             self.res_w = param[0]
             self.res_h = param[1]
             self.quality = param[2]
-            self.fps = min(param[3], self.fps_orig)
+            self.fps = min(param[3], self.codec_info_orig.fps)
             self.color = param[4]
 
             self.tmp_f = io.BytesIO()
             msg = self.MSG_COMP.format(
                     self.in_f_name, self.out_f_name,
                     self.res_w, self.res_h,
-                    self.quality, self.fps, self.color, 
+                    self.quality, int(self.fps), self.color, 
                     step_lower, step_current, step_upper
                 )
             self.cb_msg.put(msg)
@@ -159,7 +165,7 @@ class StickerConvert:
 
             self.tmp_f.seek(0)
             self.size = self.tmp_f.getbuffer().nbytes
-            if CodecInfo.is_anim(self.in_f):
+            if self.codec_info_orig.is_animated == True:
                 self.size_max = self.opt_comp.size_max_vid
             else:
                 self.size_max = self.opt_comp.size_max_img
@@ -221,31 +227,35 @@ class StickerConvert:
 
     def frames_import(self):
         if self.in_f_ext in ('.tgs', '.lottie', '.json'):
-            self.frames_import_lottie()
+            self._frames_import_lottie()
+        elif self.in_f_ext in ('.webp', '.apng', 'png'):
+            # ffmpeg do not support webp decoding (yet)
+            # ffmpeg could fail to decode apng if file is buggy
+            self._frames_import_pillow()
         else:
-            self.frames_import_imageio()
-
-    def frames_import_imageio(self):
-        # ffmpeg do not support webp decoding (yet)
-        # ffmpeg could fail to decode apng if file is buggy
-        if self.in_f_ext in ('.webp', '.apng', 'png'):
-            for frame in iio.imiter(self.in_f, plugin='pillow', mode='RGBA'):
-                self.frames_raw.append(frame)
-            return
-        
+            self._frames_import_pyav()
+
+    def _frames_import_pillow(self):
+        with Image.open(self.in_f, mode='RGBA') as im:
+            if 'n_frames'in im.__dir__():
+                for i in range(im.n_frames):
+                    im.seek(i)
+                    self.frames_raw.append(im.copy().asarray())
+            else:
+                self.frames_raw.append(im.copy().asarray())
+    
+    def _frames_import_pyav(self):
+        import av # type: ignore
+        from av.codec.context import CodecContext # type: ignore
+
         # Crashes when handling some webm in yuv420p and convert to rgba
         # https://github.com/PyAV-Org/PyAV/issues/1166
-        metadata = iio.immeta(self.in_f, plugin='pyav', exclude_applied=False)
-        context = None
-        if metadata.get('video_format') == 'yuv420p':
-            if metadata.get('codec') == 'vp8':
+        with av.open(self.in_f) as container:
+            context = container.streams.video[0].codec_context
+            if context.name == 'vp8':
                 context = CodecContext.create('libvpx', 'r')
-            elif metadata.get('codec') == 'vp9':
+            elif context.name == 'vp9':
                 context = CodecContext.create('libvpx-vp9', 'r')
-        
-        with av.open(self.in_f) as container:
-            if not context:
-                context = container.streams.video[0].codec_context
 
             for packet in container.demux(container.streams.video):
                 for frame in context.decode(packet):
@@ -288,16 +298,18 @@ class StickerConvert:
                         yuv_array[:, :, 1:] = yuv_array[:, :, 1:].clip(16, 240).astype(yuv_array.dtype) - 128
 
                         convert = np.array([
-                            [1.164,  0.000,  2.018],
-                            [1.164, -0.813, -0.391],
-                            [1.164,  1.596,  0.000]
+                            [1.164,  0.000,  1.793],
+                            [1.164, -0.213, -0.533],
+                            [1.164,  2.112,  0.000]
                         ])
                         rgb_array = np.matmul(yuv_array, convert.T).clip(0,255).astype('uint8')
                         rgba_array = np.concatenate((rgb_array, a), axis=2)
 
                         self.frames_raw.append(rgba_array)
 
-    def frames_import_lottie(self):
+    def _frames_import_lottie(self):
+        from rlottie_python import LottieAnimation # type: ignore
+        
         if self.in_f_ext == '.tgs':
             anim = LottieAnimation.from_tgs(self.in_f)
         else:
@@ -315,39 +327,40 @@ class StickerConvert:
     def frames_resize(self, frames_in: list[np.ndarray]) -> list[np.ndarray]:
         frames_out = []
 
-        for frame in frames_in:
-            im = Image.fromarray(frame, 'RGBA')
-            width, height = im.size
+        if self.opt_comp.scale_filter == 'nearest':
+            resample = Image.NEAREST
+        elif self.opt_comp.scale_filter == 'bilinear':
+            resample = Image.BILINEAR
+        elif self.opt_comp.scale_filter == 'bicubic':
+            resample = Image.BICUBIC
+        elif self.opt_comp.scale_filter == 'lanczos':
+            resample = Image.LANCZOS
+        else:
+            resample = Image.LANCZOS
 
-            if self.res_w == None:
-                self.res_w = width
-            if self.res_h == None:
-                self.res_h = height
+        for frame in frames_in:
+            with Image.fromarray(frame, 'RGBA') as im:
+                width, height = im.size
 
-            if width > height:
-                width_new = self.res_w
-                height_new = height * self.res_w // width
-            else:
-                height_new = self.res_h
-                width_new = width * self.res_h // height
-            
-            if self.opt_comp.scale_filter == 'nearest':
-                resample = Image.NEAREST
-            elif self.opt_comp.scale_filter == 'bilinear':
-                resample = Image.BILINEAR
-            elif self.opt_comp.scale_filter == 'bicubic':
-                resample = Image.BICUBIC
-            elif self.opt_comp.scale_filter == 'lanczos':
-                resample = Image.LANCZOS
-            else:
-                resample = Image.LANCZOS
+                if self.res_w == None:
+                    self.res_w = width
+                if self.res_h == None:
+                    self.res_h = height
 
-            im = im.resize((width_new, height_new), resample=resample)
-            im_new = Image.new('RGBA', (self.res_w, self.res_h), (0, 0, 0, 0))
-            im_new.paste(
-                im, ((self.res_w - width_new) // 2, (self.res_h - height_new) // 2)
-                )
-            frames_out.append(np.asarray(im_new))
+                if width > height:
+                    width_new = self.res_w
+                    height_new = height * self.res_w // width
+                else:
+                    height_new = self.res_h
+                    width_new = width * self.res_h // height
+
+                with (im.resize((width_new, height_new), resample=resample) as im_resized,
+                      Image.new('RGBA', (self.res_w, self.res_h), (0, 0, 0, 0)) as im_new):
+                    
+                    im_new.paste(
+                        im_resized, ((self.res_w - width_new) // 2, (self.res_h - height_new) // 2)
+                    )
+                    frames_out.append(np.asarray(im_new))
         
         return frames_out
     
@@ -359,15 +372,15 @@ class StickerConvert:
 
         # fps_ratio: 1 frame in new anim equal to how many frame in old anim
         # speed_ratio: How much to speed up / slow down
-        fps_ratio = self.fps_orig / self.fps
+        fps_ratio = self.codec_info_orig.fps / self.fps
         if (self.opt_comp.duration_min != None and
-            self.duration_orig < self.opt_comp.duration_min):
+            self.codec_info_orig.duration < self.opt_comp.duration_min):
 
-            speed_ratio = self.duration_orig / self.opt_comp.duration_min
+            speed_ratio = self.codec_info_orig.duration / self.opt_comp.duration_min
         elif (self.opt_comp.duration_max != None and
-              self.duration_orig > self.opt_comp.duration_max):
+              self.codec_info_orig.duration > self.opt_comp.duration_max):
             
-            speed_ratio = self.duration_orig / self.opt_comp.duration_max
+            speed_ratio = self.codec_info_orig.duration / self.opt_comp.duration_max
         else:
             speed_ratio = 1
 
@@ -382,25 +395,27 @@ class StickerConvert:
 
     def frames_export(self):
         if self.out_f_ext in ('.apng', '.png') and self.fps:
-            self.frames_export_apng()
+            self._frames_export_apng()
         elif self.out_f_ext == '.png':
-            self.frames_export_png()
+            self._frames_export_png()
         elif self.out_f_ext == '.webp' and self.fps:
-            self.frames_export_webp()
+            self._frames_export_webp()
         elif self.fps:
-            self.frames_export_pyav()
+            self._frames_export_pyav()
         else:
-            self.frames_export_pil()
+            self._frames_export_pil()
     
-    def frames_export_pil(self):
-        image = Image.fromarray(self.frames_processed[0])
-        image.save(
-            self.tmp_f,
-            format=self.out_f_ext.replace('.', ''),
-            quality=self.quality
-        )
+    def _frames_export_pil(self):
+        with Image.fromarray(self.frames_processed[0]) as im:
+            im.save(
+                self.tmp_f,
+                format=self.out_f_ext.replace('.', ''),
+                quality=self.quality
+            )
+
+    def _frames_export_pyav(self):
+        import av # type: ignore
 
-    def frames_export_pyav(self):
         options = {}
         
         if isinstance(self.quality, int):
@@ -416,10 +431,14 @@ class StickerConvert:
             codec = 'apng'
             pixel_format = 'rgba'
             options['plays'] = '0'
-        else:
-            codec = 'vp9'
+        elif self.out_f_ext in ('.webp', '.webm', '.mkv'):
+            codec = 'libvpx-vp9'
             pixel_format = 'yuva420p'
             options['loop'] = '0'
+        else:
+            codec = 'libx264'
+            pixel_format = 'yuv420p'
+            options['loop'] = '0'
         
         with av.open(self.tmp_f, 'w', format=self.out_f_ext.replace('.', '')) as output:
             out_stream = output.add_stream(codec, rate=int(self.fps), options=options)
@@ -435,7 +454,9 @@ class StickerConvert:
             for packet in out_stream.encode():
                 output.mux(packet)
     
-    def frames_export_webp(self):
+    def _frames_export_webp(self):
+        import webp # type: ignore
+
         config = webp.WebPConfig.new(quality=self.quality)
         enc = webp.WebPAnimEncoder.new(self.res_w, self.res_h)
         timestamp_ms = 0
@@ -445,26 +466,35 @@ class StickerConvert:
             timestamp_ms += int(1 / self.fps * 1000)
         anim_data = enc.assemble(timestamp_ms)
         self.tmp_f.write(anim_data.buffer())
+    
+    def _frames_export_png(self):
+        import oxipng
+
+        with Image.fromarray(self.frames_processed[0], 'RGBA') as image:
+            if self.color and self.color <= 256:
+                image_quant = self.quantize(image)
+            else:
+                image_quant = image.copy()
 
-    def frames_export_png(self):
-        image = Image.fromarray(self.frames_processed[0], 'RGBA')
-        if self.color and self.color <= 256:
-            image_quant = image.quantize(colors=self.color, method=2)
-        else:
-            image_quant = image
         with io.BytesIO() as f:
             image_quant.save(f, format='png')
             f.seek(0)
             frame_optimized = oxipng.optimize_from_memory(f.read(), level=4)
             self.tmp_f.write(frame_optimized)
 
-    def frames_export_apng(self):
+    def _frames_export_apng(self):
+        import oxipng
+        from apngasm_python._apngasm_python import APNGAsm, create_frame_from_rgba
+
         frames_concat = np.concatenate(self.frames_processed)
-        image_concat = Image.fromarray(frames_concat, 'RGBA')
-        if self.color and self.color <= 256:
-            image_quant = image_concat.quantize(colors=self.color, method=2)
-        else:
-            image_quant = image_concat
+        with Image.fromarray(frames_concat, 'RGBA') as image_concat:
+            if self.color and self.color <= 256:
+                image_quant = self.quantize(image_concat)
+            else:
+                image_quant = image_concat.copy()
+
+        if self.apngasm == None:
+            self.apngasm = APNGAsm()
 
         for i in range(0, image_quant.height, self.res_h):
             with io.BytesIO() as f:
@@ -473,12 +503,13 @@ class StickerConvert:
                 image_cropped.save(f, format='png')
                 f.seek(0)
                 frame_optimized = oxipng.optimize_from_memory(f.read(), level=4)
-            image_final = Image.open(io.BytesIO(frame_optimized)).convert('RGBA')
+            with Image.open(io.BytesIO(frame_optimized)) as im:
+                image_final = im.convert('RGBA')
             frame_final = create_frame_from_rgba(
                 np.array(image_final),
                 image_final.width,
                 image_final.height
-                )
+            )
             frame_final.delay_num = int(1000 / self.fps)
             frame_final.delay_den = 1000
             self.apngasm.add_frame(frame_final)
@@ -489,4 +520,35 @@ class StickerConvert:
             with open(os.path.join(tempdir, f'out{self.out_f_ext}'), 'rb') as f:
                 self.tmp_f.write(f.read())
 
-        self.apngasm.reset()
+        self.apngasm.reset()
+
+    def quantize(self, image: Image.Image) -> Image.Image:
+        if self.opt_comp.quantize_method == 'imagequant':
+            return self._quantize_by_imagequant(image)
+        elif self.opt_comp.quantize_method == 'fastoctree':
+            return self._quantize_by_fastoctree(image)
+        else:
+            return image
+
+    def _quantize_by_imagequant(self, image: Image.Image) -> Image.Image:
+        import imagequant
+
+        dither = 1 - (self.quality - self.opt_comp.quality_min) / (self.opt_comp.quality_max - self.opt_comp.quality_min)
+        image_quant = None
+        for i in range(self.quality, 101, 5):
+            try:
+                image_quant = imagequant.quantize_pil_image(
+                    image,
+                    dithering_level=dither,
+                    max_colors=self.color,
+                    min_quality=self.opt_comp.quality_min,
+                    max_quality=i
+                )
+                return image_quant
+            except RuntimeError:
+                pass
+        
+        return image
+
+    def _quantize_by_fastoctree(self, image: Image.Image) -> Image.Image:
+        return image.quantize(colors=self.color, method=2)

sticker_convert/downloaders/download_line.py

@@ -315,10 +315,14 @@ class DownloadLine(DownloadBase):
                 base_path = os.path.join(self.out_dir, i.replace('-text.png', '.png'))
                 text_path = os.path.join(self.out_dir, i)
 
-                base_img = Image.open(base_path).convert('RGBA')
-                text_img = Image.open(text_path).convert('RGBA')
+                with Image.open(base_path) as im:
+                    base_img = im.convert('RGBA')
+                
+                with Image.open(text_path) as im:
+                    text_img = im.convert('RGBA')
 
-                Image.alpha_composite(base_img, text_img).save(base_path)
+                with Image.alpha_composite(base_img, text_img) as im:
+                    im.save(base_path)
 
                 os.remove(text_path)
 

sticker_convert/gui.py

@@ -13,7 +13,7 @@ from urllib.parse import urlparse
 from typing import Optional, Any
 
 from PIL import ImageFont
-from ttkbootstrap import Window, StringVar, BooleanVar, IntVar # type: ignore
+from ttkbootstrap import Window, StringVar, BooleanVar, IntVar, DoubleVar # type: ignore
 from ttkbootstrap.dialogs import Messagebox, Querybox # type: ignore
 
 from .job import Job # type: ignore
@@ -104,18 +104,22 @@ class GUI(Window):
         self.fps_min_var = IntVar(self)
         self.fps_max_var = IntVar(self)
         self.fps_disable_var = BooleanVar()
+        self.fps_power_var = DoubleVar()
         self.res_w_min_var = IntVar(self)
         self.res_w_max_var = IntVar(self)
         self.res_w_disable_var = BooleanVar()
         self.res_h_min_var = IntVar(self)
         self.res_h_max_var = IntVar(self)
         self.res_h_disable_var = BooleanVar()
+        self.res_power_var = DoubleVar()
         self.quality_min_var = IntVar(self)
         self.quality_max_var = IntVar(self)
         self.quality_disable_var = BooleanVar()
+        self.quality_power_var = DoubleVar()
         self.color_min_var = IntVar(self)
         self.color_max_var = IntVar(self)
         self.color_disable_var = BooleanVar()
+        self.color_power_var = DoubleVar()
         self.duration_min_var = IntVar(self)
         self.duration_max_var = IntVar(self)
         self.duration_disable_var = BooleanVar()
@@ -126,6 +130,7 @@ class GUI(Window):
         self.vid_format_var = StringVar(self)
         self.fake_vid_var = BooleanVar()
         self.scale_filter_var = StringVar(self)
+        self.quantize_method_var = StringVar(self)
         self.cache_dir_var = StringVar(self)
         self.default_emoji_var = StringVar(self)
         self.steps_var = IntVar(self) 
@@ -356,7 +361,8 @@ class GUI(Window):
             },
             'fps': {
                 'min': self.fps_min_var.get() if not self.fps_disable_var.get() else None,
-                'max': self.fps_max_var.get() if not self.fps_disable_var.get() else None
+                'max': self.fps_max_var.get() if not self.fps_disable_var.get() else None,
+                'power': self.fps_power_var.get()
             },
             'res': {
                 'w': {
@@ -366,15 +372,18 @@ class GUI(Window):
                 'h': {
                     'min': self.res_h_min_var.get() if not self.res_h_disable_var.get() else None,
                     'max': self.res_h_max_var.get() if not self.res_h_disable_var.get() else None
-                }
+                },
+                'power': self.res_power_var.get()
             },
             'quality': {
                 'min': self.quality_min_var.get() if not self.quality_disable_var.get() else None,
-                'max': self.quality_max_var.get() if not self.quality_disable_var.get() else None
+                'max': self.quality_max_var.get() if not self.quality_disable_var.get() else None,
+                'power': self.quality_power_var.get()
             },
             'color': {
                 'min': self.color_min_var.get() if not self.color_disable_var.get() else None,
-                'max': self.color_max_var.get() if not self.color_disable_var.get() else None
+                'max': self.color_max_var.get() if not self.color_disable_var.get() else None,
+                'power': self.color_power_var.get()
             },
             'duration': {
                 'min': self.duration_min_var.get() if not self.duration_disable_var.get() else None,
@@ -383,6 +392,7 @@ class GUI(Window):
             'steps': self.steps_var.get(),
             'fake_vid': self.fake_vid_var.get(),
             'scale_filter': self.scale_filter_var.get(),
+            'quantize_method': self.quantize_method_var.get(),
             'cache_dir': self.cache_dir_var.get() if self.cache_dir_var.get() != '' else None,
             'default_emoji': self.default_emoji_var.get(),
             'no_compress': self.no_compress_var.get(),

sticker_convert/gui_components/frames/comp_frame.py

@@ -66,14 +66,18 @@ class CompFrame(LabelFrame):
 
         self.gui.fps_min_var.set(self.gui.compression_presets[selection]['fps']['min'])
         self.gui.fps_max_var.set(self.gui.compression_presets[selection]['fps']['max'])
+        self.gui.fps_power_var.set(self.gui.compression_presets[selection]['fps']['power'])
         self.gui.res_w_min_var.set(self.gui.compression_presets[selection]['res']['w']['min'])
         self.gui.res_w_max_var.set(self.gui.compression_presets[selection]['res']['w']['max'])
         self.gui.res_h_min_var.set(self.gui.compression_presets[selection]['res']['h']['min'])
         self.gui.res_h_max_var.set(self.gui.compression_presets[selection]['res']['h']['max'])
+        self.gui.res_power_var.set(self.gui.compression_presets[selection]['res']['power'])
         self.gui.quality_min_var.set(self.gui.compression_presets[selection]['quality']['min'])
         self.gui.quality_max_var.set(self.gui.compression_presets[selection]['quality']['max'])
+        self.gui.quality_power_var.set(self.gui.compression_presets[selection]['quality']['power'])
         self.gui.color_min_var.set(self.gui.compression_presets[selection]['color']['min'])
         self.gui.color_max_var.set(self.gui.compression_presets[selection]['color']['max'])
+        self.gui.color_power_var.set(self.gui.compression_presets[selection]['color']['power'])
         self.gui.duration_min_var.set(self.gui.compression_presets[selection]['duration']['min'])
         self.gui.duration_max_var.set(self.gui.compression_presets[selection]['duration']['max'])
         self.gui.img_size_max_var.set(self.gui.compression_presets[selection]['size_max']['img'])
@@ -82,6 +86,7 @@ class CompFrame(LabelFrame):
         self.gui.vid_format_var.set(self.gui.compression_presets[selection]['format']['vid'])
         self.gui.fake_vid_var.set(self.gui.compression_presets[selection]['fake_vid'])
         self.gui.scale_filter_var.set(self.gui.compression_presets[selection]['scale_filter'])
+        self.gui.quantize_method_var.set(self.gui.compression_presets[selection]['quantize_method'])
         self.gui.default_emoji_var.set(self.gui.compression_presets[selection]['default_emoji'])
         self.gui.steps_var.set(self.gui.compression_presets[selection]['steps'])