fix_gif_compatibility.py

#!/usr/bin/env python3
"""
Improved GIF creation with better macOS compatibility
"""

import os
from PIL import Image, ImageSequence
import sys

def create_compatible_gif(input_frames_dir, output_gif_path, duration=100, max_frames=100):
    """
    Create a GIF with enhanced macOS compatibility
    """
    try:
        # Get all frame files
        frame_files = sorted([f for f in os.listdir(input_frames_dir) if f.endswith('.png')])
        
        if not frame_files:
            print(f"❌ No PNG frames found in {input_frames_dir}")
            return False
        
        if len(frame_files) < 2:
            print(f"❌ Need at least 2 frames, found {len(frame_files)}")
            return False
        
        print(f"📸 Processing {len(frame_files)} frames...")
        
        # Load and process images
        frames = []
        step = max(1, len(frame_files) // max_frames)
        
        for i in range(0, len(frame_files), step):
            frame_path = os.path.join(input_frames_dir, frame_files[i])
            try:
                img = Image.open(frame_path)
                
                # Convert to RGB first, then to palette mode for better compatibility
                if img.mode != 'RGB':
                    img = img.convert('RGB')
                
                # Resize for manageable file size
                width, height = img.size
                if width > 800:
                    new_width = 800
                    new_height = int(height * new_width / width)
                    img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
                
                # Convert to palette mode with dithering for better compression
                img = img.convert('P', palette=Image.ADAPTIVE, colors=256)
                
                frames.append(img)
                
            except Exception as e:
                print(f"⚠️ Skipping frame {frame_files[i]}: {e}")
                continue
        
        if len(frames) < 2:
            print(f"❌ Not enough valid frames processed")
            return False
        
        print(f"✅ Processed {len(frames)} frames")
        
        # Create GIF with specific settings for macOS compatibility
        frames[0].save(
            output_gif_path,
            save_all=True,
            append_images=frames[1:],
            duration=duration,
            loop=0,
            disposal=2,  # Clear frame before next
            optimize=False,  # Don't optimize for better compatibility
            transparency=None  # No transparency
        )
        
        # Verify the GIF was created correctly
        if os.path.exists(output_gif_path):
            with Image.open(output_gif_path) as gif:
                print(f"✅ GIF created successfully:")
                print(f"   Path: {output_gif_path}")
                print(f"   Size: {gif.size}")
                print(f"   Frames: {getattr(gif, 'n_frames', 1)}")
                print(f"   Animated: {getattr(gif, 'is_animated', False)}")
                print(f"   File size: {os.path.getsize(output_gif_path) / 1024:.1f} KB")
                return True
        else:
            print(f"❌ GIF file was not created")
            return False
            
    except Exception as e:
        print(f"❌ Error creating GIF: {e}")
        import traceback
        traceback.print_exc()
        return False

def fix_existing_gif(input_gif_path, output_gif_path=None):
    """
    Fix an existing GIF for better compatibility
    """
    if not output_gif_path:
        output_gif_path = input_gif_path.replace('.gif', '_fixed.gif')
    
    try:
        with Image.open(input_gif_path) as img:
            if not getattr(img, 'is_animated', False):
                print(f"❌ {input_gif_path} is not animated")
                return False
            
            frames = []
            durations = []
            
            for frame in ImageSequence.Iterator(img):
                # Convert frame to RGB then to palette
                frame = frame.convert('RGB')
                frame = frame.convert('P', palette=Image.ADAPTIVE, colors=256)
                frames.append(frame)
                durations.append(frame.info.get('duration', 100))
            
            # Save with fixed settings
            frames[0].save(
                output_gif_path,
                save_all=True,
                append_images=frames[1:],
                duration=durations,
                loop=0,
                disposal=2,
                optimize=False,
                transparency=None
            )
            
            print(f"✅ Fixed GIF saved as: {output_gif_path}")
            return True
            
    except Exception as e:
        print(f"❌ Error fixing GIF: {e}")
        return False

if __name__ == "__main__":
    print("=== GIF Compatibility Fixer ===")
    
    # Check if we have frame directories
    recordings_dir = "recordings"
    if os.path.exists(recordings_dir):
        # Look for frame directories
        for item in os.listdir(recordings_dir):
            item_path = os.path.join(recordings_dir, item)
            if os.path.isdir(item_path):
                # Check if it has PNG frames
                png_files = [f for f in os.listdir(item_path) if f.endswith('.png')]
                if png_files:
                    print(f"\\n📁 Found frame directory: {item}")
                    gif_name = f"{item}.gif"
                    gif_path = os.path.join(recordings_dir, gif_name)
                    
                    if create_compatible_gif(item_path, gif_path):
                        print(f"\\n🎬 Testing GIF playback...")
                        os.system(f"open '{gif_path}'")
    
    # Also fix existing GIFs
    print("\\n=== Fixing existing GIFs ===")
    for gif_file in ["recordings/bubble_sort.gif", "recordings/test_algorithm.gif"]:
        if os.path.exists(gif_file):
            print(f"\\n🔧 Fixing {gif_file}...")
            fix_existing_gif(gif_file)