PDASC 0.1.0__py3-none-any.whl

core/audio_player.py

@@ -0,0 +1,150 @@
+import pyaudio
+import threading
+import numpy as np
+import warnings
+from typing import Generator
+
+class AudioPlayer:
+    def __init__(self, audio_gen: Generator[np.ndarray, None, None],
+                 samplerate=44100, channels=2, blocksize=1024,
+                 enable_audio=True):
+        self.audio_gen = audio_gen
+        self.samplerate = samplerate
+        self.channels = channels
+        self.blocksize = blocksize
+        self.buffer = np.empty((0, channels), dtype=np.float32)
+        self.lock = threading.Lock()
+        self.done = False
+        self.stream = None
+        self.feed_thread = None
+        self.stopped = False
+        self.enable_audio = enable_audio
+        self.p = None
+
+    def _check_audio_available(self):
+        """Quick check if audio is available - full init happens in start()"""
+        try:
+            # Just do a minimal check - don't enumerate all devices
+            p = pyaudio.PyAudio()
+            # Quick check: just verify we can get default output device
+            try:
+                default_output = p.get_default_output_device_info()
+                has_output = int(default_output['maxOutputChannels']) > 0
+            except Exception:
+                has_output = False
+            
+            p.terminate()
+            
+            if not has_output:
+                warnings.warn("Audio disabled: no output devices found")
+                return False
+            
+            return True
+            
+        except Exception as e:
+            warnings.warn(f"Audio disabled: {e}")
+            return False
+
+    def callback(self, in_data, frame_count, time_info, status):
+        """PyAudio callback function"""
+        with self.lock:
+            if len(self.buffer) >= frame_count:
+                data = self.buffer[:frame_count]
+                self.buffer = self.buffer[frame_count:]
+            else:
+                # Not enough data, pad with zeros
+                data = np.zeros((frame_count, self.channels), dtype=np.float32)
+                if len(self.buffer) > 0:
+                    data[:len(self.buffer)] = self.buffer
+                    self.buffer = np.empty((0, self.channels), dtype=np.float32)
+        
+        return (data.tobytes(), pyaudio.paContinue)
+
+    def start(self):
+        if not self.enable_audio:
+            self._start_silent_consumer()
+            return
+
+        try:
+            self.p = pyaudio.PyAudio()
+            self.stream = self.p.open(
+                format=pyaudio.paFloat32,
+                channels=self.channels,
+                rate=self.samplerate,
+                output=True,
+                frames_per_buffer=self.blocksize,
+                stream_callback=self.callback
+            )
+            self.stream.start_stream()
+        except Exception as e:
+            warnings.warn(f"Could not start audio stream: {e}")
+            self.enable_audio = False
+            if self.p:
+                self.p.terminate()
+                self.p = None
+            self._start_silent_consumer()
+            return
+
+        def feed():
+            try:
+                for chunk in self.audio_gen:
+                    if self.stopped:
+                        break
+                    if not isinstance(chunk, np.ndarray):
+                        chunk = np.array(chunk, dtype=np.float32)
+                    if chunk.dtype != np.float32:
+                        chunk = chunk.astype(np.float32) / 32768.0
+                    if chunk.ndim == 1 and self.channels == 2:
+                        chunk = np.stack([chunk, chunk], axis=-1)
+                    elif chunk.ndim == 2 and chunk.shape[1] != self.channels:
+                        if chunk.shape[1] == 1:
+                            chunk = np.repeat(chunk, self.channels, axis=1)
+                        else:
+                            warnings.warn("Audio chunk channel mismatch; skipping")
+                            continue
+                    with self.lock:
+                        self.buffer = np.concatenate([self.buffer, chunk])
+            except Exception as e:
+                warnings.warn(f"Audio feed thread exception: {e}")
+            finally:
+                self.done = True
+
+        self.feed_thread = threading.Thread(target=feed, daemon=True)
+        self.feed_thread.start()
+
+    def _start_silent_consumer(self):
+        """Consume generator without audio output"""
+        def feed_silent():
+            try:
+                for _ in self.audio_gen:
+                    if self.stopped:
+                        break
+            except Exception as e:
+                warnings.warn(f"Audio generator exception: {e}")
+            finally:
+                self.done = True
+        
+        self.feed_thread = threading.Thread(target=feed_silent, daemon=True)
+        self.feed_thread.start()
+    
+    def stop(self):
+        self.stopped = True
+        if self.feed_thread and self.feed_thread.is_alive():
+            self.feed_thread.join(timeout=0.5)
+        if self.stream:
+            try:
+                import time
+                time.sleep(0.1)
+                if self.stream.is_active():
+                    self.stream.stop_stream()
+                time.sleep(0.05)
+                self.stream.close()
+            except Exception:
+                pass
+            self.stream = None
+        if self.p:
+            try:
+                self.p.terminate()
+            except Exception:
+                pass
+            self.p = None

