streamdeck-gui-ng 4.1.3__py3-none-any.whl

streamdeck_ui/config.py

@@ -0,0 +1,244 @@
+"""Defines shared configuration variables for the streamdeck_ui project"""
+
+import json
+import os
+from typing import Dict
+
+from streamdeck_ui.model import ButtonMultiState, ButtonState, DeckState, DeckStateV1
+
+PROJECT_PATH = os.path.dirname(os.path.abspath(__file__))
+APP_NAME = "StreamDeck UI"
+APP_LOGO = os.path.join(PROJECT_PATH, "logo.png")
+FONTS_PATH = os.path.join(PROJECT_PATH, "fonts", "roboto")
+FONTS_FALLBACK_PATH = os.path.join(PROJECT_PATH, "fonts", "roboto")
+DEFAULT_FONT = "Roboto-Regular.ttf"
+DEFAULT_FONT_FALLBACK_PATH = os.path.join(FONTS_FALLBACK_PATH, DEFAULT_FONT)
+DEFAULT_FONT_SIZE = 14
+DEFAULT_FONT_COLOR = "#ffffff"
+DEFAULT_BACKGROUND_COLOR = "#000000"
+STATE_FILE = os.environ.get("STREAMDECK_UI_CONFIG", os.path.expanduser("~/.streamdeck_ui.json"))
+LOG_FILE = os.environ.get("STREAMDECK_UI_LOG_FILE", os.path.expanduser("~/.streamdeck_ui.log"))
+STATE_FILE_BACKUP = os.path.expanduser("~/.streamdeck_ui.json_old")
+CONFIG_FILE_VERSION = 2
+CONFIG_FILE_PREVIOUS_VERSION = 1
+CONFIG_FILE_SUPPORTED_VERSIONS = [CONFIG_FILE_VERSION, CONFIG_FILE_PREVIOUS_VERSION]
+WARNING_ICON = os.path.join(PROJECT_PATH, "icons", "warning_icon_button.png")
+
+
+def config_file_need_migration(config_file_path: str) -> bool:
+    """Check if the config file need to be updated"""
+    if not os.path.isfile(config_file_path):
+        return False
+    with open(config_file_path, "r") as config_file:
+        config = json.load(config_file)
+        file_version = config.get("streamdeck_ui_version", CONFIG_FILE_VERSION)
+        return file_version != CONFIG_FILE_VERSION
+
+
+def do_config_file_backup(config_file_path: str, backup_config_file_path: str) -> None:
+    """Make a copy of the config file"""
+    if os.path.isfile(config_file_path):
+        os.replace(config_file_path, backup_config_file_path)
+
+
+def do_config_file_migration() -> None:
+    """Update the config file to the latest version"""
+    state = read_state_from_config(STATE_FILE)
+    do_config_file_backup(STATE_FILE, STATE_FILE_BACKUP)
+    write_state_to_config(STATE_FILE, state)
+
+
+def read_state_from_config(config_file_path: str) -> Dict[str, DeckState]:
+    """Open the config file and return its content as a dict"""
+
+    with open(config_file_path, "r") as config_file:
+        config = json.load(config_file)
+        file_version = config.get("streamdeck_ui_version", 0)
+        if file_version not in CONFIG_FILE_SUPPORTED_VERSIONS:
+            raise ValueError(
+                f"Incompatible version of config file found: {file_version} does not match required version {CONFIG_FILE_VERSION}."
+            )
+        if file_version == CONFIG_FILE_PREVIOUS_VERSION:
+            return _migrate_deck_state_from_previous_version(config["state"])
+        state = _to_deck_states(config["state"])
+        validate_current_page(state)
+        validate_current_button_state(state)
+        return state
+
+
+def validate_current_page(state: Dict[str, DeckState]) -> None:
+    """Validate that the current page is valid, if the current page is not valid, set it to the first page
+    of the deck"""
+    for _deck_id, deck_state in state.items():
+        if deck_state.page not in deck_state.buttons:
+            deck_state.page = next(iter(deck_state.buttons))
+
+
+def validate_current_button_state(state: Dict[str, DeckState]) -> None:
+    """Validate that the current button state is valid, if the current button state is not valid, set it to the first state
+    of the button"""
+    for _deck_id, deck_state in state.items():
+        for _page_of_buttons_id, page_of_buttons_state in deck_state.buttons.items():
+            for _button_id, button_state in page_of_buttons_state.items():
+                if button_state.state not in button_state.states:
+                    button_state.state = next(iter(button_state.states))
+
+
+def write_state_to_config(config_file_path: str, state: Dict[str, DeckState]) -> None:
+    """Write the state to the config file"""
+    temp_file_path = config_file_path + ".tmp"
+    try:
+        with open(temp_file_path, "w") as config_file:
+            config = {
+                "state": _to_deck_config(state),
+                "streamdeck_ui_version": CONFIG_FILE_VERSION,
+            }
+            json.dump(config, config_file, indent=4)
+    except Exception as error:
+        raise ValueError(f"The configuration file '{config_file_path}' was not updated. Error: {error}")
+    else:
+        os.replace(temp_file_path, os.path.realpath(config_file_path))
+
+
+def _to_deck_states(state: dict) -> Dict[str, DeckState]:
+    return {
+        deck_id: DeckState(
+            buttons={
+                int(page_of_buttons_id): {
+                    int(button_id): _to_button_multi_state(button)
+                    for button_id, button in page_of_buttons_state.items()
+                }
+                for page_of_buttons_id, page_of_buttons_state in deck_state["buttons"].items()
+            },
+            display_timeout=deck_state["display_timeout"],
+            brightness=deck_state["brightness"],
+            brightness_dimmed=deck_state["brightness_dimmed"],
+            rotation=deck_state["rotation"],
+            page=deck_state["page"],
+        )
+        for deck_id, deck_state in state.items()
+    }
+
+
+def _migrate_deck_state_from_previous_version(state: dict) -> Dict[str, DeckState]:
+    deck_state = _to_deck_states_v1(state)
+    return {
+        deck_id: DeckState(
+            buttons={
+                page_of_buttons_id: {
+                    button_id: _migrate_button_state_to_multi_state(button)
+                    for button_id, button in page_of_buttons_state.items()
+                }
+                for page_of_buttons_id, page_of_buttons_state in deck_state.buttons.items()
+            },
+            display_timeout=deck_state.display_timeout,
+            brightness=deck_state.brightness,
+            brightness_dimmed=deck_state.brightness_dimmed,
+            rotation=deck_state.rotation,
+            page=deck_state.page,
+        )
+        for deck_id, deck_state in deck_state.items()
+    }
+
+
+def _migrate_button_state_to_multi_state(button: ButtonState) -> ButtonMultiState:
+    return ButtonMultiState(
+        state=0,
+        states={
+            0: button,
+        },
+    )
+
+
+def _to_deck_states_v1(state: dict) -> Dict[str, DeckStateV1]:
+    """Convert a dict to a DeckStateV1 object"""
+    return {
+        deck_id: DeckStateV1(
+            buttons={
+                int(page_of_buttons_id): {
+                    int(button_id): _to_button_state(button) for button_id, button in page_of_buttons_state.items()
+                }
+                for page_of_buttons_id, page_of_buttons_state in deck_state.get("buttons", {}).items()
+            },
+            display_timeout=deck_state.get("display_timeout", 0),
+            brightness=deck_state.get("brightness", 0),
+            brightness_dimmed=deck_state.get("brightness_dimmed", 0),
+            rotation=deck_state.get("rotation", 0),
+            page=deck_state.get("page", 0),
+        )
+        for deck_id, deck_state in state.items()
+    }
+
+
+def _to_button_state(button: dict) -> ButtonState:
+    """Convert a dict to a ButtonState object"""
+    return ButtonState(
+        text=button.get("text", ""),
+        icon=button.get("icon", ""),
+        keys=button.get("keys", ""),
+        write=button.get("write", ""),
+        command=button.get("command", ""),
+        switch_page=button.get("switch_page", 0),
+        switch_state=button.get("switch_state", 0),
+        brightness_change=button.get("brightness_change", 0),
+        text_vertical_align=button.get("text_vertical_align", ""),
+        text_horizontal_align=button.get("text_horizontal_align", ""),
+        font=button.get("font", ""),
+        font_color=button.get("font_color", ""),
+        font_size=button.get("font_size", 0),
+        background_color=button.get("background_color", ""),
+    )
+
+
+def _to_button_multi_state(button: dict) -> ButtonMultiState:
+    return ButtonMultiState(
+        state=button.get("state", 0),
+        states={int(state_id): _to_button_state(state) for state_id, state in button.get("states", {}).items()},
+    )
+
+
+def _to_deck_config(state: Dict[str, DeckState]) -> dict:
+    return {
+        deck_id: {
+            "buttons": {
+                page_of_buttons_id: {
+                    button_id: _to_multi_state_button_config(button)
+                    for button_id, button in page_of_buttons_state.items()
+                }
+                for page_of_buttons_id, page_of_buttons_state in deck_state.buttons.items()
+            },
+            "display_timeout": deck_state.display_timeout,
+            "brightness": deck_state.brightness,
+            "brightness_dimmed": deck_state.brightness_dimmed,
+            "rotation": deck_state.rotation,
+            "page": deck_state.page,
+        }
+        for deck_id, deck_state in state.items()
+    }
+
+
+def _to_button_config(button: ButtonState) -> dict:
+    """Convert a ButtonState object to a dict"""
+    return {
+        "text": button.text,
+        "icon": button.icon,
+        "keys": button.keys,
+        "write": button.write,
+        "command": button.command,
+        "brightness_change": button.brightness_change,
+        "switch_page": button.switch_page,
+        "switch_state": button.switch_state,
+        "text_vertical_align": button.text_vertical_align,
+        "text_horizontal_align": button.text_horizontal_align,
+        "font": button.font,
+        "font_color": button.font_color,
+        "font_size": button.font_size,
+        "background_color": button.background_color,
+    }
+
+
+def _to_multi_state_button_config(button: ButtonMultiState) -> dict:
+    return {
+        "state": button.state,
+        "states": {state_id: _to_button_config(state) for state_id, state in button.states.items()},
+    }

