Stereo Panorama Mixer — User Guide

Automatic spatial distribution: equally spaces multiple sounds across stereo field, applies constant-power panning, mixes to stereo with peak normalization for clean, balanced output.

Author: Shai Cohen Affiliation: Department of Music, Bar-Ilan University, Israel Version: 0.1 (2025) License: MIT License Repo: https://github.com/ShaiCohen-ops/Praat-plugin_AudioTools

Contents:

What this does Quick start Panning Theory Mixing Algorithm Applications

What this does

This script implements automatic stereo panorama mixing — a spatial audio processing tool that takes multiple mono or stereo sounds and distributes them equally across the stereo field. Process involves: (1) Input validation: Ensures at least 2 sounds selected, handles stereo-to-mono conversion. (2) Parameter detection: Determines maximum duration and common sampling rate. (3) Spatial distribution: Calculates equal pan positions from hard left to hard right. (4) Constant-power panning: Applies psychoacoustically correct gain coefficients. (5) Accumulative mixing: Builds stereo mix by summing panned signals. (6) Peak normalization: Prevents clipping while maintaining optimal levels. Result: A clean stereo mix where each input sound occupies its own distinct spatial position, creating width and separation.

Key Features:

Automatic Panning — Equal spacing across stereo field
Constant-Power Law — Psychoacoustically correct panning
Format Agnostic — Handles mono and stereo inputs
Duration Adaptive — Mixes to longest sound duration
Clipping Prevention — Automatic peak normalization
Real-time Feedback — Progress reporting and pan positions

What is stereo panorama mixing? Traditional mixing: manual panning decisions, subjective positioning. Automatic panorama: mathematical distribution creating equal spacing. Benefits: (1) Objective separation: Eliminates masking by spatial distribution. (2) Time efficiency: Instant spatial organization of multiple sounds. (3) Consistent results: Same inputs always produce same spatial arrangement. (4) Educational value: Demonstrates stereo field principles. (5) Creative starting point: Provides baseline for further manual adjustment. Use cases: Sound mass composition, granular synthesis spatialization, educational demonstrations, quick mixes, algorithmic composition, sound installation setups.

Technical Implementation: (1) Input handling: Store sound IDs, detect sampling rate, find maximum duration. (2) Stereo canvas: Create empty stereo sound of maximum duration. (3) Pan calculation: Linear mapping from sound index to pan position (-1 to +1). (4) Mono conversion: Convert stereo inputs to mono for consistent processing. (5) Gain computation: Square-root constant-power panning coefficients. (6) Accumulative mixing: Apply gains to left/right channels using Praat Formula. (7) Peak management: Scale final mix to prevent clipping. (8) Cleanup: Remove temporary objects, preserve only final mix. Processing time scales with number of sounds and their durations.

Quick start

In Praat, select 2 or more Sound objects.
Run script… → stereo_panorama_mixer.praat.
Script automatically:
- Detects common sampling rate
- Finds longest duration
- Spaces sounds equally left to right
- Applies constant-power panning
- Normalizes peak to prevent clipping
Output: "originalname_mix" stereo Sound object
Result automatically played (can be disabled in script)

Quick tip: Select 3-8 sounds for optimal results. Mixed mono/stereo sources are fine — all converted to mono before panning. The script shows real-time progress: "Mixing X sounds..." → reports each sound's pan position → "Done! Output scaled to 0.99 peak amplitude." Output appears in Objects window named after first selected sound plus "_mix". For many sounds (>10), processing may take longer due to Formula calculations. All original sounds remain unchanged — only the mix is created as new object.

Important: MINIMUM 2 SOUNDS REQUIRED — script exits with error if fewer than 2 sounds selected. Processing time: Formula calculations can be slow for long files — be patient with extended durations. Memory usage: Temporary copies created during processing — large files may cause memory pressure. Peak normalization: Output scaled to 0.99 peak — may be quieter than individual files due to phase cancellation. Stereo inputs: Converted to mono before panning — spatial information from original stereo files is lost. Panning order: Sounds panned in selection order (first = left, last = right). Duration handling: Mix length = longest input sound — shorter sounds stop while longer sounds continue.