core/generate_color_ramp.py

@@ -0,0 +1,69 @@
+from PIL import Image, ImageDraw, ImageFont
+import numpy as np
+import os
+
+def generate_color_ramp(font_size: int = 32, image_size: int = 48, font_path: str = "CascadiaMono.ttf", chars: list[str] = [chr(i) for i in range(32, 127)]):
+    if not os.path.exists(font_path):
+        raise FileNotFoundError(f"Font not found at {font_path}")
+    
+    font = ImageFont.truetype(font_path, font_size)
+    results = []
+    
+    for char in chars:
+        img = Image.new("L", (image_size, image_size), 255)
+        draw = ImageDraw.Draw(img)
+        
+        draw.text((0, 0), char, fill=0, font=font)
+        
+        img_data = np.asarray(img, dtype=np.float32) / 255.0
+        total_luminance = img_data.mean()
+        
+        results.append((char, total_luminance))
+    
+    lums = [lum for _, lum in results]
+    min_lum = min(lums)
+    max_lum = max(lums)
+
+    # Normalize 1-0
+    results = [
+        (char, 1.0 - (lum - min_lum) / (max_lum - min_lum))
+        for char, lum in results
+    ]
+
+    return results
+
+def get_charmap(color_ramp: list[tuple[str, float]], levels: int = 8):
+    if levels < 2:
+        raise ValueError("levels must be >= 2")
+    
+    if levels >= len(color_ramp):
+        color_ramp.sort(key=lambda x: x[1])
+        return "".join([char[0] for char in color_ramp])
+    
+    quantized_values = [i/levels for i in range(levels + 1)]
+    
+    out_ramp = []
+    for value in quantized_values:
+        best_char = (color_ramp[0][0], abs(color_ramp[0][1] - value))
+        for char, lum in color_ramp:
+            distance = abs(value - lum)
+            if distance < best_char[1] and char not in out_ramp:
+                best_char = (char, distance)
+        out_ramp.append(best_char[0])
+    return "".join(out_ramp)
+
+def render_charmap(charmap: str, font_path="font8x8.ttf", font_size=8, padding=0):
+    char_width = font_size
+    char_height = font_size
+    w = len(charmap) * (char_width + padding)
+    h = char_height + 2 * padding
+
+    img = Image.new("L", (w, h), 0)  # black background
+    draw = ImageDraw.Draw(img)
+    font = ImageFont.truetype(font_path, font_size)
+
+    for i, ch in enumerate(charmap):
+        x = i * (char_width + padding) + padding
+        y = padding
+        draw.text((x, y), ch, fill=255, font=font)
+    return img

core/utils.py

@@ -0,0 +1,26 @@
+import numpy as np
+
+def pack_int24(color: tuple[int, int, int]) -> int:
+    return (color[0] << 16) | (color[1] << 8) | color[2]
+
+def unpack_int24(packed: int) -> tuple[int, int, int]:
+    return ((packed >> 16) & 0xFF, (packed >> 8) & 0xFF, packed & 0xFF)
+
+def pack_int24_chunk(rgb: np.ndarray) -> np.ndarray:
+    r = rgb[..., 0].astype(np.uint32)
+    g = rgb[..., 1].astype(np.uint32)
+    b = rgb[..., 2].astype(np.uint32)
+    return (r << 16) | (g << 8) | b
+
+def unpack_int24_array(colors : np.ndarray):
+    r = (colors >> 16) & 0xFF
+    g = (colors >> 8) & 0xFF
+    b = colors & 0xFF
+    return r, g, b
+
+def format_file_size(size_bytes: float) -> str:
+    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.2f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.2f} PB"