streamdeck_ui/dimmer.py

@@ -0,0 +1,93 @@
+import threading
+from typing import Callable, Optional
+
+from StreamDeck.Transport.Transport import TransportError
+
+
+class Dimmer:
+    def __init__(
+        self, timeout: int, brightness: int, brightness_dimmed: int, brightness_callback: Callable[[int], None]
+    ):
+        """Constructs a new Dimmer instance
+
+        :param int timeout: The time in seconds before the dimmer starts.
+        :param int brightness: The normal brightness level.
+        :param int brightness_dimmed: The percentage of normal brightness when dimmed.
+        :param Callable[[int], None] brightness_callback: Callback that receives the current
+                                                          brightness level.
+        """
+        self.timeout = timeout
+        self.brightness = brightness
+        "The brightness when not dimmed"
+        self.brightness_dimmed = brightness_dimmed
+        "The percentage of normal brightness when dimmed"
+        self.brightness_callback = brightness_callback
+        self.__stopped = False
+        self.dimmed = True
+        "True if the Stream Deck is dimmed, False otherwise"
+        self.__timer: Optional[threading.Timer] = None
+
+    def dimmed_brightness(self) -> int:
+        """Calculates the effective brightness when dimmed.
+
+        :return: The brightness value when applying the dim percentage to the normal brightness.
+        :rtype: int
+        """
+        return int(self.brightness * (self.brightness_dimmed / 100))
+
+    def stop(self) -> None:
+        """Stops the dimmer and sets the brightness back to normal. Call
+        reset to start normal dimming operation."""
+        if self.__timer:
+            self.__timer.cancel()
+            self.__timer = None
+
+        try:
+            self.brightness_callback(self.brightness)
+        except KeyError:
+            # During detach cleanup, this is likely to happen
+            pass
+        except TransportError:
+            pass
+        self.__stopped = True
+
+    def reset(self) -> bool:
+        """Reset the dimmer and start counting down again. If it was busy dimming, it will
+        immediately stop dimming. Callback fires to set brightness back to normal."""
+
+        self.__stopped = False
+        if self.__timer:
+            self.__timer.cancel()
+            self.__timer = None
+
+        if self.timeout:
+            self.__timer = threading.Timer(self.timeout, self.dim)
+            self.__timer.start()
+
+        if self.dimmed:
+            self.brightness_callback(self.brightness)
+            self.dimmed = False
+            if self.dimmed_brightness() < 20:
+                # The screen was "too dark" so reset and let caller know
+                return True
+
+        return False
+        # Returning false means "I didn't have to reset it"
+
+    def dim(self, toggle: bool = False):
+        """Manually initiate a dim event.
+        If the dimmer is stopped, this has no effect."""
+
+        if self.__stopped:
+            return
+
+        if toggle and self.dimmed:
+            # Don't dim
+            self.reset()
+        elif self.__timer:
+            # No need for the timer anymore, stop it
+            self.__timer.cancel()
+            self.__timer = None
+
+            self.brightness_callback(self.dimmed_brightness())
+            self.dimmed = True