Panning Theory

Stereo Panning Fundamentals

What is Panning?

Spatial audio positioning:

Panning = Controlling amplitude ratio between left and right channels Purpose: Create illusion of sound source position between speakers Pan parameter range: -1 to +1 -1.0 = fully left (100% left, 0% right) 0.0 = center (equal left/right) +1.0 = fully right (0% left, 100% right) Physical reality: Two speakers, no true "position" between them Perceptual illusion: Brain interprets amplitude differences as spatial position Our implementation: Equal spacing from -1 to +1 based on number of sounds Sound 1: pan = -1.0 (hard left) Sound 2: pan = -1 + (2/(n-1)) ... Sound n: pan = +1.0 (hard right)

Why Constant-Power Panning?

Perceptual loudness consistency:

Problem: Simple linear panning causes center dip Linear: leftGain = (1 - pan)/2, rightGain = (1 + pan)/2 At center: left=0.5, right=0.5 → power = 0.5² + 0.5² = 0.5 At sides: left=1.0, right=0.0 → power = 1.0² + 0.0² = 1.0 Result: Center sounds appear quieter than sides Solution: Constant-power panning leftGain = cos(pan × π/4) OR sqrt((1 - pan)/2) rightGain = sin(pan × π/4) OR sqrt((1 + pan)/2) Our implementation: Square-root method leftGain = sqrt((1 - pan) / 2) rightGain = sqrt((1 + pan) / 2) Verification: leftGain² + rightGain² = 1 for all pan positions Center: (√0.5)² + (√0.5)² = 0.5 + 0.5 = 1.0 Left: (√1.0)² + (√0.0)² = 1.0 + 0.0 = 1.0 Right: (√0.0)² + (√1.0)² = 0.0 + 1.0 = 1.0 Result: Consistent perceived loudness across all positions

Panning Mathematics

Position Calculation

Equal stereo spacing:

Given n sounds, calculate pan position for sound i: pan[i] = -1 + (2 × (i - 1) / (n - 1)) Examples: n=2 sounds: i=1: pan = -1 + (2×0/1) = -1.0 (left) i=2: pan = -1 + (2×1/1) = +1.0 (right) n=3 sounds: i=1: pan = -1 + (2×0/2) = -1.0 (left) i=2: pan = -1 + (2×1/2) = 0.0 (center) i=3: pan = -1 + (2×2/2) = +1.0 (right) n=4 sounds: i=1: pan = -1.00 (left) i=2: pan = -0.33 (left-center) i=3: pan = +0.33 (right-center) i=4: pan = +1.00 (right) Properties: - First sound always at -1.0 (hard left) - Last sound always at +1.0 (hard right) - Equal spacing between adjacent sounds - Works for any n ≥ 2

Gain Coefficient Computation

Constant-power implementation:

INPUT: pan position p (-1 ≤ p ≤ +1) METHOD 1: Trigonometric (sine/cosine) leftGain = cos((p + 1) × π/4) rightGain = sin((p + 1) × π/4) METHOD 2: Square-root (our implementation) leftGain = sqrt((1 - p) / 2) rightGain = sqrt((1 + p) / 2) Why square-root method? - Computationally simpler (no trig functions) - Same constant-power property - Standard in digital audio workstations - Intuitive: gain = square root of linear coefficient Verification for p = 0 (center): leftGain = sqrt((1-0)/2) = sqrt(0.5) ≈ 0.707 rightGain = sqrt((1+0)/2) = sqrt(0.5) ≈ 0.707 Power: 0.707² + 0.707² = 0.5 + 0.5 = 1.0 Verification for p = -1 (left): leftGain = sqrt((1-(-1))/2) = sqrt(2/2) = 1.0 rightGain = sqrt((1+(-1))/2) = sqrt(0/2) = 0.0 Power: 1.0² + 0.0² = 1.0

Visualizing the Panorama

Stereo Field Distribution

Stereo Panorama Distribution Examples

2 Sounds:
LEFT [ Sound 1 ] = = = = = = = = = = = = = = [ Sound 2 ] RIGHT

3 Sounds:
LEFT [ Sound 1 ] = = = [ Sound 2 ] = = = [ Sound 3 ] RIGHT