core/video_ascii_video.py

@@ -0,0 +1,220 @@
+from PIL import Image
+import moderngl
+import numpy as np
+from .generate_color_ramp import generate_color_ramp, get_charmap, render_charmap
+from .video_extractor import extract_video
+import time
+import subprocess
+import os
+
+class VideoAsciiConverter:
+    def __init__(self, fragment_shader_src: str, ascii_img: Image.Image, colored: bool = True):
+        self.colored = colored
+        
+        self.ctx = moderngl.create_standalone_context()
+
+        vertices = np.array(
+            [-1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0],
+            dtype="f4",
+        )
+
+        vertex_shader = """
+            #version 330
+            in vec2 in_vert;
+            out vec2 uv;
+            void main() {
+                uv = in_vert * 0.5 + 0.5;
+                gl_Position = vec4(in_vert, 0.0, 1.0);
+            }
+        """
+
+        self.prog = self.ctx.program(
+            vertex_shader=vertex_shader, fragment_shader=fragment_shader_src
+        )
+        
+        self.prog["colored"] = self.colored
+        
+        width, height = ascii_img.size
+        ascii_img_data = ascii_img.tobytes()
+        self.ascii_tex = self.ctx.texture((width, height), 1, ascii_img_data)
+        self.ascii_tex.filter = (moderngl.NEAREST, moderngl.NEAREST)
+        self.ascii_tex.use(1)
+        self.prog["ascii_map"] = 1
+        
+        self.vbo = self.ctx.buffer(vertices.tobytes())
+        self.vao = self.ctx.simple_vertex_array(self.prog, self.vbo, "in_vert")
+        
+        # Pre-allocate reusable resources
+        self.current_texture = None
+        self.current_framebuffer = None
+        self.current_size = None
+
+    def _ensure_resources(self, width, height):
+        """Reuse texture and framebuffer if size matches"""
+        if self.current_size != (width, height):
+            # Release old resources
+            if self.current_texture:
+                self.current_texture.release()
+            if self.current_framebuffer:
+                self.current_framebuffer.release()
+            
+            # Create new ones
+            self.current_texture = self.ctx.texture((width, height), 4)
+            self.current_framebuffer = self.ctx.simple_framebuffer((width, height))
+            self.current_size = (width, height)
+
+    def process_frame(self, image: Image.Image):
+        try:
+            # Avoid conversion if already RGBA
+            if image.mode != "RGBA":
+                img = image.convert("RGBA")
+            else:
+                img = image
+                
+            input_width, input_height = img.size
+            
+            # Reuse texture and framebuffer
+            self._ensure_resources(input_width, input_height)
+            
+            if not self.current_texture or not self.current_framebuffer:
+                raise ValueError("Failed to create texture and framebuffer")
+            
+            # Write directly to existing texture instead of creating new one
+            self.current_texture.write(img.tobytes())
+            self.current_texture.use(0)
+            self.prog["tex"] = 0
+
+            self.current_framebuffer.use()
+            self.vao.render(moderngl.TRIANGLE_STRIP)
+
+            # Read once into bytes
+            data = self.current_framebuffer.read(components=4)
+            result_img = Image.frombytes("RGBA", (input_width, input_height), data)
+
+            return result_img
+
+        except Exception as e:
+            print(f"\nError processing image:")
+            print(e)
+            return None
+    
+    def cleanup(self):
+        """Call this when done processing all frames"""
+        if self.current_texture:
+            self.current_texture.release()
+        if self.current_framebuffer:
+            self.current_framebuffer.release()
+
+
+def feed_audio(audio_gen, ffmpeg_process):
+    """Thread function to feed audio to ffmpeg"""
+    try:
+        if ffmpeg_process.stdin and audio_gen:
+            for audio_chunk in audio_gen:
+                ffmpeg_process.stdin.write(audio_chunk.tobytes())
+    except (OSError, BrokenPipeError):
+        pass
+
+def process_video(converter: VideoAsciiConverter, video_path: str, output_path: str = "", audio: bool = True) -> str:
+    fps, frame_gen, audio_gen = extract_video(video_path)
+
+    if output_path == "":
+        parts = os.path.splitext(os.path.basename(video_path))
+        output_path = f"ascii_{parts[0]}.asc{parts[-1]}"
+    
+    if os.path.dirname(output_path) and not os.path.exists(os.path.dirname(output_path)):
+        os.mkdir(os.path.dirname(output_path))
+
+    # Build ffmpeg command based on audio parameter
+    ffmpeg_cmd = [
+        'ffmpeg',
+        '-y',
+        # Video input from stdin
+        '-f', 'rawvideo',
+        '-vcodec', 'rawvideo',
+        '-s', '1280x720',  # Will be updated after first frame
+        '-pix_fmt', 'rgba',
+        '-r', str(fps),
+        '-i', '-',
+    ]
+    
+    if audio:
+        # Audio input from the original file (force MP4 format)
+        ffmpeg_cmd.extend([
+            '-f', 'mp4',
+            '-i', video_path,
+            # Map video from stdin, audio from file
+            '-map', '0:v',
+            '-map', '1:a?',
+        ])
+    
+    # Video and audio encoding settings
+    ffmpeg_cmd.extend([
+        '-c:v', 'libx264',
+        '-pix_fmt', 'yuv420p',
+        '-preset', 'medium',
+        '-crf', '23',
+    ])
+    
+    if audio:
+        ffmpeg_cmd.extend([
+            '-c:a', 'aac',
+            '-b:a', '192k',
+            '-shortest',
+        ])
+    
+    ffmpeg_cmd.extend([
+        '-f', 'mp4',  # Force MP4 output format
+        output_path
+    ])
+    
+    ffmpeg_process = None
+    start = time.time()
+    frame_count = 0
+
+    try:
+        for frame in frame_gen:
+            out_frame = converter.process_frame(frame)
+            
+            if out_frame is None:
+                continue
+            
+            # Initialize ffmpeg process after first frame to get correct dimensions
+            if ffmpeg_process is None:
+                width, height = out_frame.size
+                ffmpeg_cmd[7] = f'{width}x{height}'
+                ffmpeg_process = subprocess.Popen(
+                    ffmpeg_cmd, 
+                    stdin=subprocess.PIPE, 
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL
+                )
+            
+            # Write frame to ffmpeg stdin
+            try:
+                if ffmpeg_process.stdin:
+                    ffmpeg_process.stdin.write(out_frame.tobytes())
+            except (OSError, BrokenPipeError) as e:
+                print(f"\nError writing to ffmpeg: {e}")
+                break
+                
+            frame_count += 1
+            
+            if frame_count % 30 == 0:
+                print(f"Processed {frame_count} frames...", end='\r')
+
+    finally:
+        # Close ffmpeg stdin and wait for process to finish
+        if ffmpeg_process:
+            if ffmpeg_process.stdin:
+                try:
+                    ffmpeg_process.stdin.close()
+                except:
+                    pass
+            ffmpeg_process.wait()
+        
+        converter.cleanup()
+        elapsed = time.time() - start
+        print(f"\nCompleted: {elapsed:.2f}s for {frame_count} frames ({frame_count/elapsed:.1f} fps)")
+        print(f"Output saved to: {output_path}")
+        return output_path

