PDASC 0.1.0__py3-none-any.whl

core/__init__.py

@@ -0,0 +1,10 @@
+from .ascii_converter import AsciiConverter
+from .ascii_displayer import AsciiDisplayer
+from .ascii_file_encoding import AsciiEncoder, AsciiDecoder
+from .audio_player import AudioPlayer
+from .generate_color_ramp import generate_color_ramp, get_charmap, render_charmap
+from .utils import pack_int24, unpack_int24, pack_int24_chunk, unpack_int24_array, format_file_size
+from .video_ascii_video import VideoAsciiConverter, process_video
+from .video_extractor import extract_video
+
+__all__ = ["AsciiConverter", "AsciiDisplayer", "AsciiEncoder", "AsciiDecoder", "AudioPlayer", "generate_color_ramp", "get_charmap", "render_charmap", "pack_int24", "unpack_int24", "pack_int24_chunk", "unpack_int24_array", "format_file_size", "VideoAsciiConverter", "process_video", "extract_video"]

core/ascii_converter.py

@@ -0,0 +1,111 @@
+from PIL import Image
+import numpy as np
+from .generate_color_ramp import generate_color_ramp, get_charmap
+from numba import njit, prange
+
+@njit(parallel=True, fastmath=True, cache=True)
+def compute_blocks(img: np.ndarray, cs: int, gray_levels: int, color: bool):
+    h, w, _ = img.shape
+    bh, bw = h // cs, w // cs
+
+    char_idx = np.empty((bh, bw), np.int32)
+    colors = np.empty((bh, bw), np.uint32)  # Always allocate
+
+    inv_area = 1.0 / (cs * cs)
+
+    for by in prange(bh):
+        for bx in range(bw):
+            r = g = b = 0.0
+            
+            if color:
+                for y in range(cs):
+                    for x in range(cs):
+                        px = img[by*cs + y, bx*cs + x]
+                        r += px[0]
+                        g += px[1]
+                        b += px[2]
+
+                r *= inv_area
+                g *= inv_area
+                b *= inv_area
+            else:
+                # compute grayscale
+                for y in range(cs):
+                    for x in range(cs):
+                        px = img[by*cs + y, bx*cs + x]
+                        r += px[0]
+                        g += px[1]
+                        b += px[2]
+
+                r *= inv_area
+                g *= inv_area
+                b *= inv_area
+
+            # Grayscale -> char index
+            lum = 0.2126*r + 0.7152*g + 0.0722*b
+            gi = int(lum * gray_levels)
+            if gi >= gray_levels:
+                gi = gray_levels - 1
+            char_idx[by, bx] = gi
+            
+            if color:
+                # Convert to 8-bit RGB
+                ri = np.uint32(r * 255.0)
+                gi_color = np.uint32(g * 255.0)
+                bi = np.uint32(b * 255.0)
+
+                # Pack RGB -> 0xRRGGBB
+                colors[by, bx] = (ri << 16) | (gi_color << 8) | bi
+            else:
+                colors[by, bx] = 0  # Dummy value when no color
+    
+    return char_idx, colors
+
+class AsciiConverter:
+    def __init__(self, num_ascii: int = 8, chunk_size: int = 8, font_path: str = "CascadiaMono.ttf"):
+        self.font_path = font_path
+        self.chunk_size: int = chunk_size
+        self.char_map = get_charmap(generate_color_ramp(font_path=self.font_path), num_ascii)
+        self.num_ascii: int = min(num_ascii, len(self.char_map))
+    
+    def regen_charmap(self):
+        self.char_map = get_charmap(generate_color_ramp(font_path=self.font_path), self.num_ascii)
+    
+    def quantize_grayscale(self, image: Image.Image) -> Image.Image:
+        img_data = np.array(image, dtype=np.float32) / 255.0
+        height, width, channels = img_data.shape
+        out_data = np.zeros_like(img_data)
+        
+        for y in range(height):
+            for x in range(width):
+                in_pix = img_data[y, x]
+                gray = sum([0.2126 * in_pix[0], 0.7152 * in_pix[1], 0.0722 * in_pix[2]])
+                quantized = np.floor(gray * self.num_ascii) / (self.num_ascii - 1)
+                out_data[y, x] = [quantized, quantized, quantized]
+        
+        out_data = (out_data * 255).astype(np.uint8)
+        
+        return Image.fromarray(out_data, "RGB")
+    
+    def get_ascii(self, image: Image.Image, color: bool = True) -> np.ndarray:
+        img = np.asarray(image, dtype=np.float32) / 255.0
+        cs = self.chunk_size
+
+        char_idx, colors = compute_blocks(
+            img,
+            cs,
+            self.num_ascii,
+            color
+        )
+
+        # map char indices to chars
+        char_map_arr = np.array(list(self.char_map), dtype='<U1')
+        chars = char_map_arr[char_idx]
+
+        # Structured array
+        dtype = np.dtype([('char', '<U1'), ('color', np.uint32)])
+        out = np.empty(chars.shape, dtype=dtype)
+        out['char'] = chars
+        out['color'] = colors if color else np.zeros_like(colors, dtype=np.uint32)
+
+        return out