4 Sounds:
LEFT [ S1 ] = = [ S2 ] = = [ S3 ] = = [ S4 ] RIGHT

5 Sounds:
LEFT [ S1 ] = [ S2 ] = [ S3 ] = [ S4 ] = [ S5 ] RIGHT

Each sound occupies distinct spatial position
Equal spacing prevents masking and creates width

Gain Curves Visualization

Constant-Power Panning Curves:

Left Channel Gain: leftGain = √((1-pan)/2)
pan=-1.0 → left=1.00, pan=0.0 → left=0.71, pan=+1.0 → left=0.00

Right Channel Gain: rightGain = √((1+pan)/2)
pan=-1.0 → right=0.00, pan=0.0 → right=0.71, pan=+1.0 → right=1.00

Total Power: left² + right² = 1.0 (constant)
Verified: (1.00²+0.00²)=1.0, (0.71²+0.71²)=0.5+0.5=1.0, (0.00²+1.00²)=1.0

Comparison to Linear:
Linear: center power = 0.5²+0.5²=0.5 (sounds quieter)
Constant-power: center power = 0.71²+0.71²=1.0 (consistent loudness)

Mixing Algorithm

Input Processing Phase

Sound Selection and Validation

Initial setup:

STEP 1: Count selection numberOfSounds = numberOfSelected("Sound") IF numberOfSounds < 2 → exit with error STEP 2: Store sound IDs FOR i from 1 to numberOfSounds: sound[i] = selected("Sound", i) STEP 3: Determine output parameters Select sound[1] sampleRate = Get sampling frequency maxDuration = 0 FOR i from 1 to numberOfSounds: Select sound[i] thisDuration = Get total duration IF thisDuration > maxDuration: maxDuration = thisDuration STEP 4: Create naming base baseName$ = selected$("Sound", 1) + "_mix" Output: Ready for mixing with known parameters

Stereo Canvas Creation

Empty mix container:

Create Sound from formula: baseName$ + "_mix", 2, 0, maxDuration, sampleRate, "0" Parameters: Name: "originalname_mix" Channels: 2 (stereo) Start: 0 seconds End: maxDuration (longest input) Sampling: common sample rate Formula: "0" (silence - initialized to zero) Why start with silence? - Clean slate for accumulation - Avoids adding noise or artifacts - Ensures proper initialization - Praat handles memory allocation Alternative: Could use first sound as base But starting silent is safer and more predictable

Panning and Mixing Phase

Per-Sound Processing

Iterative mixing algorithm:

FOR i from 1 to numberOfSounds: STEP 1: Calculate pan position pan = -1 + (2 × (i - 1) / (numberOfSounds - 1)) STEP 2: Handle input format Select sound[i] nChannels = Get number of channels IF nChannels > 1: mono = Convert to mono ELSE: mono = Copy: "temp_mono" STEP 3: Compute constant-power gains leftGain = sqrt((1 - pan) / 2) rightGain = sqrt((1 + pan) / 2) STEP 4: Get sound duration Select mono soundDuration = Get total duration STEP 5: Mix to left channel Select stereoMix Formula (part): 0, soundDuration, 1, 1, "self + object[mono] × " + string$(leftGain) STEP 6: Mix to right channel Formula (part): 0, soundDuration, 2, 2, "self + object[mono] × " + string$(rightGain) STEP 7: Cleanup removeObject: mono STEP 8: Progress reporting appendInfoLine: "Processed sound ", i, " at pan position ", fixed$(pan, 2) END FOR

Formula Application Details

Praat Formula usage:

Formula (part): startTime, endTime, fromChannel, toChannel, expression Our usage: Formula (part): 0, soundDuration, 1, 1, "self + object[mono] × leftGain" Breakdown: startTime=0, endTime=soundDuration: Only process actual sound duration fromChannel=1, toChannel=1: Left channel only Expression: "self + object[mono] × leftGain" self = current stereo mix value object[mono] = reference to mono sound object leftGain = computed gain coefficient Why part processing? - Only processes actual sound duration (saves CPU) - Leaves silence beyond sound duration untouched - More efficient than processing entire maxDuration Object reference: Praat's object[] syntax allows referencing by variable

