stopi/main_c.py

#!/usr/bin/env python3
#
#  main_c.py
#  
#  v0.1 - 2024 schnappy <contact@schnappy.xyz>
#  
#  The Tuffy font is public domain and was created by
#  Thatcher Ulrich <tu@tulrich.com> http://tulrich.com
#  Karoly Barta bartakarcsi@gmail.com
#  Michael Evans http://www.evertype.com
#
#  This program is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
#  
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#  
#  A full copy of the GNU General Public License is available from
#  https://www.gnu.org/licenses/gpl-3.0.en.html
#  
import collections
import gettext
# DLSR support
import gphoto2 as gp
from io import BytesIO
from itertools import count
import locale
import os
from PIL import Image, ImageTk, ImageFilter, ImageDraw, ImageOps, ImageFont
import sys
import threading
import time
import tkinter as tk
from tkinter import filedialog, messagebox
import tomllib
# async FFMPEG exportation support
import asyncio
from ffmpeg.asyncio import FFmpeg
from send2trash import send2trash

# TODO : Todo List
#
# X wait event mode
# X remove frames
# X keep images in memory (odict > list ?)
# X resize images upon shooting/crop output video ?
# X project workflow
#    X use a different folder for each project (A, B, C, etc...) 
#    X startup : check for existing folder with name A, B, C, etc.
#    X startup : offer to continue previous project or new project
#        X if continue, find last frame in folder X else, find next letter and create folder
# X colored onion skin frame (pillow filters)
# X startup frame
# X Import config values from config file
# X Translation
# X Allow opening and exporting without a camera connected
# o Better settings names 
# o webcam support (pygame, win and linux only)
# X picam support (picamera2)
# o notify export ending
# o Use try/except for picam and pygame lib import
# o picam liveview

running_from_folder = os.path.realpath(__file__)
alphabet = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']

# l10n
LOCALE = os.getenv('LANG', 'en_EN')
_ = gettext.translation('template', localedir='locales', languages=[LOCALE]).gettext

# Config 
# defaults
project_settings_defaults = {
    # DSLR = 0, picam = 1, webcam = 2
    'camera_type': 0,
    'file_extension':'JPG',
    'trigger_mode': 'key',
    'projects_folder': '',
    # ~ 'project_letter': 'A'
    'onion_skin_onstartup' : False,
    'onionskin_alpha_default' : 0.4,
    'onionskin_fx' : False,
    'fullscreen_bool' : True,
    'screen_w' : 640,
    'screen_h' : 480,
    'framerate' : 16,
    'vflip' : False,
    'hflip' : False,
    'export_options' : 'scale=1920:-1,crop=1920:1080:0:102',
    'cache_images' : False,
}

# Camera Settings (Nikon D40x)
# See `gphoto2 --list-config` to find your camera's values
camera_settings = camera_status = {}
           
# Load from file
config_locations = ["./", "~/.", "~/.config/"]
config_found_msg = _("No configuration file found, using defaults.")
project_settings = project_settings_defaults
for location in config_locations:
    # Optional config files, ~ is expanded to $HOME on *nix, %USERPROFILE% on windows
    if os.path.exists( os.path.expanduser(os.path.join(location, 'config.toml'))):
        with open(os.path.expanduser(location + 'config.toml'), 'rb') as config_file:
            project_settings = tomllib.load(config_file)
            if 'CHECK' in project_settings:
                camera_status = project_settings['CHECK']
            if 'CAMERA' in project_settings:
                camera_settings = project_settings['CAMERA']
            if 'DEFAULT' in project_settings:
                project_settings = project_settings['DEFAULT']
            config_found_msg = _("Found configuration file in {}").format(os.path.expanduser(location))
print(config_found_msg)