core/video_extractor.py

@@ -0,0 +1,128 @@
+import subprocess
+import numpy as np
+from PIL import Image
+import json
+from pathlib import Path
+from typing import Generator, Tuple, Dict, Any, Optional
+
+def extract_video(video_path: str, audio_rate=44100) -> Tuple[float, Generator[Image.Image, None, None], Optional[Generator[np.ndarray, None, None]]]:
+    """
+    Extracts video frames and audio from a video file as generators.
+
+    Args:
+        video_path: Path to video
+        audio_rate: Sample rate for audio (default 44100 Hz)
+
+    Returns:
+        fps: float
+        frame_gen: generator yielding PIL.Image frames
+        audio_gen: generator yielding np.ndarray audio chunks (shape: [N, 2]) or None if no audio
+    """
+
+    video_file = Path(video_path)
+    if not video_file.is_file():
+        raise FileNotFoundError(f"{video_path} does not exist")
+
+    # Probe video resolution and FPS
+    probe_cmd = [
+        "ffprobe",
+        "-v", "error",
+        "-select_streams", "v:0",
+        "-show_entries", "stream=width,height,r_frame_rate",
+        "-of", "json",
+        str(video_file)
+    ]
+    probe = subprocess.run(probe_cmd, capture_output=True, text=True)
+    info: Dict[str, Any] = json.loads(probe.stdout or "{}")
+    streams = info.get('streams', [])
+    if not streams:
+        raise RuntimeError("No video streams found or FFprobe failed")
+
+    stream: Dict[str, Any] = streams[0]
+    orig_width = int(stream['width'])
+    orig_height = int(stream['height'])
+
+    # Parse FPS
+    num, den = map(int, stream.get('r_frame_rate', '30/1').split('/'))
+    fps = round(num / den)
+
+    # Downscale to 720p if necessary
+    if orig_height > 720:
+        height = 720
+        width = int(orig_width * (720 / orig_height))
+        # Make width even for compatibility
+        width = width - (width % 2)
+        scale_filter = f"scale={width}:{height}"
+    else:
+        width = orig_width
+        height = orig_height
+        scale_filter = None
+
+    # Video command raw RGB24
+    video_cmd = [
+        "ffmpeg",
+        "-i", str(video_file),
+    ]
+    
+    if scale_filter:
+        video_cmd.extend(["-vf", scale_filter])
+    
+    video_cmd.extend([
+        "-f", "rawvideo",
+        "-pix_fmt", "rgb24",
+        "-an",  # No audio
+        "-"
+    ])
+    
+    video_proc = subprocess.Popen(video_cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+
+    # Audio: PCM16 stereo
+    audio_cmd = [
+        "ffmpeg",
+        "-i", str(video_file),
+        "-f", "s16le",
+        "-acodec", "pcm_s16le",
+        "-ac", "2",
+        "-ar", str(audio_rate),
+        "-vn",  # No video
+        "-"
+    ]
+    audio_proc = subprocess.Popen(audio_cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+
+    frame_size = width * height * 3
+    audio_chunk_size = audio_rate * 2 * 2  # 1 second buffer: 2 bytes/sample, 2 channels
+
+    def frame_generator():
+        try:
+            if video_proc.stdout is not None:
+                while True:
+                    raw = video_proc.stdout.read(frame_size)
+                    if not raw:
+                        break
+                    if len(raw) < frame_size:
+                        continue
+                    img_np = np.frombuffer(raw, dtype=np.uint8).reshape((height, width, 3))
+                    yield Image.fromarray(img_np, "RGB")
+        finally:
+            if video_proc.stdout is not None:
+                video_proc.stdout.close()
+            video_proc.wait()
+
+    def audio_generator():
+        try:
+            if audio_proc.stdout is not None:
+                while True:
+                    raw = audio_proc.stdout.read(audio_chunk_size)
+                    if not raw:
+                        break
+                    valid_size = (len(raw) // 4) * 4
+                    if valid_size == 0:
+                        continue
+                    audio_np = np.frombuffer(raw[:valid_size], dtype=np.int16).reshape(-1, 2)
+                    yield audio_np
+        finally:
+            if audio_proc.stdout is not None:
+                audio_proc.stdout.close()
+            audio_proc.wait()
+
+    return fps, frame_generator(), audio_generator()