Finalization Phase

Peak Normalization

Clipping prevention:

Problem: Summing multiple signals usually causes clipping Even with constant-power panning per sound Multiple sounds playing simultaneously → amplitude > 1.0 Solution: Peak normalization after mixing Select stereoMix Scale peak: 0.99 Why 0.99 instead of 1.0? - Safety margin for floating-point precision - Prevents potential intersample peaks - Standard practice in digital audio - Prevents hard clipping in DAC conversion Alternative approaches: - Could use compression/limiting - Could normalize to lower level for headroom - But simple peak scaling works well for this application Result: Clean, clip-free output at optimal level

Memory Management

Temporary object handling:

Temporary Objects Created:

During processing:
- mono: Temporary mono version of each sound
- stereoMix: The accumulating mix

Cleanup strategy:
- mono objects removed immediately after use
- Only stereoMix remains at end
- Original selected sounds preserved unchanged

Memory considerations:
- Each mono copy = additional memory usage
- stereoMix = 2 channels × maxDuration × sampleRate
- Large numbers of long sounds may strain memory
- Temporary objects deleted promptly to minimize peak usage

Complete Processing Pipeline

PHASE 1: SETUP Validate selection (≥2 sounds) Store sound IDs Determine common sample rate Find maximum duration Create empty stereo canvas PHASE 2: MIXING LOOP FOR each sound i from 1 to n: Calculate pan position Convert to mono if needed Compute left/right gains Mix to left channel (only sound duration) Mix to right channel (only sound duration) Remove temporary mono Report progress PHASE 3: FINALIZATION Select final mix Scale peak to 0.99 Report completion Play result (optional) OUTPUT: Single stereo sound "originalname_mix" All temporary objects cleaned up Original selections unchanged

Parameters & Behavior

Input Requirements

Parameter	Requirement	Description
Number of Sounds	≥ 2	Minimum 2 sounds required
File Formats	Any Praat-supported	WAV, AIFF, etc.
Channel Config	Mono or Stereo	Auto-converted to mono
Sampling Rates	Any	Uses first sound's rate
Durations	Any	Mix length = longest sound

Output Characteristics

Characteristic	Value	Description
Channels	2 (Stereo)	Left/Right output
Duration	Longest input	Full length of longest sound
Peak Level	0.99	Normalized to prevent clipping
Naming	"name_mix"	Based on first selected sound
Panning Law	Constant-Power	Square-root method

Performance Characteristics

Aspect	Behavior	Notes
Processing Time	O(n × duration)	Scales with sounds and length
Memory Usage	Moderate	Temporary mono copies
CPU Load	Formula-intensive	Praat Formula can be slow
Object Cleanup	Automatic	Only final mix remains

Usage Guidance

Optimal sound counts:

2-4 sounds: Clear separation, distinct positions
5-8 sounds: Good density, still good separation
9-12 sounds: Dense mix, some overlap possible
13+ sounds: Very dense, consider grouping

Sound selection strategies:

Similar sounds: Creates cohesive spatial field
Different sounds: Highlights separation effect
Rhythmic sounds: Creates interesting patterns
Sustained sounds: Creates texture clouds

Performance optimization:

Shorter files: Process much faster
Fewer sounds: Linear time reduction
Similar durations: More efficient processing
Mono sources: Avoid conversion overhead

Applications

Sound Mass Composition

Use case: Creating dense textural fields from multiple sounds

Technique: Process 8-12 similar sustained sounds

Result: Rich stereo texture with inherent width and movement

Granular Synthesis Spatialization

Use case: Distributing granular particles across stereo field

Technique: Process individual grains or micro-sounds

Benefits: Automatic spatial organization without manual panning

Educational Demonstrations

Use case: Teaching stereo theory and panning principles

Technique: Show how different sounds occupy space

Learning outcomes: Understand constant-power panning, spatial separation

Quick Mixing and Mockups

Use case: Rapid stereo mixes for demonstrations or sketches

Technique: Process complete musical elements or sound effects

Advantage: Instant professionally panned mix from raw elements

Practical Workflow Examples