class KISStopmo(tk.Tk):

    def __init__(self, *args, **kargs):
        self.check_config()
        if project_settings['camera_type'] != 0:
            from picamera2 import Picamera2
        # Default config 
        # Set script settings according to config file
        self.onion_skin = project_settings['onion_skin_onstartup']
        self.onionskin_alpha_default = project_settings['onionskin_alpha_default']
        self.onionskin_fx = project_settings['onionskin_fx']
        self.fullscreen_bool = project_settings['fullscreen_bool']
        self.screen_w, self.screen_h = project_settings['screen_w'], project_settings['screen_h']
        self.framerate = project_settings['framerate']
        self.playback = False
        
        # ~ self.photo = None
        self.end_thread = False
        # Window setup
        self.screen_w, self.screen_h = root.winfo_screenwidth(), root.winfo_screenheight()
        root.wm_attributes("-fullscreen", self.fullscreen_bool)
        root.title('KISStopmotion')
        root.iconbitmap('@' + os.path.join(os.getcwd(), 'kisstopmo.xbm'))
        # Image container creation
        self.label = tk.Label(root)
        self.label.pack()
        
        # Savepath setup
        self.projects_folder = tk.filedialog.askdirectory()
        self.savepath = self.get_session_folder()
        if len(self.savepath):
            self.project_letter = self.savepath.split(os.sep)[-1]
        else:
            self.project_letter = 'A'
        # Export settings
        # ~ self.input_filename = "{folder}{sep}{letter}.%04d.{ext}".format(folder=self.savepath, sep=os.sep, letter=project_settings['project_letter'], ext=project_settings["file_extension"])
        self.input_filename = "{folder}{sep}{letter}.%04d.{ext}".format(folder=self.savepath, sep=os.sep, letter=self.project_letter, ext=project_settings["file_extension"])
        self.input_options = {"f": "image2", "r": str(self.framerate)}
        # ~ self.output_filename = "{folder}{sep}{filename}.mp4".format(folder=self.projects_folder, sep=os.sep, filename=self.savepath.split(os.sep)[-1])
        self.output_filename = "{filename}.mp4".format(filename=self.project_letter)
        self.output_options = self.parse_export_options(project_settings['export_options'], project_settings['vflip'], project_settings['hflip'] )
        # Get frames list
        self.img_list = {}
        self.img_list = self.get_frames_list(self.savepath)
        self.img_index = self.check_range(len(self.img_list)-1, False)
        self.splash_text = _("No images yet! Start shooting...")
        # Camera setup
        if project_settings['camera_type'] != 0:
            try:
                self.camera = Picamera2()
                self.picam_conf_full = self.camera.create_still_configuration(main={"size":(1920,1080)}, lores={"size":(800,600)})
                self.camera.configure(self.picam_conf_full)
                # Autofocus, get lens position and switch to manual mode
                # Set Af mode to Manual (1). Default is Continuous (2), Auto is 1
                # TODO: lock exposure, wb
                self.camera.set_controls({'AfMode':1})
                self.camera.start(show_preview=False)
                self.camera.autofocus_cycle()
                self.camera_lenspos = self.camera.capture_metadata()['LensPosition']
                self.camera.set_controls({'AfMode':0, 'AwbEnable': False, 'AeEnable': False})
                self.camera.stop()
            except:
                self.camera = False
                self.splash_text += _("\nCamera not found or busy.")
        else:
            self.camera = gp.check_result(gp.gp_camera_new())
            try:
                gp.check_result(gp.gp_camera_init(self.camera))
                        # get configuration tree
                self.current_camera_config = gp.check_result(gp.gp_camera_get_config(self.camera))
                self.apply_camera_settings(self.camera, self.current_camera_config)
                if self.check_status(self.camera, self.current_camera_config) is False:
                    print(_("Warning: Some settings are not set to the recommended value!"))
            except:
                self.camera = False
                
                self.splash_text += _("\nCamera not found or busy.")

        self.timeout = 3000  # milliseconds
        
        self.splashscreen = self.generate_splashscreen()

        self.image = None
        self.update_image()
        if self.image:
            if self.onion_skin:
                if self.img_index:
                    photo = self.apply_onionskin(self.image, self.onionskin_alpha_default, self.onionskin_fx)
            else:
                photo = ImageTk.PhotoImage(self.image)
            self.label.configure(image=photo)
            self.label.image = photo

        if project_settings['trigger_mode'] == 'event':
            root.after(1000, self.trigger_bg_loop)
        
        # Key binding
        root.bind("<Escape>", lambda event: root.attributes("-fullscreen", False))
        root.bind("<f>", lambda event: root.attributes("-fullscreen", True))
        root.bind("<e>", self.next_frame)
        root.bind("<j>", self.previous_frame)
        root.bind("<J>", self.toggle_onionskin)
        root.bind("<N>", self.preview_animation)
        root.bind("<E>", self.trigger_export_animation)
        root.bind("<d>", self.remove_frame)
        root.bind("<a>", self.print_imglist)
        
        if project_settings['trigger_mode'] != 'event':
            root.bind("<n>", self.capture_image)


    def check_config(self):
        global project_settings
        for setting in project_settings_defaults:
            if setting not in project_settings:
                project_settings[setting] = project_settings_defaults[setting]
        
        
    def parse_export_options(self, options:str, vflip:bool=False, hflip:bool=False):
        options = {"vf" : options}
        if vflip:
            options['vf'] += ',vflip'
        if hflip:
            options['vf'] += ',hflip'
        return options
    
    def generate_splashscreen(self):
        splash = Image.new('RGB', (self.screen_w, self.screen_h), (200,200,200))
        splash_draw = ImageDraw.Draw(splash)
        if self.splash_text is not None:
            font = ImageFont.truetype("Tuffy_Bold.ttf", 60)
            font_len = font.getlength(self.splash_text.split('\n')[0])
            splash_draw.multiline_text((self.screen_w/2 - font_len/2, self.screen_h/2 ), self.splash_text, fill=(255, 255, 255), font=font, align='center', spacing=20)
        # Use in-memory
        splash_bytes = BytesIO()
        splash.save(splash_bytes, 'png')
        return splash

    
    def find_letter_after(self, letter:str):
        if letter in alphabet and alphabet.index(letter) < len(alphabet) - 1:
            return alphabet[alphabet.index(letter) + 1]
        else:
            return False


    def get_projects_folder(self):
        if len(self.projects_folder):
            project_folder = self.projects_folder
        else:
            # Get user folder
            project_folder = os.path.expanduser('~')
            # If a project folder is defined in settings, use it
            if project_settings['projects_folder'] != '':
                subfolder = project_settings['projects_folder']
            else:
                # If it doesn't exist, use a default name
                subfolder = 'Stopmotion Projects'
            project_folder = os.path.join(project_folder, subfolder)
        # Create folder if it doesn't exist
        if os.path.exists(project_folder) == False:
            os.mkdir(project_folder)
        else:
            if not os.path.isdir(project_folder):
                # If file exists but is not a folder, can't create it, abort
                return False
        return project_folder


    def get_session_folder(self):
        project_folder = self.get_projects_folder()
        if project_folder:
            sessions_list = []
            dir_list = os.listdir(project_folder)
            # Filter folders with name only one char long
            for dir in dir_list:
                if len(dir) == 1 and dir in alphabet:
                    sessions_list.append(dir)
            # If folders exist, find last folder in alphabetical order
            if len(sessions_list):
                sessions_list.sort()
                last_letter = sessions_list[-1]
                # By default, find next letter for a new session
                next_letter = self.find_letter_after(last_letter)
                if next_letter is False:
                    return False
                # A previous session folder was found; ask the user if they wish to resume session
                resume_session = tk.messagebox.askyesno(_("Resume session?"), _("A previous session was found in {}, resume shooting ?").format(os.path.join(project_folder, last_letter)))
                if resume_session:
                    next_letter = last_letter
            else:
                next_letter = 'A'
            if os.path.exists(os.path.join(project_folder, next_letter)) is False:
                os.mkdir(os.path.join(project_folder, next_letter))
            print(_("Using {} as session folder.").format(os.path.join(project_folder, next_letter)))
            return os.path.join(project_folder, next_letter)
        return False

    def trigger_bg_loop(self):
        self.event_thread = threading.Thread(target=self.wait_for_capture)
        self.event_thread.start()
    
    
    def wait_for_event(self):
        # ~ while True:
        event_type, event_data = self.camera.wait_for_event(self.timeout)
        if event_type == gp.GP_EVENT_FILE_ADDED:
            cam_file = self.camera.file_get(
                event_data.folder, event_data.name, gp.GP_FILE_TYPE_NORMAL)
            # ~ next_filename = prefix+next(filename)+ext
            next_filename = self.return_next_frame_number(self.get_last_frame(self.savepath))
            target_path = os.path.join(os.getcwd(), next_filename)
            print(_("Image is being saved to {}").format(target_path))
            cam_file.save(target_path)
    # ~ return 0


    def print_imglist(self, event):
        print(self.img_list)


    def get_frames_list(self, folder:str):
        # Get JPG files list in current directory
        # ~ existing_animation_files = []
        # ~ if not len(self.img_list):
        existing_animation_files = self.img_list
        # ~ existing_animation_files =
        file_list = os.listdir(folder)
        for file in file_list:
            if (file.startswith(self.project_letter) and file.endswith(project_settings['file_extension'])):
                if file not in existing_animation_files:
                # ~ existing_animation_files.append(file)
                    existing_animation_files[file] = None
        if len(existing_animation_files) == 0:
            # If no images were found, return fake name set to -001 to init file count to 000
            # ~ return ["{}.{:04d}.{}".format(project_settings['project_letter'], -1, project_settings['file_extension'])]
            return {"{}.{:04d}.{}".format(self.project_letter, -1, project_settings['file_extension']):None}
        # ~ else:
            # Remove fake file name as soon as we have real pics
            # ~ if 'A.-001.JPG' in existing_animation_files:
                # ~ existing_animation_files.pop('A.-001.JPG')
        # ~ existing_animation_files.sort()
        existing_animation_files = collections.OrderedDict(sorted(existing_animation_files.items()))
        return existing_animation_files


    def clean_img_list(self, folder_path):
        # Check file in dict exists, else remove it
        file_list = os.listdir(folder_path)
        # Iterate over copy of dict to avoid OOR error
        img_list_copy = dict(self.img_list)
        for file in img_list_copy:
            if file not in file_list:
                self.img_list.pop(file)


    def batch_rename(self, folder:str):        
        # initialize counter to 0
        frame_list = self.get_frames_list(folder)
        counter = (".%04i." % x for x in count(0))
        # ~ for i in range(len(frame_list)):
        for i in frame_list.keys():
            # ~ if os.path.exists(os.path.realpath(frame_list[i])):
            if os.path.exists(os.path.join(folder, i)):
                # ~ os.rename(os.path.realpath(frame_list[i]), os.path.realpath("{}{}{}".format(project_settings['project_letter'], next(counter), project_settings['file_extension'])))
                os.rename(os.path.join(folder, i), os.path.join(folder, "{}{}{}".format(self.project_letter, next(counter), project_settings['file_extension'])))
                # ~ print(os.path.join(folder, "{}{}{}".format(self.project_letter, next(counter), project_settings['file_extension'])))
            else:
                print(_("{} does not exist").format(str(i)))
        return self.get_frames_list(folder)


    def offset_dictvalues(self, from_index=0):
        dict_copy = dict(self.img_list)
        for i in range(from_index, len(dict_copy)):
            if i < len(self.img_list)-1:
                self.img_list[list(self.img_list.keys())[i]] = list(self.img_list.values())[i+1]
            else:
                self.img_list[list(self.img_list.keys())[i]] = None


    def remove_frame(self, event):
        if len(list(self.img_list.items())):
            
            folder_path = os.path.realpath(self.savepath)
            frame_name = list(self.img_list.items())[self.img_index][0]
            # ~ frame_path = os.path.realpath(frame_name)
            frame_path = os.path.join(folder_path, frame_name)

            if not os.path.exists(frame_path):
                return 0
            
            print(_("Removing {}").format(frame_path))
            # trash file
            send2trash(frame_path)
            # remove entry from dict
            self.img_list.pop(frame_name)
            # offset cached images
            self.offset_dictvalues(self.img_index)
            # rename files and get new list
            self.img_list = self.batch_rename(folder_path)
            self.clean_img_list(folder_path)
            # update index if possible
            self.img_index = self.check_range(self.img_index, False)
            # update display
        self.update_image(None, self.img_index)

    # ~ def open_jpg(self, filepath:str, w:int, h:int):
    def open_jpg(self, filetuple:tuple, w:int, h:int, vflip:bool=False, hflip:bool=False):
        # If pic not cached
        if filetuple[-1] is None:
            try:
                image = Image.open(os.path.join(self.savepath, filetuple[0]))
                image = ImageOps.fit(image, (w, h))
                if vflip:
                    image = image.transpose(Image.Transpose.FLIP_TOP_BOTTOM)
                if hflip:
                    image = image.transpose(Image.Transpose.FLIP_LEFT_RIGHT)
                if project_settings['cache_images']:
                    # TODO : Do not cache image to preserve memory
                    self.img_list[filetuple[0]] = image
            except FileNotFoundError:
                return False
        else:
            if project_settings['cache_images']:
                image = filetuple[-1]
        return image

            
    def check_range(self, x, loop=True):
        if x < 0:
            if loop:
                return len(self.img_list)-1
            else:
                return 0
        elif x > len(self.img_list)-1:
            if loop:
                return 0
            else:
                return len(self.img_list)-1
        else:
            return x


    def apply_onionskin(self, image, alpha, fx=False):
        # ~ prev_image = Image.open(self.img_list[self.img_index-1])
        # ~ prev_image = prev_image.resize((self.screen_w,  self.screen_h))
        prev_image = list(self.img_list.items())[self.img_index-1]
        if prev_image[-1] is None:
            prev_image = self.open_jpg(prev_image, project_settings['screen_w'], project_settings['screen_h'], project_settings['vflip'], project_settings['hflip'])
        else:
            prev_image = prev_image[-1]
        if fx:
            prev_image = prev_image.filter(ImageFilter.FIND_EDGES)
        composite = Image.blend(prev_image, image, alpha)
        photo = ImageTk.PhotoImage(composite)
        return photo


    def update_image(self, event=None, index=None):
        # TODO : check event mode still works
        if event is not None:
            self.img_index = self.check_range(self.img_index+1)
        if index is None:
            # ~ index = self.img_index
            index = self.check_range(self.img_index)
        if len(list(self.img_list.items())):
            # TODO: better approach
            # If name == X.-001.JPG, we don't have any frame yet, so display splashscreen
            if list(self.img_list.items())[index][0] == "{}.{:04d}.{}".format(self.project_letter, -1, project_settings['file_extension']):
                new_image = self.splashscreen
            else:
                new_image = self.open_jpg(list(self.img_list.items())[index], project_settings['screen_w'], project_settings['screen_h'], project_settings['vflip'], project_settings['hflip'])
        else:
            new_image = self.splashscreen
        if new_image:
            photo = ImageTk.PhotoImage(new_image)
            if self.onion_skin:
                if index:
                    photo = self.apply_onionskin(new_image, project_settings['onionskin_alpha_default'], project_settings['onionskin_fx'])
            self.label.configure(image=photo)
            self.label.image = photo
            # ~ return new_image
            self.image = new_image
            # ~ new_image.close()
            return True
        else:
            return False
        

    def next_frame(self, event):
        self.img_index = self.check_range(self.img_index+1)
        self.update_image(None, self.img_index)
        

    def previous_frame(self, event):
        self.img_index = self.check_range(self.img_index-1)
        self.update_image(None, self.img_index)


    def playback_animation(self):
        while self.img_index < len(self.img_list)-1:
            self.img_index += 1
            root.after(62, self.update_image(None, self.img_index))
            root.update_idletasks()


    def preview_animation(self, event):
        # save OS state
        if self.onion_skin:
            self.onion_skin = False
            onion_skin_was_on = True
        # playback
        # TODO : Use async function for playback
        # ~ self.playback = not self.playback
        # ~ self.img_index = 0
        # ~ self.playback_animation()
        for img in self.img_list:
            # ~ self.update_image(None, self.img_list.index(img))
            # ~ if self.playback:
            self.update_image(None, list(self.img_list.keys()).index(img))
            root.update_idletasks()
            time.sleep(1/self.framerate)
            # ~ else:
                # ~ break
        # ~ self.update_image(None, self.img_index)
        self.display_last_frame()
        # restore OS state
        if 'onion_skin_was_on' in locals():
            self.toggle_onionskin()
        return 0


    def toggle_onionskin(self, event=None):
        self.onion_skin = not self.onion_skin
        self.update_image()


    def get_last_frame(self, folder:str):
        # Refresh file list
        existing_animation_files = self.get_frames_list(folder)
        # Get last file
        # Filename pattern is A.0001.JPG
        # ~ return existing_animation_files[-1].split('.')
        print(next(reversed(existing_animation_files.keys())))
        return next(reversed(existing_animation_files.keys())).split('.')


    def display_last_frame(self):
        self.img_list = self.get_frames_list(self.savepath)
        self.img_index = len(self.img_list)-1
        self.update_image(None, self.img_index)


    def return_next_frame_number(self, last_frame_name):
        prefix, filecount, ext = last_frame_name
        filename = '.{:04d}.'.format(int(filecount)+1)
        # ~ filename = (".%04i." % x for x in count(int(filecount) + 1))
        # ~ return prefix + next(filename) + ext
        return prefix + filename + ext


    def set_config_value(self, config, setting, new_value):
        cur_setting = gp.check_result(gp.gp_widget_get_child_by_name(config, setting))
        # find corresponding choice 
        cur_setting_choice = gp.check_result(gp.gp_widget_get_choice(cur_setting, new_value))
        # set config value
        gp.check_result(gp.gp_widget_set_value(cur_setting, cur_setting_choice))


    def apply_camera_settings(self, camera, config):
        # iterate over the settings dictionary
        for setting in camera_settings:
            # find the capture mode config item
            # ~ cur_setting = gp.check_result(gp.gp_widget_get_child_by_name(config, setting))
            # ~ # find corresponding choice 
            # ~ cur_setting_choice = gp.check_result(gp.gp_widget_get_choice(cur_setting, camera_settings[setting]))
            # ~ # set config value
            # ~ gp.check_result(gp.gp_widget_set_value(cur_setting, cur_setting_choice))
            self.set_config_value(config, setting, camera_settings[setting])
        # validate config
        gp.check_result(gp.gp_camera_set_config(self.camera, config))


    def check_status_value(self, config, value, optimal_value=None):
        cur_check = gp.check_result(gp.gp_widget_get_child_by_name(config, value))
        cur_check_value = gp.check_result(gp.gp_widget_get_value(cur_check))
        if optimal_value is not None:
            cur_check_choice = gp.check_result(gp.gp_widget_get_choice(cur_check, optimal_value[value]))
            return [cur_check_value, cur_check_choice]
        else:
            return cur_check_value
            

    def check_status(self, camera, config):
        for value in camera_status:
            # ~ cur_check = gp.check_result(gp.gp_widget_get_child_by_name(config, value))
            # ~ cur_check_choice = gp.check_result(gp.gp_widget_get_choice(cur_check, camera_status[value]))
            # ~ cur_check_value = gp.check_result(gp.gp_widget_get_value(cur_check))
            cur_check_value, cur_check_choice = self.check_status_value(config, value, camera_status)
            if cur_check_value == cur_check_choice:
                return True
            else:
                # Some values are not optimal
                return False


    # ~ def find_shutterspeed(camera, config):
    def find_shutterspeed(self, camera):
        # get exposure using /main/status/lightmeter > should be 0
        config = gp.check_result(gp.gp_camera_get_config(camera))
        current_lightmeter_value = self.check_status_value(config, 'lightmeter')
        current_shutterspeed_value = self.check_status_value(config, 'shutterspeed2')
        # ~ previous_shutterspeed_value = -1
        print(str(current_lightmeter_value) + " - " + str(current_shutterspeed_value))
        speed = 30
        if current_lightmeter_value < 0: # or current_lightmeter_value > 7:
        # ~ while current_lightmeter_value < -7:
            print(_("speed too high"))
            while current_lightmeter_value < -7:
                self.set_config_value(config, 'shutterspeed2', speed) # 0 to 46
                gp.check_result(gp.gp_camera_set_config(camera, config))
                time.sleep(1)
                config = gp.check_result(gp.gp_camera_get_config(camera))
                # ~ previous_shutterspeed_value = current_shutterspeed_value
                current_lightmeter_value = self.check_status_value(config, 'lightmeter')
                current_shutterspeed_value = self.check_status_value(config, 'shutterspeed2')
                speed += 1
                print(speed)
                print(str(current_lightmeter_value) + " - " + str(current_shutterspeed_value))
        if current_lightmeter_value > 0:
            print(_("Speed too low."))
            while current_lightmeter_value > 7:
                self.set_config_value(config, 'shutterspeed2', speed) # 0 to 46
                gp.check_result(gp.gp_camera_set_config(camera, config))
                time.sleep(1)
                config = gp.check_result(gp.gp_camera_get_config(self.camera))
                # ~ previous_shutterspeed_value = current_shutterspeed_value
                current_lightmeter_value = self.check_status_value(config, 'lightmeter')
                current_shutterspeed_value = self.check_status_value(config, 'shutterspeed2')
                speed -= 1
                print(speed)
                print(str(current_lightmeter_value) + " - " + str(current_shutterspeed_value))
        return True

    def capture_image(self, event=None, event_data=None):
        # get net file name based on prefix, file count and extension
        next_filename = self.return_next_frame_number(self.get_last_frame(self.savepath))
        # build full path to file
        target_path = os.path.join(self.savepath, next_filename)
        if project_settings['camera_type'] != 0:
            self.camera.start(show_preview=False)
            self.camera.set_controls({"LensPosition": self.camera_lenspos})
            self.camera.capture_file(target_path, 'main', format='jpeg')
            self.camera.stop()
        else:
            # Get file from DSLR camera
            if event_data is None:
                new_frame_path = self.camera.capture(gp.GP_CAPTURE_IMAGE)
                # ~ self.camera.trigger_capture()
                new_frame = self.camera.file_get(
                    new_frame_path.folder, new_frame_path.name, gp.GP_FILE_TYPE_NORMAL)
                print(_("Saving {}{}").format(new_frame_path.folder, new_frame_path.name))
            else:
                print(_("Getting file {}").format(event_data.name))
                new_frame = self.camera.file_get(
                        event_data.folder, event_data.name, gp.GP_FILE_TYPE_NORMAL)
            new_frame.save(target_path)
            # ~ next_filename = prefix+next(filename)+ext
        if '{letter}.-001.JPG'.format(letter=self.project_letter) in self.img_list:
            self.img_list.pop('{letter}.-001.JPG'.format(letter=self.project_letter))
        # Display new frame
        self.display_last_frame()
        
    
    def wait_for_capture(self):
        if self.end_thread == True:
            print(_("Ending thread"))
            return
        event_type, event_data = self.camera.wait_for_event(self.timeout)
        if event_type == gp.GP_EVENT_FILE_ADDED:
            self.capture_image(None, event_data)
        # ~ root.after(self.timeout, self.wait_for_capture)
        self.wait_for_capture()


    async def export_animation(self):
        ffmpeg = (
            FFmpeg()
            # overwrite file
            .option("y")
            .input(
                self.input_filename,
                self.input_options)
            .output(
                # ~ self.output_filename,
                self.export_filename,
                self.output_options
            )
        )
        
        await ffmpeg.execute()

    def trigger_export_animation(self, event):
        # ~ output_folder = filedialog.askdirectory()
        self.export_filename = ()
        self.export_filename = filedialog.asksaveasfilename(defaultextension='.mp4', filetypes=((_("Mp4 files"), '*.mp4'),))
        if not self.export_filename:
            # ~ self.export_filename = "{folder}{sep}{filename}".format(folder=os.getcwd(), sep=os.sep, filename=self.output_filename)
            return False
        print(_("Exporting to {}").format(self.export_filename))
        self.export_task = asyncio.run(self.export_animation())
        # check with self.export_task.done() == True ? https://stackoverflow.com/questions/69350645/proper-way-to-retrieve-the-result-of-tasks-in-asyncio

def end_bg_loop(KISStopmo):
    if KISStopmo.camera is not False:
        if project_settings['camera_type'] != 0:
                KISStopmo.camera.stop()
        else:
            KISStopmo.camera.exit()
    KISStopmo.end_thread = True

root = tk.Tk()
toot = KISStopmo(root)
root.protocol('WM_DELETE_WINDOW', end_bg_loop(toot))
root.mainloop()