streamdeck_ui/display/background_color_filter.py

@@ -0,0 +1,41 @@
+from fractions import Fraction
+from typing import Callable, Optional, Tuple
+
+from PIL import Image, ImageColor
+
+from streamdeck_ui.display.filter import Filter
+
+
+class BackgroundColorFilter(Filter):
+    image: Optional[Image.Image]
+
+    def __init__(self, color: str):
+        super(BackgroundColorFilter, self).__init__()
+        self.image = None
+        self.color = to_rgb(color)
+        self.hashcode = hash((self.__class__, self.color))
+
+    def initialize(self, size: Tuple[int, int]):
+        self.image = Image.new("RGB", size)
+        self.image.paste(self.color, (0, 0, size[0], size[1]))
+
+    def transform(  # type: ignore[override]
+        self,
+        get_input: Callable[[], Image.Image],
+        get_output: Callable[[int], Image.Image],
+        input_changed: bool,
+        time: Fraction,
+    ) -> Tuple[Optional[Image.Image], int]:
+        if not input_changed:
+            return None, self.hashcode
+        return self.image, self.hashcode
+
+
+def to_rgb(hex_str: str) -> Tuple[int, ...]:
+    """
+    Converts a hex string or a color string to an RGB tuple.
+    """
+    if hex_str.startswith("#"):
+        hex_str = hex_str.lstrip("#")
+        return tuple(int(hex_str[i : i + 2], 16) for i in (0, 2, 4))
+    return ImageColor.getrgb(hex_str)