🎵 Textural Sound Cloud

Goal: Create evolving texture from sustained sounds

Setup:

Selection: 6-8 pad sounds, string sustains, or ambient textures
Characteristics: Similar spectral content, long duration
Processing: Let script distribute equally across stereo field

Result: Rich, wide texture with automatic spatial organization

🥁 Rhythmic Element Separation

Goal: Separate similar percussive elements spatially

Setup:

Selection: 4-6 drum hits, percussion samples, rhythmic elements
Characteristics: Short duration, percussive attacks
Processing: Automatic left-to-right distribution

Result: Clear rhythmic pattern with spatial interest

🎭 Dialog or Voice Separation

Goal: Spatialize multiple voice recordings

Setup:

Selection: 3-5 voice recordings, dialog samples, spoken phrases
Characteristics: Speech, similar vocal qualities
Processing: Equal left-to-right spacing

Result: Clear voice separation for multi-speaker content

Advanced Techniques

Multi-stage spatialization:

Stage 1: Process similar sounds together in subgroups
Stage 2: Process resulting mixes as new "super-sounds"
Stage 3: Create hierarchical spatial organization
Result: Complex spatial structures with grouped elements

Hybrid manual/auto panning:

Step 1: Use script for initial automatic distribution
Step 2: Manually adjust individual pan positions as needed
Step 3: Use script's output as starting point for fine-tuning
Result: Combined efficiency of auto with control of manual

Troubleshooting Common Issues

Problem: Script fails with "Please select at least 2 Sound objects"
Cause: Only one or no sounds selected
Solution: Select multiple Sound objects before running script

Problem: Processing very slow for long files
Cause: Praat Formula calculations are computationally intensive
Solution: Use shorter sounds, fewer sounds, or be patient

Problem: Output much quieter than individual sounds
Cause: Phase cancellation or conservative normalization
Solution: This is normal - use Praat's "Scale peak" to adjust level if needed

Problem: Memory errors with many/large sounds
Cause: Too many temporary objects or very long files
Solution: Process fewer sounds, use shorter files, close other applications

Algorithmic Extensions

Alternative Panning Laws

Beyond Constant-Power

Other panning curves:

LINEAR PANNING: leftGain = (1 - pan) / 2 rightGain = (1 + pan) / 2 Simple but causes center loudness dip SINE-COSINE PANNING: leftGain = cos(pan × π/4) rightGain = sin(pan × π/4) True constant-power, slightly different curve -3dB CENTER PANNING: leftGain = sqrt((1 - pan) / 2) × 0.707 // -3dB at center rightGain = sqrt((1 + pan) / 2) × 0.707 Prevents center buildup in dense mixes COMPRESSED PANNING: leftGain = (sqrt((1 - pan) / 2))^0.8 // Apply compression rightGain = (sqrt((1 + pan) / 2))^0.8 Reduces extreme panning effects

Advanced Spatial Distribution

Beyond Linear Spacing

Alternative distribution patterns:

CLUSTERED DISTRIBUTION: Group similar sounds together spatially Use timbral similarity to determine clusters Space clusters evenly, pack sounds within clusters FREQUENCY-BASED PANNING: Pan sounds based on spectral centroid Bright sounds → sides, dark sounds → center Mimics orchestral seating arrangements RANDOM DISTRIBUTION: Random pan positions within constraints Avoid too-close spacing Creates more natural, less mathematical distribution MANUAL PRIORITY ORDERING: Let user specify importance order Important sounds → center, background → sides More musically intentional distribution

Enhanced Mixing Techniques

Beyond Simple Summation

Advanced mixing approaches:

COMPRESSION DURING MIX: Apply gentle compression during accumulation Prevents excessive peaks while summing More consistent level across the mix AUTOMATIC GAIN COMPENSATION: Analyze each sound's RMS level Apply corrective gains before panning Balanced mix regardless of input levels CROSSFADE AT BOUNDARIES: Apply short crossfades between sounds Smoother transitions, especially for rhythmic content Prevents clicks or abrupt changes MULTIBAND PANNING: Split sounds into frequency bands Pan different bands differently Creates wider, more enveloping spatial image