Quickbend 1.0.0__tar.gz

quickbend-1.0.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: Quickbend
+Version: 1.0.0
+Summary: an app to create glitchart using pyside6
+Author-email: Daniel Crutti <dancrutti@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: audioop-lts==0.2.2
+Requires-Dist: numpy==2.4.6
+Requires-Dist: pillow==12.2.0
+Requires-Dist: PySide6==6.11.1
+Requires-Dist: PySide6_Addons==6.11.1
+Requires-Dist: PySide6_Essentials==6.11.1
+Requires-Dist: shiboken6==6.11.1
+
+# Quickbend
+
+**Quickbend** is a tool for creating art via databending with images. It uses interpreting bmp files as logarithmic audio encoding schemes (a-law/u-law/adpcm) and then reconverting those back to bmp to create warped and glitched images.

quickbend-1.0.0/README.md

@@ -0,0 +1,3 @@
+# Quickbend
+
+**Quickbend** is a tool for creating art via databending with images. It uses interpreting bmp files as logarithmic audio encoding schemes (a-law/u-law/adpcm) and then reconverting those back to bmp to create warped and glitched images.

quickbend-1.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "Quickbend"
+version = "1.0.0"
+description = "an app to create glitchart using pyside6"
+readme = "README.md"
+authors = [
+    { name = "Daniel Crutti", email = "dancrutti@gmail.com" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "audioop-lts==0.2.2",
+    "numpy==2.4.6",
+    "pillow==12.2.0",
+    "PySide6==6.11.1",
+    "PySide6_Addons==6.11.1",
+    "PySide6_Essentials==6.11.1",
+    "shiboken6==6.11.1"
+]
+
+[project.scripts]
+Quickbend = "Quickbend.app:main"

quickbend-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

quickbend-1.0.0/src/Quickbend/app.py

@@ -0,0 +1,152 @@
+import os
+import shutil
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QPixmap
+from PySide6.QtWidgets import (
+    QApplication,
+    QComboBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QMainWindow,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from .databend import databend
+from .files import browse_file, save_file
+
+cleanup_paths = []
+
+
+# main window
+class MainWindow(QMainWindow):
+    def __init__(self):
+        # main class
+        super().__init__()
+
+        self.setWindowTitle("My App")
+        layout = QVBoxLayout()
+
+        # button that opens file selection dialog
+        self.file_button = QPushButton("Get Files:")
+        self.file_button.clicked.connect(self.LoadNewImage)
+        layout.addWidget(self.file_button)
+
+        self.encoding_box = QComboBox()
+        self.encoding_box.addItems(["alaw", "ulaw", "adpcm"])
+        self.encoding_box_label = QLabel("Select Encoding:")
+        encoding_layout = QHBoxLayout()
+
+        encoding_layout.addWidget(self.encoding_box_label)
+        encoding_layout.addWidget(self.encoding_box, stretch=1)
+        layout.addLayout(encoding_layout)
+
+        self.xor_box = QComboBox()
+        self.xor_box.addItems(["Off", "On"])
+        self.xor_box_label = QLabel("Xor Mixing:")
+        xor_layout = QHBoxLayout()
+
+        xor_layout.addWidget(self.xor_box_label)
+        xor_layout.addWidget(self.xor_box, stretch=1)
+        layout.addLayout(xor_layout)
+
+        self.echo_time = QLineEdit()
+        self.echo_time.setPlaceholderText("Enter a Number (Decimals Accepted)")
+        self.echo_time.setInputMask("00.00;_")
+        self.echo_time_label = QLabel("Echo Time (Leave blank for no echo):")
+        echo_layout = QHBoxLayout()
+
+        echo_layout.addWidget(self.echo_time_label)
+        echo_layout.addWidget(self.echo_time, stretch=1)
+
+        layout.addLayout(echo_layout)
+
+        # image from file selection
+        self.image_preview = QLabel()
+        self.original_pixmap = QPixmap("placeholder.jpg")
+        layout.addWidget(self.image_preview)
+
+        save_button = QPushButton("export image")
+        save_button.clicked.connect(self.export_handler)
+        layout.addWidget(save_button)
+
+        # container to hold all widgets
+        container = QWidget()
+        container.setLayout(layout)
+
+        self.setCentralWidget(container)
+
+    # handles window resizes and keeps aspect ratio
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        scaled_pixmap = self.original_pixmap.scaled(
+            self.image_preview.size(),
+            Qt.AspectRatioMode.KeepAspectRatio,
+            Qt.TransformationMode.SmoothTransformation,
+        )
+        self.image_preview.setPixmap(scaled_pixmap)
+        self.image_preview.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
+    # loads image from file dialog into pixmap of QLabel
+    def LoadNewImage(self):
+        path = browse_file()
+        # gets paths for program cleanup later.
+        global cleanup_paths
+        cleanup_paths = path
+        if self.xor_box.currentText() == "On":
+            xor_flag = True
+        else:
+            xor_flag = False
+        if path:
+            try:
+                delay_time = float(self.echo_time.text())
+            except ValueError:
+                delay_time = 0
+            synced_files = databend(
+                path,
+                "/tmp/mash.bmp",
+                encoding=self.encoding_box.currentText(),
+                use_xor=xor_flag,
+                delay_time=delay_time,
+            )
+            if synced_files:
+                cleanup_paths.extend(synced_files)
+            self.original_pixmap = QPixmap("/tmp/mash.bmp")
+            scaled_pixmap = self.original_pixmap.scaled(
+                self.image_preview.size(),
+                Qt.AspectRatioMode.KeepAspectRatio,
+                Qt.TransformationMode.SmoothTransformation,
+            )
+            self.image_preview.setPixmap(scaled_pixmap)
+
+    def export_handler(self):
+        (save_file_path) = save_file()
+        if save_file_path:
+            shutil.move("/tmp/mash.bmp", save_file_path)
+
+
+def cleanup():
+    if os.path.exists("/tmp/mash.bmp"):
+        os.remove("/tmp/mash.bmp")
+    for file in cleanup_paths:
+        if os.path.exists(file):
+            os.remove(file)
+
+
+# open and show window
+def main():
+    global app, window
+    app = QApplication()
+
+    app.aboutToQuit.connect(cleanup)
+
+    window = MainWindow()
+    window.show()
+
+    app.exec()
+
+if __name__ == "__main__":
+    main()

quickbend-1.0.0/src/Quickbend/databend.py

@@ -0,0 +1,214 @@
+import argparse
+import audioop
+import os
+import struct
+
+import numpy as np
+from PIL import Image
+
+
+def databend(input_files, output_file, encoding="alaw", use_xor=False, delay_time=0.0):
+    if not input_files:
+        print("No input files provided.")
+        return []
+
+    # filter out non-existent files
+    valid_files = [f for f in input_files if os.path.exists(f)]
+    if not valid_files:
+        print("No valid input files found.")
+        return []
+
+    # get dimensions and areas to find the lowest resolution
+    file_dims = {}
+    min_area = float("inf")
+    target_w, target_h = None, None
+    target_file = None
+
+    for f in valid_files:
+        try:
+            with Image.open(f) as img:
+                w, h = img.size
+                area = w * h
+                file_dims[f] = (w, h, area)
+                if area < min_area:
+                    min_area = area
+                    target_w, target_h = w, h
+                    target_file = f
+        except Exception as e:
+            print(f"Error reading dimensions for {f}: {e}")
+            return []
+
+    # downscale higher resolution files to match the lowest resolution file
+    synced_files = []
+    created_synced_files = []  # array to track newly generated downscaled files
+
+    for f in valid_files:
+        w, h, area = file_dims[f]
+        if area > min_area:
+            synced_name = f"{os.path.splitext(f)[0]}_synced.bmp"
+            print(
+                f"Downscaling {f} ({w}x{h}) to match {target_file} ({target_w}x{target_h})..."
+            )
+            try:
+                with Image.open(f) as img:
+                    resized_img = img.resize(
+                        (target_w, target_h), Image.Resampling.LANCZOS
+                    )
+                    resized_img.save(synced_name, format="BMP")
+                synced_files.append(synced_name)
+                created_synced_files.append(synced_name)  # log the file path
+            except Exception as e:
+                print(f"Failed to resize {f}: {e}")
+                return []
+        else:
+            synced_files.append(f)
+
+    print(
+        f"Bending {len(synced_files)} BMP file(s) | Enc: {encoding.upper()} | XOR: {use_xor} | Echo: {delay_time}s"
+    )
+
+    # extract header from the first synced file
+    with open(synced_files[0], "rb") as f:
+        first_file_data = f.read()
+
+    pixel_offset = struct.unpack_from("<I", first_file_data, 10)[0]
+    header = bytearray(first_file_data[:pixel_offset])
+
+    target_byte_length = len(first_file_data) - pixel_offset
+
+    if encoding == "adpcm":
+        sample_multiplier = 2
+    else:
+        sample_multiplier = 1
+
+    target_sample_length = target_byte_length * sample_multiplier
+
+    # buffer for math
+    if use_xor:
+        mix_buffer = np.zeros(target_sample_length, dtype=np.int16)
+    else:
+        mix_buffer = np.zeros(target_sample_length, dtype=np.float32)
+
+    # where the real shit happens
+    for file in synced_files:
+        with open(file, "rb") as f:
+            data = f.read()
+            offset = struct.unpack_from("<I", data, 10)[0]
+            pixel_data = data[offset:]
+
+            if encoding == "ulaw":
+                pcm16_bytes = audioop.ulaw2lin(pixel_data, 2)
+            elif encoding == "adpcm":
+                pcm16_bytes, _ = audioop.adpcm2lin(pixel_data, 2, None)
+            else:
+                pcm16_bytes = audioop.alaw2lin(pixel_data, 2)
+
+            if use_xor:
+                audio_track = np.frombuffer(pcm16_bytes, dtype=np.int16)
+            else:
+                audio_track = np.frombuffer(pcm16_bytes, dtype=np.int16).astype(
+                    np.float32
+                )
+
+            if len(audio_track) > target_sample_length:
+                audio_track = audio_track[:target_sample_length]
+            elif len(audio_track) < target_sample_length:
+                if use_xor:
+                    padded = np.zeros(target_sample_length, dtype=np.int16)
+                else:
+                    padded = np.zeros(target_sample_length, dtype=np.float32)
+                padded[: len(audio_track)] = audio_track
+                audio_track = padded
+
+            if use_xor:
+                mix_buffer ^= audio_track
+            else:
+                mix_buffer += audio_track
+
+    # apply delay / echo
+    if delay_time > 0.0:
+        delay_samples = int(delay_time * 44100)
+        echo_track = np.roll(mix_buffer, delay_samples)
+
+        if use_xor:
+            mix_buffer ^= echo_track
+        else:
+            mix_buffer += echo_track * 0.5
+
+    # Prepare for export
+    if not use_xor:
+        mix_buffer = np.clip(mix_buffer, -32768.0, 32767.0)
+        mixed_pcm16_bytes = mix_buffer.astype(np.int16).tobytes()
+    else:
+        mixed_pcm16_bytes = mix_buffer.tobytes()
+
+    if encoding == "ulaw":
+        final_pixels = audioop.lin2ulaw(mixed_pcm16_bytes, 2)
+    elif encoding == "adpcm":
+        final_pixels, _ = audioop.lin2adpcm(mixed_pcm16_bytes, 2, None)
+    else:
+        final_pixels = audioop.lin2alaw(mixed_pcm16_bytes, 2)
+
+    # export
+    with open(output_file, "wb") as f:
+        f.write(header)
+        f.write(final_pixels[:target_byte_length])
+
+    print(f"Successfully bended: {output_file}")
+
+    # returns array of downscaled images to the caller app for deletion later
+    return created_synced_files
+
+
+# exec stuff
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Databend BMP files using audio algorithms."
+    )
+    parser.add_argument("images", nargs="+", help="Input BMP files")
+    parser.add_argument(
+        "-o",
+        "--output",
+        default="out/mash.bmp",
+        help="Output BMP file (default: out/mash.bmp)",
+    )
+    parser.add_argument("-u", "--ulaw", action="store_true", help="Use u-law encoding")
+    parser.add_argument("-a", "--adpcm", action="store_true", help="Use ADPCM encoding")
+    parser.add_argument(
+        "-x",
+        "--xor",
+        action="store_true",
+        help="Use Bitwise XOR mixing instead of additive",
+    )
+    parser.add_argument(
+        "-e", "--echo", action="store_true", help="Enable Delay/Echo effect"
+    )
+    parser.add_argument(
+        "-n",
+        "--delay_time",
+        type=float,
+        default=0.1,
+        help="Delay time in seconds for echo (default: 0.1)",
+    )
+
+    args = parser.parse_args()
+
+    encoding = "alaw"
+    if args.adpcm:
+        encoding = "adpcm"
+    elif args.ulaw:
+        encoding = "ulaw"
+
+    delay_to_pass = args.delay_time if args.echo else 0.0
+
+    output_dir = os.path.dirname(args.output)
+    if output_dir:
+        os.makedirs(output_dir, exist_ok=True)
+
+    databend(
+        args.images,
+        args.output,
+        encoding=encoding,
+        use_xor=args.xor,
+        delay_time=delay_to_pass,
+    )

quickbend-1.0.0/src/Quickbend/files.py

@@ -0,0 +1,33 @@
+import os
+
+from PIL import Image
+from PySide6.QtWidgets import QFileDialog
+
+
+def browse_file():
+    input_file_path, _ = QFileDialog.getOpenFileNames(
+        None, caption="Select bmp files", filter="Images (*.png *.jpg *.jpeg *.bmp)"
+    )
+
+    file_path = []
+    if input_file_path:
+        for paths in input_file_path:
+            imgbeforergb = Image.open(paths)
+            img = imgbeforergb.convert("RGB")
+            file_basename = os.path.basename(paths)
+            name, extension = os.path.splitext(file_basename)
+            bmp_filename = name + ".bmp"
+
+            output_path = os.path.join("/tmp", bmp_filename)
+
+            img.save(output_path)
+            file_path.append(output_path)
+        return file_path
+
+
+def save_file():
+    save_path, _ = QFileDialog.getSaveFileName(
+        parent=None, caption="Save file:", filter="Bitmap Files (*.bmp)"
+    )
+    if save_path:
+        return save_path

quickbend-1.0.0/src/Quickbend.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: Quickbend
+Version: 1.0.0
+Summary: an app to create glitchart using pyside6
+Author-email: Daniel Crutti <dancrutti@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: audioop-lts==0.2.2
+Requires-Dist: numpy==2.4.6
+Requires-Dist: pillow==12.2.0
+Requires-Dist: PySide6==6.11.1
+Requires-Dist: PySide6_Addons==6.11.1
+Requires-Dist: PySide6_Essentials==6.11.1
+Requires-Dist: shiboken6==6.11.1
+
+# Quickbend
+
+**Quickbend** is a tool for creating art via databending with images. It uses interpreting bmp files as logarithmic audio encoding schemes (a-law/u-law/adpcm) and then reconverting those back to bmp to create warped and glitched images.

quickbend-1.0.0/src/Quickbend.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+src/Quickbend/__init__.py
+src/Quickbend/app.py
+src/Quickbend/databend.py
+src/Quickbend/files.py
+src/Quickbend.egg-info/PKG-INFO
+src/Quickbend.egg-info/SOURCES.txt
+src/Quickbend.egg-info/dependency_links.txt
+src/Quickbend.egg-info/entry_points.txt
+src/Quickbend.egg-info/requires.txt
+src/Quickbend.egg-info/top_level.txt

quickbend-1.0.0/src/Quickbend.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

quickbend-1.0.0/src/Quickbend.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+Quickbend = Quickbend.app:main

quickbend-1.0.0/src/Quickbend.egg-info/requires.txt

@@ -0,0 +1,7 @@
+audioop-lts==0.2.2
+numpy==2.4.6
+pillow==12.2.0
+PySide6==6.11.1
+PySide6_Addons==6.11.1
+PySide6_Essentials==6.11.1
+shiboken6==6.11.1

quickbend-1.0.0/src/Quickbend.egg-info/top_level.txt

@@ -0,0 +1 @@
+Quickbend