core/ascii_displayer.py

@@ -0,0 +1,317 @@
+from PIL import Image
+import numpy as np
+import time
+import sys
+import signal
+import atexit
+from .ascii_converter import AsciiConverter
+from .utils import unpack_int24_array
+from .audio_player import AudioPlayer
+from .ascii_file_encoding import AsciiDecoder
+
+class AsciiDisplayer:
+    def __init__(self, converter: AsciiConverter, debug: bool = False):
+        self.converter: AsciiConverter = converter
+        self._cleanup_done = False
+        self.debug = debug
+
+    def color_text(self, text: str, r: int, g: int, b: int):
+        r = max(min(r, 255), 0)
+        g = max(min(g, 255), 0)
+        b = max(min(b, 255), 0)
+        return f"\033[38;2;{r};{g};{b}m{text}"
+
+    def render_ascii(self, ascii_array: np.ndarray, colored: bool):
+        """
+        Render a structured ASCII array to a colored string for terminal.
+        
+        ascii_array: np.ndarray with dtype [('char','<U1'),('color',np.uint32)]
+        
+        Returns: str with ANSI color codes (or plain text if not colored)
+        """
+
+        lines = []
+        if colored:
+            for row in ascii_array:
+                chars = np.char.multiply(row['char'], 2)
+                r, g, b = unpack_int24_array(row['color'])
+                line = ""
+                last_color = None
+                for ch, ri, gi, bi in zip(chars, r, g, b):
+                    color = (ri, gi, bi)
+                    if color != last_color:
+                        line += f"\033[38;2;{ri};{gi};{bi}m"
+                        last_color = color
+                    line += ch
+                lines.append(line)
+            return "\033[1;40m" + "\n".join(lines) + "\033[0m" # set background black and bold at start and reset everything at end
+        else:
+            for row in ascii_array:
+                chars = np.char.multiply(row['char'], 2)
+                line = "".join(chars)
+                lines.append(line)
+            return "\n".join(lines)
+    
+    def render_image(self, image: Image.Image, color: bool = True):
+        ascii = self.converter.get_ascii(image, color)
+        frame = self.render_ascii(ascii, color)
+        sys.stdout.write(f"\033[H{frame}")
+        sys.stdout.flush()
+    
+    def _cleanup_terminal(self):
+        """Restore terminal to normal state"""
+        if not self._cleanup_done:
+            self._cleanup_done = True
+            # Disable signal handlers during cleanup to prevent interruption
+            signal.signal(signal.SIGINT, signal.SIG_IGN)
+            signal.signal(signal.SIGTERM, signal.SIG_IGN)
+            
+            # Write cleanup sequences atomically
+            try:
+                cleanup_seq = "\033[0m\033[?25h\033[?1049l" # reset style, show cursor, old buffer
+                sys.stdout.write(cleanup_seq)
+                sys.stdout.flush()
+            except:
+                # If stdout fails, try stderr as fallback
+                try:
+                    sys.stderr.write(cleanup_seq)
+                    sys.stderr.flush()
+                except:
+                    pass
+            
+            # Force terminal back to sane state using stty for linux
+            import subprocess
+            try:
+                subprocess.run(['stty', 'echo', 'icanon'], 
+                             stdin=sys.stdin, 
+                             stdout=subprocess.DEVNULL,
+                             stderr=subprocess.DEVNULL,
+                             timeout=0.5)
+            except:
+                pass
+    
+    def _setup_terminal(self):
+        """Setup terminal and ensure cleanup happens"""
+        print("\033[?1049h\033[?25l\033[H\033[2J", end="") # seperate buffer, hide cursor, move cursor home, clear
+        sys.stdout.flush()
+        
+        self._cleanup_done = False
+        
+        # Multiple layers of protection
+        atexit.register(self._cleanup_terminal)
+        
+        def signal_handler(sig, frame):
+            self._cleanup_terminal()
+            # Force exit without further exception handling
+            import os
+            os._exit(0)
+        
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+    
+    def display_image(self, image: Image.Image, color: bool = True):
+        import shutil
+        
+        self._setup_terminal()
+        
+        try:
+            term_cols, term_rows = shutil.get_terminal_size()
+            
+            img_width, img_height = image.size
+            chars_wide = img_width // self.converter.chunk_size
+            chars_tall = img_height // self.converter.chunk_size
+            
+            needed_cols = chars_wide * 2
+            needed_rows = chars_tall
+            
+            # Scale down if image would be larger than terminal because would cut off
+            if needed_cols > term_cols or needed_rows > (term_rows - 2):
+                scale_factor = min(
+                    term_cols / needed_cols,
+                    (term_rows - 2) / needed_rows
+                )
+                new_width = int(img_width * scale_factor)
+                new_height = int(img_height * scale_factor)
+                image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+            
+            self.render_image(image, color)
+            input()
+        finally:
+            self._cleanup_terminal()
+
+    def display_video(self, video_path: str, play_audio: bool = True, color: bool = True):
+        from core.video_extractor import extract_video
+
+        self._setup_terminal()
+        
+        player = None
+        
+        try:
+            fps, frame_gen, audio_gen = extract_video(video_path)
+            
+            if play_audio and audio_gen is not None:
+                player = AudioPlayer(audio_gen)
+                player.start()
+            
+            frame_time = 1.0 / fps
+            start_time = time.time()
+            frame_idx = 0
+            
+            for frame in frame_gen:
+                elapsed = time.time() - start_time
+                target_frame = int(elapsed * fps)
+                
+                frame_idx += 1
+                
+                # Skip frame if behind
+                if frame_idx - 1 < target_frame:
+                    continue
+                
+                self.render_image(frame, color)
+                
+                if self.debug:
+                    current_time = time.time()
+                    actual_fps = frame_idx / (current_time - start_time)
+                    sys.stdout.write(f"\n\033[2KFPS: {round(actual_fps)}")
+                    sys.stdout.flush()
+                
+                # Sleep if extra time to cap fps to video frame rate
+                target_time = start_time + frame_idx * frame_time
+                sleep_time = target_time - time.time()
+                if sleep_time > 0:
+                    time.sleep(sleep_time)
+        
+        except KeyboardInterrupt:
+            pass  # Handle Ctrl+C gracefully
+                    
+        finally:
+            if player:
+                try:
+                    player.stop()
+                except:
+                    pass
+            self._cleanup_terminal()
+    
+    def display_asc_file(self, asc_path: str, play_audio: bool = True):
+        """Display a pre-encoded .asc file - BLAZING FAST!"""
+        decoder = AsciiDecoder()
+        decoder.read(asc_path)
+        
+        self._setup_terminal()
+        
+        player = None
+        
+        try:
+            if play_audio and decoder.has_audio and decoder.audio_data:
+                def audio_gen():
+                    if decoder.audio_data:
+                        chunk_size = decoder.audio_rate * 2 * decoder.audio_channels
+                        for i in range(0, len(decoder.audio_data), chunk_size):
+                            chunk = decoder.audio_data[i:i+chunk_size]
+                            valid_size = (len(chunk) // 4) * 4
+                            if valid_size > 0:
+                                audio_np = np.frombuffer(chunk[:valid_size], dtype=np.int16).reshape(-1, decoder.audio_channels)
+                                yield audio_np
+                
+                player = AudioPlayer(audio_gen(), samplerate=decoder.audio_rate, channels=decoder.audio_channels)
+                player.start()
+            
+            if decoder.is_video:
+                # Video playback - just write pre-rendered strings!
+                frame_time = 1.0 / decoder.fps
+                start_time = time.time()
+                
+                for frame_idx, frame_str in enumerate(decoder.frames):
+                    elapsed = time.time() - start_time
+                    target_frame = int(elapsed * decoder.fps)
+                    
+                    # Skip frame if behind
+                    if frame_idx < target_frame:
+                        continue
+                    
+                    sys.stdout.write(f"\033[H{frame_str}")
+                    sys.stdout.flush()
+                    
+                    # Sleep to maintain frame rate
+                    target_time = start_time + (frame_idx + 1) * frame_time
+                    sleep_time = target_time - time.time()
+                    if sleep_time > 0:
+                        time.sleep(sleep_time)
+            else:
+                sys.stdout.write(f"\033[H{decoder.frames[0]}")
+                sys.stdout.flush()
+                input()
+        
+        except KeyboardInterrupt:
+            pass
+        
+        finally:
+            if player and player.stream:
+                player.stream.stop()
+                player.stream.close()
+            self._cleanup_terminal()
+            
+    def display_camera(self, camera_index: int = 0, color: bool = True):
+        """Display live camera feed as ASCII art"""
+        import cv2
+        import os
+        
+        # Suppress OpenCV errors temporarily
+        devnull = open(os.devnull, 'w')
+        old_stderr = os.dup(2)
+        os.dup2(devnull.fileno(), 2)
+        
+        try:
+            # Try to open camera before setting up terminal for better errors
+            cap = cv2.VideoCapture(camera_index)
+            
+            # read test frame
+            ret, test_frame = cap.read()
+        finally:
+            # Restore stderr
+            os.dup2(old_stderr, 2)
+            os.close(old_stderr)
+            devnull.close()
+        
+        if not ret or test_frame is None:
+            cap.release()
+            print(f"Error: Could not open camera {camera_index}")
+            print("Make sure a camera is connected and is available")
+            return
+        
+        self._setup_terminal()
+        
+        # Get camera FPS (default 30)
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        if fps == 0 or fps > 60:
+            fps = 30
+        
+        frame_time = 1.0 / fps
+        
+        try:
+            last_time = time.time()
+            
+            while True:
+                ret, frame = cap.read()
+                
+                if not ret:
+                    break
+                
+                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                
+                image = Image.fromarray(frame_rgb)
+                
+                self.render_image(image, color)
+                
+                elapsed = time.time() - last_time
+                sleep_time = frame_time - elapsed
+                if sleep_time > 0:
+                    time.sleep(sleep_time)
+                last_time = time.time()
+        
+        except KeyboardInterrupt:
+            pass  # Handle Ctrl+C gracefully
+                
+        finally:
+            cap.release()
+            self._cleanup_terminal()

core/ascii_file_encoding.py

@@ -0,0 +1,258 @@
+import struct
+import os
+from .utils import format_file_size
+from typing import List
+import zstandard as zstd
+
+class AsciiEncoder:
+    """Encoder for .asc (ASCII Container) file format - stores pre-rendered ANSI strings"""
+    
+    MAGIC = b'ASII'
+    VERSION = 2
+    
+    # Flag bits
+    FLAG_IS_VIDEO = 1 << 0
+    FLAG_HAS_AUDIO = 1 << 1
+    
+    def __init__(self):
+        self.frames: list[str] = []  # Store actual ANSI strings
+        self.fps: float = 30.0
+        self.has_audio: bool = False
+        self.audio_data = None
+        self.audio_rate: int = 44100
+        self.audio_channels: int = 2
+    
+    def add_rendered_frame(self, ansi_string: str):
+        """
+        Add a pre-rendered frame
+        
+        Args:
+            ansi_string: Complete ANSI string ready to display
+        """
+        self.frames.append(ansi_string)
+    
+    def set_audio(self, audio_data: bytes, sample_rate: int = 44100, channels: int = 2):
+        """Set audio data (raw PCM16)"""
+        self.has_audio = True
+        self.audio_data = audio_data
+        self.audio_rate = sample_rate
+        self.audio_channels = channels
+    
+    def write(self, output_path: str):
+        """Write encoded data to file"""
+        if not self.frames:
+            raise ValueError("No frames added")
+        
+        with open(output_path, 'wb') as f:
+            flags = 0
+            is_video = len(self.frames) > 1
+            
+            if is_video:
+                flags |= self.FLAG_IS_VIDEO
+            if self.has_audio:
+                flags |= self.FLAG_HAS_AUDIO
+            
+            # Write header (24 bytes)
+            header = struct.pack(
+                '!4sHHfI8s',
+                self.MAGIC,                 # Magic number (4 bytes)
+                self.VERSION,               # Version (2 bytes)
+                flags,                      # Flags (2 bytes)
+                self.fps,                   # FPS (4 bytes)
+                len(self.frames),  # Frame count (4 bytes)
+                b'\x00' * 8                 # Reserved (8 bytes)
+            )
+            
+            f.write(header)
+
+            frame_bytes = [frame.encode("utf-8") for frame in self.frames]
+            frame_lengths = [len(b) for b in frame_bytes]
+            all_frames_bytes = b"".join(frame_bytes)
+
+            print("Compressing")
+            cctx = zstd.ZstdCompressor(level=5)
+            compressed = cctx.compress(all_frames_bytes)
+            
+            print("Writing")
+            for l in frame_lengths:
+                f.write(struct.pack("!I", l))
+
+            # write compressed blob
+            f.write(struct.pack("!I", len(compressed)))
+            f.write(compressed)
+            
+            # Write audio if present
+            if self.has_audio and self.audio_data:
+                audio_header = struct.pack(
+                    '!IBI',
+                    len(self.audio_data),  # Audio data size
+                    1,                     # Audio format (1 = PCM16)
+                    self.audio_rate,       # Sample rate
+                )
+                f.write(audio_header)
+                f.write(struct.pack('!B', self.audio_channels))
+                f.write(self.audio_data)
+    
+    def encode_image_to_asc(self, image_path: str, output_path: str, color: bool = True, converter=None, displayer=None):
+        """Encode a single image to .asc format"""
+        from PIL import Image
+        
+        if not converter or not displayer:
+            from .ascii_converter import AsciiConverter
+            from .ascii_displayer import AsciiDisplayer
+            converter = converter or AsciiConverter()
+            displayer = displayer or AsciiDisplayer(converter)
+        
+        # Load and convert image
+        image = Image.open(image_path)
+        ascii_array = converter.get_ascii(image, color)
+        
+        # Render to ANSI string
+        ansi_string = displayer.render_ascii(ascii_array, color)
+        
+        self.fps = 1.0
+        self.add_rendered_frame(ansi_string)
+        self.write(output_path)
+        
+        print(f"Encoded image to {output_path}")
+        print(f"File size: {format_file_size(os.path.getsize(output_path))}")
+    
+    def encode_video_to_asc(self, video_path: str, output_path: str, 
+                           play_audio: bool = True, color: bool = True, 
+                           converter=None, displayer=None):
+        """Encode a video to .asc format"""
+        from core.video_extractor import extract_video
+        import threading
+        
+        if not converter:
+            from .ascii_converter import AsciiConverter
+            converter = converter or AsciiConverter()
+        if not displayer:
+            from .ascii_displayer import AsciiDisplayer
+            displayer = displayer or AsciiDisplayer(converter)
+        
+        print(f"Encoding {video_path}...")
+        
+        # Extract video
+        fps, frame_gen, audio_gen = extract_video(video_path)
+        self.fps = fps
+        
+        # Collect audio in background
+        audio_chunks = []
+        audio_thread = None
+        
+        if play_audio and audio_gen is not None:
+            def collect_audio():
+                for chunk in audio_gen:
+                    audio_chunks.append(chunk.tobytes())
+            
+            audio_thread = threading.Thread(target=collect_audio, daemon=True)
+            audio_thread.start()
+        
+        # Encode frames
+        frame_count = 0
+        try:
+            for frame in frame_gen:
+                # Convert to ASCII and render to ANSI string
+                ascii_array = converter.get_ascii(frame, color)
+                ansi_string = displayer.render_ascii(ascii_array, color)
+                
+                self.add_rendered_frame(ansi_string)
+                frame_count += 1
+                
+                if frame_count % 30 == 0:
+                    print(f"Encoded {frame_count} frames...", end='\r')
+            
+            print(f"\nEncoded {frame_count} frames total")
+            
+            # Wait for audio
+            if audio_thread:
+                audio_thread.join(timeout=5.0)
+                
+                if audio_chunks:
+                    audio_data = b''.join(audio_chunks)
+                    self.set_audio(audio_data)
+                    print(f"Added {format_file_size(len(audio_data))} of audio")
+            
+            self.write(output_path)
+            
+            file_size = os.path.getsize(output_path)
+            print(f"Saved to {output_path}")
+            print(f"File size: {format_file_size(file_size)}")
+            
+        except Exception as e:
+            print(f"\nError during encoding: {e}")
+            raise
+
+
+class AsciiDecoder:
+    """Decoder for .asc (ASCII Container) file format - reads pre-rendered frames"""
+    
+    def __init__(self):
+        self.fps = 0.0
+        self.has_audio = False
+        self.is_video = False
+        self.frames = []  # Pre-rendered ANSI strings
+        self.audio_data = None
+        self.audio_rate = 44100
+        self.audio_channels = 2
+    
+    def read(self, input_path: str):
+        """Read and decode .asc file with block-compressed frames"""
+        with open(input_path, 'rb') as f:
+            # Read header (24 bytes)
+            header_data = f.read(24)
+            if len(header_data) < 24:
+                raise ValueError("Invalid file: header too short")
+            
+            magic, version, flags, fps, frame_count, reserved = struct.unpack('!4sHHfI8s', header_data)
+            
+            if magic != b'ASII':
+                raise ValueError(f"Invalid file format: expected 'ASII', got {magic}")
+            
+            if version != 2:
+                raise ValueError(f"Unsupported version: {version}")
+            
+            # Parse flags
+            self.is_video = bool(flags & AsciiEncoder.FLAG_IS_VIDEO)
+            self.has_audio = bool(flags & AsciiEncoder.FLAG_HAS_AUDIO)
+            self.fps = fps
+            
+            frame_lengths = [
+                struct.unpack("!I", f.read(4))[0]
+                for _ in range(frame_count)
+            ]
+
+            compressed_size = struct.unpack("!I", f.read(4))[0]
+            compressed = f.read(compressed_size)
+
+            print("Decompressing")
+            dctx = zstd.ZstdDecompressor()
+            all_frames_bytes = dctx.decompress(compressed)
+            print("Done decompressing")
+            
+            self.frames = []
+            idx = 0
+            for length in frame_lengths:
+                frame_bytes = all_frames_bytes[idx:idx+length]
+                self.frames.append(frame_bytes.decode('utf-8'))
+                idx += length
+            
+            if self.has_audio:
+                audio_size, audio_format, self.audio_rate = struct.unpack('!IBI', f.read(9))
+                self.audio_channels = struct.unpack('!B', f.read(1))[0]
+                
+                if audio_format != 1:
+                    raise ValueError(f"Unsupported audio format: {audio_format}")
+                
+                self.audio_data = f.read(audio_size)
+    
+    def get_frame(self, index: int) -> str:
+        """Get a pre-rendered frame by index"""
+        if index < 0 or index >= len(self.frames):
+            raise IndexError(f"Frame index {index} out of range")
+        return self.frames[index]
+    
+    def get_all_frames(self) -> List[str]:
+        """Get all pre-rendered frames"""
+        return self.frames