audacity_automation.py

#!/usr/bin/env python3
"""
Audacity Automation Script
Uses Audacity's built-in Python scripting to automate effects and export.
"""

import os
import sys
from pathlib import Path

def create_audacity_script(input_file, output_file, effects=None):
    """
    Create a Python script that can be run within Audacity.
    
    Args:
        input_file (str): Path to input bitmap file
        output_file (str): Path for output raw file
        effects (list): List of effects to apply with their parameters
    """
    
    if effects is None:
        effects = [
            {"name": "Echo", "delay": 0.3, "decay": 0.1},
            {"name": "Reverb", "room_size": 0.5, "damping": 0.5},
        ]
    
    script_content = f'''# Audacity Python Script
# This script can be run from within Audacity: Tools > Scriptables > Run Script...

import os
import audacity

def apply_effects():
    """Apply effects to the current audio track"""
    
    # Get the current project
    project = audacity.GetProject()
    
    # Select all audio
    audacity.SelectAll()
    
    # Apply effects
    for effect in {effects}:
        effect_name = effect["name"]
        print(f"Applying {{effect_name}}...")
        
        if effect_name == "Echo":
            audacity.ApplyEffect("Echo", 
                delay=effect.get("delay", 0.3),
                decay=effect.get("decay", 0.1))
        elif effect_name == "Reverb":
            audacity.ApplyEffect("Reverb",
                room_size=effect.get("room_size", 0.5),
                damping=effect.get("damping", 0.5))
        elif effect_name == "Distortion":
            audacity.ApplyEffect("Distortion",
                distortion_type=effect.get("type", "Soft Clip"),
                level=effect.get("level", 0.5))
        elif effect_name == "Phaser":
            audacity.ApplyEffect("Phaser",
                stages=effect.get("stages", 2),
                dry_wet=effect.get("dry_wet", 0.5),
                frequency=effect.get("frequency", 0.5))
        else:
            print(f"Unknown effect: {{effect_name}}")
    
    print("Effects applied successfully!")

def export_raw():
    """Export as raw audio"""
    output_path = "{output_file}"
    
    # Export as raw (header-less)
    audacity.Export2(
        filename=output_path,
        format="RAW",
        encoding="ULAW",
        channels=1
    )
    
    print(f"Exported to: {{output_path}}")

if __name__ == "__main__":
    apply_effects()
    export_raw()
'''
    
    script_file = "audacity_script.py"
    with open(script_file, 'w') as f:
        f.write(script_content)
    
    print(f"Created Audacity script: {script_file}")
    print("To use this script:")
    print("1. Open Audacity")
    print("2. Import your bitmap as raw data")
    print("3. Go to Tools > Scriptables > Run Script...")
    print("4. Select the generated script file")
    print("5. The script will apply effects and export automatically")
    
    return script_file

def create_batch_script(input_dir="input-bitmap", output_dir="output-raw", effects=None):
    """
    Create a batch processing script for multiple files.
    """
    
    input_path = Path(input_dir)
    output_path = Path(output_dir)
    output_path.mkdir(exist_ok=True)
    
    bitmap_files = list(input_path.glob("*.bmp"))
    
    if not bitmap_files:
        print(f"No bitmap files found in {input_dir}")
        return
    
    batch_script = '''# Audacity Batch Processing Script
# This script processes multiple bitmap files

import os
import audacity
from pathlib import Path

def process_file(input_file, output_file, effects):
    """Process a single file"""
    
    # Import the bitmap as raw data
    audacity.ImportRaw(
        filename=input_file,
        encoding="ULAW",
        channels=1
    )
    
    # Apply effects
    apply_effects(effects)
    
    # Export
    audacity.Export2(
        filename=output_file,
        format="RAW",
        encoding="ULAW",
        channels=1
    )
    
    # Close the project to prepare for next file
    audacity.CloseProject()

def apply_effects(effects):
    """Apply effects to current track"""
    audacity.SelectAll()
    
    for effect in effects:
        effect_name = effect["name"]
        print(f"Applying {effect_name}...")
        
        if effect_name == "Echo":
            audacity.ApplyEffect("Echo", 
                delay=effect.get("delay", 0.3),
                decay=effect.get("decay", 0.1))
        elif effect_name == "Reverb":
            audacity.ApplyEffect("Reverb",
                room_size=effect.get("room_size", 0.5),
                damping=effect.get("damping", 0.5))
        # Add more effects as needed

# Main processing loop
input_dir = "{input_dir}"
output_dir = "{output_dir}"
effects = {effects}

input_path = Path(input_dir)
output_path = Path(output_dir)

for bitmap_file in input_path.glob("*.bmp"):
    output_file = output_path / f"{{bitmap_file.stem}}.raw"
    print(f"Processing {{bitmap_file.name}}...")
    process_file(str(bitmap_file), str(output_file), effects)
    print(f"Exported to {{output_file}}")

print("Batch processing complete!")
'''
    
    with open("audacity_batch.py", 'w') as f:
        f.write(batch_script)
    
    print("Created batch processing script: audacity_batch.py")

if __name__ == "__main__":
    # Example usage
    effects = [
        {"name": "Echo", "delay": 0.3, "decay": 0.1},
        {"name": "Reverb", "room_size": 0.5, "damping": 0.5},
    ]
    
    create_audacity_script("input-bitmap/test.bmp", "output-raw/test.raw", effects)
    create_batch_script("input-bitmap", "output-raw", effects)