Audio Processing API Reference

initMasterProcessingChain() {
  // Create compressor
  this.compressor = this.audioContext.createDynamicsCompressor();
  this.compressor.threshold.value = this.dynamics.compressor.threshold;
  this.compressor.knee.value = this.dynamics.compressor.knee;
  this.compressor.ratio.value = this.dynamics.compressor.ratio;
  this.compressor.attack.value = this.dynamics.compressor.attack;
  this.compressor.release.value = this.dynamics.compressor.release;

  // Create master gain
  this.masterGain = this.audioContext.createGain();
  this.masterGain.gain.value = 1.0;

  // Create stereo panner
  this.stereoPanner = this.audioContext.createStereoPanner();
  this.stereoPanner.pan.value = 0;

  // Create limiter (another compressor with more aggressive settings)
  this.limiter = this.audioContext.createDynamicsCompressor();
  this.limiter.threshold.value = this.dynamics.limiter.threshold;
  this.limiter.knee.value = this.dynamics.limiter.knee;
  this.limiter.ratio.value = this.dynamics.limiter.ratio;
  this.limiter.attack.value = this.dynamics.limiter.attack;
  this.limiter.release.value = this.dynamics.limiter.release;

  // Connect the processing chain
  this.compressor.connect(this.masterGain);
  this.masterGain.connect(this.stereoPanner);
  this.stereoPanner.connect(this.limiter);
  this.limiter.connect(this.audioContext.destination);
}

beatBlock.updateDynamicsSettings({
  compressor: {
    threshold: -20.0,  // Lower threshold for more compression
    knee: 10.0,
    ratio: 4.0,        // Higher ratio for more aggressive compression
    attack: 0.005,
    release: 0.1       // Faster release
  },
  limiter: {
    threshold: -1.0,   // Higher threshold to prevent distortion
    knee: 0.0,
    ratio: 20.0,
    attack: 0.001,     // Very fast attack to catch transients
    release: 0.1
  }
});

async decodeAudioData(arrayBuffer, path) {
  try {
    // Check if it's an Opus file
    const isOpus = path.toLowerCase().endsWith('.opus');
    
    if (isOpus) {
      // Use Opus decoder
      const decoder = new OpusDecoder();
      await decoder.ready;
      
      // Decode the Opus data
      decoder.decode(new Uint8Array(arrayBuffer));
      const decodedData = decoder.decode_float();
      
      // Create audio buffer from decoded data
      const audioBuffer = this.audioContext.createBuffer(
        1, // Mono channel
        decodedData.length,
        48000 // Opus standard sample rate
      );
      
      // Copy decoded data to audio buffer
      const channelData = audioBuffer.getChannelData(0);
      channelData.set(decodedData);
      
      return audioBuffer;
    } else {
      // Use standard Web Audio API decoding for other formats
      return await this.audioContext.decodeAudioData(arrayBuffer);
    }
  } catch (error) {
    console.error(`Failed to decode audio data: ${error}`);
    throw new Error(`Failed to decode audio data: ${error.message}`);
  }
}

encodeMP3(audioBuffer, options = {}) {
  const { bitRate = 128, sampleRate = 44100 } = options;
  
  // Create MP3 encoder
  const encoder = new lamejs.Mp3Encoder(
    audioBuffer.numberOfChannels,
    sampleRate,
    bitRate
  );
  
  // Convert audio buffer to samples
  const samples = [];
  for (let i = 0; i < audioBuffer.numberOfChannels; i++) {
    samples.push(audioBuffer.getChannelData(i));
  }
  
  // Convert to Int16 format required by LAME
  const int16Samples = [];
  for (let i = 0; i < samples[0].length; i++) {
    for (let channel = 0; channel < audioBuffer.numberOfChannels; channel++) {
      const sample = samples[channel][i];
      const int16Sample = Math.max(-1, Math.min(1, sample)) * 0x7FFF;
      int16Samples.push(int16Sample);
    }
  }
  
  // Encode to MP3
  const mp3Data = encoder.encodeBuffer(new Int16Array(int16Samples));
  const mp3End = encoder.flush();
  
  // Combine all MP3 data
  const mp3Buffer = new Uint8Array(mp3Data.length + mp3End.length);
  mp3Buffer.set(mp3Data);
  mp3Buffer.set(mp3End, mp3Data.length);
  
  return new Blob([mp3Buffer], { type: 'audio/mp3' });
}

async downloadSong() {
  try {
    this.emit('info', "Preparing to export song...");
    
    // Create offline audio context for rendering
    const offlineCtx = new OfflineAudioContext({
      numberOfChannels: 2,
      length: 44100 * this.getTotalDuration(),
      sampleRate: 44100
    });
    
    // Recreate the song in the offline context
    await this.renderToOfflineContext(offlineCtx);
    
    // Render the audio
    this.emit('info', "Rendering audio...");
    const renderedBuffer = await offlineCtx.startRendering();
    
    // Encode as WAV
    this.emit('info', "Encoding audio...");
    const wavBlob = this.encodeWAV(renderedBuffer);
    
    // Create download link
    const url = URL.createObjectURL(wavBlob);
    const a = document.createElement('a');
    a.href = url;
    a.download = `${this.details.title || 'beatblock'}.wav`;
    
    // Trigger download
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
    URL.revokeObjectURL(url);
    
    this.emit('info', "Download complete!");
  } catch (error) {
    this.emit('error', `Export failed: ${error.message}`);
    throw error;
  }
}