streamdeck_ui/display/display_grid.py

@@ -0,0 +1,265 @@
+import threading
+from time import sleep, time
+from typing import Callable, Dict, List, Optional
+
+from PIL import Image
+from StreamDeck.Devices.StreamDeck import StreamDeck
+from StreamDeck.Devices.StreamDeckOriginal import StreamDeckOriginal
+from StreamDeck.ImageHelpers import PILHelper
+from StreamDeck.Transport.Transport import TransportError
+
+from streamdeck_ui.display.empty_filter import EmptyFilter
+from streamdeck_ui.display.filter import Filter
+from streamdeck_ui.display.keypress_filter import KeypressFilter
+from streamdeck_ui.display.pipeline import Pipeline
+
+
+class DisplayGrid:
+    """
+    A DisplayGrid is made up of a collection of pipelines, each processing
+    filters for one individual button display.
+    """
+
+    lock: threading.Lock
+
+    def __init__(
+        self,
+        lock: threading.Lock,
+        streamdeck: StreamDeck,
+        pages: List[int],
+        cpu_callback: Callable[[str, int], None],
+        fps: int = 25,
+    ):
+        """Creates a new display instance
+
+        :param lock: A lock object that will be used to get exclusive access while enumerating
+        Stream Decks. This lock must be shared by any object that will read or write to the
+        Stream Deck.
+        :type lock: threading.Lock
+        :param streamdeck: The StreamDeck instance associated with this display
+        :type streamdeck: StreamDeck
+        :param pages: The number of logical pages (screen sets)
+        :type pages: int
+        :param cpu_callback: A function to call whenever the CPU changes
+        :type cpu_callback: Callable[[str, int], None]
+        :param fps: The desired FPS, defaults to 25
+        :type fps: int, optional
+        """
+        self.streamdeck = streamdeck
+        # Reference to the actual device, used to update icons
+
+        if streamdeck.is_visual():
+            self.size = streamdeck.key_image_format()["size"]
+        else:
+            self.size = (StreamDeckOriginal.KEY_PIXEL_WIDTH, StreamDeckOriginal.KEY_PIXEL_HEIGHT)
+            # Default to original stream deck size - even though we're not actually going to display anything
+        self.serial_number = streamdeck.get_serial_number()
+
+        self._empty_filter: EmptyFilter = EmptyFilter()
+        self._empty_filter.initialize(self.size)
+        # Instance of EmptyFilter shared by all pipelines related to this
+        # DisplayGrid instance
+
+        self.pages: Dict[int, Dict[int, Pipeline]] = {}
+        # A dictionary of lists of pipelines. Each page has
+        # a list, corresponding to each button.
+
+        self.current_page: int = -1
+        self.pipeline_thread: Optional[threading.Thread] = None
+        self.quit = threading.Event()
+        self.fps = fps
+        # Configure the maximum frame rate we want to achieve
+        self.time_per_frame = 1 / fps
+        self.lock = lock
+        self.sync = threading.Event()
+        self.cpu_callback = cpu_callback
+
+        # Initialize with a pipeline per key for all pages
+        for page in pages:
+            self.initialize_page(page)
+        # The sync event allows a caller to wait until all the buttons have been processed
+
+    def initialize_page(self, page: int):
+        self.pages[page] = {}
+        for button in range(self.streamdeck.key_count()):
+            self.pages[page][button] = Pipeline()
+            self.replace(page, button, [])
+
+    def remove_page(self, page: int):
+        with self.lock:
+            del self.pages[page]
+
+    def replace(self, page: int, button: int, filters: List[Filter]):
+        with self.lock:
+            pipeline = Pipeline()
+            pipeline.add(self._empty_filter)
+            for pipeline_filter in filters:
+                pipeline_filter.initialize(self.size)
+                pipeline.add(pipeline_filter)
+            keypress = KeypressFilter()
+            keypress.initialize(self.size)
+            pipeline.add(keypress)
+            self.pages[page][button] = pipeline
+
+    def get_image(self, page: int, button: int) -> Optional[Image.Image]:
+        with self.lock:
+            # REVIEW: Consider returning not the last result, but a thumbnail
+            # or something that represents the current "static" look of
+            # a button. This will need to be added to the interface
+            # of a filter.
+            return self.pages[page][button].last_result()
+
+    def set_keypress(self, button: int, active: bool):
+        with self.lock:
+            for filter in self.pages[self.current_page][button].filters:
+                if isinstance(filter[0], KeypressFilter):
+                    filter[0].active = active
+
+    def synchronize(self):
+        # Wait until the next cycle is complete.
+        # To *guarantee* that you have one complete pass, two waits are needed.
+        # The first gets you to the end of one cycle (you could have called it
+        # mid cycle). The second gets you one pass through. Worst case, you
+        # do two full cycles. Best case, you do 1 full and one partial.
+        self.sync.wait()
+        self.sync.wait()
+
+    def _run(self):
+        """Method that runs on background thread and updates the pipelines."""
+        frames = 0
+        start = time()
+        last_page = -1
+        execution_time = 0
+        frame_cache = {}
+
+        while not self.quit.isSet():
+            current_time = time()
+
+            with self.lock:
+                page = self.pages[self.current_page]
+
+            force_update = False
+
+            if last_page != page:
+                # When a page switch happen, force the pipelines to redraw so icons update
+                force_update = True
+                last_page = page
+
+            pipeline_cache_count = 0
+
+            for button, pipeline in page.items():
+                # Process all the steps in the pipeline and return the resulting image
+                with self.lock:
+                    image, hashcode = pipeline.execute(current_time)
+
+                pipeline_cache_count += len(pipeline.output_cache)
+
+                # If none of the filters in the pipeline yielded a change, use
+                # the last known result
+                if force_update and image is None:
+                    image = pipeline.last_result()
+
+                if image:
+                    # We cannot afford to do this conversion on every final frame.
+                    # Since we want the flexibilty of a pipeline engine that can mutate the
+                    # images along a chain of filters, the outcome can be somewhat unpredicatable
+                    # For example - a clock that changes time or an animation that changes
+                    # the frame and font that overlays. In many instances there is a finite
+                    # number of frames per pipeline (a looping GIF with image, a pulsing icon etc)
+                    # Some may also be virtually have infinite mutations. A cache per pipeline
+                    # with an eviction policy of the oldest would likely suffice.
+                    # The main problem is since the pipeline can mutate it's too expensive to
+                    # calculate the actual hash of the final frame.
+                    # Create a hash function that the filter itself defines. It has to
+                    # update the hashcode with the unique attributes of the input it requires
+                    # to make the frame. This could be time, text, frame number etc.
+                    # The hash can then be passed to the next step and XOR'd or combined
+                    # with the next hash. This yields a final hash code that can then be
+                    # used to cache the output. At the end of the pipeline the hash can
+                    # be checked and final bytes will be ready to pipe to the device.
+
+                    if self.streamdeck.is_visual():
+                        # FIXME: This will be unbounded, old frames will need to be evicted
+                        if hashcode not in frame_cache:
+                            image = PILHelper.to_native_format(self.streamdeck, image)
+                            frame_cache[hashcode] = image
+                        else:
+                            image = frame_cache[hashcode]
+
+                        try:
+                            with self.lock:
+                                self.streamdeck.set_key_image(button, image)
+                        except TransportError:
+                            # Review - deadlock if you wait on yourself?
+                            self.stop()
+                            pass
+                            return
+
+            self.sync.set()
+            self.sync.clear()
+            # Calculate how long we took to process the pipeline
+            elapsed_time = time() - current_time
+            execution_time += elapsed_time
+
+            # Calculate how much we have to sleep between processing cycles to maintain the desired FPS
+            # If we have less than 5ms left, don't bother sleeping, as the context switch and
+            # overhead of sleeping/waking up is consumed
+            time_left = self.time_per_frame - elapsed_time
+            if time_left > 0.005:
+                sleep(time_left)
+
+            frames += 1
+            if time() - start > 1.0:
+                execution_time_ms = int(execution_time * 1000)
+                if self.cpu_callback:
+                    self.cpu_callback(self.serial_number, int(execution_time_ms / 1000 * 100))
+                # execution_time_ms = int(execution_time * 1000)
+                # print(f"FPS: {frames} Execution time: {execution_time_ms} ms Execution %: {int(execution_time_ms/1000 * 100)}")
+                # print(f"Output cache size: {len(frame_cache)}")
+                # print(f"Pipeline cache size: {pipeline_cache_count}")
+                execution_time = 0
+                frames = 0
+                start = time()
+
+    def set_page(self, page: int):
+        """Switches to the given page. Pipelines for that page starts running,
+        other page pipelines stop.
+
+        Args:
+            page (int): The page number to switch to.
+        """
+        with self.lock:
+            if self.current_page >= 0:
+                # Ensure none of the button filters are active anymore
+                old_page = self.pages[self.current_page]
+                for _, pipeline in old_page.items():
+                    for filter in pipeline.filters:
+                        if isinstance(filter[0], KeypressFilter):
+                            filter[0].active = False
+            # REVIEW: We could detect the active key on the last page, and make it active
+            # on the target page
+            self.current_page = page
+
+    def start(self):
+        if self.pipeline_thread is not None:
+            self.quit.set()
+            try:
+                self.pipeline_thread.join()
+            except RuntimeError:
+                pass
+
+        self.quit.clear()
+        self.pipeline_thread = threading.Thread(target=self._run)
+        self.pipeline_thread.daemon = True
+        self.pipeline_thread.start()
+        self.synchronize()
+        # Wait for first frames to become ready
+
+    def stop(self):
+        if self.pipeline_thread is not None:
+            self.quit.set()
+            try:
+                self.pipeline_thread.join()
+            except RuntimeError:
+                pass
+            self.pipeline_thread = None

streamdeck_ui/display/empty_filter.py

@@ -0,0 +1,43 @@
+from fractions import Fraction
+from typing import Callable, Optional, Tuple
+
+from PIL import Image
+
+from streamdeck_ui.display import filter
+
+
+class EmptyFilter(filter.Filter):
+    """
+    This is the empty (base) filter where all pipelines start from.
+
+    :param str name: The name of the filter. The name is useful for debugging purposes.
+    """
+
+    def __init__(self):
+        super(EmptyFilter, self).__init__()
+
+        # For EmptyFilter - create a unique hashcode based on the name of the type
+        # This will create "some value" that uniquely identifies this filter output
+        # Since it never changes, this works.
+        # Calculate it once for speed
+        self.hashcode = hash(self.__class__)
+
+    def initialize(self, size: Tuple[int, int]):
+        self.image = Image.new("RGB", size)
+
+    def transform(  # type: ignore[override]
+        self,
+        get_input: Callable[[], Image.Image],
+        get_output: Callable[[int], Image.Image],
+        input_changed: bool,
+        time: Fraction,
+    ) -> Tuple[Optional[Image.Image], int]:
+        """
+        Returns an empty Image object.
+
+        :param Fraction time: The current time in seconds, expressed as a fractional number since
+        the start of the pipeline.
+        """
+        if not input_changed:
+            return (None, self.hashcode)
+        return ((self.image), self.hashcode)