App.cpp

#include "App.h"

#include <algorithm>
#include <math.h>
#include <string.h>

#include "A2dpSourceDiagnostics.h"
#include "Config.h"
#include "Log.h"
#include "Platform.h"
#include "driver/gpio.h"
#include "pgmspace.h"
#include "esp_a2dp_legacy_api.h"
#include "esp_bt.h"
#include "esp_bt_main.h"
#include "esp_cpu.h"
#include "esp_coexist.h"
#include "esp_event.h"
#include "esp_heap_caps.h"
#include "mdns.h"
#include "esp_netif.h"
#include "nvs.h"
#include "esp_system.h"
#include "esp_timer.h"
#include "esp_wifi.h"
#include "freertos/idf_additions.h"
#include "nvs_flash.h"
#include "perfmon.h"

// 切り分け用: App.hをSYNTH_RENDER_PROFILING=1で確定させた後、
// App.cppの計測実行コードだけをcompile outする。追加されたclass layoutと
// renderVoiceFramesのABIは維持する。
#if SYNTH_RENDER_PROFILING
#define SYNTH_RENDER_PROFILING_LAYOUT 1
#else
#define SYNTH_RENDER_PROFILING_LAYOUT 0
#endif
#if SYNTH_RENDER_PROFILING && !SYNTH_RENDER_PROFILE_RUNTIME
#undef SYNTH_RENDER_PROFILING
#define SYNTH_RENDER_PROFILING 0
#endif
#if SYNTH_RENDER_PROFILING
#define SYNTH_RENDER_PROFILING_EXECUTION 1
#else
#define SYNTH_RENDER_PROFILING_EXECUTION 0
#endif

#if SYNTH_RENDER_PROFILE_CLOCK_READS
#define RENDER_PROFILE_CCOUNT() esp_cpu_get_cycle_count()
#define RENDER_PROFILE_TIME_US() static_cast<uint32_t>(esp_timer_get_time())
#else
#define RENDER_PROFILE_CCOUNT() 0U
#define RENDER_PROFILE_TIME_US() 0U
#endif

namespace {
using std::max;
using std::min;

App* g_app = nullptr;
#if SYNTH_RENDER_PROFILING && SYNTH_RENDER_PROFILE_VOICE_CODE
// renderVoiceFrames()のABIを変更せずに、呼出し元Coreのprofile対象を選ぶ。
// slot 0はCore0/helper、slot 1はCore1/mainだけが書き込むため、mutexやatomicは不要。
struct RendererProfileCallContext {
  uint32_t bank;
  bool helperCore;
};
RendererProfileCallContext g_rendererProfileCallContexts[2] = {};
#endif
// dual-core rendererの固定部分和buffer。未初期化領域へ置き、firmware imageを増やさない。
constexpr size_t kParallelRenderFrames = 256;
#if APP_USE_32BIT_IRAM_AUDIO_BUFFERS
constexpr size_t kIramAudioRingFrames = 4096;
struct AudioIramBuffers {
  uint32_t audioRing[kIramAudioRingFrames];
  int32_t mainMixedLeftQ15[kParallelRenderFrames];
  int32_t mainMixedRightQ15[kParallelRenderFrames];
  int32_t mainReverbInputQ15[kParallelRenderFrames];
  int32_t mainChorusInputQ15[kParallelRenderFrames];
  int32_t helperMixedLeftQ15[kParallelRenderFrames];
  int32_t helperMixedRightQ15[kParallelRenderFrames];
  int32_t helperReverbInputQ15[kParallelRenderFrames];
  int32_t helperChorusInputQ15[kParallelRenderFrames];
};
static_assert(sizeof(AudioIramBuffers) == 24 * 1024,
              "IRAM audio buffer slab must remain 24 KiB");
AudioIramBuffers* g_audioIramBuffers = nullptr;
int32_t* g_mainMixedLeftQ15 = nullptr;
int32_t* g_mainMixedRightQ15 = nullptr;
int32_t* g_mainReverbInputQ15 = nullptr;
int32_t* g_mainChorusInputQ15 = nullptr;
int32_t* g_helperMixedLeftQ15 = nullptr;
int32_t* g_helperMixedRightQ15 = nullptr;
int32_t* g_helperReverbInputQ15 = nullptr;
int32_t* g_helperChorusInputQ15 = nullptr;
#else
int32_t g_mainMixedLeftQ15[kParallelRenderFrames];
int32_t g_mainMixedRightQ15[kParallelRenderFrames];
int32_t g_mainReverbInputQ15[kParallelRenderFrames];
int32_t g_mainChorusInputQ15[kParallelRenderFrames];
int32_t g_helperMixedLeftQ15[kParallelRenderFrames];
int32_t g_helperMixedRightQ15[kParallelRenderFrames];
int32_t g_helperReverbInputQ15[kParallelRenderFrames];
int32_t g_helperChorusInputQ15[kParallelRenderFrames];
#endif
// Delay sendはIRAM slabとは分離してDRAMに置く。hot dataをIRAMへ置かない。
int32_t g_mainDelayInputQ15[kParallelRenderFrames];
int32_t g_helperDelayInputQ15[kParallelRenderFrames];
#if APP_USE_ADPCM_TONES
uint32_t g_adpcmNibbleDecodeCount = 0;
uint32_t g_adpcmCacheResetCount = 0;
uint32_t g_adpcmPairHitCount = 0;
uint32_t g_adpcmBlockBoundaryCount = 0;
uint32_t g_adpcmMaxDecodePerRead = 0;
#endif
#if APP_USE_MULAW_TONES
int16_t g_mulawDecodeTable[256];
#if APP_ENABLE_MULAW_CACHE_STATS
uint32_t g_mulawSameIndexHitCount = 0;
uint32_t g_mulawOneStepHitCount = 0;
uint32_t g_mulawReloadCount = 0;
#endif
#endif
constexpr uint32_t kFlashEraseBlockSize = 4096;
constexpr EventBits_t kWifiConnectedBit = BIT0;
constexpr EventBits_t kWifiFailedBit = BIT1;
constexpr uint8_t kWifiRetriesBeforeFailure = 10;
constexpr uint32_t kWifiConnectTimeoutMs = 15000;
constexpr uint32_t kWifiSetupButtonPollMs = 20;
constexpr uint32_t kWifiRollbackRetryMs = 250;
constexpr char kWifiNvsNamespace[] = "wifi_cfg";
constexpr char kWifiNvsSsidKey[] = "ssid";
constexpr char kWifiNvsPasswordKey[] = "password";
constexpr char kWifiNvsForceSetupKey[] = "force_setup";
constexpr char kWifiPlaceholderSsid[] = "YOUR_WIFI_SSID";
constexpr char kWifiPlaceholderPassword[] = "YOUR_WIFI_PASSWORD";
constexpr char kProvisioningApSsid[] = "ESP32-Tiny-MIDI-Setup";
constexpr char kProvisioningApPassword[] = "12345678";
constexpr char kProvisioningApIp[] = "192.168.4.1";
constexpr char kMdnsHostname[] = "esp32-tiny-midi";
constexpr char kMdnsInstanceName[] = "ESP32 Tiny MIDI Synthesizer";

bool wifiDeadlineReached(uint32_t nowMs, uint32_t deadlineMs) {
  return static_cast<int32_t>(nowMs - deadlineMs) >= 0;
}

bool wifiSetupButtonLongPressed() {
  const int pinNumber = Config::WifiSetupButtonGpio;
  if (pinNumber < 0 || pinNumber >= static_cast<int>(GPIO_NUM_MAX)) {
    Log::infof("Wi-Fi setup button GPIO is invalid: %d", pinNumber);
    return false;
  }

  gpio_config_t buttonConfig = {};
  buttonConfig.pin_bit_mask = 1ULL << static_cast<uint32_t>(pinNumber);
  buttonConfig.mode = GPIO_MODE_INPUT;
  buttonConfig.pull_up_en = Config::WifiSetupButtonActiveLow
      ? GPIO_PULLUP_ENABLE : GPIO_PULLUP_DISABLE;
  buttonConfig.pull_down_en = Config::WifiSetupButtonActiveLow
      ? GPIO_PULLDOWN_DISABLE : GPIO_PULLDOWN_ENABLE;
  buttonConfig.intr_type = GPIO_INTR_DISABLE;
  const esp_err_t configResult = gpio_config(&buttonConfig);
  if (configResult != ESP_OK) {
    Log::infof("Wi-Fi setup button GPIO%d init failed: %s", pinNumber,
               esp_err_to_name(configResult));
    return false;
  }

  const int activeLevel = Config::WifiSetupButtonActiveLow ? 0 : 1;
  const gpio_num_t pin = static_cast<gpio_num_t>(pinNumber);
  if (gpio_get_level(pin) != activeLevel) {
    return false;
  }

  const TickType_t holdTicks = pdMS_TO_TICKS(Config::WifiSetupButtonHoldMs);
  const TickType_t pollTicks = max<TickType_t>(
      1, pdMS_TO_TICKS(kWifiSetupButtonPollMs));
  const TickType_t startedAt = xTaskGetTickCount();
  while (gpio_get_level(pin) == activeLevel) {
    if (static_cast<TickType_t>(xTaskGetTickCount() - startedAt) >= holdTicks) {
      Log::infof(
          "Wi-Fi provisioning requested by BOOT button: GPIO%d held for %lu ms",
          pinNumber,
          static_cast<unsigned long>(Config::WifiSetupButtonHoldMs));
      return true;
    }
    vTaskDelay(pollTicks);
  }
  return false;
}

void copyWifiConfigField(uint8_t* destination, size_t capacity,
                         const char* source) {
  if (destination == nullptr || capacity == 0 || source == nullptr) return;
  const size_t length = min(strlen(source), capacity);
  memcpy(destination, source, length);
  if (length < capacity) destination[length] = '\0';
}

bool requestProvisioningOnNextBoot() {
  nvs_handle_t handle = 0;
  if (nvs_open(kWifiNvsNamespace, NVS_READWRITE, &handle) != ESP_OK) return false;
  esp_err_t result = nvs_set_u8(handle, kWifiNvsForceSetupKey, 1);
  if (result == ESP_OK) result = nvs_commit(handle);
  nvs_close(handle);
  return result == ESP_OK;
}

bool consumeProvisioningRequest() {
  nvs_handle_t handle = 0;
  if (nvs_open(kWifiNvsNamespace, NVS_READWRITE, &handle) != ESP_OK) return false;
  uint8_t requested = 0;
  const bool present =
      nvs_get_u8(handle, kWifiNvsForceSetupKey, &requested) == ESP_OK && requested != 0;
  if (present) {
    nvs_erase_key(handle, kWifiNvsForceSetupKey);
    nvs_commit(handle);
  }
  nvs_close(handle);
  return present;
}
constexpr int32_t kQ15One = 32767;
constexpr uint32_t kQ16One = 65536;
// Keep the adaptive helper split conservative for Core 0, which also runs
// Wi-Fi/Bluetooth and MIDI parsing, while allowing up to half the active
// voices on Core 0 when the adaptive measurements show enough headroom.
constexpr uint32_t kHelperVoiceCapMax = 14u;
constexpr uint32_t kHelperVoiceCapNumerator = 7u;
constexpr uint32_t kHelperVoiceCapDenominator = 16u;
constexpr uint32_t kAutoPlaybackStabilizationMs = 3000u;
struct StereoPanQ15 {
  int16_t left;
  int16_t right;
};
constexpr StereoPanQ15 kChannelPanQ15[16] = {
    {32767, 32767}, {32767, 18022}, {18022, 32767}, {32767, 24575},
    {24575, 32767}, {32767, 11468}, {11468, 32767}, {32767, 27852},
    {27852, 32767}, {32767, 32767}, {32767, 21299}, {21299, 32767},
    {32767, 14745}, {14745, 32767}, {32767, 29490}, {32767, 32767}};

inline uint32_t packStereoFrame(int16_t left, int16_t right) {
  return static_cast<uint16_t>(left) |
      (static_cast<uint32_t>(static_cast<uint16_t>(right)) << 16);
}

inline int16_t stereoLeft(uint32_t frame) {
  return static_cast<int16_t>(frame & 0xFFFFu);
}

inline int16_t stereoRight(uint32_t frame) {
  return static_cast<int16_t>(frame >> 16);
}
constexpr uint32_t kRenderHistogramUpperUs[16] = {
    250, 500, 750, 1000, 1500, 2000, 3000, 4000,
    5000, 6000, 7000, 8000, 10000, 12000, 16000, 20000};
constexpr float kMidiPitchClassHz[12] = {
    8.1757989156f, 8.6619572180f, 9.1770239974f, 9.7227182413f,
    10.3008611535f, 10.9133822323f, 11.5623257097f, 12.2498573744f,
    12.9782717994f, 13.7500000000f, 14.5676175474f, 15.4338531643f};

enum class PcmRole : uint8_t {
  Bass = 0,
  Lead,
  Pad,
  Organ,
  Brass,
  Bell,
  Pluck,
  Kick
};

struct PcmSampleDef {
#if APP_USE_ADPCM_TONES || APP_USE_MULAW_TONES
  const uint8_t* data;
#else
  const int16_t* data;
#endif
  uint32_t length;
  uint32_t loopStart;
  uint32_t loopEnd;
  uint32_t cycleLength;
  bool loopEnabled;
  bool fixedPitch;
  uint32_t sourceRate;
};

struct PcmToneDataDef {
#if APP_USE_ADPCM_TONES || APP_USE_MULAW_TONES
  const uint8_t* carrier;
  uint32_t carrierLength;
  uint32_t cycleLength;
  uint32_t loopStart;
  uint32_t loopEnd;
#if APP_USE_MULAW_TONES
  uint32_t sourceRate;
#endif
#else
  const int16_t* carrier[3];
  const int16_t* mod[3];
  uint32_t carrierLength[3];
  uint32_t modLength[3];
  uint32_t cycleLength[3];
#endif
};

#if APP_USE_MULAW_TONES
struct GeneratedGsToneDef {
  uint8_t bankMsb;
  uint8_t program;
  const uint8_t* data;
  uint32_t length;
  uint32_t loopStart;
  uint32_t loopEnd;
  uint32_t cycleLength;
  uint32_t sourceRate;
};
#endif

#if APP_USE_MULAW_TONES
#include "MulawToneSamples.generated.h"
#include "MulawDrumSamples.generated.h"
#include "MulawGsToneSamples.generated.h"
#elif APP_USE_ADPCM_TONES
#include "AdpcmToneSamples.generated.h"
#else
#include "PcmToneSamples.generated.h"
#endif

#if APP_USE_ADPCM_TONES || APP_USE_MULAW_TONES
using ToneSamplePointer = const uint8_t*;
#else
using ToneSamplePointer = const int16_t*;
#endif

constexpr PcmSampleDef makeLoopedSample(
    ToneSamplePointer data,
    uint32_t length,
    uint32_t cycleLength) {
  return PcmSampleDef{
      data,
      length,
      0,
      static_cast<uint32_t>(length > 0 ? length - 1 : 0),
      cycleLength,
      true,
      false,
      44100};
}

constexpr PcmSampleDef makeOneShotSample(
    ToneSamplePointer data,
    uint32_t length,
    uint32_t cycleLength,
    bool fixedPitch = false) {
  return PcmSampleDef{
      data,
      length,
      0,
      static_cast<uint32_t>(length > 0 ? length - 1 : 0),
      cycleLength,
      false,
      fixedPitch,
      44100};
}

const char* sbcSampleRateToText(uint8_t sampleRateMask) {
  if (sampleRateMask & ESP_A2D_SBC_CIE_SF_48K) {
    return "48k";
  }
  if (sampleRateMask & ESP_A2D_SBC_CIE_SF_44K) {
    return "44.1k";
  }
  if (sampleRateMask & ESP_A2D_SBC_CIE_SF_32K) {
    return "32k";
  }
  if (sampleRateMask & ESP_A2D_SBC_CIE_SF_16K) {
    return "16k";
  }
  return "?";
}

const char* sbcChannelModeToText(uint8_t channelModeMask) {
  if (channelModeMask & ESP_A2D_SBC_CIE_CH_MODE_JOINT_STEREO) {
    return "joint";
  }
  if (channelModeMask & ESP_A2D_SBC_CIE_CH_MODE_STEREO) {
    return "stereo";
  }
  if (channelModeMask & ESP_A2D_SBC_CIE_CH_MODE_DUAL_CHANNEL) {
    return "dual";
  }
  if (channelModeMask & ESP_A2D_SBC_CIE_CH_MODE_MONO) {
    return "mono";
  }
  return "?";
}

uint8_t sampleRateToSbcMask(uint32_t sampleRateHz) {
  if (sampleRateHz >= 44100) {
    return ESP_A2D_SBC_CIE_SF_44K;
  }
  if (sampleRateHz >= 32000) {
    return ESP_A2D_SBC_CIE_SF_32K;
  }
  return ESP_A2D_SBC_CIE_SF_16K;
}

uint32_t sbcMaskToSampleRateHz(uint8_t sampleRateMask) {
  if (sampleRateMask & ESP_A2D_SBC_CIE_SF_48K) {
    return 48000;
  }
  if (sampleRateMask & ESP_A2D_SBC_CIE_SF_44K) {
    return 44100;
  }
  if (sampleRateMask & ESP_A2D_SBC_CIE_SF_32K) {
    return 32000;
  }
  if (sampleRateMask & ESP_A2D_SBC_CIE_SF_16K) {
    return 16000;
  }
  return Config::SampleRateHz;
}

size_t maxOutputFramesForSynthChunk(
    size_t chunkFrames,
    uint32_t synthSampleRateHz,
    uint32_t outputSampleRateHz) {
  const uint32_t safeSynthRate = max<uint32_t>(1, synthSampleRateHz);
  const uint32_t safeOutputRate = max<uint32_t>(1, outputSampleRateHz);
  const uint64_t scaled =
      (static_cast<uint64_t>(chunkFrames) * safeOutputRate + safeSynthRate - 1) /
      safeSynthRate;
  return static_cast<size_t>(scaled + 2);
}

void ensureWaveTablesInitialized() {
  // 周波数表はconstexprでFlashに置くため、起動時初期化は不要。
#if APP_USE_MULAW_TONES
  for (uint16_t code = 0; code < 256; ++code) {
    const uint8_t value = static_cast<uint8_t>(~code);
    int32_t magnitude =
        (static_cast<int32_t>(value & 0x0f) << 3) + 0x84;
    magnitude <<= (value >> 4) & 0x07;
    magnitude -= 0x84;
    g_mulawDecodeTable[code] = static_cast<int16_t>(
        (value & 0x80) ? -magnitude : magnitude);
  }
#endif
}

#if APP_USE_MULAW_TONES
inline int16_t IRAM_ATTR readMulawSampleLinearQ15Raw(
    const uint8_t* data,
    uint16_t length,
    uint32_t samplePosQ16,
    uint16_t& cachedIndex,
    int16_t& cachedSample0,
    int16_t& cachedSample1,
    bool& cacheValid) {
  if (data == nullptr || length == 0) return 0;
  uint16_t index = static_cast<uint16_t>(samplePosQ16 >> 16);
  if (index >= length - 1) {
    index = static_cast<uint16_t>(length - 1);
  }
  if (!cacheValid || index < cachedIndex || index > cachedIndex + 1) {
#if APP_ENABLE_MULAW_CACHE_STATS
    ++g_mulawReloadCount;
#endif
    cachedSample0 = g_mulawDecodeTable[data[index]];
    cachedSample1 = index + 1 < length
        ? g_mulawDecodeTable[data[index + 1]]
        : cachedSample0;
    cachedIndex = index;
    cacheValid = true;
  } else if (index == cachedIndex + 1) {
#if APP_ENABLE_MULAW_CACHE_STATS
    ++g_mulawOneStepHitCount;
#endif
    cachedSample0 = cachedSample1;
    cachedSample1 = index + 1 < length
        ? g_mulawDecodeTable[data[index + 1]]
        : cachedSample0;
    cachedIndex = index;
#if APP_ENABLE_MULAW_CACHE_STATS
  } else {
    ++g_mulawSameIndexHitCount;
#endif
  }
  const uint32_t frac = samplePosQ16 & 0xffffu;
  return static_cast<int16_t>(
      cachedSample0 +
      (((static_cast<int32_t>(cachedSample1) - cachedSample0) *
        static_cast<int32_t>(frac)) >> 16));
}
#endif

#if APP_USE_ADPCM_TONES
DRAM_ATTR const int8_t kImaIndexDelta[8] = {-1, -1, -1, -1, 2, 4, 6, 8};
DRAM_ATTR const int16_t kImaStepTable[89] = {
    7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31,
    34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130,
    143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408, 449,
    494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 1411,
    1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327, 3660, 4026,
    4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493, 10442,
    11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623,
    27086, 29794, 32767};

inline int16_t decodeImaNibble(
    uint8_t code, int16_t predictor, uint8_t& stepIndex) {
  const int32_t step = kImaStepTable[stepIndex];
  const int32_t delta =
      (step * static_cast<int32_t>(((code & 7) << 1) + 1)) >> 3;
  const int32_t signMask = -static_cast<int32_t>(code >> 3);
  int32_t decoded = static_cast<int32_t>(predictor) +
      ((delta ^ signMask) - signMask);
  if (decoded > 32767) decoded = 32767;
  else if (decoded < -32768) decoded = -32768;
  int32_t nextStepIndex =
      static_cast<int32_t>(stepIndex) + kImaIndexDelta[code & 7];
  if (nextStepIndex > 88) nextStepIndex = 88;
  else if (nextStepIndex < 0) nextStepIndex = 0;
  stepIndex = static_cast<uint8_t>(nextStepIndex);
  return static_cast<int16_t>(decoded);
}

inline int16_t readAdpcmSampleLinearQ15Raw(
    const uint8_t* data,
    uint16_t length,
    uint32_t samplePosQ16,
    uint16_t& cachedIndex,
    int16_t& cachedSample0,
    int16_t& cachedSample1,
    uint8_t& cachedStepIndex,
    bool& cacheValid) {
  if (data == nullptr || length == 0) return 0;
  uint16_t index = static_cast<uint16_t>(samplePosQ16 >> 16);
  if (index >= length) index = static_cast<uint16_t>(length - 1);
  const uint16_t blockStart = static_cast<uint16_t>(index & ~(kImaAdpcmBlockSamples - 1));

  if (cacheValid && cachedIndex == index + 1 &&
      (cachedIndex / kImaAdpcmBlockSamples) == (index / kImaAdpcmBlockSamples)) {
    ++g_adpcmPairHitCount;
    const uint32_t frac = samplePosQ16 & 0xffffu;
    return static_cast<int16_t>(cachedSample0 +
        (((static_cast<int32_t>(cachedSample1) - cachedSample0) *
          static_cast<int32_t>(frac)) >> 16));
  }

  if (!cacheValid || index < cachedIndex ||
      (cachedIndex / kImaAdpcmBlockSamples) != (index / kImaAdpcmBlockSamples)) {
    ++g_adpcmCacheResetCount;
    const uint8_t* block = data +
        (static_cast<uint32_t>(index) / kImaAdpcmBlockSamples) * kImaAdpcmBlockBytes;
    cachedSample0 = static_cast<int16_t>(
        static_cast<uint16_t>(block[0]) | (static_cast<uint16_t>(block[1]) << 8));
    cachedSample1 = cachedSample0;
    cachedStepIndex = min<uint8_t>(88, block[2]);
    cachedIndex = blockStart;
    cacheValid = true;
  }

  const uint8_t* block = data +
      (static_cast<uint32_t>(index) / kImaAdpcmBlockSamples) * kImaAdpcmBlockBytes;
  uint32_t decodeCount = 0;
  while (cachedIndex < index) {
    const uint16_t nextWithinBlock =
        static_cast<uint16_t>((cachedIndex + 1) - blockStart);
    const uint16_t nibbleIndex = static_cast<uint16_t>(nextWithinBlock - 1);
    const uint8_t packed = block[4 + (nibbleIndex >> 1)];
    const uint8_t code =
        (nibbleIndex & 1) ? static_cast<uint8_t>(packed >> 4) : (packed & 0x0f);
    cachedSample0 = cachedSample1;
    cachedSample1 = decodeImaNibble(code, cachedSample1, cachedStepIndex);
    ++cachedIndex;
    ++decodeCount;
  }

  const int16_t a = cachedSample1;
  int16_t b = a;
  if (index + 1 < length) {
    if (((index + 1) % kImaAdpcmBlockSamples) == 0) {
      ++g_adpcmBlockBoundaryCount;
      const uint8_t* nextBlock = block + kImaAdpcmBlockBytes;
      b = static_cast<int16_t>(
          static_cast<uint16_t>(nextBlock[0]) |
          (static_cast<uint16_t>(nextBlock[1]) << 8));
      cachedSample0 = b;
      cachedSample1 = b;
      cachedStepIndex = min<uint8_t>(88, nextBlock[2]);
      cachedIndex = static_cast<uint16_t>(index + 1);
    } else {
      const uint16_t nibbleIndex = static_cast<uint16_t>(index - blockStart);
      const uint8_t packed = block[4 + (nibbleIndex >> 1)];
      const uint8_t code =
          (nibbleIndex & 1) ? static_cast<uint8_t>(packed >> 4) : (packed & 0x0f);
      b = decodeImaNibble(code, a, cachedStepIndex);
      ++decodeCount;
      cachedSample0 = a;
      cachedSample1 = b;
      cachedIndex = static_cast<uint16_t>(index + 1);
    }
  }
  g_adpcmNibbleDecodeCount += decodeCount;
  if (decodeCount > g_adpcmMaxDecodePerRead) {
    g_adpcmMaxDecodePerRead = decodeCount;
  }
  const uint32_t frac = samplePosQ16 & 0xffffu;
  return static_cast<int16_t>(
      a + (((static_cast<int32_t>(b) - a) * static_cast<int32_t>(frac)) >> 16));
}
#else
inline int16_t readPcmSampleLinearQ15Raw(
    const int16_t* data,
    uint16_t length,
    uint32_t samplePosQ16) {
  if (data == nullptr || length == 0) {
    return 0;
  }
  const uint32_t index = samplePosQ16 >> 16;
  if (index >= length - 1) {
    return data[length - 1];
  }
  const int16_t a = data[index];
  const int16_t b = data[index + 1];
  const uint32_t frac = samplePosQ16 & 0xffffu;
  return static_cast<int16_t>(
      a + (((static_cast<int32_t>(b) - a) * static_cast<int32_t>(frac)) >> 16));
}
#endif

inline bool advancePcmPositionQ16Raw(
    uint32_t& samplePosQ16,
    uint32_t sampleStepQ16,
    uint16_t length,
    uint16_t loopStart,
    uint16_t loopEnd,
    bool loopEnabled) {
  samplePosQ16 += sampleStepQ16;
  if (!loopEnabled) {
    return (samplePosQ16 >> 16) < length;
  }
  if (loopEnd <= loopStart || loopEnd >= length) {
    return true;
  }
  const uint32_t loopStartQ16 = static_cast<uint32_t>(loopStart) << 16;
  const uint32_t loopEndQ16 = static_cast<uint32_t>(loopEnd) << 16;
  const uint32_t loopLenQ16 = loopEndQ16 - loopStartQ16;
  if (samplePosQ16 >= loopEndQ16 && loopLenQ16 > 0) {
    samplePosQ16 -= loopLenQ16;
    if (samplePosQ16 >= loopEndQ16) {
      samplePosQ16 = loopStartQ16 + ((samplePosQ16 - loopStartQ16) % loopLenQ16);
    }
  }
  return true;
}

inline __attribute__((always_inline)) void advanceLoopedPositionQ16Raw(
    uint32_t& samplePosQ16,
    uint32_t sampleStepQ16,
    uint32_t loopStartQ16,
    uint32_t loopEndQ16,
    uint32_t loopLengthQ16) {
  samplePosQ16 += sampleStepQ16;
  if (samplePosQ16 < loopEndQ16) {
    return;
  }
  samplePosQ16 -= loopLengthQ16;
  // 通常pitchは1回の減算で収まる。極端なpitchだけ安全な剰余経路へ入る。
  if (samplePosQ16 >= loopEndQ16) {
    samplePosQ16 = loopStartQ16 +
        ((samplePosQ16 - loopStartQ16) % loopLengthQ16);
  }
}

inline __attribute__((always_inline)) bool advanceOneShotPositionQ16Raw(
    uint32_t& samplePosQ16,
    uint32_t sampleStepQ16,
    uint32_t sampleLengthQ16) {
  // Check before addition. A 65,535-sample one-shot ends near UINT32_MAX in
  // Q16 and a high pitch step could otherwise wrap the position to zero.
  if (samplePosQ16 >= sampleLengthQ16 ||
      sampleStepQ16 >= sampleLengthQ16 - samplePosQ16) {
    samplePosQ16 = sampleLengthQ16;
    return false;
  }
  samplePosQ16 += sampleStepQ16;
  return true;
}

inline bool advancePcmPositionQ16(
    uint32_t& samplePosQ16,
    uint32_t sampleStepQ16,
    const PcmSampleDef& sample) {
  return advancePcmPositionQ16Raw(
      samplePosQ16,
      sampleStepQ16,
      sample.length,
      sample.loopStart,
      sample.loopEnd,
      sample.loopEnabled);
}

PcmSampleDef sampleForToneClass(
    MidiEvent::ToneClass toneClass,
    App::WaveTableSet waveTableSet,
    bool secondaryLayer) {
  size_t toneIndex = static_cast<size_t>(toneClass);
#if APP_USE_MULAW_TONES
  (void)waveTableSet;
  (void)secondaryLayer;
  if (toneIndex >= 128) toneIndex = 0;
  const PcmToneDataDef& toneData = g_mulawToneData[toneIndex];
  const uint8_t* data = toneData.carrier;
  const uint32_t length = toneData.carrierLength;
  const uint32_t cycleLength = toneData.cycleLength;
  const uint32_t loopStart = toneData.loopStart;
  const uint32_t loopEnd = toneData.loopEnd;
  const uint32_t sourceRate = toneData.sourceRate;
#elif APP_USE_ADPCM_TONES
  (void)waveTableSet;
  (void)secondaryLayer;
  const uint8_t program = static_cast<uint8_t>(toneIndex & 0x7f);
  toneIndex =
      program <= 3 ? (program == 1 ? 19 : (program == 3 ? 20 : 18)) :
      program <= 5 ? 14 : program <= 7 ? 9 : program <= 10 ? 11 :
      program <= 15 ? 3 : program <= 20 ? 15 : program <= 23 ? 31 :
      program == 24 ? 21 : program <= 26 ? 22 : program <= 31 ? 23 :
      program <= 33 ? 24 : program <= 35 ? 12 : program <= 39 ? 7 :
      program <= 43 ? 25 : program <= 47 ? 26 : program <= 51 ? 25 :
      program <= 55 ? 26 : program == 56 ? 27 : program <= 63 ? 10 :
      program <= 68 ? 28 : program <= 70 ? 29 : program == 71 ? 30 :
      program <= 75 ? 13 : program <= 79 ? 6 : program <= 83 ? 0 :
      program <= 87 ? 8 : program <= 95 ? 16 : program <= 103 ? 4 :
      program <= 111 ? 11 : program <= 119 ? 5 : 16;
  const PcmToneDataDef& toneData = g_adpcmToneData[toneIndex];
  const uint8_t* data = toneData.carrier;
  const uint32_t length = toneData.carrierLength;
  const uint32_t cycleLength = toneData.cycleLength;
  const uint32_t loopStart = toneData.loopStart;
  const uint32_t loopEnd = toneData.loopEnd;
#else
  const uint8_t program = static_cast<uint8_t>(toneIndex & 0x7f);
  toneIndex =
      program <= 3 ? (program == 1 ? 19 : (program == 3 ? 20 : 18)) :
      program <= 5 ? 14 : program <= 7 ? 9 : program <= 10 ? 11 :
      program <= 15 ? 3 : program <= 20 ? 15 : program <= 23 ? 31 :
      program == 24 ? 21 : program <= 26 ? 22 : program <= 31 ? 23 :
      program <= 33 ? 24 : program <= 35 ? 12 : program <= 39 ? 7 :
      program <= 43 ? 25 : program <= 47 ? 26 : program <= 51 ? 25 :
      program <= 55 ? 26 : program == 56 ? 27 : program <= 63 ? 10 :
      program <= 68 ? 28 : program <= 70 ? 29 : program == 71 ? 30 :
      program <= 75 ? 13 : program <= 79 ? 6 : program <= 83 ? 0 :
      program <= 87 ? 8 : program <= 95 ? 16 : program <= 103 ? 4 :
      program <= 111 ? 11 : program <= 119 ? 5 : 16;
  const size_t setIndex = waveTableSet == App::WaveTableSet::Famicom
                              ? 1
                              : (waveTableSet == App::WaveTableSet::Soft ? 2 : 0);
  const PcmToneDataDef& toneData = g_pcmToneData[toneIndex];
  const int16_t* data = secondaryLayer ? toneData.mod[setIndex] : toneData.carrier[setIndex];
  const uint32_t length =
      secondaryLayer ? toneData.modLength[setIndex] : toneData.carrierLength[setIndex];
  const uint32_t cycleLength = toneData.cycleLength[setIndex];
#endif

  // Some GM percussion/effect programs are short single-cycle waveforms
  // (roughly 135-200 samples). Treating the entire 112-127 range as one-shot
  // ended those waves after only a few milliseconds and produced a click.
  // Generated long samples advertise a distinct pitch cycle and are the
  // actual one-shots; short samples whose cycle equals their length must loop.
#if APP_USE_ADPCM_TONES || APP_USE_MULAW_TONES
  if (loopEnd > loopStart && loopEnd <= length) {
    PcmSampleDef sample = makeLoopedSample(data, length, cycleLength);
    sample.sourceRate = sourceRate;
    sample.loopStart = loopStart;
    sample.loopEnd = loopEnd;
    return sample;
  }
  PcmSampleDef sample = makeOneShotSample(data, length, cycleLength, false);
  sample.sourceRate = sourceRate;
  return sample;
#else
  if (length != cycleLength) {
    return makeOneShotSample(data, length, cycleLength, false);
  }
  return makeLoopedSample(data, length, cycleLength);
#endif
}

#if APP_USE_MULAW_TONES
bool sampleForGsTone(uint8_t bankMsb, uint8_t program, PcmSampleDef& sample) {
  if (bankMsb == 0) return false;
  for (const GeneratedGsToneDef& tone : g_mulawGsToneData) {
    if (tone.bankMsb != bankMsb || tone.program != program) continue;
    sample = PcmSampleDef{
        tone.data,
        tone.length,
        tone.loopStart,
        tone.loopEnd,
        tone.cycleLength,
        tone.loopEnd > tone.loopStart,
        false,
        tone.sourceRate};
    return true;
  }
  return false;
}
#endif

#if APP_USE_MULAW_TONES
struct DrumMapEntry {
  uint8_t firstNote;
  uint8_t lastNote;
  uint8_t sampleIndex;
};

// GM Standard Kit notes 35-81 and GS extension notes 82-87 use dedicated
// samples. Only undefined low notes 27-34 retain the side-stick fallback.
constexpr DrumMapEntry kGmDrumMap[] = {
    {27, 34, kMulawDrumSideStick},
    {35, 35, kMulawDrumAcousticBassDrum},
    {36, 36, kMulawDrumBassDrum1},
    {37, 37, kMulawDrumSideStick},
    {38, 38, kMulawDrumAcousticSnare},
    {39, 39, kMulawDrumHandClap},
    {40, 40, kMulawDrumElectricSnare},
    {41, 41, kMulawDrumLowFloorTom},
    {42, 42, kMulawDrumClosedHiHat},
    {43, 43, kMulawDrumHighFloorTom},
    {44, 44, kMulawDrumPedalHiHat},
    {45, 45, kMulawDrumLowTom},
    {46, 46, kMulawDrumOpenHiHat},
    {47, 47, kMulawDrumLowMidTom},
    {49, 49, kMulawDrumCrashCymbal1},
    {48, 48, kMulawDrumHiMidTom},
    {50, 50, kMulawDrumHighTom},
    {51, 51, kMulawDrumRideCymbal1},
    {52, 52, kMulawDrumChineseCymbal},
    {53, 53, kMulawDrumRideBell},
    {54, 54, kMulawDrumTambourine},
    {55, 55, kMulawDrumSplashCymbal},
    {56, 56, kMulawDrumCowbell},
    {57, 57, kMulawDrumCrashCymbal2},
    {58, 58, kMulawDrumVibraslap},
    {59, 59, kMulawDrumRideCymbal2},
    {60, 60, kMulawDrumHiBongo},
    {61, 61, kMulawDrumLowBongo},
    {62, 62, kMulawDrumMuteHiConga},
    {63, 63, kMulawDrumOpenHiConga},
    {64, 64, kMulawDrumLowConga},
    {65, 65, kMulawDrumHighTimbale},
    {66, 66, kMulawDrumLowTimbale},
    {67, 67, kMulawDrumHighAgogo},
    {68, 68, kMulawDrumLowAgogo},
    {69, 69, kMulawDrumCabasa},
    {70, 70, kMulawDrumMaracas},
    {71, 71, kMulawDrumShortWhistle},
    {72, 72, kMulawDrumLongWhistle},
    {73, 73, kMulawDrumShortGuiro},
    {74, 74, kMulawDrumLongGuiro},
    {75, 75, kMulawDrumClaves},
    {76, 76, kMulawDrumHighWoodBlock},
    {77, 77, kMulawDrumLowWoodBlock},
    {78, 78, kMulawDrumMuteCuica},
    {79, 79, kMulawDrumOpenCuica},
    {80, 80, kMulawDrumMuteTriangle},
    {81, 81, kMulawDrumOpenTriangle},
    {82, 82, kMulawDrumShaker},
    {83, 83, kMulawDrumJingleBell},
    {84, 84, kMulawDrumBellTree},
    {85, 85, kMulawDrumCastanets},
    {86, 86, kMulawDrumMuteSurdo},
    {87, 87, kMulawDrumOpenSurdo},
};

bool sampleForGmDrum(
    uint8_t midiNote,
    PcmSampleDef& sample,
    float& pitchRatio) {
  for (const DrumMapEntry& entry : kGmDrumMap) {
    if (midiNote < entry.firstNote || midiNote > entry.lastNote) {
      continue;
    }
    const GeneratedMulawDrumDef& drum = g_mulawDrumSamples[entry.sampleIndex];
    sample = makeOneShotSample(drum.data, drum.length, 1, true);
    pitchRatio = powf(
        2.0f,
        (static_cast<int>(midiNote) - drum.rootNote) / 12.0f);
    return true;
  }
  return false;
}
#endif


void formatBdAddr(const esp_bd_addr_t address, char* buffer, size_t capacity) {
  if (buffer == nullptr || capacity == 0) {
    return;
  }
  snprintf(
      buffer,
      capacity,
      "%02X:%02X:%02X:%02X:%02X:%02X",
      address[0],
      address[1],
      address[2],
      address[3],
      address[4],
      address[5]);
}

bool parseBdAddr(const char* text, esp_bd_addr_t out) {
  if (text == nullptr || out == nullptr) {
    return false;
  }
  unsigned int values[6];
  if (sscanf(
          text,
          "%02x:%02x:%02x:%02x:%02x:%02x",
          &values[0],
          &values[1],
          &values[2],
          &values[3],
          &values[4],
          &values[5]) != 6) {
    return false;
  }

  for (int i = 0; i < 6; ++i) {
    out[i] = static_cast<uint8_t>(values[i]);
  }
  return true;
}

bool getNameFromEir(uint8_t* eir, char* bdname, uint8_t* bdnameLen) {
  if (eir == nullptr || bdname == nullptr || bdnameLen == nullptr) {
    return false;
  }

  uint8_t* remoteBdname = nullptr;
  uint8_t remoteBdnameLen = 0;
  remoteBdname = esp_bt_gap_resolve_eir_data(
      eir,
      ESP_BT_EIR_TYPE_CMPL_LOCAL_NAME,
      &remoteBdnameLen);
  if (remoteBdname == nullptr) {
    remoteBdname = esp_bt_gap_resolve_eir_data(
        eir,
        ESP_BT_EIR_TYPE_SHORT_LOCAL_NAME,
        &remoteBdnameLen);
  }
  if (remoteBdname == nullptr || remoteBdnameLen == 0) {
    return false;
  }

  const uint8_t length = min<uint8_t>(remoteBdnameLen, ESP_BT_GAP_MAX_BDNAME_LEN);
  memcpy(bdname, remoteBdname, length);
  bdname[length] = 0;
  *bdnameLen = length;
  return true;
}

float midiToHz(int midiNote) {
  if (midiNote < 0) {
    midiNote = 0;
  } else if (midiNote > 127) {
    midiNote = 127;
  }
  return ldexpf(kMidiPitchClassHz[midiNote % 12], midiNote / 12);
}

const char* resetReasonToText(esp_reset_reason_t reason) {
  switch (reason) {
    case ESP_RST_POWERON:
      return "poweron";
    case ESP_RST_EXT:
      return "external";
    case ESP_RST_SW:
      return "software";
    case ESP_RST_PANIC:
      return "panic";
    case ESP_RST_INT_WDT:
      return "int_wdt";
    case ESP_RST_TASK_WDT:
      return "task_wdt";
    case ESP_RST_WDT:
      return "other_wdt";
    case ESP_RST_DEEPSLEEP:
      return "deepsleep";
    case ESP_RST_BROWNOUT:
      return "brownout";
    case ESP_RST_SDIO:
      return "sdio";
    default:
      return "unknown";
  }
}

constexpr char kSongMagic[8] = {'F', 'M', 'S', 'O', 'N', 'G', '2', '\0'};
constexpr char kRawMidiMagic[8] = {'R', 'A', 'W', 'M', 'I', 'D', '1', '\0'};

int32_t gainToQ15(float value) {
  if (value <= 0.0f) {
    return 0;
  }
  if (value >= 1.0f) {
    return kQ15One;
  }
  return static_cast<int32_t>(value * static_cast<float>(kQ15One));
}

int32_t msToEnvelopeStepQ15(float ms, uint32_t sampleRateHz, uint32_t updateDivider) {
  if (ms <= 0.0f) {
    return kQ15One;
  }
  const float updatesPerSecond =
      static_cast<float>(sampleRateHz) / static_cast<float>(max<uint32_t>(1, updateDivider));
  const float totalUpdates = max(1.0f, (ms / 1000.0f) * updatesPerSecond);
  return max<int32_t>(1, static_cast<int32_t>(static_cast<float>(kQ15One) / totalUpdates));
}

void IRAM_ATTR advanceEnvelope(
    App::EnvelopeStage& stage,
    int32_t& levelQ15,
    int32_t attackStepQ15,
    int32_t decayStepQ15,
    int32_t sustainLevelQ15,
    int32_t releaseStepQ15) {
  switch (stage) {
    case App::EnvelopeStage::Attack:
      levelQ15 += attackStepQ15;
      if (levelQ15 >= kQ15One) {
        levelQ15 = kQ15One;
        stage = App::EnvelopeStage::Decay;
      }
      break;
    case App::EnvelopeStage::Decay:
      levelQ15 -= decayStepQ15;
      if (levelQ15 <= sustainLevelQ15) {
        levelQ15 = sustainLevelQ15;
        stage = App::EnvelopeStage::Sustain;
      }
      break;
    case App::EnvelopeStage::Release:
      levelQ15 -= releaseStepQ15;
      if (levelQ15 <= 0) {
        levelQ15 = 0;
        stage = App::EnvelopeStage::Off;
      }
      break;
    case App::EnvelopeStage::Sustain:
      levelQ15 = sustainLevelQ15;
      break;
    case App::EnvelopeStage::Off:
    default:
      levelQ15 = 0;
      break;
  }
}

void IRAM_ATTR advanceEnvelopeOptimized(
    App::EnvelopeStage& stage,
    int32_t& levelQ15,
    int32_t attackStepQ15,
    int32_t decayStepQ15,
    int32_t sustainLevelQ15,
    int32_t releaseStepQ15,
    bool allowSlowUpdate) {
  if (stage == App::EnvelopeStage::Attack) {
    advanceEnvelope(
        stage,
        levelQ15,
        attackStepQ15,
        decayStepQ15,
        sustainLevelQ15,
        releaseStepQ15);
    return;
  }

  if (stage == App::EnvelopeStage::Sustain) {
    return;
  }

  if (!allowSlowUpdate) {
    return;
  }

  advanceEnvelope(
      stage,
      levelQ15,
      attackStepQ15,
      decayStepQ15,
      sustainLevelQ15,
      releaseStepQ15);
}

float toneClassSampleGain(MidiEvent::ToneClass toneClass) {
  switch (toneClass) {
    case MidiEvent::ToneClass::Piano:
    case MidiEvent::ToneClass::BrightPiano:
    case MidiEvent::ToneClass::HonkyTonk:
      return 1.20f;
    case MidiEvent::ToneClass::Bell:
      return 1.45f;
    case MidiEvent::ToneClass::Pluck:
    case MidiEvent::ToneClass::NylonGuitar:
    case MidiEvent::ToneClass::CleanGuitar:
    case MidiEvent::ToneClass::MutedGuitar:
      return 1.40f;
    case MidiEvent::ToneClass::Perc:
      return 1.40f;
    case MidiEvent::ToneClass::Mallet:
      return 1.40f;
    case MidiEvent::ToneClass::EPiano:
      return 1.42f;
    case MidiEvent::ToneClass::Metal:
      return 1.45f;
    case MidiEvent::ToneClass::KickPerc:
      return 1.35f;
    case MidiEvent::ToneClass::Strings:
    case MidiEvent::ToneClass::Choir:
    case MidiEvent::ToneClass::Accordion:
      return 1.14f;
    case MidiEvent::ToneClass::Trumpet:
    case MidiEvent::ToneClass::Sax:
    case MidiEvent::ToneClass::Flute:
    case MidiEvent::ToneClass::Clarinet:
      return 1.10f;
    case MidiEvent::ToneClass::Lead:
    case MidiEvent::ToneClass::Pad:
    case MidiEvent::ToneClass::SoftLead:
    case MidiEvent::ToneClass::WarmPad:
    case MidiEvent::ToneClass::Keys:
    case MidiEvent::ToneClass::Brass:
    case MidiEvent::ToneClass::HardLead:
    case MidiEvent::ToneClass::Organ:
      return 1.08f;
    case MidiEvent::ToneClass::Bass:
    case MidiEvent::ToneClass::PunchBass:
    case MidiEvent::ToneClass::SubBass:
    case MidiEvent::ToneClass::PickedBass:
    default:
      return 1.0f;
  }
}

}  // namespace

void logStagedHeap(const char* stage) {
#if APP_ENABLE_STAGED_HEAP_DIAGNOSTICS
  const uint32_t internal = heap_caps_get_free_size(MALLOC_CAP_INTERNAL);
  const uint32_t internal8 = heap_caps_get_free_size(
      MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
  const uint32_t largest8 = heap_caps_get_largest_free_block(
      MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
  const uint32_t minimum8 = heap_caps_get_minimum_free_size(
      MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
  Log::infof("HEAPSTAGE %-24s int=%lu i8=%lu largest=%lu min=%lu",
             stage != nullptr ? stage : "?",
             static_cast<unsigned long>(internal),
             static_cast<unsigned long>(internal8),
             static_cast<unsigned long>(largest8),
             static_cast<unsigned long>(minimum8));
#else
  (void)stage;
#endif
}

void App::begin() {
  g_app = this;
  ensureWaveTablesInitialized();
  m_requestedSampleRateHz = Config::SampleRateHz;
  m_sampleRateHz = Config::SampleRateHz;
  m_outputSampleRateHz = Config::SampleRateHz;
  m_lastStreamFrame = 0;
  m_synthMutex = xSemaphoreCreateMutex();
  m_rawMidiParserMutex = xSemaphoreCreateMutex();
  // Preview can be requested before the first song start. Initialize channel
  // pitch/modulation state here so its Q16 scales are unity, not zero.
  resetChannelPitchBends();
  delay(300);
  // Log::begin() is idempotent and is called early from app_main so native
  // ESP-IDF logs and the first heap diagnostic share the API/UART stream.
  Log::begin();
  Log::info("ESP32 Tiny MIDI Synthesizer starting");
  Log::infof("Application build: %s %s", __DATE__, __TIME__);
#if APP_USE_MULAW_TONES
  Log::info("Tone storage: GM128 G.711 mu-law + attack loops + pair cache");
#elif APP_USE_ADPCM_TONES
  Log::info("Tone storage: IMA ADPCM 4-bit, 16 samples/block + perfmon");
#else
  Log::info("Tone storage: PCM 16-bit");
#endif
  Log::infof("VoiceState bytes=%u", static_cast<unsigned>(sizeof(VoiceState)));
  Log::infof("Reset reason: %s", resetReasonToText(esp_reset_reason()));
  logStagedHeap("App begin");

#if APP_USE_32BIT_IRAM_AUDIO_BUFFERS
  g_audioIramBuffers = static_cast<AudioIramBuffers*>(heap_caps_malloc(
      sizeof(AudioIramBuffers),
      MALLOC_CAP_INTERNAL | MALLOC_CAP_EXEC | MALLOC_CAP_32BIT));
  if (g_audioIramBuffers == nullptr) {
    Log::infof("32-bit IRAM audio buffer allocation failed: need=%u largest=%u",
               static_cast<unsigned>(sizeof(AudioIramBuffers)),
               static_cast<unsigned>(heap_caps_get_largest_free_block(
                   MALLOC_CAP_INTERNAL | MALLOC_CAP_EXEC | MALLOC_CAP_32BIT)));
    return;
  }
  uint32_t* const clearWords =
      reinterpret_cast<uint32_t*>(g_audioIramBuffers);
  for (size_t i = 0; i < sizeof(AudioIramBuffers) / sizeof(uint32_t); ++i) {
    clearWords[i] = 0;
  }
  m_audioRingBuffer = g_audioIramBuffers->audioRing;
  g_mainMixedLeftQ15 = g_audioIramBuffers->mainMixedLeftQ15;
  g_mainMixedRightQ15 = g_audioIramBuffers->mainMixedRightQ15;
  g_mainReverbInputQ15 = g_audioIramBuffers->mainReverbInputQ15;
  g_mainChorusInputQ15 = g_audioIramBuffers->mainChorusInputQ15;
  g_helperMixedLeftQ15 = g_audioIramBuffers->helperMixedLeftQ15;
  g_helperMixedRightQ15 = g_audioIramBuffers->helperMixedRightQ15;
  g_helperReverbInputQ15 = g_audioIramBuffers->helperReverbInputQ15;
  g_helperChorusInputQ15 = g_audioIramBuffers->helperChorusInputQ15;
  Log::infof("Audio buffers in 32-bit IRAM: addr=%p bytes=%u",
             g_audioIramBuffers,
             static_cast<unsigned>(sizeof(AudioIramBuffers)));
#endif

  esp_err_t nvsResult = nvs_flash_init();
  if (nvsResult == ESP_ERR_NVS_NO_FREE_PAGES ||
      nvsResult == ESP_ERR_NVS_NEW_VERSION_FOUND) {
    nvsResult = nvs_flash_erase();
    if (nvsResult == ESP_OK) {
      nvsResult = nvs_flash_init();
    }
  }
  if (nvsResult != ESP_OK) {
    Log::infof("NVS init failed: %s", esp_err_to_name(nvsResult));
    return;
  }
  logStagedHeap("NVS init");

  beginStorage();
  beginWifi();
  beginWebServer();
  beginMdns();
  if (m_wifiProvisioningMode) {
    Log::info("Wi-Fi provisioning mode: Bluetooth/audio deferred until credentials are saved");
  } else {
    beginBluetooth();
    beginRenderer();
    Log::info("Raw MIDI upload mode: CPU0 streaming parser, CPU1 renderer");
  }
}

void App::update() {
  const unsigned long nowMs = millis();
  Log::service(static_cast<uint32_t>(nowMs));
  serviceWifiSetupButton(static_cast<uint32_t>(nowMs));
  serviceWifiReconfigure();
  // serviceWifiReconfigure() can start a connection and set its timestamp
  // after the first millis() sample above.  Use a fresh sample for timeout
  // checks so a 1 ms scheduling difference cannot look like uint32 underflow.
  const uint32_t wifiNowMs = millis();
  if (m_wifiReconfiguring && !m_wifiConnected &&
      m_wifiReconfigureStartedAtMs != 0 &&
      wifiDeadlineReached(
          wifiNowMs,
          m_wifiReconfigureStartedAtMs + kWifiConnectTimeoutMs)) {
    m_wifiReconfiguring = false;
    m_wifiReconfigureStartedAtMs = 0;
    if (m_wifiPreviousCredentialsValid && !m_wifiRollbackRequested) {
      m_wifiRollbackRequested = true;
      Log::info("Wi-Fi reconfigure timed out; scheduling rollback");
    }
  }
  if (m_wifiRollbackInProgress && !m_wifiConnected &&
      m_wifiReconfigureStartedAtMs != 0 &&
      wifiDeadlineReached(
          wifiNowMs,
          m_wifiReconfigureStartedAtMs + kWifiConnectTimeoutMs)) {
    Log::info("Wi-Fi rollback timed out; restarting with saved credentials");
    Log::flushPending();
    vTaskDelay(pdMS_TO_TICKS(50));
    esp_restart();
  }
  serviceWifiRollback();
  servicePreview(nowMs);
  updateHeartbeat(nowMs);
#if APP_ENABLE_DEBUG_DIAGNOSTICS
  if (kEnableRuntimeDebugDiagnostics) {
    monitorLowHeap(nowMs);
  }
#endif
}

void App::beginStorage() {
  m_songPartition = esp_partition_find_first(
      ESP_PARTITION_TYPE_DATA,
      ESP_PARTITION_SUBTYPE_DATA_SPIFFS,
      nullptr);
  if (m_songPartition == nullptr) {
    Log::info("Song partition not found");
    return;
  }

  Log::infof(
      "Song partition ready: size=%lu",
      static_cast<unsigned long>(m_songPartition->size));
  loadSongMetadataFromPartition();
}

bool App::loadWifiCredentials() {
  m_wifiSsid[0] = '\0';
  m_wifiPassword[0] = '\0';
  bool ssidLoaded = false;
  nvs_handle_t handle = 0;
  if (nvs_open(kWifiNvsNamespace, NVS_READONLY, &handle) == ESP_OK) {
    size_t ssidLength = sizeof(m_wifiSsid);
    ssidLoaded = nvs_get_str(handle, kWifiNvsSsidKey, m_wifiSsid, &ssidLength) == ESP_OK;
    if (ssidLoaded) {
      size_t passwordLength = sizeof(m_wifiPassword);
      if (nvs_get_str(handle, kWifiNvsPasswordKey, m_wifiPassword,
                      &passwordLength) != ESP_OK) {
        // An empty password is valid. If an old/partial NVS entry has no
        // password key, keep the stored SSID and treat it as an open AP.
        m_wifiPassword[0] = '\0';
      }
    }
    nvs_close(handle);
  }
  if (!ssidLoaded) {
    strncpy(m_wifiSsid, Config::WifiSsid, sizeof(m_wifiSsid) - 1);
    strncpy(m_wifiPassword, Config::WifiPassword, sizeof(m_wifiPassword) - 1);
    m_wifiSsid[sizeof(m_wifiSsid) - 1] = '\0';
    m_wifiPassword[sizeof(m_wifiPassword) - 1] = '\0';
  }
  return ssidLoaded;
}

bool App::wifiCredentialsNeedProvisioning() const {
  // An empty password is valid for an open network and must not force the
  // device into provisioning mode. Only the untouched placeholders (or an
  // empty SSID) indicate that credentials have not been configured yet.
  return m_wifiSsid[0] == '\0' ||
      strcmp(m_wifiSsid, kWifiPlaceholderSsid) == 0 ||
      strcmp(m_wifiPassword, kWifiPlaceholderPassword) == 0;
}

void App::serviceWifiSetupButton(uint32_t nowMs) {
  if (m_wifiProvisioningMode || Config::WifiSetupButtonGpio < 0 ||
      Config::WifiSetupButtonGpio >= static_cast<int>(GPIO_NUM_MAX)) {
    return;
  }
  const gpio_num_t pin = static_cast<gpio_num_t>(Config::WifiSetupButtonGpio);
  const int activeLevel = Config::WifiSetupButtonActiveLow ? 0 : 1;
  const bool active = gpio_get_level(pin) == activeLevel;
  if (!active) {
    m_wifiSetupButtonPressed = false;
    m_wifiSetupButtonTriggered = false;
    m_wifiSetupButtonPressedAtMs = 0;
    return;
  }
  if (!m_wifiSetupButtonPressed) {
    m_wifiSetupButtonPressed = true;
    m_wifiSetupButtonPressedAtMs = nowMs;
    return;
  }
  if (!m_wifiSetupButtonTriggered &&
      static_cast<uint32_t>(nowMs - m_wifiSetupButtonPressedAtMs) >=
          Config::WifiSetupButtonHoldMs) {
    m_wifiSetupButtonTriggered = true;
    Log::info("Wi-Fi provisioning requested by BOOT button; restarting");
    if (!requestProvisioningOnNextBoot()) {
      Log::info("Wi-Fi provisioning request could not be saved");
      return;
    }
    Log::flushPending();
    vTaskDelay(pdMS_TO_TICKS(50));
    esp_restart();
  }
}

bool App::saveWifiCredentials(const char* ssid, const char* password) {
  if (ssid == nullptr || password == nullptr) return false;
  const size_t ssidLength = strlen(ssid);
  const size_t passwordLength = strlen(password);
  if (ssidLength == 0 || ssidLength > 32 || passwordLength > 63 ||
      (passwordLength != 0 && passwordLength < 8)) {
    return false;
  }
  nvs_handle_t handle = 0;
  if (nvs_open(kWifiNvsNamespace, NVS_READWRITE, &handle) != ESP_OK) {
    return false;
  }
  esp_err_t result = nvs_set_str(handle, kWifiNvsSsidKey, ssid);
  if (result == ESP_OK) {
    result = nvs_set_str(handle, kWifiNvsPasswordKey, password);
  }
  if (result == ESP_OK) {
    result = nvs_commit(handle);
  }
  nvs_close(handle);
  return result == ESP_OK;
}

#if APP_ENABLE_MDNS
void App::beginMdns() {
  esp_err_t result = mdns_init();
  if (result != ESP_OK && result != ESP_ERR_INVALID_STATE) {
    Log::infof("mDNS init failed: %s", esp_err_to_name(result));
    return;
  }
  result = mdns_hostname_set(kMdnsHostname);
  if (result != ESP_OK) {
    Log::infof("mDNS hostname failed: %s", esp_err_to_name(result));
    return;
  }
  result = mdns_instance_name_set(kMdnsInstanceName);
  if (result != ESP_OK) {
    Log::infof("mDNS instance name failed: %s", esp_err_to_name(result));
    return;
  }
  const char* mode = m_wifiProvisioningMode ? "setup" : "player";
  mdns_txt_item_t txt[] = {
      {"path", "/"},
      {"product", "ESP32 Tiny MIDI Synthesizer"},
      {"mode", mode},
  };
  result = mdns_service_add(
      kMdnsInstanceName, "_http", "_tcp", 80, txt,
      sizeof(txt) / sizeof(txt[0]));
  if (result != ESP_OK) {
    Log::infof("mDNS HTTP service failed: %s", esp_err_to_name(result));
    return;
  }
  Log::infof("mDNS ready: http://%s.local/ mode=%s", kMdnsHostname, mode);
  logStagedHeap("mDNS ready");
}
#else
void App::beginMdns() {}
#endif

bool App::startProvisioningAp() {
  // Set this before stopping STA so queued STA disconnect events cannot start
  // another station reconnect while the fallback AP is being configured.
  m_wifiProvisioningMode = true;
  m_wifiReconfiguring = false;
  m_wifiReconfigureStartedAtMs = 0;
  m_wifiReconfigureNotBeforeMs = 0;
  m_wifiIgnoreNextDisconnect = false;
  m_wifiRollbackRequested = false;
  m_wifiRollbackInProgress = false;
  m_wifiRollbackRetryAtMs = 0;
  m_wifiReconfigureRequested = false;
  m_wifiScanRunning = false;
  m_wifiScanReady = false;

  esp_err_t result = ESP_OK;
  if (m_wifiStarted) {
    result = esp_wifi_disconnect();
    if (result != ESP_OK && result != ESP_ERR_WIFI_NOT_CONNECT) {
      Log::infof("Wi-Fi disconnect before AP fallback failed: %s",
                 esp_err_to_name(result));
    }
    result = esp_wifi_stop();
    if (result != ESP_OK && result != ESP_ERR_WIFI_NOT_STARTED) {
      Log::infof("Wi-Fi STA stop before AP fallback failed: %s",
                 esp_err_to_name(result));
      return false;
    }
    m_wifiStarted = false;
  }

  if (!m_wifiApNetifCreated) {
    if (esp_netif_create_default_wifi_ap() == nullptr) {
      Log::info("Wi-Fi AP netif init failed");
      return false;
    }
    m_wifiApNetifCreated = true;
    logStagedHeap("Wi-Fi AP netif");
  }

  wifi_config_t apConfig = {};
  strncpy(reinterpret_cast<char*>(apConfig.ap.ssid), kProvisioningApSsid,
          sizeof(apConfig.ap.ssid) - 1);
  strncpy(reinterpret_cast<char*>(apConfig.ap.password), kProvisioningApPassword,
          sizeof(apConfig.ap.password) - 1);
  apConfig.ap.ssid_len = strlen(kProvisioningApSsid);
  apConfig.ap.channel = 1;
  apConfig.ap.max_connection = 2;
  apConfig.ap.authmode = WIFI_AUTH_WPA2_PSK;
  apConfig.ap.pmf_cfg.capable = true;
  apConfig.ap.pmf_cfg.required = false;
  // Keep the provisioning AP online while the STA interface performs a
  // background scan.  This lets a user stay on 192.168.4.1 and choose the
  // target network from the setup page instead of typing its SSID blindly.
  result = esp_wifi_set_mode(WIFI_MODE_APSTA);
  if (result == ESP_OK) {
    result = esp_wifi_set_config(WIFI_IF_AP, &apConfig);
  }
  if (result == ESP_OK) {
    result = esp_wifi_start();
  }
  if (result != ESP_OK) {
    Log::infof("Wi-Fi AP start failed: %s", esp_err_to_name(result));
    return false;
  }

  m_wifiStarted = true;
  m_wifiConnected = true;
  m_wifiRetryCount = 0;
  strncpy(m_ipAddress, kProvisioningApIp, sizeof(m_ipAddress) - 1);
  m_ipAddress[sizeof(m_ipAddress) - 1] = '\0';
  if (m_wifiEventGroup != nullptr) {
    xEventGroupClearBits(m_wifiEventGroup, kWifiConnectedBit | kWifiFailedBit);
    xEventGroupSetBits(m_wifiEventGroup, kWifiConnectedBit);
  }
  Log::infof("Wi-Fi provisioning AP ready: SSID=%s password=%s IP=%s",
             kProvisioningApSsid, kProvisioningApPassword, m_ipAddress);
  logStagedHeap("Wi-Fi AP ready");
  return true;
}

void App::beginWifi() {
  const bool buttonProvisioning =
      consumeProvisioningRequest() || wifiSetupButtonLongPressed();
  const bool credentialsLoaded = loadWifiCredentials();
  const bool credentialsProvisioning =
      !credentialsLoaded || wifiCredentialsNeedProvisioning();
  m_wifiProvisioningMode = buttonProvisioning || credentialsProvisioning;
  if (buttonProvisioning) {
    Log::info("Wi-Fi provisioning requested by BOOT button");
  } else if (credentialsProvisioning) {
    Log::info("Wi-Fi provisioning requested: SSID is empty or not configured");
  }
  esp_err_t result = esp_netif_init();
  if (result != ESP_OK && result != ESP_ERR_INVALID_STATE) {
    Log::infof("esp_netif_init failed: %s", esp_err_to_name(result));
    return;
  }
  logStagedHeap("esp_netif_init");
  result = esp_event_loop_create_default();
  if (result != ESP_OK && result != ESP_ERR_INVALID_STATE) {
    Log::infof("event loop init failed: %s", esp_err_to_name(result));
    return;
  }
  logStagedHeap("event loop");
  // The STA netif is needed even in provisioning mode: APSTA mode uses it
  // for passive/active SSID scans while the setup AP remains reachable.
  if (esp_netif_create_default_wifi_sta() == nullptr) {
    Log::info("Wi-Fi station netif init failed");
    return;
  }
  logStagedHeap("Wi-Fi STA netif");

  m_wifiEventGroup = xEventGroupCreate();
  if (m_wifiEventGroup == nullptr) {
    Log::info("Wi-Fi event group allocation failed");
    return;
  }

  wifi_init_config_t initConfig = WIFI_INIT_CONFIG_DEFAULT();
  result = esp_wifi_init(&initConfig);
  if (result != ESP_OK) {
    Log::infof("esp_wifi_init failed: %s", esp_err_to_name(result));
    return;
  }
  logStagedHeap("esp_wifi_init");
  result = esp_coex_preference_set(ESP_COEX_PREFER_BT);
  if (result != ESP_OK) {
    Log::infof("BT coexistence preference failed: %s", esp_err_to_name(result));
  } else {
    Log::info("BT coexistence preference: Bluetooth preferred");
  }
  result = esp_event_handler_instance_register(
      WIFI_EVENT,
      ESP_EVENT_ANY_ID,
      &App::wifiEventHandler,
      this,
      &m_wifiAnyEventInstance);
  if (result == ESP_OK) {
    result = esp_event_handler_instance_register(
        IP_EVENT,
        IP_EVENT_STA_GOT_IP,
        &App::wifiEventHandler,
        this,
        &m_wifiGotIpInstance);
  }
  if (result != ESP_OK) {
    Log::infof("Wi-Fi event registration failed: %s", esp_err_to_name(result));
    return;
  }

  if (m_wifiProvisioningMode) {
    if (!startProvisioningAp()) {
      return;
    }
    return;
  }

  wifi_config_t wifiConfig = {};
  copyWifiConfigField(wifiConfig.sta.ssid, sizeof(wifiConfig.sta.ssid),
                      m_wifiSsid);
  copyWifiConfigField(wifiConfig.sta.password, sizeof(wifiConfig.sta.password),
                      m_wifiPassword);
  wifiConfig.sta.threshold.authmode = m_wifiPassword[0] == '\0'
      ? WIFI_AUTH_OPEN : WIFI_AUTH_WPA2_PSK;
  wifiConfig.sta.pmf_cfg.capable = true;
  wifiConfig.sta.pmf_cfg.required = false;

  result = esp_wifi_set_mode(WIFI_MODE_STA);
  if (result == ESP_OK) {
    result = esp_wifi_set_config(WIFI_IF_STA, &wifiConfig);
  }
  if (result == ESP_OK) {
    result = esp_wifi_start();
  }
  if (result != ESP_OK) {
    Log::infof("Wi-Fi start failed: %s", esp_err_to_name(result));
    return;
  }
  m_wifiStarted = true;

  Log::infof("Connecting to Wi-Fi SSID: %s", m_wifiSsid);
  const EventBits_t bits = xEventGroupWaitBits(
      m_wifiEventGroup,
      kWifiConnectedBit | kWifiFailedBit,
      pdFALSE,
      pdFALSE,
      pdMS_TO_TICKS(kWifiConnectTimeoutMs));
  if (bits & kWifiConnectedBit) {
    Log::infof("Wi-Fi connected: %s", m_ipAddress);
    logStagedHeap("Wi-Fi connected");
  } else {
    Log::infof(
        "Wi-Fi connect failed (attempts=%u, timeout=%lu ms); falling back to provisioning AP",
        static_cast<unsigned>(m_wifiRetryCount),
        static_cast<unsigned long>(kWifiConnectTimeoutMs));
    if (!startProvisioningAp()) {
      Log::info("Wi-Fi provisioning AP fallback failed");
    }
  }
}

void App::serviceWifiReconfigure() {
  if (!m_wifiReconfigureRequested || m_wifiReconfiguring ||
      m_wifiRollbackRequested || m_wifiRollbackInProgress ||
      m_wifiProvisioningMode) {
    return;
  }
  const uint32_t nowMs = millis();
  if (m_wifiReconfigureNotBeforeMs != 0 &&
      !wifiDeadlineReached(nowMs, m_wifiReconfigureNotBeforeMs)) {
    return;
  }
  char pendingSsid[sizeof(m_wifiPendingSsid)] = {};
  char pendingPassword[sizeof(m_wifiPendingPassword)] = {};
  portENTER_CRITICAL(&m_wifiConfigMux);
  if (!m_wifiReconfigureRequested) {
    portEXIT_CRITICAL(&m_wifiConfigMux);
    return;
  }
  memcpy(pendingSsid, m_wifiPendingSsid, sizeof(pendingSsid));
  memcpy(pendingPassword, m_wifiPendingPassword, sizeof(pendingPassword));
  m_wifiReconfigureRequested = false;
  m_wifiReconfigureNotBeforeMs = 0;
  portEXIT_CRITICAL(&m_wifiConfigMux);
  strncpy(m_wifiPreviousSsid, m_wifiSsid, sizeof(m_wifiPreviousSsid) - 1);
  m_wifiPreviousSsid[sizeof(m_wifiPreviousSsid) - 1] = '\0';
  strncpy(m_wifiPreviousPassword, m_wifiPassword,
          sizeof(m_wifiPreviousPassword) - 1);
  m_wifiPreviousPassword[sizeof(m_wifiPreviousPassword) - 1] = '\0';
  m_wifiPreviousCredentialsValid = true;

  wifi_config_t wifiConfig = {};
  copyWifiConfigField(wifiConfig.sta.ssid, sizeof(wifiConfig.sta.ssid),
                      pendingSsid);
  copyWifiConfigField(wifiConfig.sta.password, sizeof(wifiConfig.sta.password),
                      pendingPassword);
  wifiConfig.sta.threshold.authmode = pendingPassword[0] == '\0'
      ? WIFI_AUTH_OPEN : WIFI_AUTH_WPA2_PSK;
  wifiConfig.sta.pmf_cfg.capable = true;
  wifiConfig.sta.pmf_cfg.required = false;

  m_wifiReconfiguring = true;
  m_wifiReconfigureStartedAtMs = millis();
  m_wifiIgnoreNextDisconnect = true;
  esp_err_t result = esp_wifi_disconnect();
  if (result != ESP_OK) m_wifiIgnoreNextDisconnect = false;
  if (result == ESP_OK || result == ESP_ERR_WIFI_NOT_CONNECT) {
    result = esp_wifi_set_config(WIFI_IF_STA, &wifiConfig);
  }
  if (result == ESP_OK) {
    strncpy(m_wifiSsid, pendingSsid, sizeof(m_wifiSsid) - 1);
    m_wifiSsid[sizeof(m_wifiSsid) - 1] = '\0';
    strncpy(m_wifiPassword, pendingPassword, sizeof(m_wifiPassword) - 1);
    m_wifiPassword[sizeof(m_wifiPassword) - 1] = '\0';
    m_wifiRetryCount = 0;
    m_wifiConnected = false;
    strncpy(m_ipAddress, "0.0.0.0", sizeof(m_ipAddress));
    if (m_wifiEventGroup != nullptr) {
      xEventGroupClearBits(m_wifiEventGroup, kWifiConnectedBit | kWifiFailedBit);
    }
    result = esp_wifi_connect();
  }
  if (result != ESP_OK) {
    m_wifiReconfiguring = false;
    m_wifiReconfigureStartedAtMs = 0;
    m_wifiIgnoreNextDisconnect = false;
    m_wifiRollbackRequested = m_wifiPreviousCredentialsValid;
    Log::infof("Wi-Fi reconfigure failed: %s", esp_err_to_name(result));
    return;
  }
  Log::infof("Wi-Fi reconnect started for SSID: %s", m_wifiSsid);
}

void App::serviceWifiRollback() {
  if (!m_wifiRollbackRequested || m_wifiRollbackInProgress ||
      m_wifiProvisioningMode || !m_wifiPreviousCredentialsValid) {
    return;
  }
  const uint32_t nowMs = millis();
  if (m_wifiRollbackRetryAtMs != 0 &&
      !wifiDeadlineReached(nowMs, m_wifiRollbackRetryAtMs)) {
    return;
  }
  m_wifiRollbackRetryAtMs = 0;
  m_wifiRollbackRequested = false;
  m_wifiRollbackInProgress = true;
  m_wifiReconfigureStartedAtMs = 0;

  char previousSsid[sizeof(m_wifiPreviousSsid)] = {};
  char previousPassword[sizeof(m_wifiPreviousPassword)] = {};
  strncpy(previousSsid, m_wifiPreviousSsid, sizeof(previousSsid) - 1);
  strncpy(previousPassword, m_wifiPreviousPassword, sizeof(previousPassword) - 1);
  wifi_config_t wifiConfig = {};
  copyWifiConfigField(wifiConfig.sta.ssid, sizeof(wifiConfig.sta.ssid),
                      previousSsid);
  copyWifiConfigField(wifiConfig.sta.password, sizeof(wifiConfig.sta.password),
                      previousPassword);
  wifiConfig.sta.threshold.authmode = previousPassword[0] == '\0'
      ? WIFI_AUTH_OPEN : WIFI_AUTH_WPA2_PSK;
  wifiConfig.sta.pmf_cfg.capable = true;
  wifiConfig.sta.pmf_cfg.required = false;

  m_wifiConnected = false;
  strncpy(m_ipAddress, "0.0.0.0", sizeof(m_ipAddress));
  if (m_wifiEventGroup != nullptr) {
    xEventGroupClearBits(m_wifiEventGroup, kWifiConnectedBit | kWifiFailedBit);
  }
  m_wifiIgnoreNextDisconnect = true;
  esp_err_t result = esp_wifi_disconnect();
  if (result != ESP_OK) m_wifiIgnoreNextDisconnect = false;
  if (result != ESP_OK && result != ESP_ERR_WIFI_NOT_CONNECT) {
    Log::infof("Wi-Fi disconnect before rollback failed: %s",
               esp_err_to_name(result));
  }
  if (result == ESP_OK || result == ESP_ERR_WIFI_NOT_CONNECT) {
    result = esp_wifi_set_config(WIFI_IF_STA, &wifiConfig);
  }
  if (result == ESP_OK) {
    strncpy(m_wifiSsid, previousSsid, sizeof(m_wifiSsid) - 1);
    m_wifiSsid[sizeof(m_wifiSsid) - 1] = '\0';
    strncpy(m_wifiPassword, previousPassword, sizeof(m_wifiPassword) - 1);
    m_wifiPassword[sizeof(m_wifiPassword) - 1] = '\0';
    m_wifiRetryCount = 0;
    m_wifiConnected = false;
    strncpy(m_ipAddress, "0.0.0.0", sizeof(m_ipAddress));
    if (m_wifiEventGroup != nullptr) {
      xEventGroupClearBits(m_wifiEventGroup, kWifiConnectedBit | kWifiFailedBit);
    }
    result = esp_wifi_connect();
  } else {
    m_wifiIgnoreNextDisconnect = false;
  }

  m_wifiReconfiguring = false;
  if (result != ESP_OK) {
    m_wifiReconfigureStartedAtMs = 0;
    m_wifiRollbackInProgress = false;
    m_wifiIgnoreNextDisconnect = false;
    m_wifiRollbackRequested = true;
    m_wifiRollbackRetryAtMs = millis() + kWifiRollbackRetryMs;
    Log::infof("Wi-Fi rollback failed: %s", esp_err_to_name(result));
  } else {
    m_wifiRollbackRetryAtMs = 0;
    m_wifiReconfigureStartedAtMs = millis();
    Log::infof("Wi-Fi credentials rejected; reconnecting to previous SSID: %s",
               previousSsid);
  }
}

void App::finishWifiScan() {
  WifiNetworkInfo found[kMaxWifiNetworks] = {};
  uint8_t foundCount = 0;
  uint16_t recordCount = 0;
  uint16_t recordsFetched = 0;
  esp_err_t result = esp_wifi_scan_get_ap_num(&recordCount);
  if (result == ESP_OK) {
    for (uint16_t i = 0; i < recordCount; ++i) {
      wifi_ap_record_t record = {};
      const esp_err_t recordResult = esp_wifi_scan_get_ap_record(&record);
      if (recordResult != ESP_OK) {
        result = recordResult;
        break;
      }
      ++recordsFetched;
      const size_t ssidLength = strnlen(
          reinterpret_cast<const char*>(record.ssid), sizeof(record.ssid));
      if (ssidLength == 0) continue;
      bool duplicate = false;
      for (uint8_t j = 0; j < foundCount; ++j) {
        if (strlen(found[j].ssid) == ssidLength &&
            memcmp(found[j].ssid, record.ssid, ssidLength) == 0) {
          duplicate = true;
          break;
        }
      }
      if (duplicate || foundCount >= kMaxWifiNetworks) continue;
      found[foundCount].inUse = true;
      memcpy(found[foundCount].ssid, record.ssid, ssidLength);
      found[foundCount].ssid[ssidLength] = '\0';
      found[foundCount].rssi = record.rssi;
      found[foundCount].authmode = static_cast<uint8_t>(record.authmode);
      ++foundCount;
    }
  }
  if (result != ESP_OK || recordsFetched < recordCount) {
    // get_ap_record() frees one record at a time.  Clear any records left
    // after an early driver error or after the compact result list is full.
    esp_wifi_clear_ap_list();
  }
  portENTER_CRITICAL(&m_wifiScanMux);
  memcpy(m_wifiNetworks, found, sizeof(found));
  m_wifiNetworkCount = foundCount;
  m_wifiScanReady = result == ESP_OK;
  m_wifiScanRunning = false;
  portEXIT_CRITICAL(&m_wifiScanMux);
  Log::infof("Wi-Fi scan %s: %u networks",
             result == ESP_OK ? "complete" : "failed",
             static_cast<unsigned>(foundCount));
}

void App::wifiEventHandler(
    void* context,
    esp_event_base_t eventBase,
    int32_t eventId,
    void* eventData) {
  App* app = static_cast<App*>(context);
  if (app == nullptr || app->m_wifiEventGroup == nullptr) {
    return;
  }
  if (eventBase == WIFI_EVENT && eventId == WIFI_EVENT_SCAN_DONE) {
    app->finishWifiScan();
    return;
  }
  if (eventBase == WIFI_EVENT && eventId == WIFI_EVENT_AP_START) {
    if (!app->m_wifiProvisioningMode) {
      return;
    }
    app->m_wifiConnected = true;
    strncpy(app->m_ipAddress, kProvisioningApIp, sizeof(app->m_ipAddress) - 1);
    app->m_ipAddress[sizeof(app->m_ipAddress) - 1] = '\0';
    return;
  }
  if (eventBase == WIFI_EVENT && eventId == WIFI_EVENT_STA_START) {
    if (!app->m_wifiProvisioningMode && !app->m_wifiRollbackRequested &&
        !app->m_wifiRollbackInProgress) {
      esp_wifi_connect();
    }
    return;
  }
  if (eventBase == WIFI_EVENT && eventId == WIFI_EVENT_STA_DISCONNECTED) {
    if (app->m_wifiProvisioningMode) {
      // A STA disconnect queued before the fallback AP started must not
      // overwrite the AP's connected/status state.
      app->m_wifiConnected = true;
      strncpy(app->m_ipAddress, kProvisioningApIp,
              sizeof(app->m_ipAddress) - 1);
      app->m_ipAddress[sizeof(app->m_ipAddress) - 1] = '\0';
      return;
    }
    app->m_wifiConnected = false;
    strncpy(app->m_ipAddress, "0.0.0.0", sizeof(app->m_ipAddress));
    if (app->m_wifiRollbackRequested) {
      app->m_wifiRetryCount = 0;
      return;
    }
    if (app->m_wifiIgnoreNextDisconnect) {
      app->m_wifiIgnoreNextDisconnect = false;
      app->m_wifiRetryCount = 0;
      return;
    }
    if (app->m_wifiRollbackInProgress) {
      if (app->m_wifiRetryCount < UINT8_MAX) ++app->m_wifiRetryCount;
      if (app->m_wifiRetryCount < kWifiRetriesBeforeFailure) {
        esp_wifi_connect();
      }
      return;
    }
    if (app->m_wifiReconfiguring) {
      if (app->m_wifiRetryCount < UINT8_MAX) {
        ++app->m_wifiRetryCount;
      }
      if (app->m_wifiRetryCount >= kWifiRetriesBeforeFailure) {
        app->m_wifiReconfiguring = false;
        app->m_wifiReconfigureStartedAtMs = 0;
        if (app->m_wifiPreviousCredentialsValid) {
          app->m_wifiRollbackRequested = true;
          Log::infof(
              "Wi-Fi reconfigure failed after %u attempts; scheduling rollback",
              static_cast<unsigned>(kWifiRetriesBeforeFailure));
        } else {
          xEventGroupSetBits(app->m_wifiEventGroup, kWifiFailedBit);
        }
        return;
      }
      esp_wifi_connect();
      return;
    }
    esp_wifi_connect();
    if (app->m_wifiRetryCount < UINT8_MAX) {
      ++app->m_wifiRetryCount;
    }
    if (app->m_wifiRetryCount >= kWifiRetriesBeforeFailure) {
      xEventGroupSetBits(app->m_wifiEventGroup, kWifiFailedBit);
    }
    return;
  }
  if (eventBase == IP_EVENT && eventId == IP_EVENT_STA_GOT_IP) {
    if (app->m_wifiProvisioningMode || app->m_wifiRollbackRequested) {
      return;
    }
    const ip_event_got_ip_t* event =
        static_cast<const ip_event_got_ip_t*>(eventData);
    snprintf(
        app->m_ipAddress,
        sizeof(app->m_ipAddress),
        IPSTR,
        IP2STR(&event->ip_info.ip));
    app->m_wifiConnected = true;
    app->m_wifiRetryCount = 0;
    const bool completedReconfigure = app->m_wifiReconfiguring;
    const bool completedRollback = app->m_wifiRollbackInProgress;
    app->m_wifiReconfiguring = false;
    app->m_wifiRollbackInProgress = false;
    app->m_wifiReconfigureStartedAtMs = 0;
    app->m_wifiIgnoreNextDisconnect = false;
    bool credentialsCommitted = !completedReconfigure;
    if (completedReconfigure) {
      credentialsCommitted =
          app->saveWifiCredentials(app->m_wifiSsid, app->m_wifiPassword);
      if (!credentialsCommitted) {
        Log::info("Wi-Fi connected, but saving credentials to NVS failed");
        // Do not expose the uncommitted network as the active connection.  A
        // reset before rollback would otherwise appear to have succeeded in
        // the runtime state while NVS still contains the old credentials.
        app->m_wifiConnected = false;
        strncpy(app->m_ipAddress, "0.0.0.0", sizeof(app->m_ipAddress));
        xEventGroupClearBits(app->m_wifiEventGroup, kWifiConnectedBit);
        if (app->m_wifiPreviousCredentialsValid) {
          app->m_wifiRollbackRequested = true;
          Log::info("Wi-Fi NVS save failed; scheduling rollback");
        }
      }
    }
    if (completedReconfigure && credentialsCommitted) {
      Log::infof("Wi-Fi credentials committed for SSID: %s", app->m_wifiSsid);
    } else if (completedRollback) {
      Log::infof("Wi-Fi rollback connected: %s", app->m_wifiSsid);
    }
    if (!app->m_wifiRollbackRequested) {
      app->m_wifiPreviousCredentialsValid = false;
      memset(app->m_wifiPreviousSsid, 0, sizeof(app->m_wifiPreviousSsid));
      memset(app->m_wifiPreviousPassword, 0, sizeof(app->m_wifiPreviousPassword));
      memset(app->m_wifiPendingSsid, 0, sizeof(app->m_wifiPendingSsid));
      memset(app->m_wifiPendingPassword, 0, sizeof(app->m_wifiPendingPassword));
      xEventGroupClearBits(app->m_wifiEventGroup, kWifiFailedBit);
      xEventGroupSetBits(app->m_wifiEventGroup, kWifiConnectedBit);
    }
  }
}

void App::beginBluetooth() {
  if (!Config::EnableBluetooth) {
    Log::info("Bluetooth disabled by config");
    return;
  }

  if (esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_IDLE) {
    const esp_err_t releaseResult = esp_bt_mem_release(ESP_BT_MODE_BLE);
    if (releaseResult != ESP_OK && releaseResult != ESP_ERR_INVALID_STATE) {
      Log::infof(
          "BLE memory release skipped: %s",
          esp_err_to_name(releaseResult));
    }
    logStagedHeap("BLE memory release");
    esp_bt_controller_config_t btConfig = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    const esp_err_t initResult = esp_bt_controller_init(&btConfig);
    if (initResult != ESP_OK) {
      Log::infof(
          "Bluetooth controller init failed: %s",
          esp_err_to_name(initResult));
      return;
    }
    logStagedHeap("BT controller init");
  }

  if (esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_INITED) {
    const esp_err_t enableResult =
        esp_bt_controller_enable(ESP_BT_MODE_CLASSIC_BT);
    if (enableResult != ESP_OK) {
      Log::infof(
          "Bluetooth controller enable failed: %s",
          esp_err_to_name(enableResult));
      return;
    }
    logStagedHeap("BT controller enable");
  }

  if (esp_bt_controller_get_status() != ESP_BT_CONTROLLER_STATUS_ENABLED) {
    Log::info("Bluetooth controller did not reach enabled state");
    return;
  }

  // A2DPはClassic Bluetooth (BR/EDR)を使用するため、BLE用の送信電力API
  // ではなくBR/EDR用APIを使う。コントローラ有効化後かつSDP/A2DP開始前に
  // 設定することで、問い合わせ・接続・接続中の電力範囲を引き上げる。
  const esp_power_level_t btTxPowerMin = ESP_PWR_LVL_P3;
  const esp_power_level_t btTxPowerMax = ESP_PWR_LVL_P9;
  const esp_err_t txPowerResult =
      esp_bredr_tx_power_set(btTxPowerMin, btTxPowerMax);
  if (txPowerResult != ESP_OK) {
    Log::infof(
        "BT BR/EDR TX power set failed: %s (requested +3..+9 dBm)",
        esp_err_to_name(txPowerResult));
  } else {
    esp_power_level_t effectiveMin = btTxPowerMin;
    esp_power_level_t effectiveMax = btTxPowerMax;
    const esp_err_t getPowerResult =
        esp_bredr_tx_power_get(&effectiveMin, &effectiveMax);
    if (getPowerResult == ESP_OK) {
      Log::infof(
          "BT BR/EDR TX power: requested +3..+9 dBm, effective levels %d..%d",
          static_cast<int>(effectiveMin),
          static_cast<int>(effectiveMax));
    } else {
      Log::infof(
          "BT BR/EDR TX power set: +3..+9 dBm (readback failed: %s)",
          esp_err_to_name(getPowerResult));
    }
  }

  if (esp_bluedroid_get_status() == ESP_BLUEDROID_STATUS_UNINITIALIZED &&
      esp_bluedroid_init() != ESP_OK) {
    Log::info("esp_bluedroid_init failed");
    return;
  }
  logStagedHeap("Bluedroid init");

  if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED &&
      esp_bluedroid_enable() != ESP_OK) {
    Log::info("esp_bluedroid_enable failed");
    return;
  }
  logStagedHeap("Bluedroid enable");

  esp_bt_gap_register_callback(App::btGapCallback);

  esp_a2d_register_callback(App::a2dpCallback);
  esp_a2d_source_register_data_callback(App::audioDataCallback);

  if (esp_a2d_source_init() != ESP_OK) {
    Log::info("esp_a2d_source_init failed");
    return;
  }
  logStagedHeap("A2DP source init");

  registerA2dpSourceEndpoint();
  logStagedHeap("A2DP SEP register");

  esp_bt_gap_set_device_name(Config::DeviceName);
  esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE);
  m_btReady = true;
  Log::info("Bluetooth Classic + A2DP source ready");
}

void App::registerA2dpSourceEndpoint() {
  esp_a2d_mcc_t mcc = {};
  mcc.type = ESP_A2D_MCT_SBC;
  mcc.cie.sbc_info.samp_freq = sampleRateToSbcMask(m_requestedSampleRateHz);
  mcc.cie.sbc_info.ch_mode = ESP_A2D_SBC_CIE_CH_MODE_JOINT_STEREO;
  mcc.cie.sbc_info.block_len = ESP_A2D_SBC_CIE_BLOCK_LEN_16;
  mcc.cie.sbc_info.num_subbands = ESP_A2D_SBC_CIE_NUM_SUBBANDS_8;
  mcc.cie.sbc_info.alloc_mthd = ESP_A2D_SBC_CIE_ALLOC_MTHD_LOUDNESS;
  mcc.cie.sbc_info.min_bitpool = 2;
  // Joint stereoで44.1kHz時の音質を確保する。接続先が対応範囲内で選択する。
  mcc.cie.sbc_info.max_bitpool = 53;

  const esp_err_t result = esp_a2d_source_register_stream_endpoint(0, &mcc);
  Log::infof(
      "A2DP SEP register: result=%d sr=%s ch=joint bitpool=%u-%u",
      static_cast<int>(result),
      sbcSampleRateToText(mcc.cie.sbc_info.samp_freq),
      static_cast<unsigned>(mcc.cie.sbc_info.min_bitpool),
      static_cast<unsigned>(mcc.cie.sbc_info.max_bitpool));
}

void App::beginRenderer() {
  if (m_renderTaskHandle != nullptr) {
    return;
  }

  BaseType_t helperResult = xTaskCreatePinnedToCore(
      App::rendererHelperTaskEntry,
      "SynthHelp",
      2048,
      this,
      2,
      &m_renderHelperTaskHandle,
      0);
  if (helperResult != pdPASS) {
    m_renderHelperTaskHandle = nullptr;
    Log::info("Failed to start synth helper task; using core 1 only");
  }
  logStagedHeap("SynthHelp task");

  BaseType_t parserResult = xTaskCreatePinnedToCore(
      App::rawMidiParserTaskEntry,
      "MidiParse",
      4096,
      this,
      1,
      &m_rawMidiParserTaskHandle,
      0);
  if (parserResult != pdPASS) {
    m_rawMidiParserTaskHandle = nullptr;
    Log::info("Failed to start raw MIDI parser task");
  }
  logStagedHeap("MidiParse task");

  BaseType_t result = xTaskCreatePinnedToCore(
      App::rendererTaskEntry,
      "SynthRender",
      4096,
      this,
      2,
      &m_renderTaskHandle,
      1);
  if (result == pdPASS) {
    Log::infof(
        "Synth render task started on core 1, helper=%s",
        m_renderHelperTaskHandle != nullptr
            ? "core 0 (initial 22:10, adaptive max 18:14 at 32 voices)"
            : "off");
  } else {
    Log::info("Failed to start synth render task");
  }
  logStagedHeap("SynthRender task");
}

void App::updateMusic(unsigned long nowMs) {
  if (!m_playing || !m_songLoaded) {
    return;
  }

  if (!m_audioStarted) {
    return;
  }

  if (m_playbackStartMs == 0) {
    const unsigned long autoPlaybackNotBeforeMs = m_autoPlaybackNotBeforeMs;
    if (autoPlaybackNotBeforeMs != 0 &&
        static_cast<int32_t>(nowMs - autoPlaybackNotBeforeMs) < 0) {
      return;
    }
    startSongPlayback();
  }

  const uint32_t elapsedMs = nowMs - m_playbackStartMs;
  processPendingSongEvents(elapsedMs);

  // An empty/malformed raw file can reach EOF without producing a duration.
  // Stop it after any zero-time events have drained instead of leaving the
  // renderer in a permanent restart/parse cycle.
  if (m_songFormatVersion == kSongFormatVersionRawMidi &&
      m_rawMidiParserEof && m_song.durationMs == 0) {
    MidiEvent pending;
    if (!peekRawMidiEvent(pending)) {
      m_playing = false;
      stopAllVoices();
      return;
    }
  }

  // The parser marks this flag false only after reaching EOF.  Using the
  // published task flag avoids reading parser internals concurrently here.
  // Raw MIDI starts with an unknown duration and is parsed asynchronously.
  // Do not treat the parser's transient stopped state as end-of-song: doing
  // so can restart the song about once per parser wake-up and starve CPU0.
  const bool rawDurationKnown = m_songFormatVersion != kSongFormatVersionRawMidi ||
      (m_rawMidiParserEof && m_song.durationMs != UINT32_MAX &&
       m_song.durationMs > 0);
  const bool songEnded = rawDurationKnown &&
      m_song.durationMs != UINT32_MAX && m_song.durationMs > 0 &&
      (elapsedMs > m_song.durationMs && elapsedMs - m_song.durationMs > 200);
  if (songEnded) {
    if (m_loopSong) {
      startSongPlayback();
    } else {
      m_playing = false;
      stopAllVoices();
    }
  }
}

void App::updateHeartbeat(unsigned long nowMs) {
  const uint32_t heartbeatWindowMs = nowMs - m_lastHeartbeatMs;
  if (heartbeatWindowMs < 4000) {
    return;
  }
  m_lastHeartbeatMs = nowMs;
#if !APP_ENABLE_RUNTIME_STATS
  // デバッグ用の周期ログ・統計収集は通常ビルドでは停止。
  return;
#endif
#if SYNTH_RENDER_PROFILING && SYNTH_RENDER_PROFILE_HEARTBEAT
  // 書込み先を先に切り替え、旧bankを使用中の最大1ジョブだけ完了待ちする。
  // render中の統計加算にはatomic/mutexを使わず、heartbeat側だけで同期する。
  const uint32_t completedProfileBank = __atomic_load_n(
      &m_rendererProfileActiveBank, __ATOMIC_ACQUIRE) & 1U;
  __atomic_store_n(
      &m_rendererProfileActiveBank,
      completedProfileBank ^ 1U,
      __ATOMIC_RELEASE);
  while (__atomic_load_n(&m_mainProfileWriterBank, __ATOMIC_ACQUIRE) ==
             completedProfileBank ||
         __atomic_load_n(&m_helperProfileWriterBank, __ATOMIC_ACQUIRE) ==
             completedProfileBank) {
    taskYIELD();
  }
  RendererProfileBank& completedProfile =
      m_rendererProfileBanks[completedProfileBank];
#endif
  const uint32_t idleRuntimeUs0 = static_cast<uint32_t>(
      ulTaskGetIdleRunTimeCounterForCore(0));
  const uint32_t idleRuntimeUs1 = static_cast<uint32_t>(
      ulTaskGetIdleRunTimeCounterForCore(1));
  const uint32_t idleDeltaUs0 = idleRuntimeUs0 - m_prevIdleRuntimeUs[0];
  const uint32_t idleDeltaUs1 = idleRuntimeUs1 - m_prevIdleRuntimeUs[1];
  m_prevIdleRuntimeUs[0] = idleRuntimeUs0;
  m_prevIdleRuntimeUs[1] = idleRuntimeUs1;
  const uint64_t heartbeatWindowUs =
      static_cast<uint64_t>(heartbeatWindowMs) * 1000ULL;
  const uint32_t idlePermille0 = heartbeatWindowUs != 0
      ? min<uint32_t>(
          1000,
          static_cast<uint32_t>(
              (static_cast<uint64_t>(idleDeltaUs0) * 1000ULL) /
              heartbeatWindowUs))
      : 0;
  const uint32_t idlePermille1 = heartbeatWindowUs != 0
      ? min<uint32_t>(
          1000,
          static_cast<uint32_t>(
              (static_cast<uint64_t>(idleDeltaUs1) * 1000ULL) /
              heartbeatWindowUs))
      : 0;
  const uint32_t busyPermille0 = 1000 - idlePermille0;
  const uint32_t busyPermille1 = 1000 - idlePermille1;
  const unsigned stackHw =
      m_renderTaskHandle != nullptr
          ? static_cast<unsigned>(uxTaskGetStackHighWaterMark(m_renderTaskHandle))
          : 0U;
  const unsigned helperStackHw =
      m_renderHelperTaskHandle != nullptr
          ? static_cast<unsigned>(uxTaskGetStackHighWaterMark(m_renderHelperTaskHandle))
          : 0U;
  const unsigned long ifr = static_cast<unsigned long>(
      heap_caps_get_free_size(MALLOC_CAP_INTERNAL));
  const unsigned long ilm = static_cast<unsigned long>(
      heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL));
  const unsigned long f8 = static_cast<unsigned long>(
      heap_caps_get_free_size(MALLOC_CAP_8BIT));
  const unsigned long l8 = static_cast<unsigned long>(
      heap_caps_get_largest_free_block(MALLOC_CAP_8BIT));
  if (f8 < m_windowMinF8) {
    m_windowMinF8 = static_cast<uint32_t>(f8);
  }
  if (l8 < m_windowMinL8) {
    m_windowMinL8 = static_cast<uint32_t>(l8);
  }
  const uint32_t btCbCount = m_btDataCbCount;
  const uint32_t btCbBytes = m_btDataCbBytes;
  const uint32_t btCbWindowCount = btCbCount - m_btDataCbPrevCount;
  const uint32_t btCbWindowBytes = btCbBytes - m_btDataCbPrevBytes;
  m_btDataCbPrevCount = btCbCount;
  m_btDataCbPrevBytes = btCbBytes;
  const uint32_t btCbGapMaxUs = m_btDataCbGapMaxUs;
  const uint32_t btCbLateCount = m_btDataCbLateCount;
  const uint32_t btCbBurstCount = m_btDataCbBurstCount;
  const uint32_t btCbMinRf = m_btDataCbMinReadableFrames;
  const uint32_t btCbMaxRf = m_btDataCbMaxReadableFrames;
  const uint32_t renderCount = m_renderChunkCount;
  const uint32_t renderTotalUs = m_renderTotalUs;
  const uint32_t renderMaxUs = m_renderMaxUs;
  const uint32_t renderMutexMisses = m_renderMutexMissCount;
  const uint32_t renderNotifyCount = m_renderNotifyCount;
  const uint32_t parallelJobCount = m_parallelJobCount;
  const uint64_t parallelMainCycleTotal = m_parallelMainCycleTotal;
  const uint64_t parallelHelperCycleTotal = m_parallelHelperCycleTotal;
  const uint64_t parallelWaitCycleTotal = m_parallelWaitCycleTotal;
  const uint32_t parallelMainCycleMax = m_parallelMainCycleMax;
  const uint32_t parallelHelperCycleMax = m_parallelHelperCycleMax;
  const uint32_t parallelWaitCycleMax = m_parallelWaitCycleMax;
#if SYNTH_RENDER_PROFILING && SYNTH_RENDER_PROFILE_HEARTBEAT
  const RenderProfileStats& renderProfile = completedProfile.render;
  const uint32_t profilePhaseCount = renderProfile.phaseCount;
  const uint64_t profilePrepCycleTotal = renderProfile.prepCycleTotal;
  const uint64_t profileMainCycleTotal = renderProfile.mainCycleTotal;
  const uint64_t profileWaitCycleTotal = renderProfile.waitCycleTotal;
  const uint64_t profileMergeCycleTotal = renderProfile.mergeCycleTotal;
  const uint64_t profileFxoutCycleTotal = renderProfile.fxoutCycleTotal;
  const uint32_t profilePrepCycleMax = renderProfile.prepCycleMax;
  const uint32_t profileMainCycleMax = renderProfile.mainCycleMax;
  const uint32_t profileWaitCycleMax = renderProfile.waitCycleMax;
  const uint32_t profileMergeCycleMax = renderProfile.mergeCycleMax;
  const uint32_t profileFxoutCycleMax = renderProfile.fxoutCycleMax;
  const VoiceProfileStats& mainVoiceProfile = completedProfile.mainVoice;
  const VoiceProfileStats& helperVoiceProfile = completedProfile.helperVoice;
  const uint32_t helperStartLatencyCount =
      completedProfile.helperStartLatencyCount;
  const uint64_t helperStartLatencyTotalUs =
      completedProfile.helperStartLatencyTotalUs;
  const uint32_t helperStartLatencyMaxUs =
      completedProfile.helperStartLatencyMaxUs;
#endif
  MidiEvent rawQueueHead;
  const bool rawQueueAvailable = peekRawMidiEvent(rawQueueHead);
  const uint16_t rawQueueDepth = static_cast<uint16_t>(
      (m_rawMidiQueueWrite + kRawMidiQueueSize - m_rawMidiQueueRead) %
      kRawMidiQueueSize);
#if APP_ENABLE_TONE_PERFMON
  const uint64_t perfCycleTotal = m_perfCycleTotal;
  const uint64_t perfDataStallTotal = m_perfDataStallTotal;
  const uint64_t perfInstructionStallTotal = m_perfInstructionStallTotal;
  const uint32_t perfCycleMax = m_perfCycleMax;
  const uint32_t perfDataStallMax = m_perfDataStallMax;
  const uint32_t perfInstructionStallMax = m_perfInstructionStallMax;
#endif
#if APP_USE_ADPCM_TONES
  const uint32_t adpcmNibbleDecodes = g_adpcmNibbleDecodeCount;
  const uint32_t adpcmCacheResets = g_adpcmCacheResetCount;
  const uint32_t adpcmPairHits = g_adpcmPairHitCount;
  const uint32_t adpcmBlockBoundaries = g_adpcmBlockBoundaryCount;
  const uint32_t adpcmMaxDecode = g_adpcmMaxDecodePerRead;
#endif
#if APP_USE_MULAW_TONES && APP_ENABLE_MULAW_CACHE_STATS
  const uint32_t mulawSameHits = g_mulawSameIndexHitCount;
  const uint32_t mulawOneStepHits = g_mulawOneStepHitCount;
  const uint32_t mulawReloads = g_mulawReloadCount;
#endif
  uint32_t renderHistogram[16];
  for (uint8_t i = 0; i < 16; ++i) {
    renderHistogram[i] = m_renderDurationHistogram[i];
    m_renderDurationHistogram[i] = 0;
  }
  m_renderChunkCount = 0;
  m_renderTotalUs = 0;
  m_renderMaxUs = 0;
  m_renderMutexMissCount = 0;
  m_renderNotifyCount = 0;
  m_parallelJobCount = 0;
  m_parallelMainCycleTotal = 0;
  m_parallelHelperCycleTotal = 0;
  m_parallelWaitCycleTotal = 0;
  m_parallelMainCycleMax = 0;
  m_parallelHelperCycleMax = 0;
  m_parallelWaitCycleMax = 0;
#if APP_ENABLE_TONE_PERFMON
  m_perfCycleTotal = 0;
  m_perfDataStallTotal = 0;
  m_perfInstructionStallTotal = 0;
  m_perfCycleMax = 0;
  m_perfDataStallMax = 0;
  m_perfInstructionStallMax = 0;
#endif
#if APP_USE_ADPCM_TONES
  g_adpcmNibbleDecodeCount = 0;
  g_adpcmCacheResetCount = 0;
  g_adpcmPairHitCount = 0;
  g_adpcmBlockBoundaryCount = 0;
  g_adpcmMaxDecodePerRead = 0;
#endif
#if APP_USE_MULAW_TONES && APP_ENABLE_MULAW_CACHE_STATS
  g_mulawSameIndexHitCount = 0;
  g_mulawOneStepHitCount = 0;
  g_mulawReloadCount = 0;
#endif
  auto percentileUs = [&](uint32_t numerator, uint32_t denominator) -> uint32_t {
    if (renderCount == 0) {
      return 0;
    }
    const uint32_t target =
        (renderCount * numerator + denominator - 1) / denominator;
    uint32_t cumulative = 0;
    for (uint8_t i = 0; i < 16; ++i) {
      cumulative += renderHistogram[i];
      if (cumulative >= target) {
        return i == 15 ? renderMaxUs : kRenderHistogramUpperUs[i];
      }
    }
    return 8000U;
  };
  m_btDataCbGapMaxUs = 0;
  m_btDataCbLateCount = 0;
  m_btDataCbBurstCount = 0;
  m_btDataCbMinReadableFrames = kAudioRingFrames;
  m_btDataCbMaxReadableFrames = 0;
  Log::infof(
      "u=%lu v=%u stk=%u hstk=%u ifr=%lu ilm=%lu f8=%lu l8=%lu mf8=%lu ml8=%lu",
      static_cast<unsigned long>(m_audioUnderrunCount),
      static_cast<unsigned>(activeVoiceCount()),
      stackHw,
      helperStackHw,
      ifr,
      ilm,
      f8,
      l8,
      static_cast<unsigned long>(m_windowMinF8 == UINT32_MAX ? f8 : m_windowMinF8),
      static_cast<unsigned long>(m_windowMinL8 == UINT32_MAX ? l8 : m_windowMinL8));
#if APP_ENABLE_STAGED_HEAP_DIAGNOSTICS
  app_a2dp_source_stats_t a2dpStats{};
  app_a2dp_source_get_stats(&a2dpStats, 1);
  Log::infof(
      "a2dpq peer=%u mtu=%u alloc=%u q=%u qmax=%u qbytes=%lu qmbytes=%lu pmax=%u allocn=%lu fail=%lu bound=%lu",
      static_cast<unsigned>(a2dpStats.peer_mtu),
      static_cast<unsigned>(a2dpStats.tx_mtu),
      static_cast<unsigned>(a2dpStats.allocation_size),
      static_cast<unsigned>(a2dpStats.queue_depth),
      static_cast<unsigned>(a2dpStats.queue_depth_max),
      static_cast<unsigned long>(a2dpStats.queue_depth * a2dpStats.allocation_size),
      static_cast<unsigned long>(a2dpStats.queue_depth_max * a2dpStats.allocation_size),
      static_cast<unsigned>(a2dpStats.payload_used_max),
      static_cast<unsigned long>(a2dpStats.allocation_count),
      static_cast<unsigned long>(a2dpStats.allocation_fail_count),
      static_cast<unsigned long>(a2dpStats.bounds_error_count));
#endif
  Log::infof(
      "cpu b0=%lu.%lu%% b1=%lu.%lu%% i0=%lu.%lu%% i1=%lu.%lu%% win=%lums",
      static_cast<unsigned long>(busyPermille0 / 10),
      static_cast<unsigned long>(busyPermille0 % 10),
      static_cast<unsigned long>(busyPermille1 / 10),
      static_cast<unsigned long>(busyPermille1 % 10),
      static_cast<unsigned long>(idlePermille0 / 10),
      static_cast<unsigned long>(idlePermille0 % 10),
      static_cast<unsigned long>(idlePermille1 / 10),
      static_cast<unsigned long>(idlePermille1 % 10),
      static_cast<unsigned long>(heartbeatWindowMs));
  Log::infof(
      "btcb=%lu dcb=%lu dbytes=%lu gmax=%lu late=%lu burst=%lu minrf=%lu maxrf=%lu",
      static_cast<unsigned long>(btCbCount),
      static_cast<unsigned long>(btCbWindowCount),
      static_cast<unsigned long>(btCbWindowBytes),
      static_cast<unsigned long>(btCbGapMaxUs),
      static_cast<unsigned long>(btCbLateCount),
      static_cast<unsigned long>(btCbBurstCount),
      static_cast<unsigned long>(btCbMinRf),
      static_cast<unsigned long>(btCbMaxRf));
  Log::infof(
      "render n=%lu avg=%luus max=%luus p99<=%luus p999<=%luus mutexmiss=%lu notify=%lu",
      static_cast<unsigned long>(renderCount),
      static_cast<unsigned long>(renderCount != 0 ? renderTotalUs / renderCount : 0),
      static_cast<unsigned long>(renderMaxUs),
      static_cast<unsigned long>(percentileUs(99, 100)),
      static_cast<unsigned long>(percentileUs(999, 1000)),
      static_cast<unsigned long>(renderMutexMisses),
      static_cast<unsigned long>(renderNotifyCount));
  constexpr uint32_t kCyclesPerUs = 240;
  Log::infof(
      "split n=%lu main=%lu/%luus help=%lu/%luus wait=%lu/%luus",
      static_cast<unsigned long>(parallelJobCount),
      static_cast<unsigned long>(parallelJobCount != 0
          ? parallelMainCycleTotal / parallelJobCount / kCyclesPerUs : 0),
      static_cast<unsigned long>(parallelMainCycleMax / kCyclesPerUs),
      static_cast<unsigned long>(parallelJobCount != 0
          ? parallelHelperCycleTotal / parallelJobCount / kCyclesPerUs : 0),
      static_cast<unsigned long>(parallelHelperCycleMax / kCyclesPerUs),
      static_cast<unsigned long>(parallelJobCount != 0
          ? parallelWaitCycleTotal / parallelJobCount / kCyclesPerUs : 0),
      static_cast<unsigned long>(parallelWaitCycleMax / kCyclesPerUs));
#if SYNTH_RENDER_PROFILING && SYNTH_RENDER_PROFILE_HEARTBEAT
  auto profileAverageUs = [](uint64_t cycles, uint32_t count) -> uint32_t {
    return count != 0
        ? static_cast<uint32_t>(cycles / count / kCyclesPerUs)
        : 0U;
  };
  auto profileMaxUs = [](uint32_t cycles) -> uint32_t {
    return cycles / kCyclesPerUs;
  };
  auto profileVoiceAverageTenths = [](uint64_t voices, uint64_t samples)
      -> uint32_t {
    return samples != 0
        ? static_cast<uint32_t>((voices * 10ULL + samples / 2ULL) / samples)
        : 0U;
  };
  Log::infof(
      "phase n=%lu prep=%lu/%lu main=%lu/%lu wait=%lu/%lu merge=%lu/%lu fxout=%lu/%lu us",
      static_cast<unsigned long>(profilePhaseCount),
      static_cast<unsigned long>(profileAverageUs(
          profilePrepCycleTotal, profilePhaseCount)),
      static_cast<unsigned long>(profileMaxUs(profilePrepCycleMax)),
      static_cast<unsigned long>(profileAverageUs(
          profileMainCycleTotal, profilePhaseCount)),
      static_cast<unsigned long>(profileMaxUs(profileMainCycleMax)),
      static_cast<unsigned long>(profileAverageUs(
          profileWaitCycleTotal, profilePhaseCount)),
      static_cast<unsigned long>(profileMaxUs(profileWaitCycleMax)),
      static_cast<unsigned long>(profileAverageUs(
          profileMergeCycleTotal, profilePhaseCount)),
      static_cast<unsigned long>(profileMaxUs(profileMergeCycleMax)),
      static_cast<unsigned long>(profileAverageUs(
          profileFxoutCycleTotal, profilePhaseCount)),
      static_cast<unsigned long>(profileMaxUs(profileFxoutCycleMax)));
  const uint32_t mainVoiceCallCount = mainVoiceProfile.renderCallCount;
  const uint32_t helperVoiceCallCount = helperVoiceProfile.renderCallCount;
  Log::infof(
      "vprof1 clear=%lu/%lu fast=%lu/%lu generic=%lu/%lu mod=%lu/%lu us",
      static_cast<unsigned long>(profileAverageUs(
          mainVoiceProfile.clearCycleTotal, mainVoiceCallCount)),
      static_cast<unsigned long>(profileMaxUs(mainVoiceProfile.clearCycleMax)),
      static_cast<unsigned long>(profileAverageUs(
          mainVoiceProfile.fastCycleTotal, mainVoiceCallCount)),
      static_cast<unsigned long>(profileMaxUs(mainVoiceProfile.fastCycleMax)),
      static_cast<unsigned long>(profileAverageUs(
          mainVoiceProfile.genericCycleTotal, mainVoiceCallCount)),
      static_cast<unsigned long>(profileMaxUs(mainVoiceProfile.genericCycleMax)),
      static_cast<unsigned long>(profileAverageUs(
          mainVoiceProfile.modCycleTotal, mainVoiceCallCount)),
      static_cast<unsigned long>(profileMaxUs(mainVoiceProfile.modCycleMax)));
  Log::infof(
      "vprof0 clear=%lu/%lu fast=%lu/%lu generic=%lu/%lu mod=%lu/%lu us",
      static_cast<unsigned long>(profileAverageUs(
          helperVoiceProfile.clearCycleTotal, helperVoiceCallCount)),
      static_cast<unsigned long>(profileMaxUs(helperVoiceProfile.clearCycleMax)),
      static_cast<unsigned long>(profileAverageUs(
          helperVoiceProfile.fastCycleTotal, helperVoiceCallCount)),
      static_cast<unsigned long>(profileMaxUs(helperVoiceProfile.fastCycleMax)),
      static_cast<unsigned long>(profileAverageUs(
          helperVoiceProfile.genericCycleTotal, helperVoiceCallCount)),
      static_cast<unsigned long>(profileMaxUs(helperVoiceProfile.genericCycleMax)),
      static_cast<unsigned long>(profileAverageUs(
          helperVoiceProfile.modCycleTotal, helperVoiceCallCount)),
      static_cast<unsigned long>(profileMaxUs(helperVoiceProfile.modCycleMax)));
  const uint32_t mainFastVoices = profileVoiceAverageTenths(
      mainVoiceProfile.fastVoiceCountTotal,
      mainVoiceProfile.voiceCountSampleTotal);
  const uint32_t mainGenericVoices = profileVoiceAverageTenths(
      mainVoiceProfile.genericVoiceCountTotal,
      mainVoiceProfile.voiceCountSampleTotal);
  const uint32_t helperFastVoices = profileVoiceAverageTenths(
      helperVoiceProfile.fastVoiceCountTotal,
      helperVoiceProfile.voiceCountSampleTotal);
  const uint32_t helperGenericVoices = profileVoiceAverageTenths(
      helperVoiceProfile.genericVoiceCountTotal,
      helperVoiceProfile.voiceCountSampleTotal);
  Log::infof(
      "vcount mf=%lu.%lu mg=%lu.%lu hf=%lu.%lu hg=%lu.%lu",
      static_cast<unsigned long>(mainFastVoices / 10),
      static_cast<unsigned long>(mainFastVoices % 10),
      static_cast<unsigned long>(mainGenericVoices / 10),
      static_cast<unsigned long>(mainGenericVoices % 10),
      static_cast<unsigned long>(helperFastVoices / 10),
      static_cast<unsigned long>(helperFastVoices % 10),
      static_cast<unsigned long>(helperGenericVoices / 10),
      static_cast<unsigned long>(helperGenericVoices % 10));
  Log::infof(
      "helper hstart=%lu/%luus",
      static_cast<unsigned long>(helperStartLatencyCount != 0
          ? helperStartLatencyTotalUs / helperStartLatencyCount : 0),
      static_cast<unsigned long>(helperStartLatencyMaxUs));
  const VoiceProfileStats* kindProfiles[] = {
      &mainVoiceProfile, &helperVoiceProfile};
  for (unsigned coreIndex = 0; coreIndex < 2; ++coreIndex) {
    const VoiceProfileStats& kinds = *kindProfiles[coreIndex];
    unsigned selected[4] = {128, 128, 128, 128};
    for (unsigned rank = 0; rank < 4; ++rank) {
      uint32_t best = 0;
      for (unsigned kind = 0; kind < 128; ++kind) {
        bool used = false;
        for (unsigned previous = 0; previous < rank; ++previous) {
          if (selected[previous] == kind) used = true;
        }
        if (!used && kinds.genericKinds[kind] > best) {
          best = kinds.genericKinds[kind];
          selected[rank] = kind;
        }
      }
      if (selected[rank] == 128) break;
      const unsigned kind = selected[rank];
      Log::infof(
          "gkind core=%u rank=%u stage=%c loop=%u filter=%u fx=%u hits=%lu blocks=%lu",
          coreIndex == 0 ? 1u : 0u, rank + 1,
          "ADSR"[kind >> 5], (kind >> 4) & 1u, (kind >> 3) & 1u,
          kind & 7u, static_cast<unsigned long>(best),
          static_cast<unsigned long>(kinds.voiceCountSampleTotal));
    }
  }
  completedProfile = RendererProfileBank{};
#endif
  if (m_songFormatVersion == kSongFormatVersionRawMidi) {
    Log::infof(
        "raw q=%u head=%lu prod=%lu out=%08lx pend=%08lx end=%08lx "
        "t1=%lu t2=%lu t4=%lu t13=%lu fh=%lu fm=%lu fb=%lu run=%u eof=%u",
        static_cast<unsigned>(rawQueueDepth),
        static_cast<unsigned long>(rawQueueAvailable ? rawQueueHead.timeMs : 0),
        static_cast<unsigned long>(m_rawMidiParserProducedCount),
        static_cast<unsigned long>(m_rawMidiProducedTrackMask),
        static_cast<unsigned long>(m_rawMidiPendingTrackMask),
        static_cast<unsigned long>(m_rawMidiEndedTrackMask),
        static_cast<unsigned long>(m_rawMidiProbeTicks[0]),
        static_cast<unsigned long>(m_rawMidiProbeTicks[1]),
        static_cast<unsigned long>(m_rawMidiProbeTicks[2]),
        static_cast<unsigned long>(m_rawMidiProbeTicks[3]),
        static_cast<unsigned long>(m_rawMidiFlashCacheHits),
        static_cast<unsigned long>(m_rawMidiFlashCacheMisses),
        static_cast<unsigned long>(m_rawMidiFlashBytesRead),
        m_rawMidiParserRunning ? 1U : 0U,
        m_rawMidiParserEof ? 1U : 0U);
  }
#if APP_ENABLE_TONE_PERFMON
  const uint32_t perfAverageCycles =
      renderCount != 0 ? static_cast<uint32_t>(perfCycleTotal / renderCount) : 0;
  const uint32_t perfAverageDataStall = renderCount != 0
      ? static_cast<uint32_t>(perfDataStallTotal / renderCount)
      : 0;
  const uint32_t perfAverageInstructionStall = renderCount != 0
      ? static_cast<uint32_t>(perfInstructionStallTotal / renderCount)
      : 0;
  const uint32_t perfDataPercent = perfCycleTotal != 0
      ? static_cast<uint32_t>((perfDataStallTotal * 100u) / perfCycleTotal)
      : 0;
  const uint32_t perfInstructionPercent = perfCycleTotal != 0
      ? static_cast<uint32_t>((perfInstructionStallTotal * 100u) / perfCycleTotal)
      : 0;
  Log::infof(
      "perf cycavg=%lu cycmax=%lu davg=%lu dmax=%lu dpct=%lu iavg=%lu imax=%lu ipct=%lu ready=%u",
      static_cast<unsigned long>(perfAverageCycles),
      static_cast<unsigned long>(perfCycleMax),
      static_cast<unsigned long>(perfAverageDataStall),
      static_cast<unsigned long>(perfDataStallMax),
      static_cast<unsigned long>(perfDataPercent),
      static_cast<unsigned long>(perfAverageInstructionStall),
      static_cast<unsigned long>(perfInstructionStallMax),
      static_cast<unsigned long>(perfInstructionPercent),
      m_perfmonReady ? 1U : 0U);
#endif
#if APP_USE_ADPCM_TONES
  Log::infof(
      "adpcm nib=%lu reset=%lu pair=%lu boundary=%lu maxdec=%lu",
      static_cast<unsigned long>(adpcmNibbleDecodes),
      static_cast<unsigned long>(adpcmCacheResets),
      static_cast<unsigned long>(adpcmPairHits),
      static_cast<unsigned long>(adpcmBlockBoundaries),
      static_cast<unsigned long>(adpcmMaxDecode));
#endif
#if APP_USE_MULAW_TONES && APP_ENABLE_MULAW_CACHE_STATS
  Log::infof(
      "mulaw same=%lu step=%lu reload=%lu",
      static_cast<unsigned long>(mulawSameHits),
      static_cast<unsigned long>(mulawOneStepHits),
      static_cast<unsigned long>(mulawReloads));
#endif
  m_windowMinF8 = UINT32_MAX;
  m_windowMinL8 = UINT32_MAX;
}

void App::noteHttpActivity(const char* tag) {
  m_lastHttpActivityMs = millis();
  if (tag == nullptr) {
    m_lastHttpTag[0] = '\0';
    return;
  }
  strncpy(m_lastHttpTag, tag, sizeof(m_lastHttpTag) - 1);
  m_lastHttpTag[sizeof(m_lastHttpTag) - 1] = '\0';
}

void App::monitorLowHeap(unsigned long nowMs) {
  const unsigned long f8 = static_cast<unsigned long>(
      heap_caps_get_free_size(MALLOC_CAP_8BIT));
  const unsigned long l8 = static_cast<unsigned long>(
      heap_caps_get_largest_free_block(MALLOC_CAP_8BIT));
  if (f8 < m_windowMinF8) {
    m_windowMinF8 = static_cast<uint32_t>(f8);
  }
  if (l8 < m_windowMinL8) {
    m_windowMinL8 = static_cast<uint32_t>(l8);
  }

  HeapAlertState nextState = HeapAlertState::Normal;
  if (f8 < 3000UL) {
    nextState = HeapAlertState::Critical;
  } else if (f8 < 8000UL) {
    nextState = HeapAlertState::Low;
  }

  if (nextState == HeapAlertState::Normal && f8 >= 16000UL) {
    if (m_heapAlertState != HeapAlertState::Normal) {
      Log::infof(
          "RECOVER t=%lu i=%lu/%lu h=%lu/%lu u=%lu v=%u s=%u p=%u r=%u w=%u b=%u a=%u d=%u q=%s dt=%lu g=%lu l=%lu n=%lu x=%lu",
          static_cast<unsigned long>(nowMs),
          static_cast<unsigned long>(heap_caps_get_free_size(MALLOC_CAP_INTERNAL)),
          static_cast<unsigned long>(heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL)),
          f8,
          l8,
          static_cast<unsigned long>(m_audioUnderrunCount),
          static_cast<unsigned>(activeVoiceCount()),
          m_renderTaskHandle != nullptr
              ? static_cast<unsigned>(uxTaskGetStackHighWaterMark(m_renderTaskHandle))
              : 0U,
          m_playing ? 1U : 0U,
          static_cast<unsigned>(bufferedAudioFrames()),
          static_cast<unsigned>(writableAudioFrames()),
          m_a2dpConnected ? 1U : 0U,
          m_audioStarted ? 1U : 0U,
          m_discoveryRunning ? 1U : 0U,
          m_lastHttpTag[0] != '\0' ? m_lastHttpTag : "-",
          m_lastHttpActivityMs != 0
              ? static_cast<unsigned long>(nowMs - m_lastHttpActivityMs)
              : 0UL,
          static_cast<unsigned long>(m_btDataCbGapMaxUs),
          static_cast<unsigned long>(m_btDataCbLateCount),
          static_cast<unsigned long>(m_btDataCbMinReadableFrames),
          static_cast<unsigned long>(m_btDataCbMaxReadableFrames));
    }
    m_heapAlertState = HeapAlertState::Normal;
    m_lastHeapAlertLogMs = 0;
    return;
  }
  if (nextState == HeapAlertState::Normal) {
    return;
  }

  bool shouldLog = false;
  if (static_cast<uint8_t>(nextState) > static_cast<uint8_t>(m_heapAlertState)) {
    shouldLog = true;
  } else if (
      nextState == HeapAlertState::Critical &&
      m_heapAlertState == HeapAlertState::Critical &&
      (m_lastHeapAlertLogMs == 0 ||
       nowMs - m_lastHeapAlertLogMs >= 1000UL)) {
    shouldLog = true;
  }
  if (!shouldLog) {
    return;
  }

  m_heapAlertState = nextState;
  m_lastHeapAlertLogMs = static_cast<uint32_t>(nowMs);
  const unsigned long ifr = static_cast<unsigned long>(
      heap_caps_get_free_size(MALLOC_CAP_INTERNAL));
  const unsigned long ilm = static_cast<unsigned long>(
      heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL));
  const unsigned stackHw =
      m_renderTaskHandle != nullptr
          ? static_cast<unsigned>(uxTaskGetStackHighWaterMark(m_renderTaskHandle))
          : 0U;
  const unsigned long dtHttp =
      m_lastHttpActivityMs != 0 ? static_cast<unsigned long>(nowMs - m_lastHttpActivityMs) : 0UL;

  Log::infof(
      "%s t=%lu i=%lu/%lu h=%lu/%lu u=%lu v=%u s=%u p=%u r=%u w=%u b=%u a=%u d=%u q=%s dt=%lu g=%lu l=%lu n=%lu x=%lu",
      nextState == HeapAlertState::Critical ? "CRIT" : "LOW",
      static_cast<unsigned long>(nowMs),
      ifr,
      ilm,
      f8,
      l8,
      static_cast<unsigned long>(m_audioUnderrunCount),
      static_cast<unsigned>(activeVoiceCount()),
      stackHw,
      m_playing ? 1U : 0U,
      static_cast<unsigned>(bufferedAudioFrames()),
      static_cast<unsigned>(writableAudioFrames()),
      m_a2dpConnected ? 1U : 0U,
      m_audioStarted ? 1U : 0U,
      m_discoveryRunning ? 1U : 0U,
      m_lastHttpTag[0] != '\0' ? m_lastHttpTag : "-",
      dtHttp,
      static_cast<unsigned long>(m_btDataCbGapMaxUs),
      static_cast<unsigned long>(m_btDataCbLateCount),
      static_cast<unsigned long>(m_btDataCbMinReadableFrames),
      static_cast<unsigned long>(m_btDataCbMaxReadableFrames));
}

void App::rendererTaskEntry(void* context) {
  App* app = static_cast<App*>(context);
  if (app != nullptr) {
    app->rendererTaskLoop();
  }
  vTaskDelete(nullptr);
}

void App::servicePreview(unsigned long nowMs) {
  if (m_previewVoiceIndex < 0 || nowMs < m_previewStopAtMs) {
    return;
  }

  if (m_synthMutex != nullptr &&
      xSemaphoreTake(m_synthMutex, pdMS_TO_TICKS(5)) == pdTRUE) {
    if (m_previewVoiceIndex >= 0 &&
        m_previewVoiceIndex < kMaxVoices &&
        m_voices[m_previewVoiceIndex].hotCore.active &&
        m_voices[m_previewVoiceIndex].cold.channel == 15 &&
        m_voices[m_previewVoiceIndex].cold.note == m_previewNote &&
        m_voices[m_previewVoiceIndex].cold.toneClass == m_previewToneClass) {
      setVoiceActive(static_cast<uint8_t>(m_previewVoiceIndex), false);
      m_voices[m_previewVoiceIndex].hotCore.carrierFixedGainLeftQ15 = 0;
      m_voices[m_previewVoiceIndex].hotCore.carrierFixedGainRightQ15 = 0;
    }
    m_previewVoiceIndex = -1;
    m_previewNote = 0;
    m_previewToneClass = MidiEvent::ToneClass::Lead;
    m_previewStopAtMs = 0;
    xSemaphoreGive(m_synthMutex);
  }
}

void App::rendererTaskLoop() {
#if APP_ENABLE_TONE_PERFMON
  xtensa_perfmon_stop();
  m_perfmonReady =
      xtensa_perfmon_init(
          0, XTPERF_CNT_D_STALL, XTPERF_MASK_D_STALL_ALL, 0, 0) == ESP_OK &&
      xtensa_perfmon_init(
          1,
          XTPERF_CNT_I_STALL,
          XTPERF_MASK_I_STALL_ALL,
          0,
          0) == ESP_OK;
#endif
  while (true) {
    const bool previewActive =
        m_previewVoiceIndex >= 0 &&
        m_previewVoiceIndex < kMaxVoices &&
        m_voices[m_previewVoiceIndex].hotCore.active;
    const bool renderNeeded =
        previewActive ||
        (m_audioStarted && m_a2dpConnected && m_playing && m_songLoaded);
    if (!renderNeeded) {
      ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(32));
      continue;
    }

    const size_t bufferedFrames = bufferedAudioFrames();
    const size_t requiredWritableFrames =
        maxOutputFramesForSynthChunk(kRenderChunkFrames, m_sampleRateHz, m_outputSampleRateHz);

    if (writableAudioFrames() < requiredWritableFrames) {
      ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(2));
      continue;
    }

    if (m_synthMutex != nullptr &&
        xSemaphoreTake(m_synthMutex, pdMS_TO_TICKS(4)) == pdTRUE) {
      const uint32_t renderStartUs = micros();
      const unsigned long aheadMs =
          static_cast<unsigned long>(
              (bufferedFrames * 1000UL) / max<uint32_t>(1, m_outputSampleRateHz));
      updateMusic(millis() + aheadMs);
#if APP_ENABLE_TONE_PERFMON
      if (m_perfmonReady) {
        xtensa_perfmon_reset(0);
        xtensa_perfmon_reset(1);
        xtensa_perfmon_start();
      }
#endif
      const uint32_t renderStartCycles = esp_cpu_get_cycle_count();
      renderChunkToAudioRingLocked();
      const uint32_t renderCycles =
          esp_cpu_get_cycle_count() - renderStartCycles;
#if APP_ENABLE_TONE_PERFMON
      if (m_perfmonReady) {
        xtensa_perfmon_stop();
        const uint32_t dataStall = xtensa_perfmon_value(0);
        const uint32_t instructionStall = xtensa_perfmon_value(1);
        m_perfCycleTotal += renderCycles;
        m_perfDataStallTotal += dataStall;
        m_perfInstructionStallTotal += instructionStall;
        if (renderCycles > m_perfCycleMax) m_perfCycleMax = renderCycles;
        if (dataStall > m_perfDataStallMax) {
          m_perfDataStallMax = dataStall;
        }
        if (instructionStall > m_perfInstructionStallMax) {
          m_perfInstructionStallMax = instructionStall;
        }
      }
#endif
      const uint32_t renderUs = micros() - renderStartUs;
      ++m_renderChunkCount;
      m_renderTotalUs += renderUs;
      if (renderUs > m_renderMaxUs) {
        m_renderMaxUs = renderUs;
      }
      uint32_t bucket = 0;
      while (bucket < 15 && renderUs > kRenderHistogramUpperUs[bucket]) {
        ++bucket;
      }
      ++m_renderDurationHistogram[bucket];
      xSemaphoreGive(m_synthMutex);
    } else {
      ++m_renderMutexMissCount;
      // mutex競合時は可聴な無音chunkを投入せず、次回すぐ再試行する。
      taskYIELD();
      continue;
    }
  }
}

void App::rawMidiParserTaskEntry(void* context) {
  App* app = static_cast<App*>(context);
  if (app != nullptr) app->rawMidiParserTaskLoop();
  vTaskDelete(nullptr);
}

void App::rawMidiParserTaskLoop() {
  uint8_t workSinceYield = 0;
  while (true) {
    if (m_rawMidiParserCommand != 0) {
      // Take the parser mutex before consuming the command.  The upload and
      // seek paths deliberately hold this mutex while replacing/resetting
      // the parser.  Consuming the command before taking the mutex used to
      // lose a reset when the task woke during that critical section, leaving
      // m_rawMidiParserRunning false forever.
      if (m_rawMidiParserMutex != nullptr &&
          xSemaphoreTake(m_rawMidiParserMutex, pdMS_TO_TICKS(20)) == pdTRUE) {
        const uint8_t command = m_rawMidiParserCommand;
        m_rawMidiParserCommand = 0;
        resetRawMidiQueue();
        m_rawMidiParserEof = false;
          m_rawMidiParserProducedCount = 0;
          m_rawMidiProducedTrackMask = 0;
          m_rawMidiPendingTrackMask = 0;
          m_rawMidiEndedTrackMask = 0;
          m_rawMidiFlashCacheHits = 0;
          m_rawMidiFlashCacheMisses = 0;
          m_rawMidiFlashBytesRead = 0;
        if (command == 1 && m_rawMidiParser.valid()) {
          m_rawMidiParser.reset();
          m_rawMidiParserRunning = true;
          Log::infof(
              "Raw parser started: valid=1 tracks=%u division=%u",
              static_cast<unsigned>(m_rawMidiParser.trackCount()),
              static_cast<unsigned>(m_rawMidiParser.division()));
#if APP_ENABLE_DEBUG_DIAGNOSTICS
          for (uint16_t i = 0; i < m_rawMidiParser.trackCount(); ++i) {
            Log::infof("Raw parser pending[%u]: has=%u tick=%lu status=0x%02x",
                static_cast<unsigned>(i),
                m_rawMidiParser.pendingEvent(i) ? 1U : 0U,
                static_cast<unsigned long>(m_rawMidiParser.pendingTick(i)),
                static_cast<unsigned>(m_rawMidiParser.pendingStatus(i)));
          }
#endif
        } else {
          m_rawMidiParserRunning = false;
          Log::infof(
              "Raw parser not started: command=%u valid=%u",
              static_cast<unsigned>(command),
              m_rawMidiParser.valid() ? 1U : 0U);
        }
        xSemaphoreGive(m_rawMidiParserMutex);
      } else {
        // Keep the command pending until it can be applied.  A notification
        // is not sufficient here because the owner of the mutex may release
        // it after the task has already consumed its wakeup.
        vTaskDelay(1);
        continue;
      }
    }
    if (!m_rawMidiParserRunning || m_rawMidiParserPaused ||
        !m_songLoaded || m_songFormatVersion != kSongFormatVersionRawMidi) {
      ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(20));
      continue;
    }
    bool pushed = false;
    const uint16_t nextWrite = static_cast<uint16_t>(
        (m_rawMidiQueueWrite + 1) % kRawMidiQueueSize);
    if (nextWrite == m_rawMidiQueueRead) {
      vTaskDelay(pdMS_TO_TICKS(2));
      continue;
    }
    if (m_rawMidiParserMutex != nullptr &&
        xSemaphoreTake(m_rawMidiParserMutex, pdMS_TO_TICKS(2)) == pdTRUE) {
      MidiEvent event;
      if (m_rawMidiParser.next(event)) {
        const uint16_t next = static_cast<uint16_t>(
            (m_rawMidiQueueWrite + 1) % kRawMidiQueueSize);
        if (next != m_rawMidiQueueRead) {
          portENTER_CRITICAL(&m_rawMidiQueueMux);
          m_rawMidiQueue[m_rawMidiQueueWrite] = event;
          m_rawMidiQueueWrite = next;
          portEXIT_CRITICAL(&m_rawMidiQueueMux);
#if APP_ENABLE_DEBUG_DIAGNOSTICS
          if (m_rawMidiParserProducedCount < 64) {
            Log::infof(
                "Raw parser event[%u]: trk=%u tick=%lu type=%u time=%lu ch=%u note=%u vel=%u",
                static_cast<unsigned>(m_rawMidiParserProducedCount),
                static_cast<unsigned>(m_rawMidiParser.lastTrackIndex()),
                static_cast<unsigned long>(m_rawMidiParser.currentTick()),
                static_cast<unsigned>(event.type),
                static_cast<unsigned long>(event.timeMs),
                static_cast<unsigned>(event.channel),
                static_cast<unsigned>(event.note),
                static_cast<unsigned>(event.velocity));
          }
#endif
          ++m_rawMidiParserProducedCount;
          const uint16_t producedTrack = m_rawMidiParser.lastTrackIndex();
          if (producedTrack < 32) {
            m_rawMidiProducedTrackMask |= 1UL << producedTrack;
          }
          pushed = true;
        }
      } else if (m_rawMidiParser.workPending()) {
        // next() has a bounded raw-event budget so dense metadata/controller
        // runs cannot monopolize CPU0. Keep the parser alive and yield below.
      } else {
        m_rawMidiParserRunning = false;
        m_rawMidiParserEof = m_rawMidiParser.valid() && m_rawMidiParser.eof();
        if (m_rawMidiParser.error()) {
          snprintf(m_uploadError, sizeof(m_uploadError),
              "MIDI parse error: %s (track %u, offset %lu)",
              m_rawMidiParser.errorText(),
              static_cast<unsigned>(m_rawMidiParser.errorTrackIndex()),
              static_cast<unsigned long>(m_rawMidiParser.errorOffset()));
          m_uploadError[sizeof(m_uploadError) - 1] = '\0';
          Log::infof(
              "Raw parser error: %s track=%u offset=%lu status=0x%02x tick=%lu",
              m_rawMidiParser.errorText(),
              static_cast<unsigned>(m_rawMidiParser.errorTrackIndex()),
              static_cast<unsigned long>(m_rawMidiParser.errorOffset()),
              static_cast<unsigned>(m_rawMidiParser.errorStatus()),
              static_cast<unsigned long>(m_rawMidiParser.currentTick()));
        } else {
          Log::infof(
              "Raw parser stopped: valid=%u eof=%u produced=%lu duration=%lu",
              m_rawMidiParser.valid() ? 1U : 0U,
              m_rawMidiParserEof ? 1U : 0U,
              static_cast<unsigned long>(m_rawMidiParserProducedCount),
              static_cast<unsigned long>(m_rawMidiParser.durationMs()));
        }
        if (m_rawMidiParserEof && m_rawMidiParser.durationMs() > 0) {
          m_song.durationMs = m_rawMidiParser.durationMs();
        }
      }
      m_rawMidiPendingTrackMask = m_rawMidiParser.pendingTrackMask();
      m_rawMidiEndedTrackMask = m_rawMidiParser.endedTrackMask();
      m_rawMidiProbeTicks[0] = static_cast<uint32_t>(m_rawMidiParser.pendingTick(1));
      m_rawMidiProbeTicks[1] = static_cast<uint32_t>(m_rawMidiParser.pendingTick(2));
      m_rawMidiProbeTicks[2] = static_cast<uint32_t>(m_rawMidiParser.pendingTick(4));
      m_rawMidiProbeTicks[3] = static_cast<uint32_t>(m_rawMidiParser.pendingTick(13));
      m_rawMidiFlashCacheHits = m_rawMidiParser.flashCacheHits();
      m_rawMidiFlashCacheMisses = m_rawMidiParser.flashCacheMisses();
      m_rawMidiFlashBytesRead = m_rawMidiParser.flashBytesRead();
      xSemaphoreGive(m_rawMidiParserMutex);
    }
    if (!pushed) {
      workSinceYield = 0;
      vTaskDelay(pdMS_TO_TICKS(2));
    } else if (++workSinceYield >= 16) {
      // The parser is pinned to CPU0.  Yield periodically even when the
      // queue is being drained, otherwise IDLE0 cannot feed the task WDT.
      workSinceYield = 0;
      vTaskDelay(1);
    }
  }
}

void App::rendererHelperTaskEntry(void* context) {
  App* app = static_cast<App*>(context);
  if (app != nullptr) {
    app->rendererHelperTaskLoop();
  }
  vTaskDelete(nullptr);
}

void App::rendererHelperTaskLoop() {
  while (true) {
    ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
    uint32_t profileBank = 0;
#if SYNTH_RENDER_PROFILING && SYNTH_RENDER_PROFILE_HELPER_CODE
    const uint32_t helperStartUs = RENDER_PROFILE_TIME_US();
#if SYNTH_RENDER_PROFILE_BANK_HANDSHAKE
    while (true) {
      profileBank = __atomic_load_n(
          &m_rendererProfileActiveBank, __ATOMIC_ACQUIRE) & 1U;
      __atomic_store_n(
          &m_helperProfileWriterBank, profileBank, __ATOMIC_RELEASE);
      if ((__atomic_load_n(
               &m_rendererProfileActiveBank, __ATOMIC_ACQUIRE) & 1U) ==
          profileBank) {
        break;
      }
      __atomic_store_n(
          &m_helperProfileWriterBank, kProfileWriterIdle, __ATOMIC_RELEASE);
    }
#endif
    RendererProfileBank& helperProfile = m_rendererProfileBanks[profileBank];
    const uint32_t helperJobStartUs = __atomic_load_n(
        &m_helperJobStartUs, __ATOMIC_ACQUIRE);
    if (helperJobStartUs != 0) {
      // uint32_t差分なので約71分ごとのmicrosecond wrapも正しく処理できる。
      const uint32_t latencyUs = helperStartUs - helperJobStartUs;
#if SYNTH_RENDER_PROFILE_ACCUMULATION
      helperProfile.helperStartLatencyTotalUs += latencyUs;
      ++helperProfile.helperStartLatencyCount;
      if (latencyUs > helperProfile.helperStartLatencyMaxUs) {
        helperProfile.helperStartLatencyMaxUs = latencyUs;
      }
#else
      (void)latencyUs;
#endif
    }
#endif
    const int32_t frameCount = m_helperFrameCount;
    const uint32_t voiceMask = m_helperVoiceMask;
    const bool renderFxSends = m_helperRenderFxSends;
    const uint32_t helperStartCycles = esp_cpu_get_cycle_count();
    if (frameCount > 0 && voiceMask != 0) {
#if SYNTH_RENDER_PROFILING && SYNTH_RENDER_PROFILE_VOICE_CODE
      g_rendererProfileCallContexts[0] =
          RendererProfileCallContext{profileBank, true};
#endif
      renderVoiceFrames(
          voiceMask,
          frameCount,
          g_helperMixedLeftQ15,
          g_helperMixedRightQ15,
          g_helperReverbInputQ15,
          g_helperChorusInputQ15,
          g_helperDelayInputQ15,
          renderFxSends);
    }
    m_helperLastCycles = esp_cpu_get_cycle_count() - helperStartCycles;
#if SYNTH_RENDER_PROFILING && SYNTH_RENDER_PROFILE_HELPER_CODE && \
    SYNTH_RENDER_PROFILE_BANK_HANDSHAKE
    __atomic_store_n(
        &m_helperProfileWriterBank, kProfileWriterIdle, __ATOMIC_RELEASE);
#endif
    __atomic_store_n(&m_helperJobDone, true, __ATOMIC_RELEASE);
    if (m_renderTaskHandle != nullptr) {
      xTaskNotifyGive(m_renderTaskHandle);
    }
  }
}

size_t App::renderChunkToAudioRingLocked() {
  size_t writeFrame =
      __atomic_load_n(&m_audioRingWriteFrame, __ATOMIC_RELAXED);

  if (m_sampleRateHz == m_outputSampleRateHz) {
    const size_t firstFrames = min(kRenderChunkFrames, kAudioRingFrames - writeFrame);
    renderStereoFrames(
        &m_audioRingBuffer[writeFrame], static_cast<int32_t>(firstFrames));
    const size_t secondFrames = kRenderChunkFrames - firstFrames;
    if (secondFrames > 0) {
      renderStereoFrames(m_audioRingBuffer, static_cast<int32_t>(secondFrames));
    }
    m_resamplePhaseQ16 = 0;
    m_resamplePrevFrame =
        m_audioRingBuffer[(writeFrame + kRenderChunkFrames - 1) &
                          (kAudioRingFrames - 1)];
    writeFrame = (writeFrame + kRenderChunkFrames) & (kAudioRingFrames - 1);
    __atomic_store_n(&m_audioRingWriteFrame, writeFrame, __ATOMIC_RELEASE);
    return kRenderChunkFrames;
  }

  uint32_t synthFrames[kRenderChunkFrames];
  renderStereoFrames(synthFrames, static_cast<int32_t>(kRenderChunkFrames));
  const uint32_t stepQ16 = static_cast<uint32_t>(
      (static_cast<uint64_t>(m_sampleRateHz) << 16) /
      max<uint32_t>(1, m_outputSampleRateHz));
  const uint32_t chunkLimitQ16 = static_cast<uint32_t>(kRenderChunkFrames << 16);
  const size_t outputCapacity = writableAudioFrames();
  size_t outputFrames = 0;
  while (m_resamplePhaseQ16 < chunkLimitQ16 && outputFrames < outputCapacity) {
    const uint32_t index = m_resamplePhaseQ16 >> 16;
    const uint32_t frac = m_resamplePhaseQ16 & 0xffffu;
    const uint32_t frameA = index == 0 ? m_resamplePrevFrame : synthFrames[index - 1];
    const uint32_t frameB = synthFrames[index];
    const int32_t leftA = stereoLeft(frameA);
    const int32_t rightA = stereoRight(frameA);
    const int32_t left = leftA +
        (((static_cast<int32_t>(stereoLeft(frameB)) - leftA) *
          static_cast<int32_t>(frac)) >> 16);
    const int32_t right = rightA +
        (((static_cast<int32_t>(stereoRight(frameB)) - rightA) *
          static_cast<int32_t>(frac)) >> 16);
    m_audioRingBuffer[writeFrame] =
        packStereoFrame(static_cast<int16_t>(left), static_cast<int16_t>(right));
    writeFrame = (writeFrame + 1) & (kAudioRingFrames - 1);
    ++outputFrames;
    m_resamplePhaseQ16 += stepQ16;
  }
  m_resamplePrevFrame = synthFrames[kRenderChunkFrames - 1];
  m_resamplePhaseQ16 =
      m_resamplePhaseQ16 >= chunkLimitQ16 ? m_resamplePhaseQ16 - chunkLimitQ16 : 0;
  __atomic_store_n(&m_audioRingWriteFrame, writeFrame, __ATOMIC_RELEASE);
  return outputFrames;
}

void App::primeAudioRingBufferLocked(size_t targetFrames) {
  if (!m_a2dpConnected || !m_audioStarted) {
    return;
  }

  const bool previewActive =
      m_previewVoiceIndex >= 0 &&
      m_previewVoiceIndex < kMaxVoices &&
      m_voices[m_previewVoiceIndex].hotCore.active;
  if (!previewActive && (!m_playing || !m_songLoaded)) {
    return;
  }

  const size_t clampedTargetFrames =
      min(targetFrames, static_cast<size_t>(kAudioRingFrames - 1));
  while (bufferedAudioFrames() < clampedTargetFrames) {
    const size_t requiredWritableFrames =
        maxOutputFramesForSynthChunk(kRenderChunkFrames, m_sampleRateHz, m_outputSampleRateHz);
    if (writableAudioFrames() < requiredWritableFrames) {
      break;
    }

    const unsigned long aheadMs =
        static_cast<unsigned long>(
            (bufferedAudioFrames() * 1000UL) / max<uint32_t>(1, m_outputSampleRateHz));
    updateMusic(millis() + aheadMs);
    if (renderChunkToAudioRingLocked() == 0) {
      break;
    }
  }
}

size_t App::bufferedAudioFrames() const {
  const size_t writeFrame =
      __atomic_load_n(&m_audioRingWriteFrame, __ATOMIC_ACQUIRE);
  const size_t readFrame =
      __atomic_load_n(&m_audioRingReadFrame, __ATOMIC_ACQUIRE);
  if (writeFrame >= readFrame) {
    return writeFrame - readFrame;
  }
  return kAudioRingFrames - (readFrame - writeFrame);
}

size_t App::writableAudioFrames() const {
  return (kAudioRingFrames - 1) - bufferedAudioFrames();
}

void App::clearAudioRingBuffer() {
  __atomic_store_n(&m_audioRingReadFrame, 0, __ATOMIC_RELEASE);
  __atomic_store_n(&m_audioRingWriteFrame, 0, __ATOMIC_RELEASE);
#if APP_USE_32BIT_IRAM_AUDIO_BUFFERS
  for (size_t frame = 0; frame < kAudioRingFrames; ++frame) {
    m_audioRingBuffer[frame] = 0;
  }
#else
  memset(m_audioRingBuffer, 0, sizeof(m_audioRingBuffer));
#endif
  m_lastStreamFrame = 0;
  m_resamplePhaseQ16 = 0;
  m_resamplePrevFrame = 0;
}

void App::retimeActiveVoices(
    uint32_t oldSampleRateHz, uint32_t newSampleRateHz) {
  if (oldSampleRateHz == 0 || newSampleRateHz == 0 ||
      oldSampleRateHz == newSampleRateHz) {
    return;
  }
  auto scaleU32 = [&](uint32_t value) -> uint32_t {
    if (value == 0) return 0;
    const uint64_t scaled =
        (static_cast<uint64_t>(value) * oldSampleRateHz + newSampleRateHz / 2) /
        newSampleRateHz;
    return static_cast<uint32_t>(max<uint64_t>(1, min<uint64_t>(UINT32_MAX, scaled)));
  };
  auto scaleI16 = [&](int16_t value) -> int16_t {
    if (value <= 0) return value;
    const uint32_t scaled = scaleU32(static_cast<uint16_t>(value));
    return static_cast<int16_t>(min<uint32_t>(INT16_MAX, scaled));
  };
  for (uint8_t i = 0; i < m_activeVoiceLimit; ++i) {
    if (!isVoiceActive(i)) continue;
    VoiceState& voice = m_voices[i];
    voice.cold.carrierBaseStepQ16 = scaleU32(voice.cold.carrierBaseStepQ16);
    voice.hotCore.carrierSampleStepQ16 = scaleU32(
        voice.hotCore.carrierSampleStepQ16);
    voice.hotEnvelope.carrierAttackStepQ15 = scaleI16(
        voice.hotEnvelope.carrierAttackStepQ15);
    voice.hotEnvelope.carrierDecayStepQ15 = scaleI16(
        voice.hotEnvelope.carrierDecayStepQ15);
    voice.hotEnvelope.carrierReleaseStepQ15 = scaleI16(
        voice.hotEnvelope.carrierReleaseStepQ15);
  }
}

void App::startBtDiscovery() {
  if (!m_btReady || m_discoveryRunning) {
    return;
  }

  // Flash erase/write can hold the SPI flash/cache lock on CPU0.  Keep it out
  // of the inquiry window so GAP and A2DP SDP get uninterrupted service.
  Log::setFlashWriteAllowed(false);
  memset(m_btDevices, 0, sizeof(m_btDevices));
  if (esp_bt_gap_start_discovery(
          ESP_BT_INQ_MODE_GENERAL_INQUIRY,
          Config::BtInquiryLength,
          0) == ESP_OK) {
    m_discoveryRunning = true;
    Log::info("Bluetooth inquiry started");
    return;
  }

  Log::info("Bluetooth inquiry start failed");
  Log::setFlashWriteAllowed(true);
}

void App::connectToAddress(const char* address) {
  if (!m_btReady) {
    Log::info("A2DP connect ignored: Bluetooth is not ready");
    return;
  }

  esp_bd_addr_t remoteAddress = {0};
  if (!parseBdAddr(address, remoteAddress)) {
    Log::info("Invalid BT address");
    return;
  }

  // Stop and drain any pending log write before submitting the A2DP request.
  // The RAM ring and UART output remain active while the connection is open.
  Log::setFlashWriteAllowed(false);

  strncpy(m_connectingAddress, address, sizeof(m_connectingAddress) - 1);
  m_connectingAddress[sizeof(m_connectingAddress) - 1] = '\0';

  if (m_a2dpConnected && strcmp(m_connectedAddress, m_connectingAddress) == 0) {
    m_connectAfterDiscovery = false;
    m_connectAfterDisconnect = false;
    m_connectingAddress[0] = '\0';
    Log::infof("A2DP already connected: %s", m_connectedAddress);
    return;
  }

  // The inquiry callback can expose a device before the inquiry itself has
  // stopped.  Connecting the A2DP source during that window is rejected by
  // some sinks (and by some Bluedroid states), so cancel inquiry and continue
  // from the GAP discovery-stopped event instead.
  if (m_discoveryRunning) {
    m_connectAfterDiscovery = true;
    const esp_err_t cancelResult = esp_bt_gap_cancel_discovery();
    Log::infof(
        "A2DP connect deferred until inquiry stops: %s cancel=%d",
        m_connectingAddress,
        static_cast<int>(cancelResult));
    if (cancelResult != ESP_OK) {
      // If cancellation races with the natural end of inquiry, the GAP stop
      // event still consumes the pending request.  Do not issue a connection
      // while the stack still reports discovery in progress.
      Log::info("Bluetooth inquiry cancellation is pending");
    }
    return;
  }

  m_connectAfterDiscovery = false;
  continueBluetoothConnectionRequest();
}

void App::continueBluetoothConnectionRequest() {
  if (!m_btReady || m_connectingAddress[0] == '\0') {
    return;
  }

  if (m_a2dpConnected && m_connectedAddress[0] != '\0') {
    esp_bd_addr_t currentAddress = {0};
    if (parseBdAddr(m_connectedAddress, currentAddress)) {
      m_connectAfterDisconnect = true;
      const esp_err_t disconnectResult = esp_a2d_source_disconnect(currentAddress);
      Log::infof(
          "A2DP switch: disconnect %s result=%d",
          m_connectedAddress,
          static_cast<int>(disconnectResult));
      if (disconnectResult != ESP_OK) {
        m_connectAfterDisconnect = false;
        m_connectingAddress[0] = '\0';
      }
      return;
    }
    Log::infof("A2DP switch: current address invalid: %s", m_connectedAddress);
  }

  m_connectAfterDisconnect = false;
  connectPendingBluetoothAddress();
}

void App::connectPendingBluetoothAddress() {
  if (!m_btReady || m_connectingAddress[0] == '\0') {
    return;
  }

  esp_bd_addr_t remoteAddress = {0};
  if (!parseBdAddr(m_connectingAddress, remoteAddress)) {
    Log::info("Invalid pending BT address");
    m_connectAfterDisconnect = false;
    m_connectingAddress[0] = '\0';
    Log::setFlashWriteAllowed(true);
    return;
  }

  char address[sizeof(m_connectingAddress)] = {};
  // Log the actual bytes submitted to Bluedroid, not just the HTTP text.
  formatBdAddr(remoteAddress, address, sizeof(address));
  Log::infof("A2DP submitting connection: %s", address);
  const esp_err_t result = esp_a2d_source_connect(remoteAddress);
  Log::infof(
      "A2DP connect requested: %s result=%d",
      address,
      static_cast<int>(result));
  if (result != ESP_OK) {
    m_connectAfterDisconnect = false;
    m_connectingAddress[0] = '\0';
    Log::setFlashWriteAllowed(true);
  }
}

void App::startSongPlayback() {
  // 明示的な再生操作、または安定化待ちを終えた自動再生で消費する。
  m_autoPlaybackNotBeforeMs = 0;
  portENTER_CRITICAL(&m_syncMux);
  ++m_syncGeneration;
  m_audioConsumedFrames = 0;
  portEXIT_CRITICAL(&m_syncMux);
  m_playbackStartMs = millis();
  m_audioUnderrunCount = 0;
  m_nextEventIndex = 0;
  m_nextEventCached = false;
  m_eventCacheCount = 0;
  if (m_songFormatVersion == kSongFormatVersionRawMidi) {
    requestRawMidiParserReset();
  }
  stopAllVoices();
  resetChannelPitchBends();
  resetEffects();
  clearAudioRingBuffer();
  processPendingSongEvents(0);
  // chunk縮小後も再生開始時の先読み量は512 frameを維持する。
  primeAudioRingBufferLocked(kAudioRingLowWaterFrames);
  Log::info("Song playback restarted");
}

void App::seekSongPlayback(uint32_t elapsedMs) {
  if (!m_songLoaded) {
    return;
  }

  if (elapsedMs > m_song.durationMs) {
    elapsedMs = m_song.durationMs;
  }

  m_playbackStartMs = millis() - elapsedMs;
  portENTER_CRITICAL(&m_syncMux);
  ++m_syncGeneration;
  m_audioConsumedFrames = 0;
  portEXIT_CRITICAL(&m_syncMux);
  m_nextEventIndex = 0;
  m_nextEventCached = false;
  m_eventCacheCount = 0;
  if (m_songFormatVersion == kSongFormatVersionRawMidi) {
    requestRawMidiParserReset();
  }
  stopAllVoices();
  resetChannelPitchBends();
  resetEffects();
  clearAudioRingBuffer();
  processPendingSongEvents(elapsedMs);
  primeAudioRingBufferLocked(kAudioRingLowWaterFrames);
  Log::infof("Song playback resumed at %lu ms", static_cast<unsigned long>(elapsedMs));
}

void App::setVoiceActive(uint8_t voiceIndex, bool active) {
  if (voiceIndex >= kMaxVoices) {
    return;
  }
  const uint32_t bit = 1UL << voiceIndex;
  m_voices[voiceIndex].hotCore.active = active;
  if (active) {
    __atomic_fetch_or(&m_activeVoiceMask, bit, __ATOMIC_RELAXED);
  } else {
    __atomic_fetch_and(&m_activeVoiceMask, ~bit, __ATOMIC_RELAXED);
  }
}

bool App::isVoiceActive(uint8_t voiceIndex) const {
  return voiceIndex < kMaxVoices &&
      (m_activeVoiceMask & (1UL << voiceIndex)) != 0;
}

void App::stopAllVoices() {
  m_previewVoiceIndex = -1;
  m_previewNote = 0;
  m_previewToneClass = MidiEvent::ToneClass::Lead;
  m_previewStopAtMs = 0;
  for (uint8_t i = 0; i < kMaxVoices; ++i) {
    m_voices[i].hotCore.active = false;
    m_voices[i].cold.toneClass = MidiEvent::ToneClass::Lead;
    m_voices[i].hotCore.decayUpdateDivider = 1;
    m_voices[i].hotCore.decayUpdateCounter = 0;
    m_voices[i].hotCore.carrierFixedGainLeftQ15 = 0;
    m_voices[i].hotCore.carrierFixedGainRightQ15 = 0;
    m_voices[i].hotCore.reverbFixedGainQ15 = 0;
    m_voices[i].hotCore.chorusFixedGainQ15 = 0;
    m_voices[i].hotCore.delayFixedGainQ15 = 0;
    m_voices[i].hotCore.filterLowQ15 = 0;
    m_voices[i].hotCore.filterBandQ15 = 0;
    m_voices[i].cold.velocity = 0;
    m_voices[i].cold.note = 0;
    m_voices[i].cold.channel = 0;
    m_voices[i].cold.carrierBaseStepQ16 = 0;
    m_voices[i].cold.baseFixedGainQ15 = 0;
    m_voices[i].cold.pan = 64;
    m_voices[i].cold.fxSends = 0;
    m_voices[i].hotCore.carrierSample = nullptr;
    m_voices[i].hotCore.carrierSampleLength = 0;
    m_voices[i].hotCore.carrierLoopStart = 0;
    m_voices[i].hotCore.carrierLoopEnd = 0;
    m_voices[i].hotCore.carrierLoopEnabled = false;
    m_voices[i].hotCore.carrierStage = EnvelopeStage::Off;
    m_voices[i].hotCore.carrierSamplePosQ16 = 0;
    m_voices[i].hotCore.carrierSampleStepQ16 = 0;
    m_voices[i].hotCore.carrierEnvelopeLevelQ15 = 0;
    m_voices[i].hotEnvelope.carrierAttackStepQ15 = 0;
    m_voices[i].hotEnvelope.carrierDecayStepQ15 = 0;
    m_voices[i].hotEnvelope.carrierSustainLevelQ15 = 0;
    m_voices[i].hotEnvelope.carrierReleaseStepQ15 = 0;
  }
  m_activeVoiceMask = 0;
}

void App::resetRawMidiQueue() {
  portENTER_CRITICAL(&m_rawMidiQueueMux);
  m_rawMidiQueueRead = 0;
  m_rawMidiQueueWrite = 0;
  portEXIT_CRITICAL(&m_rawMidiQueueMux);
}

bool App::peekRawMidiEvent(MidiEvent& event) const {
  bool available = false;
  portENTER_CRITICAL(const_cast<portMUX_TYPE*>(&m_rawMidiQueueMux));
  if (m_rawMidiQueueRead != m_rawMidiQueueWrite) {
    event = m_rawMidiQueue[m_rawMidiQueueRead];
    available = true;
  }
  portEXIT_CRITICAL(const_cast<portMUX_TYPE*>(&m_rawMidiQueueMux));
  return available;
}

bool App::popRawMidiEvent(MidiEvent& event) {
  bool available = false;
  portENTER_CRITICAL(&m_rawMidiQueueMux);
  if (m_rawMidiQueueRead != m_rawMidiQueueWrite) {
    event = m_rawMidiQueue[m_rawMidiQueueRead];
    m_rawMidiQueueRead = static_cast<uint16_t>(
        (m_rawMidiQueueRead + 1) % kRawMidiQueueSize);
    available = true;
  }
  portEXIT_CRITICAL(&m_rawMidiQueueMux);
  return available;
}

void App::requestRawMidiParserReset() {
  m_rawMidiParserRunning = false;
  m_rawMidiParserEof = false;
  resetRawMidiQueue();
  m_rawMidiParserCommand = 1;
  if (m_rawMidiParserTaskHandle != nullptr) {
    xTaskNotifyGive(m_rawMidiParserTaskHandle);
  }
}

void App::processPendingSongEvents(uint32_t elapsedMs) {
  if (m_songFormatVersion == kSongFormatVersionRawMidi) {
    MidiEvent event;
    while (peekRawMidiEvent(event) && event.timeMs <= elapsedMs) {
      if (!popRawMidiEvent(event)) break;
      if (event.type == MidiEvent::Type::NoteOn) {
        noteOn(event.note, event.velocity, event.channel,
            playbackToneClass(event.toneClass),
            event.bankMsb, event.pan, event.channelGain, event.fxSends);
      } else if (event.type == MidiEvent::Type::NoteOff) {
        noteOff(event.note, event.channel);
      } else if (event.type == MidiEvent::Type::PitchBend) {
        const uint16_t value14 = static_cast<uint16_t>(event.note & 0x7f) |
            (static_cast<uint16_t>(event.velocity & 0x7f) << 7);
        applyPitchBend(event.channel, value14);
      } else if (event.type == MidiEvent::Type::PitchBendRange) {
        applyPitchBendRange(event.channel, event.note, event.velocity);
      } else if (event.type == MidiEvent::Type::Modulation) {
        applyModulation(event.channel, event.note);
      } else if (event.type == MidiEvent::Type::Controller) {
        applyController(event.channel, event.note, event.velocity);
      } else if (event.type == MidiEvent::Type::GsEffect) {
        applyGsEffect(event.note, event.velocity);
      } else if (event.type == MidiEvent::Type::GmReset) {
        stopAllVoices();
        resetChannelPitchBends();
        resetEffects();
      }
    }
    return;
  }
  while (m_nextEventIndex < m_song.eventCount && ensureNextEventCached() &&
         m_nextEventCache.timeMs <= elapsedMs) {
    const MidiEvent& event = m_nextEventCache;
    if (event.type == MidiEvent::Type::NoteOn) {
      noteOn(
          event.note,
          event.velocity,
          event.channel,
          playbackToneClass(event.toneClass),
          event.bankMsb,
          event.pan,
          event.channelGain,
          event.fxSends);
    } else if (event.type == MidiEvent::Type::NoteOff) {
      noteOff(event.note, event.channel);
    } else if (event.type == MidiEvent::Type::PitchBend) {
      const uint16_t value14 = static_cast<uint16_t>(event.note & 0x7f) |
          (static_cast<uint16_t>(event.velocity & 0x7f) << 7);
      applyPitchBend(event.channel, value14);
    } else if (event.type == MidiEvent::Type::PitchBendRange) {
      applyPitchBendRange(event.channel, event.note, event.velocity);
    } else if (event.type == MidiEvent::Type::Modulation) {
      applyModulation(event.channel, event.note);
    } else if (event.type == MidiEvent::Type::Controller) {
      applyController(event.channel, event.note, event.velocity);
    } else if (event.type == MidiEvent::Type::GsEffect) {
      applyGsEffect(event.note, event.velocity);
    } else if (event.type == MidiEvent::Type::GmReset) {
      stopAllVoices();
      resetChannelPitchBends();
      resetEffects();
    }
    ++m_nextEventIndex;
    m_nextEventCached = false;
  }
}

MidiEvent::ToneClass App::playbackToneClass(
    MidiEvent::ToneClass sourceToneClass) const {
  return m_toneOverrideEnabled ? m_toneOverrideClass : sourceToneClass;
}

int App::noteOn(
    uint8_t note,
    uint8_t velocity,
    uint8_t channel,
    MidiEvent::ToneClass toneClass,
    uint8_t bankMsb,
    uint8_t panValue,
    uint8_t channelGain,
    uint8_t fxSends) {
  if (m_activeVoiceLimit == 0) {
    return -1;
  }

#if APP_USE_MULAW_TONES
  if ((channel & 0x0f) == 9 && (note == 42 || note == 44)) {
    // A closed or pedal hi-hat chokes an already sounding open hi-hat.
    for (uint8_t i = 0; i < m_activeVoiceLimit; ++i) {
      if (isVoiceActive(i) &&
          (m_voices[i].cold.channel & 0x0f) == 9 &&
          m_voices[i].cold.note == 46) {
        m_voices[i].hotCore.carrierStage = EnvelopeStage::Release;
      }
    }
  }
#endif

  int voiceIndex = findVoiceIndex(note, channel);
  if (voiceIndex < 0) {
    voiceIndex = allocateVoiceIndex(channel);
  }
  if (voiceIndex < 0) {
    return -1;
  }

  VoiceState& voice = m_voices[voiceIndex];
  const float baseFrequency = midiToHz(note);
  const float velocityNorm = static_cast<float>(velocity) / 127.0f;
  float velocityGain = 0.16f + velocityNorm * 0.30f;
  float layerPitchRatio = 1.0f;
  float layerDetuneCents = 0.0f;
  float layerAttackMs = 6.0f;
  float layerDecayMs = 220.0f;
  float layerSustain = 0.70f;
  float layerReleaseMs = 140.0f;
  float layerOutputLevel = 0.92f;
  const float lowNoteBoost =
      note <= 36 ? 1.18f :
      note <= 48 ? 1.10f :
      note <= 60 ? 1.04f : 1.0f;

  switch (toneClass) {
    case MidiEvent::ToneClass::Piano:
      velocityGain *= 1.00f;
      layerAttackMs = 1.0f;
      layerDecayMs = 420.0f;
      layerSustain = 0.26f;
      layerReleaseMs = 240.0f;
      layerOutputLevel = 0.86f;
      break;
    case MidiEvent::ToneClass::BrightPiano:
      velocityGain *= 1.04f;
      layerAttackMs = 0.8f;
      layerDecayMs = 320.0f;
      layerSustain = 0.18f;
      layerReleaseMs = 180.0f;
      layerOutputLevel = 0.90f;
      break;
    case MidiEvent::ToneClass::HonkyTonk:
      velocityGain *= 1.02f;
      layerAttackMs = 1.2f;
      layerDecayMs = 260.0f;
      layerSustain = 0.20f;
      layerReleaseMs = 170.0f;
      layerOutputLevel = 0.88f;
      break;
    case MidiEvent::ToneClass::Bass:
      velocityGain *= 1.10f;
      layerAttackMs = 2.0f;
      layerDecayMs = 180.0f;
      layerSustain = 0.86f;
      layerReleaseMs = 150.0f;
      layerOutputLevel = 0.96f;
      break;
    case MidiEvent::ToneClass::PunchBass:
      velocityGain *= 1.22f;
      layerAttackMs = 1.0f;
      layerDecayMs = 120.0f;
      layerSustain = 0.74f;
      layerReleaseMs = 100.0f;
      layerOutputLevel = 0.98f;
      break;
    case MidiEvent::ToneClass::SubBass:
      velocityGain *= 1.14f;
      layerAttackMs = 2.0f;
      layerDecayMs = 220.0f;
      layerSustain = 0.90f;
      layerReleaseMs = 180.0f;
      layerOutputLevel = 0.92f;
      break;
    case MidiEvent::ToneClass::Pad:
      velocityGain *= 0.86f;
      layerAttackMs = 80.0f;
      layerDecayMs = 520.0f;
      layerSustain = 0.58f;
      layerReleaseMs = 620.0f;
      layerOutputLevel = 0.66f;
      break;
    case MidiEvent::ToneClass::WarmPad:
      velocityGain *= 0.82f;
      layerAttackMs = 100.0f;
      layerDecayMs = 720.0f;
      layerSustain = 0.62f;
      layerReleaseMs = 760.0f;
      layerOutputLevel = 0.62f;
      break;
    case MidiEvent::ToneClass::Bell:
      velocityGain *= 0.96f;
      layerAttackMs = 1.0f;
      layerDecayMs = 900.0f;
      layerSustain = 0.08f;
      layerReleaseMs = 420.0f;
      layerOutputLevel = 0.78f;
      break;
    case MidiEvent::ToneClass::Mallet:
      velocityGain *= 0.94f;
      layerAttackMs = 0.8f;
      layerDecayMs = 220.0f;
      layerSustain = 0.03f;
      layerReleaseMs = 100.0f;
      layerOutputLevel = 0.74f;
      break;
    case MidiEvent::ToneClass::Metal:
      velocityGain *= 1.02f;
      layerAttackMs = 0.7f;
      layerDecayMs = 280.0f;
      layerSustain = 0.00f;
      layerReleaseMs = 120.0f;
      layerOutputLevel = 0.72f;
      break;
    case MidiEvent::ToneClass::Pluck:
    case MidiEvent::ToneClass::NylonGuitar:
    case MidiEvent::ToneClass::CleanGuitar:
    case MidiEvent::ToneClass::MutedGuitar:
      velocityGain *= 0.94f;
      layerAttackMs = 1.5f;
      layerDecayMs = 160.0f;
      layerSustain = 0.12f;
      layerReleaseMs = 100.0f;
      layerOutputLevel = 0.88f;
      if (toneClass == MidiEvent::ToneClass::NylonGuitar) {
        layerDecayMs = 240.0f;
        layerSustain = 0.18f;
      } else if (toneClass == MidiEvent::ToneClass::CleanGuitar) {
        layerDecayMs = 200.0f;
        layerSustain = 0.22f;
      } else if (toneClass == MidiEvent::ToneClass::MutedGuitar) {
        layerDecayMs = 80.0f;
        layerSustain = 0.02f;
      }
      break;
    case MidiEvent::ToneClass::Keys:
      velocityGain *= 0.92f;
      layerAttackMs = 4.0f;
      layerDecayMs = 220.0f;
      layerSustain = 0.38f;
      layerReleaseMs = 180.0f;
      layerOutputLevel = 0.84f;
      break;
    case MidiEvent::ToneClass::EPiano:
      velocityGain *= 0.96f;
      layerAttackMs = 2.0f;
      layerDecayMs = 280.0f;
      layerSustain = 0.20f;
      layerReleaseMs = 180.0f;
      layerOutputLevel = 0.78f;
      break;
    case MidiEvent::ToneClass::Organ:
      velocityGain *= 0.88f;
      layerAttackMs = 5.0f;
      layerDecayMs = 200.0f;
      layerSustain = 0.82f;
      layerReleaseMs = 260.0f;
      layerOutputLevel = 0.74f;
      break;
    case MidiEvent::ToneClass::Brass:
    case MidiEvent::ToneClass::Trumpet:
    case MidiEvent::ToneClass::Sax:
      velocityGain *= 1.06f;
      layerAttackMs = 16.0f;
      layerDecayMs = 260.0f;
      layerSustain = 0.68f;
      layerReleaseMs = 220.0f;
      layerOutputLevel = 0.82f;
      if (toneClass == MidiEvent::ToneClass::Trumpet) {
        layerAttackMs = 10.0f;
        layerOutputLevel = 0.88f;
      } else if (toneClass == MidiEvent::ToneClass::Sax) {
        layerAttackMs = 20.0f;
        layerSustain = 0.74f;
      }
      break;
    case MidiEvent::ToneClass::Perc:
      velocityGain *= 0.90f;
      layerAttackMs = 0.8f;
      layerDecayMs = 90.0f;
      layerSustain = 0.00f;
      layerReleaseMs = 35.0f;
      layerOutputLevel = 0.72f;
      break;
    case MidiEvent::ToneClass::SoftLead:
    case MidiEvent::ToneClass::Flute:
    case MidiEvent::ToneClass::Clarinet:
      velocityGain *= 0.96f;
      layerAttackMs = 10.0f;
      layerDecayMs = 240.0f;
      layerSustain = 0.52f;
      layerReleaseMs = 180.0f;
      layerOutputLevel = 0.82f;
      if (toneClass == MidiEvent::ToneClass::Flute) {
        layerAttackMs = 18.0f;
        layerSustain = 0.66f;
      } else if (toneClass == MidiEvent::ToneClass::Clarinet) {
        layerAttackMs = 12.0f;
        layerDecayMs = 300.0f;
        layerSustain = 0.62f;
      }
      break;
    case MidiEvent::ToneClass::HardLead:
      velocityGain *= 1.10f;
      layerAttackMs = 2.0f;
      layerDecayMs = 180.0f;
      layerSustain = 0.70f;
      layerReleaseMs = 130.0f;
      layerOutputLevel = 0.90f;
      break;
    case MidiEvent::ToneClass::KickPerc:
      velocityGain *= 1.10f;
      layerAttackMs = 0.4f;
      layerDecayMs = 80.0f;
      layerSustain = 0.00f;
      layerReleaseMs = 35.0f;
      layerOutputLevel = 0.88f;
      break;
    case MidiEvent::ToneClass::PickedBass:
      velocityGain *= 1.08f;
      layerAttackMs = 1.0f;
      layerDecayMs = 180.0f;
      layerSustain = 0.48f;
      layerReleaseMs = 120.0f;
      layerOutputLevel = 0.92f;
      break;
    case MidiEvent::ToneClass::Strings:
    case MidiEvent::ToneClass::Choir:
      velocityGain *= 0.84f;
      layerAttackMs = 60.0f;
      layerDecayMs = 600.0f;
      layerSustain = 0.64f;
      layerReleaseMs = 640.0f;
      layerOutputLevel = 0.66f;
      if (toneClass == MidiEvent::ToneClass::Choir) {
        layerAttackMs = 80.0f;
        layerSustain = 0.72f;
      }
      break;
    case MidiEvent::ToneClass::Accordion:
      velocityGain *= 0.92f;
      layerAttackMs = 6.0f;
      layerDecayMs = 240.0f;
      layerSustain = 0.76f;
      layerReleaseMs = 240.0f;
      layerOutputLevel = 0.78f;
      break;
    case MidiEvent::ToneClass::Lead:
    default:
      velocityGain *= 1.00f;
      layerAttackMs = 4.0f;
      layerDecayMs = 220.0f;
      layerSustain = 0.64f;
      layerReleaseMs = 150.0f;
      layerOutputLevel = 0.88f;
      break;
  }

  switch (m_waveTableSet) {
    case WaveTableSet::Famicom:
      velocityGain *= 0.96f;
      layerAttackMs *= 0.55f;
      layerDecayMs *= 0.72f;
      layerReleaseMs *= 0.60f;
      layerSustain *= 0.88f;
      layerOutputLevel *= 0.96f;
      break;
    case WaveTableSet::Soft:
      velocityGain *= 0.90f;
      layerAttackMs *= 1.80f;
      layerDecayMs *= 1.35f;
      layerReleaseMs *= 1.55f;
      layerSustain = min(0.98f, layerSustain * 1.12f + 0.05f);
      layerOutputLevel *= 0.88f;
      break;
    case WaveTableSet::Real:
    default:
      velocityGain *= 1.10f;
      layerOutputLevel *= 1.08f;
      break;
  }

  PcmSampleDef carrierSample = sampleForToneClass(toneClass, m_waveTableSet, false);
  bool gmDrum = false;
#if APP_USE_MULAW_TONES
  if ((channel & 0x0f) != 9) {
    // Undefined GS variations deliberately retain the GM capital tone.
    sampleForGsTone(
        bankMsb,
        static_cast<uint8_t>(toneClass),
        carrierSample);
  }
  if ((channel & 0x0f) == 9) {
    gmDrum = sampleForGmDrum(note, carrierSample, layerPitchRatio);
  }
#endif
  if (gmDrum) {
    // The captured one-shot already contains its complete amplitude
    // evolution. Keep the synth envelope open until the sample ends.
    // Drum captures have lower RMS than melodic tones; give them a modest
    // headroom lift while retaining velocity dynamics.
    velocityGain = 0.30f + velocityNorm * 0.65f;
    layerAttackMs = 0.2f;
    layerDecayMs = max(
        40.0f,
        static_cast<float>(carrierSample.length) * 1100.0f /
            static_cast<float>(m_sampleRateHz));
    layerSustain = 0.0f;
    layerReleaseMs = 12.0f;
    layerOutputLevel = 0.92f;
  } else {
    layerOutputLevel *= toneClassSampleGain(toneClass);
  }

  auto stepForSample = [&](const PcmSampleDef& sample, float pitchRatio, float detuneCents) -> uint32_t {
    float stepQ16 = static_cast<float>(kQ16One) * pitchRatio * powf(2.0f, detuneCents / 1200.0f);
    if (sample.fixedPitch) {
      // Captured one-shots are stored at the canonical synth rate. Keep
      // their pitch and duration constant when the internal rate changes.
      stepQ16 *= static_cast<float>(max<uint32_t>(1, sample.sourceRate)) /
          static_cast<float>(max<uint32_t>(1, m_sampleRateHz));
    } else {
      stepQ16 *= (baseFrequency * static_cast<float>(max<uint32_t>(1, sample.cycleLength))) /
                 static_cast<float>(m_sampleRateHz);
    }
    if (stepQ16 < 1.0f) {
      stepQ16 = 1.0f;
    }
    return static_cast<uint32_t>(stepQ16);
  };

  setVoiceActive(static_cast<uint8_t>(voiceIndex), true);
  voice.cold.toneClass = toneClass;
  voice.cold.note = note;
  voice.cold.channel = channel;
  voice.cold.velocity = velocity;
  voice.hotCore.decayUpdateDivider = currentDecayUpdateDivider(toneClass);
  voice.hotCore.decayUpdateCounter = 0;
  voice.hotCore.carrierSample = carrierSample.data;
  voice.hotCore.carrierSampleLength = carrierSample.length;
  voice.hotCore.carrierLoopStart = carrierSample.loopStart;
  voice.hotCore.carrierLoopEnd = carrierSample.loopEnd;
  voice.hotCore.carrierLoopEnabled = carrierSample.loopEnabled;
  voice.hotCore.carrierStage = EnvelopeStage::Attack;
  voice.hotCore.carrierSamplePosQ16 = 0;
#if APP_USE_ADPCM_TONES
  voice.hotCore.adpcmCacheValid = false;
#elif APP_USE_MULAW_TONES
  voice.hotCore.mulawCacheValid = false;
#endif
  voice.cold.carrierBaseStepQ16 =
      stepForSample(carrierSample, layerPitchRatio, layerDetuneCents);
  voice.hotCore.carrierSampleStepQ16 = (channel & 0x0f) == 9
      ? voice.cold.carrierBaseStepQ16
      : bentSampleStep(
          voice.cold.carrierBaseStepQ16,
          m_channelPitchBend[channel & 0x0f],
          m_channelPitchBendRangeCents[channel & 0x0f]);
  voice.hotCore.carrierEnvelopeLevelQ15 = 0;
  voice.hotCore.filterLowQ15 = 0;
  voice.hotCore.filterBandQ15 = 0;
  const uint32_t envelopeSlowUpdateDivider =
      max<uint32_t>(1, voice.hotCore.decayUpdateDivider);
  const uint8_t midiChannel = channel & 0x0f;
  const float attackScale = powf(2.0f,
      (static_cast<float>(m_channelAttack[midiChannel]) - 64.0f) / 32.0f);
  const float releaseScale = powf(2.0f,
      (static_cast<float>(m_channelRelease[midiChannel]) - 64.0f) / 32.0f);
  voice.hotEnvelope.carrierAttackStepQ15 =
      msToEnvelopeStepQ15(layerAttackMs * attackScale, m_sampleRateHz, 1);
  voice.hotEnvelope.carrierDecayStepQ15 =
      msToEnvelopeStepQ15(layerDecayMs * powf(2.0f,
          (static_cast<float>(m_channelDecay[midiChannel]) - 64.0f) / 32.0f),
          m_sampleRateHz, envelopeSlowUpdateDivider);
  voice.hotEnvelope.carrierSustainLevelQ15 = gainToQ15(layerSustain);
  voice.hotEnvelope.carrierReleaseStepQ15 =
      msToEnvelopeStepQ15(layerReleaseMs * releaseScale, m_sampleRateHz, envelopeSlowUpdateDivider);
  if (!gmDrum) {
    velocityGain *= lowNoteBoost;
  }
  if (toneClass == MidiEvent::ToneClass::Bass ||
      toneClass == MidiEvent::ToneClass::PunchBass ||
      toneClass == MidiEvent::ToneClass::PickedBass) {
    velocityGain *= 1.10f;
  }
  const float velocityGainLimit = gmDrum ? 0.95f : 0.58f;
  if (velocityGain > velocityGainLimit) {
    velocityGain = velocityGainLimit;
  }
  const float midiChannelGain =
      static_cast<float>(min<uint8_t>(127, channelGain)) / 127.0f;
  // Keep the global master gain unchanged; apply the requested boost only to
  // mapped GM drums so melodic voices and effects retain their balance.
  const float drumGainBoost = 1.0f;
  const float fixedGain = min(
      1.0f,
      velocityGain * layerOutputLevel * Config::MasterGain * midiChannelGain *
          drumGainBoost);
  const int32_t fixedGainQ15 = gainToQ15(fixedGain);
  voice.cold.baseFixedGainQ15 = gainToQ15(min(
      1.0f, velocityGain * layerOutputLevel * Config::MasterGain * drumGainBoost));
  voice.cold.pan = panValue <= 127 ? panValue : 64;
  voice.cold.fxSends = fxSends;
  const uint8_t reverbSend = static_cast<uint8_t>((fxSends >> 4) & 0x0f);
  const uint8_t chorusSend = static_cast<uint8_t>(fxSends & 0x0f);
  voice.hotCore.reverbFixedGainQ15 = static_cast<int16_t>(
      (fixedGainQ15 * static_cast<int32_t>(reverbSend)) / 15);
  voice.hotCore.chorusFixedGainQ15 = static_cast<int16_t>(
      (fixedGainQ15 * static_cast<int32_t>(chorusSend)) / 15);
  StereoPanQ15 pan = kChannelPanQ15[channel & 0x0f];
  if (panValue <= 127) {
    // MIDI balance pan。centerでは従来音量を維持し、端で反対側を0にする。
    if (panValue < 64) {
      pan.left = 32767;
      pan.right = static_cast<int16_t>(
          (static_cast<uint32_t>(panValue) * 32767u) / 64u);
    } else {
      pan.right = 32767;
      pan.left = static_cast<int16_t>(
          (static_cast<uint32_t>(127u - panValue) * 32767u) / 63u);
    }
  }
  voice.hotCore.carrierFixedGainLeftQ15 = static_cast<int16_t>(
      (fixedGainQ15 * static_cast<int32_t>(pan.left)) >> 15);
  voice.hotCore.carrierFixedGainRightQ15 = static_cast<int16_t>(
      (fixedGainQ15 * static_cast<int32_t>(pan.right)) >> 15);
  updateVoiceGains(voice);
  voice.cold.startedAtMs = millis();
  return voiceIndex;
}

const char* App::toneClassToText(MidiEvent::ToneClass toneClass) const {
  switch (toneClass) {
    case MidiEvent::ToneClass::Piano:
      return "piano";
    case MidiEvent::ToneClass::BrightPiano:
      return "bright_piano";
    case MidiEvent::ToneClass::HonkyTonk:
      return "honky_tonk";
    case MidiEvent::ToneClass::Bass:
      return "bass";
    case MidiEvent::ToneClass::Pad:
      return "pad";
    case MidiEvent::ToneClass::Bell:
      return "bell";
    case MidiEvent::ToneClass::Pluck:
      return "pluck";
    case MidiEvent::ToneClass::NylonGuitar:
      return "nylon_guitar";
    case MidiEvent::ToneClass::CleanGuitar:
      return "clean_guitar";
    case MidiEvent::ToneClass::MutedGuitar:
      return "muted_guitar";
    case MidiEvent::ToneClass::Perc:
      return "perc";
    case MidiEvent::ToneClass::SoftLead:
      return "soft_lead";
    case MidiEvent::ToneClass::PunchBass:
      return "punch_bass";
    case MidiEvent::ToneClass::WarmPad:
      return "warm_pad";
    case MidiEvent::ToneClass::Keys:
      return "keys";
    case MidiEvent::ToneClass::Brass:
      return "brass";
    case MidiEvent::ToneClass::Mallet:
      return "mallet";
    case MidiEvent::ToneClass::SubBass:
      return "sub_bass";
    case MidiEvent::ToneClass::PickedBass:
      return "picked_bass";
    case MidiEvent::ToneClass::HardLead:
      return "hard_lead";
    case MidiEvent::ToneClass::EPiano:
      return "epiano";
    case MidiEvent::ToneClass::Organ:
      return "organ";
    case MidiEvent::ToneClass::Metal:
      return "metal";
    case MidiEvent::ToneClass::KickPerc:
      return "kick_perc";
    case MidiEvent::ToneClass::Strings:
      return "strings";
    case MidiEvent::ToneClass::Choir:
      return "choir";
    case MidiEvent::ToneClass::Trumpet:
      return "trumpet";
    case MidiEvent::ToneClass::Sax:
      return "sax";
    case MidiEvent::ToneClass::Flute:
      return "flute";
    case MidiEvent::ToneClass::Clarinet:
      return "clarinet";
    case MidiEvent::ToneClass::Accordion:
      return "accordion";
    case MidiEvent::ToneClass::Lead:
    default:
      return "lead";
  }
}

const char* App::waveTableSetToText(WaveTableSet waveTableSet) const {
  switch (waveTableSet) {
    case WaveTableSet::Famicom:
      return "famicom";
    case WaveTableSet::Soft:
      return "soft";
    case WaveTableSet::Real:
    default:
      return "real";
  }
}

bool App::isBetterStealCandidate(const VoiceState& candidate, const VoiceState& currentBest) const {
  if (candidate.cold.startedAtMs != currentBest.cold.startedAtMs) {
    return candidate.cold.startedAtMs < currentBest.cold.startedAtMs;
  }

  return candidate.cold.note < currentBest.cold.note;
}

uint8_t App::currentDecayUpdateDivider(MidiEvent::ToneClass toneClass) const {
  uint8_t divider = 1;
  switch (toneClass) {
    case MidiEvent::ToneClass::Piano:
    case MidiEvent::ToneClass::BrightPiano:
    case MidiEvent::ToneClass::HonkyTonk:
    case MidiEvent::ToneClass::Bass:
    case MidiEvent::ToneClass::Pad:
    case MidiEvent::ToneClass::SubBass:
    case MidiEvent::ToneClass::Organ:
    case MidiEvent::ToneClass::Strings:
    case MidiEvent::ToneClass::Choir:
    case MidiEvent::ToneClass::Accordion:
      divider = 3;
      break;
    case MidiEvent::ToneClass::Perc:
    case MidiEvent::ToneClass::KickPerc:
    case MidiEvent::ToneClass::Pluck:
    case MidiEvent::ToneClass::EPiano:
    case MidiEvent::ToneClass::Brass:
    case MidiEvent::ToneClass::Trumpet:
    case MidiEvent::ToneClass::Sax:
    case MidiEvent::ToneClass::HardLead:
    case MidiEvent::ToneClass::NylonGuitar:
    case MidiEvent::ToneClass::CleanGuitar:
    case MidiEvent::ToneClass::MutedGuitar:
    case MidiEvent::ToneClass::PickedBass:
      divider = 2;
      break;
    case MidiEvent::ToneClass::Bell:
    case MidiEvent::ToneClass::Metal:
    case MidiEvent::ToneClass::Flute:
    case MidiEvent::ToneClass::Clarinet:
    case MidiEvent::ToneClass::Lead:
    default:
      divider = 1;
      break;
  }
  if (m_sampleRateHz >= 44100) {
    divider = min<uint8_t>(4, static_cast<uint8_t>(divider + 1));
  }
  return divider;
}

void App::noteOff(uint8_t note, uint8_t channel) {
#if APP_USE_MULAW_TONES
  // GM percussion is a one-shot. Many MIDI files emit very short Note Off
  // events which must not truncate cymbal and drum tails.
  if ((channel & 0x0f) == 9) {
    return;
  }
#endif
  for (uint8_t voiceIndex = 0; voiceIndex < m_activeVoiceLimit; ++voiceIndex) {
    if (!isVoiceActive(voiceIndex) ||
        m_voices[voiceIndex].cold.note != note ||
        m_voices[voiceIndex].cold.channel != channel) {
      continue;
    }
    if (m_voices[voiceIndex].hotCore.carrierStage != EnvelopeStage::Off) {
      m_voices[voiceIndex].hotCore.carrierStage = EnvelopeStage::Release;
    }
  }
}

void App::resetChannelPitchBends() {
  memset(m_channelPitchBend, 0, sizeof(m_channelPitchBend));
  for (uint8_t channel = 0; channel < 16; ++channel) {
    m_channelPitchBendRangeCents[channel] = 200;
    m_channelModulation[channel] = 0;
    m_channelModulationScaleQ16[channel] = 65536;
    m_channelVolume[channel] = 127;
    m_channelExpression[channel] = 127;
    m_channelPan[channel] = 64;
    m_channelReverb[channel] = 0;
    m_channelChorus[channel] = 0;
    m_channelResonance[channel] = 64;
    m_channelAttack[channel] = 64;
    m_channelRelease[channel] = 64;
    m_channelCutoff[channel] = 64;
    m_channelDecay[channel] = 64;
    m_channelVibratoRate[channel] = 64;
    m_channelVibratoDepth[channel] = 64;
    m_channelVibratoDelay[channel] = 64;
    m_channelDelay[channel] = 0;
    m_channelSoft[channel] = 0;
    m_channelFilterFQ15[channel] = 0;
    m_channelFilterDampingQ15[channel] = 0;
  }
  m_modulationChannelMask = 0;
  memset(m_modulationPhaseQ16, 0, sizeof(m_modulationPhaseQ16));
  m_filterChannelMask = 0;
}

void App::resetEffects() {
  m_reverbMacro = 4;
  m_reverbPreLpf = 0;
  m_reverbLevel = 127;
  m_reverbTime = 64;
  m_chorusMacro = 2;
  m_chorusPreLpf = 0;
  m_chorusLevel = 127;
  m_chorusFeedback = 0;
  m_chorusDelayParam = 127;
  m_chorusRate = 3;
  m_chorusDepth = 49;
  m_chorusToReverb = 0;
  m_reverbCharacter = 4;
  m_delayMacro = 0;
  m_delayPreLpf = 0;
  m_delayTime = 96;
  m_delayFeedback = 48;
  m_delayLevel = 96;
  m_delayToReverb = 0;
  updateEffectParameters();
#if APP_ENABLE_FREEVERB_LITE
  memset(m_reverbComb0, 0, sizeof(m_reverbComb0));
  memset(m_reverbComb1, 0, sizeof(m_reverbComb1));
  memset(m_reverbComb2, 0, sizeof(m_reverbComb2));
  memset(m_reverbComb3, 0, sizeof(m_reverbComb3));
  memset(m_reverbAllpassLeft, 0, sizeof(m_reverbAllpassLeft));
  memset(m_reverbAllpassRight, 0, sizeof(m_reverbAllpassRight));
  memset(m_reverbCombIndex, 0, sizeof(m_reverbCombIndex));
  memset(m_reverbCombLowpass, 0, sizeof(m_reverbCombLowpass));
  m_reverbAllpassLeftIndex = 0;
  m_reverbAllpassRightIndex = 0;
  m_reverbHalfInput = 0;
  m_reverbWetLeft = 0;
  m_reverbWetRight = 0;
  m_reverbHalfPhase = false;
#else
  memset(m_reverbDelay, 0, sizeof(m_reverbDelay));
  m_reverbWriteIndex = 0;
#endif
  memset(m_chorusDelay, 0, sizeof(m_chorusDelay));
  memset(m_delayBuffer, 0, sizeof(m_delayBuffer));
  m_chorusWriteIndex = 0;
  m_chorusPhaseQ16 = 0;
  m_chorusLowpassQ15 = 0;
  m_delayWriteIndex = 0;
  m_delayDownsamplePhase = 0;
  m_delayInputAccum = 0;
  m_delayLowpassQ15 = 0;
  m_routedReverbPendingQ15 = 0;
  m_effectTailFrames = 0;
  m_delayTailFrames = 0;
}

void App::updateEffectParameters() {
  const int32_t characterOffset =
      (static_cast<int32_t>(m_reverbCharacter) - 4) * 180;
  const int32_t timeOffset =
      (static_cast<int32_t>(m_reverbTime) - 64) * 54 + characterOffset;
  const int32_t feedbackBases[4] = {24904, 25559, 26214, 26870};
  for (uint8_t comb = 0; comb < 4; ++comb) {
    m_reverbFeedbackQ15[comb] = static_cast<int16_t>(min<int32_t>(
        30000, max<int32_t>(18000, feedbackBases[comb] + timeOffset)));
  }
  m_reverbDampingShift = static_cast<uint8_t>(min<int>(
      7, 2 + min<uint8_t>(4, m_reverbPreLpf) +
      (m_reverbCharacter >= 3 && m_reverbCharacter <= 4 ? 1 : 0)));
  m_reverbReturnGainQ15 = static_cast<int16_t>(
      (static_cast<int32_t>(m_reverbLevel) * 11 * 1024) / 127);
  m_legacyReverbFeedback = static_cast<uint8_t>(
      5 + (static_cast<uint32_t>(m_reverbTime) * 8) / 127);
  m_chorusFeedbackQ15 = static_cast<int16_t>(
      (static_cast<int32_t>(m_chorusFeedback) * 16384) / 127);
  m_chorusReturnGainQ15 = static_cast<int16_t>(
      (static_cast<int32_t>(m_chorusLevel) * 13 * 1024) / 127);
  m_chorusCenterFrames = static_cast<uint16_t>(
      68u + (static_cast<uint32_t>(m_chorusDelayParam) * 280u) / 127u);
  m_chorusDepthFrames = static_cast<uint16_t>(
      8u + (static_cast<uint32_t>(m_chorusDepth) * 104u) / 127u);
  m_chorusPhaseIncrement =
      6500u + static_cast<uint32_t>(m_chorusRate) * 470u;
  m_chorusLowpassShift = m_chorusPreLpf == 0 ? 0 :
      static_cast<uint8_t>(1u + min<uint8_t>(6, m_chorusPreLpf));
  m_chorusToReverbGainQ15 = static_cast<int16_t>(
      (static_cast<uint32_t>(m_chorusToReverb) * 16384u) / 127u);
  m_delayTapFrames = static_cast<uint16_t>(
      96u + (static_cast<uint32_t>(m_delayTime) * 1850u) / 127u);
  m_delayFeedbackQ15 = static_cast<int16_t>(
      (static_cast<uint32_t>(m_delayFeedback) * 24576u) / 127u);
  m_delayReturnGainQ15 = static_cast<int16_t>(
      (static_cast<uint32_t>(m_delayLevel) * 8192u) / 127u);
  m_delayToReverbGainQ15 = static_cast<int16_t>(
      (static_cast<uint32_t>(m_delayToReverb) * 16384u) / 127u);
}

#if APP_ENABLE_FREEVERB_LITE
void App::processFreeverbHalfSample(
    int32_t inputQ15, int32_t& wetLeftQ15, int32_t& wetRightQ15) {
  inputQ15 = min<int32_t>(kQ15One, max<int32_t>(-kQ15One, inputQ15));
  // Sendを抑えてparallel combのfeedback加算にheadroomを残す。
  const int32_t combInput = (inputQ15 * 13) >> 5;
  int32_t outputs[4];
  int16_t* const buffers[4] = {
      m_reverbComb0, m_reverbComb1, m_reverbComb2, m_reverbComb3};
  const uint16_t lengths[4] = {
      kReverbComb0Frames, kReverbComb1Frames,
      kReverbComb2Frames, kReverbComb3Frames};
  for (uint8_t comb = 0; comb < 4; ++comb) {
    const uint16_t index = m_reverbCombIndex[comb];
    const int32_t delayed = buffers[comb][index];
    // feedback loop内のone-pole LPF。係数0.25で金属的な高域を減衰する。
    int32_t lowpass = m_reverbCombLowpass[comb];
    lowpass += (delayed - lowpass) >> m_reverbDampingShift;
    m_reverbCombLowpass[comb] = lowpass;
    int32_t writeValue = combInput +
        static_cast<int32_t>((static_cast<int64_t>(lowpass) *
                              m_reverbFeedbackQ15[comb]) >> 15);
    writeValue = min<int32_t>(
        kQ15One, max<int32_t>(-kQ15One, writeValue));
    buffers[comb][index] = static_cast<int16_t>(writeValue);
    m_reverbCombIndex[comb] =
        static_cast<uint16_t>(index + 1u == lengths[comb] ? 0u : index + 1u);
    outputs[comb] = delayed;
  }

  int32_t left = (outputs[0] + outputs[1] + outputs[2] + outputs[3]) >> 2;
  int32_t right = (outputs[0] - outputs[1] + outputs[2] - outputs[3]) >> 2;

  auto allpass = [](int32_t input, int16_t* buffer, uint16_t length,
                    uint16_t& index) -> int32_t {
    const int32_t delayed = buffer[index];
    int32_t stored = input + (delayed >> 1);
    stored = min<int32_t>(kQ15One, max<int32_t>(-kQ15One, stored));
    buffer[index] = static_cast<int16_t>(stored);
    index = static_cast<uint16_t>(index + 1u == length ? 0u : index + 1u);
    const int32_t output = delayed - (input >> 1);
    return min<int32_t>(kQ15One, max<int32_t>(-kQ15One, output));
  };
  wetLeftQ15 = allpass(left, m_reverbAllpassLeft,
                       kReverbAllpassLeftFrames, m_reverbAllpassLeftIndex);
  wetRightQ15 = allpass(right, m_reverbAllpassRight,
                        kReverbAllpassRightFrames, m_reverbAllpassRightIndex);
}
#endif

uint32_t App::bentSampleStep(
    uint32_t baseStepQ16, int16_t bend, uint16_t rangeCents) const {
  const float semitones = static_cast<float>(bend) *
      (static_cast<float>(rangeCents) / (8192.0f * 100.0f));
  const float bent =
      static_cast<float>(baseStepQ16) * powf(2.0f, semitones / 12.0f);
  if (bent <= 1.0f) {
    return 1;
  }
  if (bent >= static_cast<float>(UINT32_MAX)) {
    return UINT32_MAX;
  }
  return static_cast<uint32_t>(bent);
}

void App::applyPitchBend(uint8_t channel, uint16_t value14) {
  channel &= 0x0f;
  if (channel == 9) {
    return;  // GM channel 10 percussion is not pitch-bent.
  }
  const int16_t bend =
      static_cast<int16_t>(min<uint16_t>(16383, value14)) - 8192;
  m_channelPitchBend[channel] = bend;
  for (uint8_t i = 0; i < m_activeVoiceLimit; ++i) {
    VoiceState& voice = m_voices[i];
    if (isVoiceActive(i) && (voice.cold.channel & 0x0f) == channel) {
      voice.hotCore.carrierSampleStepQ16 =
          bentSampleStep(
              voice.cold.carrierBaseStepQ16,
              bend,
              m_channelPitchBendRangeCents[channel]);
    }
  }
}

void App::applyPitchBendRange(
    uint8_t channel, uint8_t semitones, uint8_t cents) {
  channel &= 0x0f;
  if (channel == 9) {
    return;
  }
  const uint16_t rangeCents = static_cast<uint16_t>(
      min<uint16_t>(2400, static_cast<uint16_t>(semitones) * 100u +
          min<uint8_t>(99, cents)));
  m_channelPitchBendRangeCents[channel] = rangeCents;
  applyPitchBend(
      channel, static_cast<uint16_t>(m_channelPitchBend[channel] + 8192));
}

void App::applyModulation(uint8_t channel, uint8_t value) {
  channel &= 0x0f;
  m_channelModulation[channel] = channel == 9 ? 0 : min<uint8_t>(127, value);
  const uint16_t bit = static_cast<uint16_t>(1u << channel);
  if (m_channelModulation[channel] == 0 &&
      m_channelVibratoDepth[channel] <= 64) {
    m_modulationChannelMask &= static_cast<uint16_t>(~bit);
    m_channelModulationScaleQ16[channel] = 65536;
  } else {
    m_modulationChannelMask |= bit;
  }
}

void App::updateVoiceGains(VoiceState& voice) {
  const uint8_t channel = voice.cold.channel & 0x0f;
  const int32_t channelGain =
      (static_cast<int32_t>(m_channelVolume[channel]) *
       m_channelExpression[channel]) / 127;
  const int32_t fixedGainQ15 =
      (static_cast<int32_t>(voice.cold.baseFixedGainQ15) * channelGain) / 127;
  const int32_t softenedGainQ15 = m_channelSoft[channel]
      ? (fixedGainQ15 * 3) / 4 : fixedGainQ15;
  const uint8_t panValue = m_channelPan[channel];
  int32_t leftPan = 32767;
  int32_t rightPan = 32767;
  if (panValue < 64) rightPan = (static_cast<int32_t>(panValue) * 32767) / 64;
  else leftPan = (static_cast<int32_t>(127 - panValue) * 32767) / 63;
  voice.hotCore.carrierFixedGainLeftQ15 =
      static_cast<int16_t>((softenedGainQ15 * leftPan) >> 15);
  voice.hotCore.carrierFixedGainRightQ15 =
      static_cast<int16_t>((softenedGainQ15 * rightPan) >> 15);
  voice.hotCore.reverbFixedGainQ15 = static_cast<int16_t>(
      (softenedGainQ15 * ((m_channelReverb[channel] * 15 + 63) / 127)) / 15);
  voice.hotCore.chorusFixedGainQ15 = static_cast<int16_t>(
      (softenedGainQ15 * ((m_channelChorus[channel] * 15 + 63) / 127)) / 15);
  voice.hotCore.delayFixedGainQ15 = static_cast<int16_t>(
      (softenedGainQ15 * ((m_channelDelay[channel] * 15 + 63) / 127)) / 15);
}

void App::updateChannelFilter(uint8_t channel) {
  channel &= 0x0f;
  const uint16_t bit = static_cast<uint16_t>(1u << channel);
  if (m_channelCutoff[channel] == 64 && m_channelResonance[channel] == 64 &&
      m_channelSoft[channel] == 0) {
    m_filterChannelMask &= static_cast<uint16_t>(~bit);
    return;
  }
  m_filterChannelMask |= bit;
  // Stable Chamberlin SVF range.  CC74 opens/closes the low-pass while CC71
  // lowers damping to add a deliberately bounded resonance peak.
  const uint8_t effectiveCutoff = m_channelSoft[channel]
      ? static_cast<uint8_t>(max<int>(0, m_channelCutoff[channel] - 20))
      : m_channelCutoff[channel];
  m_channelFilterFQ15[channel] = static_cast<uint16_t>(
      1200u + (static_cast<uint32_t>(effectiveCutoff) * 16800u) / 127u);
  m_channelFilterDampingQ15[channel] = static_cast<uint16_t>(
      24500u - (static_cast<uint32_t>(m_channelResonance[channel]) * 14500u) / 127u);
}

void App::applyController(uint8_t channel, uint8_t controller, uint8_t value) {
  channel &= 0x0f;
  value &= 0x7f;
  if (controller == 121) {
    // MIDI RP-015 Reset All Controllers is not a full GM/GS reset.  Keep
    // channel volume/pan, bank/program, effect and sound-controller values,
    // and the selected pitch-bend range; reset only controller state.
    m_channelExpression[channel] = 127;
    m_channelSoft[channel] = 0;
    updateChannelFilter(channel);
    applyModulation(channel, 0);
    applyPitchBend(channel, 8192);
    for (uint8_t i = 0; i < m_activeVoiceLimit; ++i) {
      if (isVoiceActive(i) && (m_voices[i].cold.channel & 0x0f) == channel) {
        updateVoiceGains(m_voices[i]);
      }
    }
    return;
  }
  uint8_t oldValue = 64;
  if (controller == 7) m_channelVolume[channel] = value;
  else if (controller == 10) m_channelPan[channel] = value;
  else if (controller == 11) m_channelExpression[channel] = value;
  else if (controller == 91) m_channelReverb[channel] = value;
  else if (controller == 93) m_channelChorus[channel] = value;
  else if (controller == 94) m_channelDelay[channel] = value;
  else if (controller == 67) {
    m_channelSoft[channel] = value >= 64;
    updateChannelFilter(channel);
  }
  else if (controller == 71) {
    m_channelResonance[channel] = value;
    updateChannelFilter(channel);
  } else if (controller == 74) {
    m_channelCutoff[channel] = value;
    updateChannelFilter(channel);
  } else if (controller == 73) {
    oldValue = m_channelAttack[channel];
    m_channelAttack[channel] = value;
  } else if (controller == 72) {
    oldValue = m_channelRelease[channel];
    m_channelRelease[channel] = value;
  } else if (controller == 75) {
    oldValue = m_channelDecay[channel];
    m_channelDecay[channel] = value;
  } else if (controller == 76) {
    m_channelVibratoRate[channel] = value;
    applyModulation(channel, m_channelModulation[channel]);
  } else if (controller == 77) {
    m_channelVibratoDepth[channel] = value;
    applyModulation(channel, m_channelModulation[channel]);
  } else if (controller == 78) {
    m_channelVibratoDelay[channel] = value;
  } else return;

  for (uint8_t i = 0; i < m_activeVoiceLimit; ++i) {
    VoiceState& voice = m_voices[i];
    if (!isVoiceActive(i) || (voice.cold.channel & 0x0f) != channel) continue;
    if (controller == 7 || controller == 10 || controller == 11 ||
        controller == 91 || controller == 93 || controller == 94 ||
        controller == 67) {
      updateVoiceGains(voice);
    } else if (controller == 73 && voice.hotEnvelope.carrierAttackStepQ15 > 0) {
      const float ratio = powf(2.0f,
          (static_cast<float>(oldValue) - value) / 32.0f);
      voice.hotEnvelope.carrierAttackStepQ15 = static_cast<int16_t>(min<int32_t>(
          32767, max<int32_t>(1, static_cast<int32_t>(
              voice.hotEnvelope.carrierAttackStepQ15 * ratio))));
    } else if (controller == 72 && voice.hotEnvelope.carrierReleaseStepQ15 > 0) {
      const float ratio = powf(2.0f,
          (static_cast<float>(oldValue) - value) / 32.0f);
      voice.hotEnvelope.carrierReleaseStepQ15 = static_cast<int16_t>(min<int32_t>(
          32767, max<int32_t>(1, static_cast<int32_t>(
              voice.hotEnvelope.carrierReleaseStepQ15 * ratio))));
    } else if (controller == 75 && voice.hotEnvelope.carrierDecayStepQ15 > 0) {
      const float ratio = powf(2.0f,
          (static_cast<float>(oldValue) - value) / 32.0f);
      voice.hotEnvelope.carrierDecayStepQ15 = static_cast<int16_t>(min<int32_t>(
          32767, max<int32_t>(1, static_cast<int32_t>(
              voice.hotEnvelope.carrierDecayStepQ15 * ratio))));
    }
  }
}

void App::applyGsEffect(uint8_t address, uint8_t value) {
  value &= 0x7f;
  switch (address) {
    case 0x30:
      m_reverbMacro = value;
      // GS macro defaults: Room1/2/3, Hall1/2, Plate, Delay, Panning Delay.
      if (value <= 2) { m_reverbTime = 48 + value * 8; m_reverbPreLpf = 3; }
      else if (value <= 4) { m_reverbTime = 76 + (value - 3) * 12; m_reverbPreLpf = 4; }
      else { m_reverbTime = 68; m_reverbPreLpf = 2; }
      break;
    case 0x31: m_reverbCharacter = value; break;
    case 0x32: m_reverbPreLpf = value; break;
    case 0x33: m_reverbLevel = value; break;
    case 0x34: m_reverbTime = value; break;
    case 0x38:
      m_chorusMacro = value;
      // Chorus1..4, Feedback Chorus, Flanger, Short Delay, Short Delay FB.
      m_chorusRate = static_cast<uint8_t>(min<int>(127, 3 + value * 5));
      m_chorusDepth = static_cast<uint8_t>(min<int>(127, 19 + value * 7));
      m_chorusFeedback = value >= 4 ? static_cast<uint8_t>(32 + value * 6) : 8;
      break;
    case 0x39: m_chorusPreLpf = value; break;
    case 0x3a: m_chorusLevel = value; break;
    case 0x3b: m_chorusFeedback = value; break;
    case 0x3c: m_chorusDelayParam = value; break;
    case 0x3d: m_chorusRate = value; break;
    case 0x3e: m_chorusDepth = value; break;
    case 0x3f: m_chorusToReverb = value; break;
    case 0x50:
      m_delayMacro = value;
      m_delayTime = static_cast<uint8_t>(min<int>(127, 45 + value * 10));
      m_delayFeedback = static_cast<uint8_t>(min<int>(127, 28 + value * 8));
      break;
    case 0x51: m_delayPreLpf = value; break;
    case 0x52: m_delayTime = value; break;
    case 0x53: m_delayFeedback = value; break;
    case 0x54: m_delayLevel = value; break;
    case 0x55: m_delayToReverb = value; break;
    case 0x56: m_delayTime = value; break;  // center/right time approximation
    case 0x57: m_delayFeedback = value; break;
    default: return;
  }
  updateEffectParameters();
}

void App::prepareModulationScales(int32_t frameCount) {
  if (m_modulationChannelMask == 0) {
    return;
  }
  const uint32_t sampleRate = max<uint32_t>(1, m_sampleRateHz);
  // Maximum CC1 depth is approximately +/-50 cents. Around unity a linear
  // Q16 ratio is sufficiently accurate and avoids per-chunk floating point.
  static constexpr int32_t kHalfSemitoneDeltaQ16 = 1930;
  for (uint8_t channel = 0; channel < 16; ++channel) {
    const uint32_t rateMilliHz = static_cast<uint32_t>(
        max<int>(1000, 5000 + (static_cast<int>(m_channelVibratoRate[channel]) - 64) * 60));
    const uint32_t phaseAdvance = static_cast<uint32_t>(
        (static_cast<uint64_t>(rateMilliHz) * 65536u *
         static_cast<uint32_t>(max<int32_t>(0, frameCount))) /
        (sampleRate * 1000u));
    m_modulationPhaseQ16[channel] =
        (m_modulationPhaseQ16[channel] + phaseAdvance) & 0xffffu;
    const int32_t phase = static_cast<int32_t>(m_modulationPhaseQ16[channel]);
    const int32_t triangleQ15 = phase < 32768
        ? -32768 + phase * 2 : 32767 - (phase - 32768) * 2;
    const uint8_t toneDepth = m_channelVibratoDepth[channel] > 64
        ? static_cast<uint8_t>(min<int>(127,
              (m_channelVibratoDepth[channel] - 64) * 2)) : 0;
    const uint8_t depth = max(m_channelModulation[channel], toneDepth);
    const int64_t delta = static_cast<int64_t>(triangleQ15) *
        depth * kHalfSemitoneDeltaQ16;
    m_channelModulationScaleQ16[channel] = static_cast<uint32_t>(
        65536 + delta / (32768LL * 127LL));
  }
}

int App::findVoiceIndex(uint8_t note, uint8_t channel) const {
  for (uint8_t i = 0; i < m_activeVoiceLimit; ++i) {
    if (isVoiceActive(i) &&
        m_voices[i].cold.note == note &&
        m_voices[i].cold.channel == channel) {
      return i;
    }
  }
  return -1;
}

uint8_t App::activeVoiceCount() const {
  uint8_t count = 0;
  for (uint8_t i = 0; i < m_activeVoiceLimit; ++i) {
    if (isVoiceActive(i)) {
      ++count;
    }
  }
  return count;
}

int App::allocateVoiceIndex(uint8_t channel) const {
  for (uint8_t i = 0; i < m_activeVoiceLimit; ++i) {
    if (!isVoiceActive(i)) {
      return i;
    }
  }

  if (m_activeVoiceLimit == 0) {
    return -1;
  }

  int bestIndex = -1;
  for (uint8_t i = 0; i < m_activeVoiceLimit; ++i) {
    if (!isVoiceActive(i) || m_voices[i].cold.channel != channel) {
      continue;
    }
    if (bestIndex < 0 || isBetterStealCandidate(m_voices[i], m_voices[bestIndex])) {
      bestIndex = i;
    }
  }
  if (bestIndex >= 0) {
    return bestIndex;
  }

  bestIndex = 0;
  for (uint8_t i = 1; i < m_activeVoiceLimit; ++i) {
    if (isBetterStealCandidate(m_voices[i], m_voices[bestIndex])) {
      bestIndex = i;
    }
  }
  return bestIndex;
}

bool App::loadSongFromStorage() {
  return loadSongMetadataFromPartition();
}

bool App::loadSongMetadataFromPartition() {
  m_song.clear();
  m_songLoaded = false;
  m_songStoredBytes = 0;
  m_songIdHash = 0;
  m_nextEventCached = false;
  m_eventCacheCount = 0;
  m_rawMidiParserEof = false;
  clearAudioRingBuffer();

  if (m_songPartition == nullptr) {
    strncpy(m_uploadError, "song partition missing", sizeof(m_uploadError) - 1);
    m_uploadError[sizeof(m_uploadError) - 1] = '\0';
    return false;
  }

  SongPartitionHeader header;
  if (esp_partition_read(m_songPartition, 0, &header, sizeof(header)) != ESP_OK) {
    strncpy(m_uploadError, "failed to read song header", sizeof(m_uploadError) - 1);
    m_uploadError[sizeof(m_uploadError) - 1] = '\0';
    return false;
  }

  if (memcmp(header.magic, kRawMidiMagic, sizeof(kRawMidiMagic)) == 0 &&
      header.version == kSongFormatVersionRawMidi &&
      header.headerSize == kSongHeaderSize &&
      header.dataBytes >= 14 &&
      static_cast<uint32_t>(header.headerSize) + header.dataBytes <= m_songPartition->size) {
    header.name[sizeof(header.name) - 1] = 0;
    strncpy(m_song.name, header.name, sizeof(m_song.name) - 1);
    m_song.name[sizeof(m_song.name) - 1] = 0;
    m_song.durationMs = header.durationMs;
    m_song.eventCount = 0;
    m_songStoredBytes = static_cast<size_t>(header.headerSize) + header.dataBytes;
    uint32_t songHash = 2166136261u;
    uint8_t hashBuffer[512];
    size_t hashOffset = header.headerSize;
    size_t hashRemaining = header.dataBytes;
    while (hashRemaining > 0) {
      const size_t count = min(hashRemaining, sizeof(hashBuffer));
      if (esp_partition_read(m_songPartition, hashOffset, hashBuffer, count) != ESP_OK) {
        strncpy(m_uploadError, "failed to hash stored MIDI", sizeof(m_uploadError) - 1);
        m_uploadError[sizeof(m_uploadError) - 1] = '\0';
        return false;
      }
      for (size_t i = 0; i < count; ++i) {
        songHash ^= hashBuffer[i];
        songHash *= 16777619u;
      }
      hashOffset += count;
      hashRemaining -= count;
    }
    m_songIdHash = songHash;
    m_songFormatVersion = kSongFormatVersionRawMidi;
    m_songEventSizeBytes = 0;
    if (!m_rawMidiParser.begin(
            m_songPartition, header.headerSize, header.dataBytes)) {
      snprintf(m_uploadError, sizeof(m_uploadError),
          "invalid raw MIDI: %s (track %u, offset %lu)",
          m_rawMidiParser.errorText(),
          static_cast<unsigned>(m_rawMidiParser.errorTrackIndex()),
          static_cast<unsigned long>(m_rawMidiParser.errorOffset()));
      m_uploadError[sizeof(m_uploadError) - 1] = '\0';
      return false;
    }
    m_songLoaded = true;
    m_uploadError[0] = '\0';
    return true;
  }

  if (memcmp(header.magic, kSongMagic, sizeof(kSongMagic)) != 0 ||
      (header.version != kSongFormatVersionV1 &&
       header.version != kSongFormatVersionV2 &&
       header.version != kSongFormatVersionV3 &&
       header.version != kSongFormatVersionV4 &&
       header.version != kSongFormatVersionV5 &&
       header.version != kSongFormatVersionV6) ||
      header.headerSize != kSongHeaderSize) {
    m_uploadError[0] = '\0';
    return false;
  }

  const size_t expectedEventSize = header.version == kSongFormatVersionV6
      ? kSongEventSizeV6
      : (header.version == kSongFormatVersionV5
      ? kSongEventSizeV5
      : (header.version == kSongFormatVersionV4
          ? kSongEventSizeV4
          : (header.version == kSongFormatVersionV3
          ? kSongEventSizeV3
          : (header.version == kSongFormatVersionV2
              ? kSongEventSizeV2
              : kSongEventSizeV1))));
  const uint32_t expectedBytes = header.eventCount * expectedEventSize;
  if (header.dataBytes != expectedBytes ||
      static_cast<uint32_t>(header.headerSize) + header.dataBytes > m_songPartition->size) {
    strncpy(m_uploadError, "invalid stored song", sizeof(m_uploadError) - 1);
    m_uploadError[sizeof(m_uploadError) - 1] = '\0';
    return false;
  }

  header.name[sizeof(header.name) - 1] = 0;
  strncpy(m_song.name, header.name, sizeof(m_song.name) - 1);
  m_song.name[sizeof(m_song.name) - 1] = 0;
  m_song.durationMs = header.durationMs;
  m_song.eventCount = header.eventCount;
  m_songStoredBytes = static_cast<size_t>(header.headerSize) + static_cast<size_t>(header.dataBytes);
  uint32_t songHash = 2166136261u;
  songHash ^= header.version;
  songHash *= 16777619u;
  songHash ^= header.eventCount;
  songHash *= 16777619u;
  songHash ^= header.durationMs;
  songHash *= 16777619u;
  songHash ^= header.dataBytes;
  songHash *= 16777619u;
  for (size_t i = 0; i < sizeof(header.name); ++i) {
    songHash ^= static_cast<uint8_t>(header.name[i]);
    songHash *= 16777619u;
  }
  uint8_t hashBuffer[512];
  size_t hashOffset = header.headerSize;
  size_t hashRemaining = header.dataBytes;
  while (hashRemaining > 0) {
    const size_t count = min(hashRemaining, sizeof(hashBuffer));
    if (esp_partition_read(m_songPartition, hashOffset, hashBuffer, count) != ESP_OK) {
      strncpy(m_uploadError, "failed to hash stored song", sizeof(m_uploadError) - 1);
      m_uploadError[sizeof(m_uploadError) - 1] = '\0';
      return false;
    }
    for (size_t i = 0; i < count; ++i) {
      songHash ^= hashBuffer[i];
      songHash *= 16777619u;
    }
    hashOffset += count;
    hashRemaining -= count;
  }
  m_songIdHash = songHash;
  m_songFormatVersion = header.version;
  m_songEventSizeBytes = expectedEventSize;
  m_songLoaded = header.eventCount > 0;
  m_uploadError[0] = '\0';
  return m_songLoaded;
}

bool App::readEventAt(size_t index, MidiEvent& event) {
  if (m_songPartition == nullptr || index >= m_song.eventCount) {
    return false;
  }

  const bool cacheHit = m_eventCacheCount > 0 &&
      index >= m_eventCacheStartIndex &&
      index < (m_eventCacheStartIndex + m_eventCacheCount);

  if (!cacheHit) {
    const size_t remaining = m_song.eventCount - index;
    const size_t batchCount = min(kEventCacheSize, remaining);
    const size_t offset = kSongHeaderSize + index * m_songEventSizeBytes;

    m_eventCacheStartIndex = index;
    m_eventCacheCount = batchCount;
    if (m_songFormatVersion == kSongFormatVersionV6) {
      SongEventRecordV6 records[kEventCacheSize];
      if (esp_partition_read(
              m_songPartition,
              offset,
              records,
              batchCount * sizeof(SongEventRecordV6)) != ESP_OK) {
        return false;
      }
      for (size_t i = 0; i < batchCount; ++i) {
        m_eventCache[i].timeMs = records[i].timeMs;
        m_eventCache[i].note = records[i].note;
        m_eventCache[i].velocity = records[i].velocity;
        m_eventCache[i].channel = records[i].channel & 0x0f;
        m_eventCache[i].toneClass =
            static_cast<MidiEvent::ToneClass>(records[i].toneClass);
        m_eventCache[i].pan = min<uint8_t>(127, records[i].pan);
        m_eventCache[i].channelGain = min<uint8_t>(127, records[i].channelGain);
        m_eventCache[i].fxSends = records[i].fxSends;
        switch (records[i].type) {
          case 1: m_eventCache[i].type = MidiEvent::Type::NoteOn; break;
          case 2: m_eventCache[i].type = MidiEvent::Type::PitchBend; break;
          case 3: m_eventCache[i].type = MidiEvent::Type::PitchBendRange; break;
          case 4: m_eventCache[i].type = MidiEvent::Type::Modulation; break;
          case 5: m_eventCache[i].type = MidiEvent::Type::GmReset; break;
          case 6: m_eventCache[i].type = MidiEvent::Type::Controller; break;
          case 7: m_eventCache[i].type = MidiEvent::Type::GsEffect; break;
          default: m_eventCache[i].type = MidiEvent::Type::NoteOff; break;
        }
      }
    } else if (m_songFormatVersion == kSongFormatVersionV5) {
      SongEventRecordV5 records[kEventCacheSize];
      if (esp_partition_read(
              m_songPartition,
              offset,
              records,
              batchCount * sizeof(SongEventRecordV5)) != ESP_OK) {
        return false;
      }
      for (size_t i = 0; i < batchCount; ++i) {
        m_eventCache[i].timeMs = records[i].timeMs;
        m_eventCache[i].note = records[i].note;
        m_eventCache[i].velocity = records[i].velocity;
        m_eventCache[i].channel = records[i].channel & 0x0f;
        m_eventCache[i].toneClass =
            static_cast<MidiEvent::ToneClass>(records[i].toneClass);
        m_eventCache[i].pan = min<uint8_t>(127, records[i].pan);
        m_eventCache[i].channelGain = min<uint8_t>(127, records[i].channelGain);
        m_eventCache[i].fxSends = records[i].fxSends;
        m_eventCache[i].type = records[i].type == 1
            ? MidiEvent::Type::NoteOn
            : (records[i].type == 2
                ? MidiEvent::Type::PitchBend
                : MidiEvent::Type::NoteOff);
      }
    } else if (m_songFormatVersion == kSongFormatVersionV4) {
      SongEventRecordV4 records[kEventCacheSize];
      if (esp_partition_read(
              m_songPartition,
              offset,
              records,
              batchCount * sizeof(SongEventRecordV4)) != ESP_OK) {
        return false;
      }
      for (size_t i = 0; i < batchCount; ++i) {
        m_eventCache[i].timeMs = records[i].timeMs;
        m_eventCache[i].note = records[i].note;
        m_eventCache[i].velocity = records[i].velocity;
        m_eventCache[i].channel = records[i].channel & 0x0f;
        m_eventCache[i].toneClass =
            static_cast<MidiEvent::ToneClass>(records[i].toneClass);
        m_eventCache[i].pan = min<uint8_t>(127, records[i].pan);
        m_eventCache[i].channelGain = min<uint8_t>(127, records[i].channelGain);
        m_eventCache[i].fxSends = 0;
        m_eventCache[i].type = records[i].type == 1
            ? MidiEvent::Type::NoteOn
            : (records[i].type == 2
                ? MidiEvent::Type::PitchBend
                : MidiEvent::Type::NoteOff);
      }
    } else if (m_songFormatVersion == kSongFormatVersionV3) {
      SongEventRecordV3 records[kEventCacheSize];
      if (esp_partition_read(
              m_songPartition,
              offset,
              records,
              batchCount * sizeof(SongEventRecordV3)) != ESP_OK) {
        return false;
      }
      for (size_t i = 0; i < batchCount; ++i) {
        m_eventCache[i].timeMs = records[i].timeMs;
        m_eventCache[i].note = records[i].note;
        m_eventCache[i].velocity = records[i].velocity;
        m_eventCache[i].channel = records[i].channel & 0x0f;
        m_eventCache[i].toneClass =
            static_cast<MidiEvent::ToneClass>(records[i].toneClass);
        m_eventCache[i].pan = min<uint8_t>(127, records[i].pan);
        m_eventCache[i].channelGain = 127;
        m_eventCache[i].fxSends = 0;
        m_eventCache[i].type =
            records[i].type == 1 ? MidiEvent::Type::NoteOn : MidiEvent::Type::NoteOff;
      }
    } else if (m_songFormatVersion == kSongFormatVersionV2) {
      SongEventRecordV2 records[kEventCacheSize];
      if (esp_partition_read(
              m_songPartition,
              offset,
              records,
              batchCount * sizeof(SongEventRecordV2)) != ESP_OK) {
        return false;
      }
      for (size_t i = 0; i < batchCount; ++i) {
        m_eventCache[i].timeMs = records[i].timeMs;
        m_eventCache[i].note = records[i].note;
        m_eventCache[i].velocity = records[i].velocity;
        m_eventCache[i].channel = records[i].channel & 0x0f;
        m_eventCache[i].toneClass =
            static_cast<MidiEvent::ToneClass>(records[i].toneClass);
        m_eventCache[i].pan = 255;
        m_eventCache[i].channelGain = 127;
        m_eventCache[i].fxSends = 0;
        m_eventCache[i].type =
            records[i].type == 1 ? MidiEvent::Type::NoteOn : MidiEvent::Type::NoteOff;
      }
    } else {
      SongEventRecordV1 records[kEventCacheSize];
      if (esp_partition_read(
              m_songPartition,
              offset,
              records,
              batchCount * sizeof(SongEventRecordV1)) != ESP_OK) {
        return false;
      }
      for (size_t i = 0; i < batchCount; ++i) {
        m_eventCache[i].timeMs = records[i].timeMs;
        m_eventCache[i].note = records[i].note;
        m_eventCache[i].velocity = records[i].velocity;
        m_eventCache[i].channel = records[i].toneChannel & 0x0f;
        m_eventCache[i].toneClass =
            static_cast<MidiEvent::ToneClass>((records[i].toneChannel >> 4) & 0x0f);
        m_eventCache[i].pan = 255;
        m_eventCache[i].channelGain = 127;
        m_eventCache[i].fxSends = 0;
        m_eventCache[i].type =
            records[i].type == 1 ? MidiEvent::Type::NoteOn : MidiEvent::Type::NoteOff;
      }
    }
  }

  event = m_eventCache[index - m_eventCacheStartIndex];
  return true;
}

bool App::ensureNextEventCached() {
  if (!m_songLoaded || m_nextEventIndex >= m_song.eventCount) {
    return false;
  }
  if (m_nextEventCached && m_nextEventCacheIndex == m_nextEventIndex) {
    return true;
  }
  if (!readEventAt(m_nextEventIndex, m_nextEventCache)) {
    strncpy(m_uploadError, "failed to read song event", sizeof(m_uploadError) - 1);
    m_uploadError[sizeof(m_uploadError) - 1] = '\0';
    m_songLoaded = false;
    return false;
  }
  m_nextEventCacheIndex = m_nextEventIndex;
  m_nextEventCached = true;
  return true;
}


void App::btGapCallback(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t* param) {
  if (g_app != nullptr) {
    g_app->handleGapEvent(event, param);
  }
}

void App::a2dpCallback(esp_a2d_cb_event_t event, esp_a2d_cb_param_t* param) {
  if (g_app != nullptr) {
    g_app->handleA2dpEvent(event, param);
  }
}

int32_t App::audioDataCallback(uint8_t* data, int32_t len) {
  if (g_app == nullptr) {
    return 0;
  }
  return g_app->fillAudioBuffer(data, len);
}

void App::handleGapEvent(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t* param) {
  if (event == ESP_BT_GAP_DISC_RES_EVT) {
    char address[18] = {0};
    char name[sizeof(m_btDevices[0].name)] = {0};
    int rssi = -127;
    formatBdAddr(param->disc_res.bda, address, sizeof(address));

    for (int i = 0; i < param->disc_res.num_prop; ++i) {
      const auto& prop = param->disc_res.prop[i];
      if (prop.type == ESP_BT_GAP_DEV_PROP_RSSI && prop.val != nullptr) {
        rssi = *static_cast<int8_t*>(prop.val);
      } else if (prop.type == ESP_BT_GAP_DEV_PROP_BDNAME && prop.val != nullptr) {
        const size_t copyLen = min<size_t>(
            static_cast<size_t>(prop.len),
            sizeof(name) - 1);
        memcpy(name, prop.val, copyLen);
        name[copyLen] = '\0';
      } else if (prop.type == ESP_BT_GAP_DEV_PROP_EIR && prop.val != nullptr && name[0] == '\0') {
        char parsedName[ESP_BT_GAP_MAX_BDNAME_LEN + 1] = {0};
        uint8_t parsedNameLen = 0;
        if (getNameFromEir(static_cast<uint8_t*>(prop.val), parsedName, &parsedNameLen)) {
          strncpy(name, parsedName, sizeof(name) - 1);
          name[sizeof(name) - 1] = '\0';
        }
      }
    }

    for (uint8_t i = 0; i < Config::MaxBtDevices; ++i) {
      if (!m_btDevices[i].inUse || strcmp(m_btDevices[i].address, address) == 0) {
        m_btDevices[i].inUse = true;
        strncpy(m_btDevices[i].address, address, sizeof(m_btDevices[i].address) - 1);
        strncpy(m_btDevices[i].name, name, sizeof(m_btDevices[i].name) - 1);
        m_btDevices[i].address[sizeof(m_btDevices[i].address) - 1] = 0;
        m_btDevices[i].name[sizeof(m_btDevices[i].name) - 1] = 0;
        m_btDevices[i].rssi = rssi;
        break;
      }
    }
    return;
  }

  if (event == ESP_BT_GAP_DISC_STATE_CHANGED_EVT) {
    m_discoveryRunning = param->disc_st_chg.state == ESP_BT_GAP_DISCOVERY_STARTED;
    if (!m_discoveryRunning) {
      Log::info("Bluetooth inquiry finished");
      if (m_connectAfterDiscovery) {
        m_connectAfterDiscovery = false;
        continueBluetoothConnectionRequest();
      } else if (!m_a2dpConnected && m_connectingAddress[0] == '\0') {
        Log::setFlashWriteAllowed(true);
      }
    }
    return;
  }

  if (event == ESP_BT_GAP_AUTH_CMPL_EVT) {
    char address[18] = {0};
    formatBdAddr(param->auth_cmpl.bda, address, sizeof(address));
    Log::infof(
        "BT auth: address=%s status=%d name=%s",
        address,
        static_cast<int>(param->auth_cmpl.stat),
        reinterpret_cast<const char*>(param->auth_cmpl.device_name));
    return;
  }

  if (event == ESP_BT_GAP_CFM_REQ_EVT) {
    esp_bt_gap_ssp_confirm_reply(param->cfm_req.bda, true);
    Log::infof(
        "BT SSP confirm accepted: value=%lu",
        static_cast<unsigned long>(param->cfm_req.num_val));
    return;
  }

  if (event == ESP_BT_GAP_KEY_NOTIF_EVT) {
    Log::infof(
        "BT SSP passkey: %06lu",
        static_cast<unsigned long>(param->key_notif.passkey));
    return;
  }

  if (event == ESP_BT_GAP_KEY_REQ_EVT) {
    char address[18] = {0};
    formatBdAddr(param->key_req.bda, address, sizeof(address));
    Log::infof("BT SSP key requested: %s", address);
    return;
  }

  if (event == ESP_BT_GAP_PIN_REQ_EVT) {
    esp_bt_pin_code_t pinCode;
    memcpy(pinCode, "0000", 4);
    esp_bt_gap_pin_reply(param->pin_req.bda, true, 4, pinCode);
    Log::info("BT legacy PIN requested: replied 0000");
    return;
  }

  // Keep uncommon GAP failures visible without flooding the normal inquiry
  // path.  Authentication-complete above contains the peer and status.
  Log::infof("BT GAP event=%d", static_cast<int>(event));
}

void App::handleA2dpEvent(esp_a2d_cb_event_t event, esp_a2d_cb_param_t* param) {
  if (event == ESP_A2D_PROF_STATE_EVT) {
    m_a2dpReady = param->a2d_prof_stat.init_state == ESP_A2D_INIT_SUCCESS;
    Log::infof("A2DP profile init state=%d", param->a2d_prof_stat.init_state);
    logStagedHeap("A2DP profile ready");
    return;
  }

  if (event == ESP_A2D_SEP_REG_STATE_EVT) {
    Log::infof(
        "A2DP SEP reg state: seid=%u state=%d",
        static_cast<unsigned>(param->a2d_sep_reg_stat.seid),
        static_cast<int>(param->a2d_sep_reg_stat.reg_state));
    return;
  }

  if (event == ESP_A2D_AUDIO_CFG_EVT) {
    const esp_a2d_mcc_t& mcc = param->audio_cfg.mcc;
    if (mcc.type == ESP_A2D_MCT_SBC) {
      const uint32_t negotiatedSampleRateHz =
          sbcMaskToSampleRateHz(mcc.cie.sbc_info.samp_freq);
      m_outputSampleRateHz = negotiatedSampleRateHz;
      clearAudioRingBuffer();
      Log::infof(
          "A2DP audio cfg: codec=SBC sr=%s ch=%s bitpool=%u-%u out=%lu synth=%lu",
          sbcSampleRateToText(mcc.cie.sbc_info.samp_freq),
          sbcChannelModeToText(mcc.cie.sbc_info.ch_mode),
          static_cast<unsigned>(mcc.cie.sbc_info.min_bitpool),
          static_cast<unsigned>(mcc.cie.sbc_info.max_bitpool),
          static_cast<unsigned long>(m_outputSampleRateHz),
          static_cast<unsigned long>(m_sampleRateHz));
    } else {
      Log::infof("A2DP audio cfg: codec=%u", static_cast<unsigned>(mcc.type));
    }
    return;
  }

  if (event == ESP_A2D_CONNECTION_STATE_EVT) {
    m_a2dpConnected = param->conn_stat.state == ESP_A2D_CONNECTION_STATE_CONNECTED;
    if (m_a2dpConnected) {
      Log::setFlashWriteAllowed(false);
      formatBdAddr(
          param->conn_stat.remote_bda,
          m_connectedAddress,
          sizeof(m_connectedAddress));
      m_connectedAddress[sizeof(m_connectedAddress) - 1] = '\0';
      // The pending address is only a switch request. Once the requested
      // endpoint reports connected, clear it so the UI does not remain in a
      // permanent "switching" state.
      if (strcmp(m_connectingAddress, m_connectedAddress) == 0) {
        m_connectAfterDisconnect = false;
        m_connectingAddress[0] = '\0';
      }
      // 接続直後は送信先のcodec/jitter bufferが安定するまで自動再生を待つ。
      // 明示的なplay操作が先に来た場合はstartSongPlayback()が待ち時間を消費する。
      m_playbackStartMs = 0;
      m_autoPlaybackNotBeforeMs =
          millis() + kAutoPlaybackStabilizationMs;
      Log::infof("A2DP connected: %s", m_connectedAddress);
      Log::infof(
          "A2DP auto playback delayed: %lu ms",
          static_cast<unsigned long>(kAutoPlaybackStabilizationMs));
      logStagedHeap("A2DP connected");
      esp_a2d_media_ctrl(ESP_A2D_MEDIA_CTRL_CHECK_SRC_RDY);
    } else {
      // Keep Flash writes disabled for CONNECTING/DISCONNECTING as well.  A
      // final DISCONNECTED event below re-opens the idle window.
      Log::setFlashWriteAllowed(false);
      m_audioStarted = false;
      m_playbackStartMs = 0;
      m_autoPlaybackNotBeforeMs = 0;
      m_outputSampleRateHz = m_sampleRateHz;
      m_connectedAddress[0] = 0;
      char peer[18] = {};
      formatBdAddr(param->conn_stat.remote_bda, peer, sizeof(peer));
      Log::infof("A2DP state=%d peer=%s reason=%d", param->conn_stat.state,
                 peer, static_cast<int>(param->conn_stat.disc_rsn));
      // ESP-IDF reports DISCONNECTING before DISCONNECTED.  A source cannot
      // connect a second sink until the latter has arrived, so keep the
      // pending address through intermediate states and consume it only on
      // the actual disconnected event.  This also preserves a direct
      // CONNECTING request, whose state event must not clear its address.
      if (param->conn_stat.state == ESP_A2D_CONNECTION_STATE_DISCONNECTED) {
        if (m_connectAfterDisconnect) {
          m_connectAfterDisconnect = false;
          connectPendingBluetoothAddress();
        } else {
          // A failed direct attempt or an unsolicited link loss must not be
          // retried indefinitely just because its address is still displayed.
          m_connectingAddress[0] = '\0';
          Log::setFlashWriteAllowed(true);
        }
      }
    }
    return;
  }

  if (event == ESP_A2D_MEDIA_CTRL_ACK_EVT) {
    if (param->media_ctrl_stat.cmd == ESP_A2D_MEDIA_CTRL_CHECK_SRC_RDY &&
        param->media_ctrl_stat.status == ESP_A2D_MEDIA_CTRL_ACK_SUCCESS) {
      esp_a2d_media_ctrl(ESP_A2D_MEDIA_CTRL_START);
      return;
    }

    if (param->media_ctrl_stat.cmd == ESP_A2D_MEDIA_CTRL_START &&
        param->media_ctrl_stat.status == ESP_A2D_MEDIA_CTRL_ACK_SUCCESS) {
      m_audioStarted = true;
      Log::info("A2DP media started");
      logStagedHeap("A2DP media started");
    }
    return;
  }

  if (event == ESP_A2D_AUDIO_STATE_EVT) {
    m_audioStarted = param->audio_stat.state == ESP_A2D_AUDIO_STATE_STARTED;
    Log::infof("A2DP audio state=%d", param->audio_stat.state);
  }
}

template <bool AddReverb, bool AddChorus>
__attribute__((always_inline, optimize("O3"))) inline void
App::renderSustainLoopBlock(
    uint32_t activeMask,
    int32_t blockFrames,
    int32_t* __restrict mixedLeftQ15,
    int32_t* __restrict mixedRightQ15,
    int32_t* __restrict reverbInputQ15,
    int32_t* __restrict chorusInputQ15) {
  while (activeMask != 0) {
    const uint8_t voiceIndex = static_cast<uint8_t>(__builtin_ctz(activeMask));
    activeMask &= activeMask - 1;
    VoiceState::HotCoreState& hot = m_voices[voiceIndex].hotCore;

    // This kernel is selected only for an active, unfiltered sustain loop.
    // FX composition is a compile-time choice, so the sample loop contains
    // no per-frame send-presence branches.
    // Keep every sample-loop value local so the compiler does not have to
    // reload VoiceState fields from internal DRAM for each frame.
#if APP_USE_ADPCM_TONES || APP_USE_MULAW_TONES
    const uint8_t* const carrierSample = hot.carrierSample;
#else
    const int16_t* const carrierSample = hot.carrierSample;
#endif
    const uint16_t carrierSampleLength = hot.carrierSampleLength;
    uint32_t samplePosQ16 = hot.carrierSamplePosQ16;
    const uint32_t sampleStepQ16 = hot.carrierSampleStepQ16;
    const uint32_t loopStartQ16 = static_cast<uint32_t>(hot.carrierLoopStart) << 16;
    const uint32_t loopEndQ16 = static_cast<uint32_t>(hot.carrierLoopEnd) << 16;
    const uint32_t loopLengthQ16 = loopEndQ16 - loopStartQ16;
    const int32_t envelopeLevelQ15 = hot.carrierEnvelopeLevelQ15;
    const int32_t gainLeftQ15 =
        (envelopeLevelQ15 * static_cast<int32_t>(hot.carrierFixedGainLeftQ15)) >> 15;
    const int32_t gainRightQ15 =
        (envelopeLevelQ15 * static_cast<int32_t>(hot.carrierFixedGainRightQ15)) >> 15;
    int32_t reverbGainQ15 = 0;
    int32_t chorusGainQ15 = 0;
    if constexpr (AddReverb) {
      reverbGainQ15 =
          (envelopeLevelQ15 * static_cast<int32_t>(hot.reverbFixedGainQ15)) >> 15;
    }
    if constexpr (AddChorus) {
      chorusGainQ15 =
          (envelopeLevelQ15 * static_cast<int32_t>(hot.chorusFixedGainQ15)) >> 15;
    }
#if APP_USE_MULAW_TONES
    uint16_t cacheIndex = hot.mulawCachedSampleIndex;
    int16_t cache0 = hot.mulawCachedSample0;
    int16_t cache1 = hot.mulawCachedSample1;
    bool cacheValid = hot.mulawCacheValid;
#endif

    for (int32_t frame = 0; frame < blockFrames; ++frame) {
#if APP_USE_MULAW_TONES
      const int16_t waveQ15 = readMulawSampleLinearQ15Raw(
          carrierSample, carrierSampleLength, samplePosQ16,
          cacheIndex, cache0, cache1, cacheValid);
#elif APP_USE_ADPCM_TONES
      const int16_t waveQ15 = readAdpcmSampleLinearQ15Raw(
          carrierSample, carrierSampleLength, samplePosQ16,
          hot.adpcmCachedSampleIndex, hot.adpcmCachedSample0,
          hot.adpcmCachedSample1, hot.adpcmStepIndex, hot.adpcmCacheValid);
#else
      const int16_t waveQ15 = readPcmSampleLinearQ15Raw(
          carrierSample, carrierSampleLength, samplePosQ16);
#endif
      mixedLeftQ15[frame] +=
          (static_cast<int32_t>(waveQ15) * gainLeftQ15) >> 15;
      mixedRightQ15[frame] +=
          (static_cast<int32_t>(waveQ15) * gainRightQ15) >> 15;
      if constexpr (AddReverb) {
        reverbInputQ15[frame] +=
            (static_cast<int32_t>(waveQ15) * reverbGainQ15) >> 15;
      }
      if constexpr (AddChorus) {
        chorusInputQ15[frame] +=
            (static_cast<int32_t>(waveQ15) * chorusGainQ15) >> 15;
      }
      advanceLoopedPositionQ16Raw(
          samplePosQ16, sampleStepQ16,
          loopStartQ16, loopEndQ16, loopLengthQ16);
    }

    hot.carrierSamplePosQ16 = samplePosQ16;
    const uint8_t divider = max<uint8_t>(1, hot.decayUpdateDivider);
    hot.decayUpdateCounter = static_cast<uint8_t>(
        (static_cast<uint32_t>(hot.decayUpdateCounter) +
         static_cast<uint32_t>(blockFrames)) % divider);
#if APP_USE_MULAW_TONES
    hot.mulawCachedSampleIndex = cacheIndex;
    hot.mulawCachedSample0 = cache0;
    hot.mulawCachedSample1 = cache1;
    hot.mulawCacheValid = cacheValid;
#endif
  }
}

// Caller proves that every position update stays strictly before the end.
// Preserve the generic path's two Q15 rounding steps (do not combine gains).
template <bool AddChorus, bool Decay>
__attribute__((always_inline, optimize("O3"))) inline void
App::renderSustainOneShotVoice(
    VoiceState::HotCoreState& hot, int32_t frames,
    int32_t* __restrict left, int32_t* __restrict right,
    int32_t* __restrict reverb, int32_t* __restrict chorus,
    int32_t decayStep) {
#if APP_USE_MULAW_TONES
  const auto* sample = hot.carrierSample;
  const uint16_t length = hot.carrierSampleLength;
  uint32_t pos = hot.carrierSamplePosQ16;
  const uint32_t step = hot.carrierSampleStepQ16;
  int32_t envelope = hot.carrierEnvelopeLevelQ15;
  unsigned counter = hot.decayUpdateCounter;
  const unsigned divider = hot.decayUpdateDivider;
  const int32_t gainL = hot.carrierFixedGainLeftQ15;
  const int32_t gainR = hot.carrierFixedGainRightQ15;
  const int32_t gainRev = hot.reverbFixedGainQ15;
  const int32_t gainCho = hot.chorusFixedGainQ15;
  uint16_t cacheIndex = hot.mulawCachedSampleIndex;
  int16_t cache0 = hot.mulawCachedSample0;
  int16_t cache1 = hot.mulawCachedSample1;
  bool cacheValid = hot.mulawCacheValid;
  for (int32_t frame = 0; frame < frames; ++frame) {
    const int32_t wave = readMulawSampleLinearQ15Raw(
        sample, length, pos, cacheIndex, cache0, cache1, cacheValid);
    const int32_t scaled = (wave * envelope) >> 15;
    left[frame] += (scaled * gainL) >> 15;
    right[frame] += (scaled * gainR) >> 15;
    reverb[frame] += (scaled * gainRev) >> 15;
    if constexpr (AddChorus) chorus[frame] += (scaled * gainCho) >> 15;
    if constexpr (Decay) {
      if (++counter >= divider) {
        counter = 0;
        envelope -= decayStep;
      }
    }
    pos += step;
  }
  hot.carrierSamplePosQ16 = pos;
  if constexpr (Decay) {
    hot.carrierEnvelopeLevelQ15 = envelope;
    hot.decayUpdateCounter = static_cast<uint8_t>(counter);
  } else {
  hot.decayUpdateCounter = static_cast<uint8_t>(
      (static_cast<uint32_t>(hot.decayUpdateCounter) + frames) %
      hot.decayUpdateDivider);
  }
  hot.mulawCachedSampleIndex = cacheIndex;
  hot.mulawCachedSample0 = cache0;
  hot.mulawCachedSample1 = cache1;
  hot.mulawCacheValid = cacheValid;
#endif
}

void IRAM_ATTR __attribute__((optimize("O3"))) App::renderVoiceBlock(
    uint32_t activeMask,
    int32_t blockFrames,
    int32_t* __restrict mixedLeftQ15,
    int32_t* __restrict mixedRightQ15,
    int32_t* __restrict reverbInputQ15,
    int32_t* __restrict chorusInputQ15,
    int32_t* __restrict delayInputQ15) {
    while (activeMask != 0) {
      const uint8_t voiceIndex =
          static_cast<uint8_t>(__builtin_ctz(activeMask));
      activeMask &= activeMask - 1;
      VoiceState& voice = m_voices[voiceIndex];
      VoiceState::HotCoreState& hot = voice.hotCore;
      VoiceState::HotEnvelopeState& env = voice.hotEnvelope;
      VoiceState::ColdState& cold = voice.cold;
      uint32_t samplePosQ16 = hot.carrierSamplePosQ16;
#if APP_USE_MULAW_TONES
      uint16_t mulawCacheIndex = hot.mulawCachedSampleIndex;
      int16_t mulawCache0 = hot.mulawCachedSample0;
      int16_t mulawCache1 = hot.mulawCachedSample1;
      bool mulawCacheValid = hot.mulawCacheValid;
#endif
      // CC7/11 can mute and later restore an already sounding voice.  Keep
      // its sample/envelope clock advancing while its current gain is zero.
      if (!hot.active) {
        continue;
      }

#if APP_USE_ADPCM_TONES || APP_USE_MULAW_TONES
      const uint8_t* const carrierSample = hot.carrierSample;
#else
      const int16_t* const carrierSample = hot.carrierSample;
#endif
      const uint16_t carrierSampleLength = hot.carrierSampleLength;
      const uint16_t carrierLoopStart = hot.carrierLoopStart;
      const uint16_t carrierLoopEnd = hot.carrierLoopEnd;
      const bool carrierLoopEnabled = hot.carrierLoopEnabled;
      const uint32_t carrierLengthQ16 =
          static_cast<uint32_t>(carrierSampleLength) << 16;
      const uint32_t carrierLoopStartQ16 =
          static_cast<uint32_t>(carrierLoopStart) << 16;
      const uint32_t carrierLoopEndQ16 =
          static_cast<uint32_t>(carrierLoopEnd) << 16;
      const uint32_t carrierLoopLengthQ16 =
          carrierLoopEndQ16 - carrierLoopStartQ16;
      const uint8_t midiChannel = cold.channel & 0x0f;
      const bool filterActive =
          (m_filterChannelMask & static_cast<uint16_t>(1u << midiChannel)) != 0;
      const int32_t filterFQ15 = m_channelFilterFQ15[midiChannel];
      const int32_t filterDampingQ15 = m_channelFilterDampingQ15[midiChannel];

#if APP_USE_MULAW_TONES && SYNTH_DECAY_ONESHOT_FAST
      if (hot.carrierStage == EnvelopeStage::Decay &&
          !carrierLoopEnabled && !filterActive &&
          hot.reverbFixedGainQ15 > 0 && hot.chorusFixedGainQ15 == 0 &&
          hot.delayFixedGainQ15 == 0 &&
          hot.decayUpdateDivider > 0 && hot.decayUpdateDivider <= 4 &&
          hot.decayUpdateCounter < hot.decayUpdateDivider &&
          env.carrierDecayStepQ15 > 0 &&
          hot.carrierEnvelopeLevelQ15 > env.carrierSustainLevelQ15 &&
          samplePosQ16 < carrierLengthQ16 &&
          static_cast<uint64_t>(hot.carrierSampleStepQ16) *
                  static_cast<uint32_t>(blockFrames) <
              carrierLengthQ16 - samplePosQ16) {
        const uint32_t updates = (hot.decayUpdateCounter +
            static_cast<uint32_t>(blockFrames)) / hot.decayUpdateDivider;
        // Strict comparison preserves the generic stage transition, even
        // when it would occur on the final frame of this block.
        if (static_cast<int64_t>(updates) * env.carrierDecayStepQ15 <
            static_cast<int64_t>(hot.carrierEnvelopeLevelQ15) -
                env.carrierSustainLevelQ15) {
          renderSustainOneShotVoice<false, true>(hot, blockFrames,
              mixedLeftQ15, mixedRightQ15, reverbInputQ15, chorusInputQ15,
              env.carrierDecayStepQ15);
          continue;
        }
      }
#endif
#if APP_USE_MULAW_TONES && SYNTH_SUSTAIN_ONESHOT_FAST
      if (hot.carrierStage == EnvelopeStage::Sustain &&
          !carrierLoopEnabled && !filterActive &&
          hot.reverbFixedGainQ15 > 0 && hot.chorusFixedGainQ15 >= 0 &&
          hot.delayFixedGainQ15 == 0 &&
          hot.decayUpdateDivider > 0 && hot.decayUpdateDivider <= 4 &&
          hot.decayUpdateCounter < hot.decayUpdateDivider &&
          samplePosQ16 < carrierLengthQ16 &&
          static_cast<uint64_t>(hot.carrierSampleStepQ16) *
                  static_cast<uint32_t>(blockFrames) <
              carrierLengthQ16 - samplePosQ16) {
        if (hot.chorusFixedGainQ15 > 0) {
          renderSustainOneShotVoice<true>(hot, blockFrames, mixedLeftQ15,
              mixedRightQ15, reverbInputQ15, chorusInputQ15);
        } else {
          renderSustainOneShotVoice<false>(hot, blockFrames, mixedLeftQ15,
              mixedRightQ15, reverbInputQ15, chorusInputQ15);
        }
        continue;
      }
#endif

#if APP_USE_MULAW_TONES
      // The hardware D-cache fetches one 32-byte line.  Pull the first two
      // lines of each voice into the local core cache before entering the
      // 256-frame voice-major loop; this reduces the initial Flash wait on
      // DIO/40MHz without allocating additional per-voice RAM.
      if (carrierSample != nullptr && carrierSampleLength != 0) {
        __builtin_prefetch(carrierSample, 0, 3);
        __builtin_prefetch(carrierSample +
                               min<uint16_t>(32, carrierSampleLength - 1),
                           0, 3);
      }
#endif

      if (hot.carrierStage == EnvelopeStage::Sustain &&
          carrierLoopEnabled && carrierLoopLengthQ16 > 0 && !filterActive) {
        // Sustain中は振幅が一定なので、envelope×左右gainをblockごとに統合する。
        // ADSR分岐とdecay counter更新もsample loopの外へ出す。
        const int32_t sustainGainLeftQ15 =
            (hot.carrierEnvelopeLevelQ15 *
             static_cast<int32_t>(hot.carrierFixedGainLeftQ15)) >> 15;
        const int32_t sustainGainRightQ15 =
            (hot.carrierEnvelopeLevelQ15 *
             static_cast<int32_t>(hot.carrierFixedGainRightQ15)) >> 15;
        const int32_t sustainReverbGainQ15 =
            (hot.carrierEnvelopeLevelQ15 *
             static_cast<int32_t>(hot.reverbFixedGainQ15)) >> 15;
        const int32_t sustainChorusGainQ15 =
            (hot.carrierEnvelopeLevelQ15 *
             static_cast<int32_t>(hot.chorusFixedGainQ15)) >> 15;
        const int32_t sustainDelayGainQ15 =
            (hot.carrierEnvelopeLevelQ15 *
             static_cast<int32_t>(hot.delayFixedGainQ15)) >> 15;
        uint16_t processedFrames = 0;
        for (int32_t frame = 0; frame < blockFrames; ++frame) {
#if APP_USE_MULAW_TONES
          const int16_t waveQ15 = readMulawSampleLinearQ15Raw(
              carrierSample,
              carrierSampleLength,
              samplePosQ16, mulawCacheIndex, mulawCache0, mulawCache1,
              mulawCacheValid);
#elif APP_USE_ADPCM_TONES
          const int16_t waveQ15 = readAdpcmSampleLinearQ15Raw(
              carrierSample,
              carrierSampleLength,
              samplePosQ16,
              hot.adpcmCachedSampleIndex,
              hot.adpcmCachedSample0,
              hot.adpcmCachedSample1,
              hot.adpcmStepIndex,
              hot.adpcmCacheValid);
#else
          const int16_t waveQ15 = readPcmSampleLinearQ15Raw(
              carrierSample, carrierSampleLength, samplePosQ16);
#endif
          mixedLeftQ15[frame] +=
              (static_cast<int32_t>(waveQ15) * sustainGainLeftQ15) >> 15;
          mixedRightQ15[frame] +=
              (static_cast<int32_t>(waveQ15) * sustainGainRightQ15) >> 15;
          if (sustainReverbGainQ15 > 0) {
            reverbInputQ15[frame] +=
                (static_cast<int32_t>(waveQ15) * sustainReverbGainQ15) >> 15;
          }
          if (sustainChorusGainQ15 > 0) {
            chorusInputQ15[frame] +=
                (static_cast<int32_t>(waveQ15) * sustainChorusGainQ15) >> 15;
          }
          if (sustainDelayGainQ15 > 0) {
            delayInputQ15[frame] +=
                (static_cast<int32_t>(waveQ15) * sustainDelayGainQ15) >> 15;
          }
          ++processedFrames;

          advanceLoopedPositionQ16Raw(
              samplePosQ16,
              hot.carrierSampleStepQ16,
              carrierLoopStartQ16,
              carrierLoopEndQ16,
              carrierLoopLengthQ16);
        }
        const uint8_t divider = max<uint8_t>(1, hot.decayUpdateDivider);
        hot.decayUpdateCounter = static_cast<uint8_t>(
            (hot.decayUpdateCounter + processedFrames) % divider);
        hot.carrierSamplePosQ16 = samplePosQ16;
#if APP_USE_MULAW_TONES
        hot.mulawCachedSampleIndex = mulawCacheIndex;
        hot.mulawCachedSample0 = mulawCache0;
        hot.mulawCachedSample1 = mulawCache1;
        hot.mulawCacheValid = mulawCacheValid;
#endif
        continue;
      }

      for (int32_t frame = 0; frame < blockFrames; ++frame) {
        const bool slowEnvelopeUpdate =
            (hot.decayUpdateCounter + 1u) >= hot.decayUpdateDivider;
#if APP_USE_MULAW_TONES
        int32_t waveQ15 = readMulawSampleLinearQ15Raw(
            carrierSample,
            carrierSampleLength,
            samplePosQ16, mulawCacheIndex, mulawCache0, mulawCache1,
            mulawCacheValid);
#elif APP_USE_ADPCM_TONES
        int32_t waveQ15 = readAdpcmSampleLinearQ15Raw(
            carrierSample,
            carrierSampleLength,
            samplePosQ16,
            hot.adpcmCachedSampleIndex,
            hot.adpcmCachedSample0,
            hot.adpcmCachedSample1,
            hot.adpcmStepIndex,
            hot.adpcmCacheValid);
#else
        int32_t waveQ15 = readPcmSampleLinearQ15Raw(
            carrierSample, carrierSampleLength, samplePosQ16);
#endif
        if (filterActive) {
          int32_t low = hot.filterLowQ15;
          int32_t band = hot.filterBandQ15;
          low += (filterFQ15 * band) >> 15;
          const int32_t high = waveQ15 - low -
              ((filterDampingQ15 * band) >> 15);
          band += (filterFQ15 * high) >> 15;
          low = min<int32_t>(65535, max<int32_t>(-65536, low));
          band = min<int32_t>(65535, max<int32_t>(-65536, band));
          hot.filterLowQ15 = low;
          hot.filterBandQ15 = band;
          waveQ15 = min<int32_t>(32767, max<int32_t>(-32768, low));
        }
        const int32_t envelopeWaveQ15 =
            (static_cast<int32_t>(waveQ15) *
             hot.carrierEnvelopeLevelQ15) >> 15;
        mixedLeftQ15[frame] +=
            (envelopeWaveQ15 * hot.carrierFixedGainLeftQ15) >> 15;
        mixedRightQ15[frame] +=
            (envelopeWaveQ15 * hot.carrierFixedGainRightQ15) >> 15;
        if (hot.reverbFixedGainQ15 > 0) {
          reverbInputQ15[frame] +=
              (envelopeWaveQ15 * hot.reverbFixedGainQ15) >> 15;
        }
        if (hot.chorusFixedGainQ15 > 0) {
          chorusInputQ15[frame] +=
              (envelopeWaveQ15 * hot.chorusFixedGainQ15) >> 15;
        }
        if (hot.delayFixedGainQ15 > 0) {
          delayInputQ15[frame] +=
              (envelopeWaveQ15 * hot.delayFixedGainQ15) >> 15;
        }

        advanceEnvelopeOptimized(
            hot.carrierStage,
            hot.carrierEnvelopeLevelQ15,
            env.carrierAttackStepQ15,
            env.carrierDecayStepQ15,
            env.carrierSustainLevelQ15,
            env.carrierReleaseStepQ15,
            slowEnvelopeUpdate);
        if (hot.carrierStage == EnvelopeStage::Off &&
            hot.carrierEnvelopeLevelQ15 <= 0) {
          setVoiceActive(voiceIndex, false);
          cold.toneClass = MidiEvent::ToneClass::Lead;
          cold.channel = 0;
          cold.note = 0;
          cold.velocity = 0;
          hot.carrierFixedGainLeftQ15 = 0;
          hot.carrierFixedGainRightQ15 = 0;
          hot.reverbFixedGainQ15 = 0;
          hot.chorusFixedGainQ15 = 0;
          hot.delayFixedGainQ15 = 0;
          if (static_cast<int>(voiceIndex) == m_previewVoiceIndex) {
            m_previewVoiceIndex = -1;
            m_previewNote = 0;
            m_previewToneClass = MidiEvent::ToneClass::Lead;
            m_previewStopAtMs = 0;
          }
          break;
        }

        bool positionAlive = true;
        if (carrierLoopEnabled && carrierLoopLengthQ16 > 0) {
          advanceLoopedPositionQ16Raw(
              samplePosQ16,
              hot.carrierSampleStepQ16,
              carrierLoopStartQ16,
              carrierLoopEndQ16,
              carrierLoopLengthQ16);
        } else {
          positionAlive = advanceOneShotPositionQ16Raw(
            samplePosQ16,
              hot.carrierSampleStepQ16,
              carrierLengthQ16);
        }
        if (!positionAlive) {
          hot.carrierStage = EnvelopeStage::Off;
          hot.carrierEnvelopeLevelQ15 = 0;
        }
        hot.decayUpdateCounter =
            static_cast<uint8_t>(hot.decayUpdateCounter + 1);
        if (hot.decayUpdateCounter >= hot.decayUpdateDivider) {
          hot.decayUpdateCounter = 0;
        }
      }
      hot.carrierSamplePosQ16 = samplePosQ16;
#if APP_USE_MULAW_TONES
      hot.mulawCachedSampleIndex = mulawCacheIndex;
      hot.mulawCachedSample0 = mulawCache0;
      hot.mulawCachedSample1 = mulawCache1;
      hot.mulawCacheValid = mulawCacheValid;
#endif
    }


}

#if SYNTH_RENDER_PROFILING_LAYOUT && !SYNTH_RENDER_PROFILE_VOICE_CODE
#undef SYNTH_RENDER_PROFILING
#define SYNTH_RENDER_PROFILING 0
#endif
void IRAM_ATTR __attribute__((optimize("O3"))) App::renderVoiceFrames(
    uint32_t activeMask,
    int32_t frameCount,
    int32_t* mixedLeftQ15,
    int32_t* mixedRightQ15,
    int32_t* reverbInputQ15,
    int32_t* chorusInputQ15,
    int32_t* delayInputQ15,
    bool clearFxBuffers) {
  if (frameCount <= 0) {
    return;
  }
#if SYNTH_RENDER_PROFILING
  const uint32_t profileCore =
      static_cast<uint32_t>(esp_cpu_get_core_id()) & 1U;
  // helper側profileを停止した段階試験では、Core0のrenderVoiceFrames()を
  // 統計領域へ一切接続しない。従来はcontext設定だけがVOICE_CODEで有効になり、
  // HELPER_CODE=0でもCore0がbank 0へ書き込めたため、heartbeatの初期化と競合した。
  const bool profileThisCall =
      SYNTH_RENDER_PROFILE_HELPER_CODE || profileCore != 0U;
  const RendererProfileCallContext& profileContext =
      g_rendererProfileCallContexts[profileCore];
  RendererProfileBank& rendererProfile =
      m_rendererProfileBanks[profileContext.bank & 1U];
  VoiceProfileStats& profile = profileContext.helperCore
      ? rendererProfile.helperVoice : rendererProfile.mainVoice;
  const uint32_t profileClearStartCycles =
      profileThisCall ? RENDER_PROFILE_CCOUNT() : 0U;
#endif
  const size_t bytes = static_cast<size_t>(frameCount) * sizeof(int32_t);
#if APP_USE_32BIT_IRAM_AUDIO_BUFFERS
  for (int32_t frame = 0; frame < frameCount; ++frame) {
    mixedLeftQ15[frame] = 0;
    mixedRightQ15[frame] = 0;
    if (clearFxBuffers) {
      reverbInputQ15[frame] = 0;
      chorusInputQ15[frame] = 0;
      delayInputQ15[frame] = 0;
    }
  }
#else
  memset(mixedLeftQ15, 0, bytes);
  memset(mixedRightQ15, 0, bytes);
  if (clearFxBuffers) {
    memset(reverbInputQ15, 0, bytes);
    memset(chorusInputQ15, 0, bytes);
    memset(delayInputQ15, 0, bytes);
  }
#endif
#if SYNTH_RENDER_PROFILING
  const uint32_t profileClearCycles = profileThisCall
      ? RENDER_PROFILE_CCOUNT() - profileClearStartCycles : 0U;
#if SYNTH_RENDER_PROFILE_ACCUMULATION
  if (profileThisCall) {
    profile.clearCycleTotal += profileClearCycles;
    if (profileClearCycles > profile.clearCycleMax) {
      profile.clearCycleMax = profileClearCycles;
    }
  }
#else
  (void)profileClearCycles;
#endif
#endif
  uint32_t originalSteps[kMaxVoices];
#if SYNTH_RENDER_PROFILING
  const uint32_t profileModStartCycles =
      profileThisCall ? RENDER_PROFILE_CCOUNT() : 0U;
#endif
  uint32_t modulationMask =
      m_modulationChannelMask == 0 ? 0 : activeMask;
  const uint32_t appliedModulationMask = modulationMask;
  while (modulationMask != 0) {
    const uint8_t voiceIndex =
        static_cast<uint8_t>(__builtin_ctz(modulationMask));
    modulationMask &= modulationMask - 1;
    VoiceState& voice = m_voices[voiceIndex];
    const uint32_t originalStep = voice.hotCore.carrierSampleStepQ16;
    originalSteps[voiceIndex] = originalStep;
    const uint8_t channel = voice.cold.channel & 0x0f;
    uint32_t scaleQ16 = m_channelModulationScaleQ16[channel];
    if (m_channelModulation[channel] == 0 &&
        m_channelVibratoDepth[channel] > 64) {
      const uint32_t delayMs = static_cast<uint32_t>(
          m_channelVibratoDelay[channel] > 64
              ? (m_channelVibratoDelay[channel] - 64) * 25u : 0u);
      if (millis() - voice.cold.startedAtMs < delayMs) scaleQ16 = 65536;
    }
    if (scaleQ16 != 65536) {
      voice.hotCore.carrierSampleStepQ16 = static_cast<uint32_t>(min<uint64_t>(
          UINT32_MAX,
          (static_cast<uint64_t>(originalStep) * scaleQ16) >> 16));
    }
  }
#if SYNTH_RENDER_PROFILING
  const uint32_t profileModApplyCycles = profileThisCall
      ? RENDER_PROFILE_CCOUNT() - profileModStartCycles : 0U;
#endif
  // Voice-major locality: process a larger tile so each voice streams more
  // of its μ-law/PCM data before switching to the next voice.  Envelope,
  // one-shot and loop state are still updated for every sample inside the
  // block, so timing resolution is unchanged.
  static constexpr int32_t kMixBlockFrames = 256;
#if SYNTH_RENDER_PROFILING
  uint64_t profileFastCycles = 0;
  uint64_t profileGenericCycles = 0;
  uint32_t profileFastCycleMax = 0;
  uint32_t profileGenericCycleMax = 0;
  uint64_t profileFastVoiceCount = 0;
  uint64_t profileGenericVoiceCount = 0;
  uint32_t profileVoiceCountSamples = 0;
#endif
  for (int32_t blockStart = 0; blockStart < frameCount;
       blockStart += kMixBlockFrames) {
    const int32_t blockFrames =
        min(kMixBlockFrames, frameCount - blockStart);
    uint32_t sustainNoFxMask = 0;
    uint32_t sustainReverbMask = 0;
    uint32_t sustainReverbChorusMask = 0;
    uint32_t classifyMask = activeMask;
    while (classifyMask != 0) {
      const uint8_t voiceIndex =
          static_cast<uint8_t>(__builtin_ctz(classifyMask));
      classifyMask &= classifyMask - 1;
      const VoiceState& voice = m_voices[voiceIndex];
      const VoiceState::HotCoreState& hot = voice.hotCore;
      const uint16_t channelBit = static_cast<uint16_t>(
          1u << (voice.cold.channel & 0x0f));
      const bool filterActive = (m_filterChannelMask & channelBit) != 0;
      if (hot.active &&
          hot.carrierStage == EnvelopeStage::Sustain &&
          hot.carrierLoopEnabled &&
          hot.carrierLoopEnd > hot.carrierLoopStart &&
          !filterActive &&
          (hot.carrierFixedGainLeftQ15 > 0 ||
           hot.carrierFixedGainRightQ15 > 0) &&
          hot.delayFixedGainQ15 == 0) {
        const uint32_t bit = 1UL << voiceIndex;
        if (hot.reverbFixedGainQ15 == 0 &&
            hot.chorusFixedGainQ15 == 0) {
          sustainNoFxMask |= bit;
        } else if (hot.reverbFixedGainQ15 > 0 &&
                   hot.chorusFixedGainQ15 == 0) {
          sustainReverbMask |= bit;
        } else if (hot.reverbFixedGainQ15 > 0 &&
                   hot.chorusFixedGainQ15 > 0) {
          sustainReverbChorusMask |= bit;
        }
      }
    }
    const uint32_t sustainFastMask = sustainNoFxMask |
        sustainReverbMask | sustainReverbChorusMask;
    const uint32_t genericMask = activeMask & ~sustainFastMask;
#if SYNTH_RENDER_PROFILING && SYNTH_RENDER_PROFILE_ACCUMULATION
    if (profileThisCall) {
      uint32_t kindMask = genericMask;
      while (kindMask != 0) {
        const unsigned index = __builtin_ctz(kindMask);
        kindMask &= kindMask - 1;
        const VoiceState& voice = m_voices[index];
        const auto& hot = voice.hotCore;
        if (!hot.active) continue;
        unsigned stage;
        switch (hot.carrierStage) {
          case EnvelopeStage::Attack: stage = 0; break;
          case EnvelopeStage::Decay: stage = 1; break;
          case EnvelopeStage::Sustain: stage = 2; break;
          case EnvelopeStage::Release: stage = 3; break;
          default: continue;
        }
        const unsigned loop = hot.carrierLoopEnabled &&
            hot.carrierLoopEnd > hot.carrierLoopStart;
        const unsigned filter = (m_filterChannelMask &
            (1u << (voice.cold.channel & 15u))) != 0;
        const unsigned fx = (hot.reverbFixedGainQ15 > 0 ? 1u : 0u) |
            (hot.chorusFixedGainQ15 > 0 ? 2u : 0u) |
            (hot.delayFixedGainQ15 > 0 ? 4u : 0u);
        ++profile.genericKinds[(stage << 5) | (loop << 4) |
                               (filter << 3) | fx];
      }
    }
#endif
#if SYNTH_RENDER_PROFILING
    if (profileThisCall) {
      profileFastVoiceCount += static_cast<uint64_t>(
          __builtin_popcount(sustainFastMask));
      profileGenericVoiceCount += static_cast<uint64_t>(
          __builtin_popcount(genericMask));
      ++profileVoiceCountSamples;
    }
#endif
    if (sustainFastMask != 0) {
#if SYNTH_RENDER_PROFILING
      const uint32_t fastStartCycles =
          profileThisCall ? RENDER_PROFILE_CCOUNT() : 0U;
#endif
      if (sustainNoFxMask != 0) {
        renderSustainLoopBlock<false, false>(
            sustainNoFxMask,
            blockFrames,
            mixedLeftQ15 + blockStart,
            mixedRightQ15 + blockStart,
            reverbInputQ15 + blockStart,
            chorusInputQ15 + blockStart);
      }
      if (sustainReverbMask != 0) {
        renderSustainLoopBlock<true, false>(
            sustainReverbMask,
            blockFrames,
            mixedLeftQ15 + blockStart,
            mixedRightQ15 + blockStart,
            reverbInputQ15 + blockStart,
            chorusInputQ15 + blockStart);
      }
      if (sustainReverbChorusMask != 0) {
        renderSustainLoopBlock<true, true>(
            sustainReverbChorusMask,
            blockFrames,
            mixedLeftQ15 + blockStart,
            mixedRightQ15 + blockStart,
            reverbInputQ15 + blockStart,
            chorusInputQ15 + blockStart);
      }
#if SYNTH_RENDER_PROFILING
      if (profileThisCall) {
        const uint32_t fastCycles =
            RENDER_PROFILE_CCOUNT() - fastStartCycles;
        profileFastCycles += fastCycles;
        if (fastCycles > profileFastCycleMax) {
          profileFastCycleMax = fastCycles;
        }
      }
#endif
    }
#if SYNTH_RENDER_PROFILING
    const bool profileGeneric = profileThisCall && genericMask != 0;
    const uint32_t genericStartCycles = profileGeneric
        ? RENDER_PROFILE_CCOUNT() : 0;
#endif
    renderVoiceBlock(
        genericMask,
        blockFrames,
        mixedLeftQ15 + blockStart,
        mixedRightQ15 + blockStart,
        reverbInputQ15 + blockStart,
        chorusInputQ15 + blockStart,
        delayInputQ15 + blockStart);
#if SYNTH_RENDER_PROFILING
    if (profileGeneric) {
      const uint32_t genericCycles =
          RENDER_PROFILE_CCOUNT() - genericStartCycles;
      profileGenericCycles += genericCycles;
      if (genericCycles > profileGenericCycleMax) {
        profileGenericCycleMax = genericCycles;
      }
    }
#endif
  }
#if SYNTH_RENDER_PROFILING
  const uint32_t profileModRestoreStartCycles =
      profileThisCall ? RENDER_PROFILE_CCOUNT() : 0U;
#endif
  modulationMask = appliedModulationMask;
  while (modulationMask != 0) {
    const uint8_t voiceIndex =
        static_cast<uint8_t>(__builtin_ctz(modulationMask));
    modulationMask &= modulationMask - 1;
    m_voices[voiceIndex].hotCore.carrierSampleStepQ16 =
        originalSteps[voiceIndex];
  }
#if SYNTH_RENDER_PROFILING
  const uint32_t profileModCycles = profileThisCall
      ? profileModApplyCycles +
          (RENDER_PROFILE_CCOUNT() - profileModRestoreStartCycles)
      : 0U;
#if SYNTH_RENDER_PROFILE_ACCUMULATION
  if (profileThisCall) {
    ++profile.renderCallCount;
    profile.fastCycleTotal += profileFastCycles;
    profile.genericCycleTotal += profileGenericCycles;
    profile.modCycleTotal += profileModCycles;
    if (profileFastCycleMax > profile.fastCycleMax) {
      profile.fastCycleMax = profileFastCycleMax;
    }
    if (profileGenericCycleMax > profile.genericCycleMax) {
      profile.genericCycleMax = profileGenericCycleMax;
    }
    if (profileModCycles > profile.modCycleMax) {
      profile.modCycleMax = profileModCycles;
    }
    profile.fastVoiceCountTotal += profileFastVoiceCount;
    profile.genericVoiceCountTotal += profileGenericVoiceCount;
    profile.voiceCountSampleTotal += profileVoiceCountSamples;
  }
#else
  (void)profileModCycles;
#endif
#endif
}

#if SYNTH_RENDER_PROFILING_LAYOUT && !SYNTH_RENDER_PROFILE_VOICE_CODE
#undef SYNTH_RENDER_PROFILING
#define SYNTH_RENDER_PROFILING SYNTH_RENDER_PROFILING_EXECUTION
#endif

int32_t IRAM_ATTR __attribute__((optimize("O3"))) App::renderStereoFrames(
    uint32_t* framesStereo, int32_t frameCount) {
  if (frameCount <= 0) {
    return 0;
  }
  frameCount = min<int32_t>(frameCount, static_cast<int32_t>(kRenderChunkFrames));

  const bool previewActive =
      m_previewVoiceIndex >= 0 &&
      m_previewVoiceIndex < kMaxVoices &&
      m_voices[m_previewVoiceIndex].hotCore.active;
  if ((!m_a2dpConnected && !previewActive) ||
      ((!m_playing || !m_songLoaded) && !previewActive)) {
    memset(framesStereo, 0, static_cast<size_t>(frameCount) * sizeof(uint32_t));
    return frameCount;
  }

#if SYNTH_RENDER_PROFILE_CORE1_CLOCK_PROBE
  // 最小切り分けprobe。CCOUNT read自体は副作用を持つinline asmなので、
  // 結果を保存せず統計・共有メモリ・helper経路を一切変更しない。
  (void)esp_cpu_get_cycle_count();
#endif

#if SYNTH_RENDER_PROFILING
  uint32_t profileBank = 0;
#if SYNTH_RENDER_PROFILE_BANK_HANDSHAKE
  while (true) {
    profileBank = __atomic_load_n(
        &m_rendererProfileActiveBank, __ATOMIC_ACQUIRE) & 1U;
    __atomic_store_n(
        &m_mainProfileWriterBank, profileBank, __ATOMIC_RELEASE);
    if ((__atomic_load_n(
             &m_rendererProfileActiveBank, __ATOMIC_ACQUIRE) & 1U) ==
        profileBank) {
      break;
    }
    __atomic_store_n(
        &m_mainProfileWriterBank, kProfileWriterIdle, __ATOMIC_RELEASE);
  }
#endif
  RendererProfileBank& rendererProfile = m_rendererProfileBanks[profileBank];
  const uint32_t profilePrepStartCycles = RENDER_PROFILE_CCOUNT();
#endif
  uint32_t activeMask = __atomic_load_n(&m_activeVoiceMask, __ATOMIC_RELAXED);
  if (m_activeVoiceLimit < kMaxVoices) {
    activeMask &= (1UL << m_activeVoiceLimit) - 1UL;
  }
  prepareModulationScales(frameCount);

  uint32_t helperMask = 0;
  if (m_renderHelperTaskHandle != nullptr) {
    const uint32_t activeCount =
        static_cast<uint32_t>(__builtin_popcount(activeMask));
    // Start at the measured 5/16 split, then adapt slowly from measured
    // main/helper time.  Keep the assignment stable to preserve pair caches.
    // Core 0 is also responsible for Wi-Fi/Bluetooth and MIDI parsing.  Keep
    // the helper share bounded even when the adaptive controller has stale
    // measurements; otherwise it can starve IDLE0 and increase underruns.
    // The 16/32 cap permits at most 16 helper voices at 32 active voices.
    const uint32_t helperCap = min<uint32_t>(
        kHelperVoiceCapMax,
        (activeCount * kHelperVoiceCapNumerator) /
            kHelperVoiceCapDenominator);
    uint32_t helperCount = m_dynamicHelperCount != 0
        ? min<uint32_t>(m_dynamicHelperCount, helperCap)
        : min<uint32_t>((activeCount * 5u) / 16u, helperCap);
    const uint32_t helperTargetCount = helperCount;
    const uint32_t previousHelperMask =
        m_previousHelperVoiceMask & activeMask;
    // Estimate relative per-voice cost before assigning a fixed number of
    // helper voices. Fast sustain kernels are cheaper than generic sustain,
    // while attack/release/filter/delay/one-shot work is most expensive.
    // Adaptive measured timing still controls the helper count; these coarse
    // weights only choose which voices make up that count.
    uint8_t helperVoiceCost[kMaxVoices] = {0};
    uint32_t costScanMask = activeMask;
    while (costScanMask != 0) {
      const uint8_t voiceIndex =
          static_cast<uint8_t>(__builtin_ctz(costScanMask));
      costScanMask &= costScanMask - 1;
      const VoiceState& voice = m_voices[voiceIndex];
      const VoiceState::HotCoreState& hot = voice.hotCore;
      const uint16_t channelBit = static_cast<uint16_t>(
          1u << (voice.cold.channel & 0x0f));
      const bool filterActive = (m_filterChannelMask & channelBit) != 0;
      const bool sustainLoop =
          hot.carrierStage == EnvelopeStage::Sustain &&
          hot.carrierLoopEnabled &&
          hot.carrierLoopEnd > hot.carrierLoopStart;
      const bool fastEligible =
          sustainLoop && !filterActive &&
          (hot.carrierFixedGainLeftQ15 > 0 ||
           hot.carrierFixedGainRightQ15 > 0) &&
          hot.delayFixedGainQ15 == 0 &&
          (hot.chorusFixedGainQ15 == 0 ||
           hot.reverbFixedGainQ15 > 0);
      if (!fastEligible) {
        helperVoiceCost[voiceIndex] = sustainLoop ? 5u : 6u;
      } else if (hot.chorusFixedGainQ15 > 0) {
        helperVoiceCost[voiceIndex] = 4u;
      } else if (hot.reverbFixedGainQ15 > 0) {
        helperVoiceCost[voiceIndex] = 3u;
      } else {
        helperVoiceCost[voiceIndex] = 2u;
      }
    }

    // Core 0 also services Bluetooth/Wi-Fi and starts slightly after Core 1.
    // Reserve a small part of its assignment for cheaper fast voices so the
    // helper is expected to finish before the main renderer.  This avoids the
    // opposite extremes of all-fast and all-generic helper assignments.
    uint32_t fastReserve = helperTargetCount >= 11u ? 2u :
        (helperTargetCount >= 6u ? 1u : 0u);
    for (uint32_t cost = 4u;
         cost >= 2u && fastReserve > 0 && helperCount > 0; --cost) {
      for (uint32_t retain = 0;
           retain < 2u && fastReserve > 0 && helperCount > 0; ++retain) {
        for (uint32_t voiceIndex = 0;
             voiceIndex < kMaxVoices && fastReserve > 0 && helperCount > 0;
             ++voiceIndex) {
          const uint32_t bit = 1UL << voiceIndex;
          if ((activeMask & bit) == 0 || (helperMask & bit) != 0 ||
              helperVoiceCost[voiceIndex] != cost) {
            continue;
          }
          const bool wasHelper = (previousHelperMask & bit) != 0;
          if ((retain == 0) != wasHelper) {
            continue;
          }
          helperMask |= bit;
          --helperCount;
          --fastReserve;
        }
      }
    }

    // Within one cost class, retain the previous assignment first so
    // VoiceState and its pair cache do not migrate between cores needlessly.
    for (uint32_t cost = 6u; cost >= 2u && helperCount > 0; --cost) {
      for (uint32_t retain = 0; retain < 2u && helperCount > 0; ++retain) {
        for (uint32_t voiceIndex = 0;
             voiceIndex < kMaxVoices && helperCount > 0; ++voiceIndex) {
          const uint32_t bit = 1UL << voiceIndex;
          if ((activeMask & bit) == 0 || (helperMask & bit) != 0) {
            continue;
          }
          const bool wasHelper = (previousHelperMask & bit) != 0;
          if ((retain == 0) != wasHelper) {
            continue;
          }
          if (helperVoiceCost[voiceIndex] == cost) {
            helperMask |= bit;
            --helperCount;
          }
        }
      }
    }
  }
  m_previousHelperVoiceMask = helperMask;
  const uint32_t mainMask = activeMask & ~helperMask;
  const uint32_t selectedHelperCount =
      static_cast<uint32_t>(__builtin_popcount(helperMask));
  bool helperHasFxSends = false;
  uint32_t helperFxScanMask = helperMask;
  while (helperFxScanMask != 0) {
    const uint8_t voiceIndex =
        static_cast<uint8_t>(__builtin_ctz(helperFxScanMask));
    helperFxScanMask &= helperFxScanMask - 1;
    const VoiceState::HotCoreState& hot = m_voices[voiceIndex].hotCore;
    if (hot.reverbFixedGainQ15 != 0 || hot.chorusFixedGainQ15 != 0 ||
        hot.delayFixedGainQ15 != 0) {
      helperHasFxSends = true;
      break;
    }
  }

  if (helperMask != 0) {
    m_helperVoiceMask = helperMask;
    m_helperFrameCount = frameCount;
    m_helperRenderFxSends = helperHasFxSends;
    __atomic_store_n(&m_helperJobDone, false, __ATOMIC_RELEASE);
#if SYNTH_RENDER_PROFILING && SYNTH_RENDER_PROFILE_HELPER_CODE
    // esp_timerは両コア共通の時刻基準。通知直前に記録し、Core0側で
    // 通知から実際のhelper実行開始までのscheduler遅延を測る。
    __atomic_store_n(
        &m_helperJobStartUs,
        RENDER_PROFILE_TIME_US(),
        __ATOMIC_RELEASE);
#endif
    xTaskNotifyGive(m_renderHelperTaskHandle);
  }

#if SYNTH_RENDER_PROFILE_CORE1_CLOCK_PROBE
  (void)esp_cpu_get_cycle_count();
#endif

#if SYNTH_RENDER_PROFILING
  const uint32_t profilePrepCycles =
      RENDER_PROFILE_CCOUNT() - profilePrepStartCycles;
#endif
  const uint32_t mainStartCycles = esp_cpu_get_cycle_count();
#if SYNTH_RENDER_PROFILING && SYNTH_RENDER_PROFILE_VOICE_CODE
  g_rendererProfileCallContexts[1] =
      RendererProfileCallContext{profileBank, false};
#endif
  renderVoiceFrames(
      mainMask,
      frameCount,
      g_mainMixedLeftQ15,
      g_mainMixedRightQ15,
      g_mainReverbInputQ15,
      g_mainChorusInputQ15,
      g_mainDelayInputQ15);
  const uint32_t mainCycles = esp_cpu_get_cycle_count() - mainStartCycles;

  uint32_t waitCycles = 0;
  uint32_t helperCycles = 0;
#if SYNTH_RENDER_PROFILING
  uint32_t profileMergeCycles = 0;
#endif
  if (helperMask != 0) {
    const uint32_t waitStartCycles = esp_cpu_get_cycle_count();
    while (!__atomic_load_n(&m_helperJobDone, __ATOMIC_ACQUIRE)) {
      ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(1));
    }
    waitCycles = esp_cpu_get_cycle_count() - waitStartCycles;
    helperCycles = m_helperLastCycles;
    if (activeMask != 0) {
      const uint32_t margin = 24000U; // 約100us @240MHz
      const uint32_t activeVoiceCount =
          static_cast<uint32_t>(__builtin_popcount(activeMask));
      const uint32_t helperCap = min<uint32_t>(
          kHelperVoiceCapMax,
          (activeVoiceCount * kHelperVoiceCapNumerator) /
              kHelperVoiceCapDenominator);
      // A long wait means Core 0 is the bottleneck (or pre-empted by system
      // work), so reduce helper load before considering any increase.
      if (waitCycles > 120000U && selectedHelperCount > 1u) {
        if (++m_helperAdjustDown >= 2) {
          m_dynamicHelperCount = static_cast<uint8_t>(selectedHelperCount - 1u);
          m_helperAdjustDown = 0;
          m_helperAdjustUp = 0;
        }
      } else if (waitCycles < 60000U &&
                 mainCycles > helperCycles + margin &&
                 selectedHelperCount < helperCap) {
        if (++m_helperAdjustUp >= 4) {
          m_dynamicHelperCount = static_cast<uint8_t>(selectedHelperCount + 1);
          m_helperAdjustUp = 0;
          m_helperAdjustDown = 0;
        }
      } else if (helperCycles > mainCycles + margin && selectedHelperCount > 1) {
        if (++m_helperAdjustDown >= 4) {
          m_dynamicHelperCount = static_cast<uint8_t>(selectedHelperCount - 1);
          m_helperAdjustDown = 0;
          m_helperAdjustUp = 0;
        }
      } else {
        m_helperAdjustUp = 0;
        m_helperAdjustDown = 0;
      }
    }
    ++m_parallelJobCount;
    m_parallelMainCycleTotal += mainCycles;
    m_parallelHelperCycleTotal += helperCycles;
    m_parallelWaitCycleTotal += waitCycles;
    if (mainCycles > m_parallelMainCycleMax) m_parallelMainCycleMax = mainCycles;
    if (helperCycles > m_parallelHelperCycleMax) {
      m_parallelHelperCycleMax = helperCycles;
    }
    if (waitCycles > m_parallelWaitCycleMax) m_parallelWaitCycleMax = waitCycles;
#if SYNTH_RENDER_PROFILING
    const uint32_t profileMergeStartCycles = RENDER_PROFILE_CCOUNT();
#endif
    for (int32_t frame = 0; frame < frameCount; ++frame) {
      g_mainMixedLeftQ15[frame] += g_helperMixedLeftQ15[frame];
      g_mainMixedRightQ15[frame] += g_helperMixedRightQ15[frame];
      if (helperHasFxSends) {
        g_mainReverbInputQ15[frame] += g_helperReverbInputQ15[frame];
        g_mainChorusInputQ15[frame] += g_helperChorusInputQ15[frame];
        g_mainDelayInputQ15[frame] += g_helperDelayInputQ15[frame];
      }
    }
#if SYNTH_RENDER_PROFILING
    profileMergeCycles = RENDER_PROFILE_CCOUNT() - profileMergeStartCycles;
#endif
  }
#if SYNTH_RENDER_PROFILE_CORE1_CLOCK_PROBE
  (void)esp_cpu_get_cycle_count();
#endif
#if SYNTH_RENDER_PROFILING
  const uint32_t profileFxoutStartCycles = RENDER_PROFILE_CCOUNT();
#endif
  for (int32_t frame = 0; frame < frameCount; ++frame) {
      int32_t leftQ15 = g_mainMixedLeftQ15[frame];
      int32_t rightQ15 = g_mainMixedRightQ15[frame];
      int32_t reverbInput = g_mainReverbInputQ15[frame] +
          m_routedReverbPendingQ15;
      m_routedReverbPendingQ15 = 0;
      const int32_t chorusInput = g_mainChorusInputQ15[frame];
      const int32_t delayInput = g_mainDelayInputQ15[frame];
      if (delayInput != 0) m_delayTailFrames = m_sampleRateHz * 2u;
      if (reverbInput != 0 || chorusInput != 0 || delayInput != 0) {
#if APP_ENABLE_FREEVERB_LITE
        m_effectTailFrames = m_sampleRateHz * 3u;
#else
        m_effectTailFrames = m_sampleRateHz * 2u;
#endif
      }
      if (m_effectTailFrames > 0) {
        --m_effectTailFrames;

#if APP_ENABLE_FREEVERB_LITE
        const int32_t clampedReverbInput = min<int32_t>(
            kQ15One, max<int32_t>(-kQ15One, reverbInput));
        if (!m_reverbHalfPhase) {
          m_reverbHalfInput = clampedReverbInput;
          m_reverbHalfPhase = true;
        } else {
          const int32_t halfInput =
              (m_reverbHalfInput + clampedReverbInput) >> 1;
          int32_t wetLeft = 0;
          int32_t wetRight = 0;
          processFreeverbHalfSample(halfInput, wetLeft, wetRight);
          m_reverbWetLeft = static_cast<int16_t>(wetLeft);
          m_reverbWetRight = static_cast<int16_t>(wetRight);
          m_reverbHalfPhase = false;
        }
        leftQ15 += (static_cast<int32_t>(m_reverbWetLeft) *
                    m_reverbReturnGainQ15) >> 15;
        rightQ15 += (static_cast<int32_t>(m_reverbWetRight) *
                     m_reverbReturnGainQ15) >> 15;
#else
        const uint16_t reverbWrite =
            m_reverbWriteIndex & (kReverbDelayFrames - 1);
        const uint16_t reverbTapLeft =
            (reverbWrite - 733u) & (kReverbDelayFrames - 1);
        const uint16_t reverbTapRight =
            (reverbWrite - 997u) & (kReverbDelayFrames - 1);
        const int32_t reverbLeft = m_reverbDelay[reverbTapLeft];
        const int32_t reverbRight = m_reverbDelay[reverbTapRight];
        int32_t reverbWriteValue = reverbInput +
            (((reverbLeft + reverbRight) * m_legacyReverbFeedback) >> 5);
        reverbWriteValue = min<int32_t>(
            kQ15One, max<int32_t>(-kQ15One, reverbWriteValue));
        m_reverbDelay[reverbWrite] = static_cast<int16_t>(reverbWriteValue);
        m_reverbWriteIndex =
            (reverbWrite + 1u) & (kReverbDelayFrames - 1);
        leftQ15 += (reverbLeft * m_reverbReturnGainQ15) >> 15;
        rightQ15 += (reverbRight * m_reverbReturnGainQ15) >> 15;
#endif

        const uint32_t chorusPhase = m_chorusPhaseQ16 >> 16;
        const uint32_t chorusTriangle = chorusPhase < 2048u
            ? chorusPhase
            : 4095u - chorusPhase;
        const int32_t chorusMod =
            (static_cast<int32_t>(chorusTriangle) * m_chorusDepthFrames) >> 11;
        const uint16_t chorusDelayLeft = static_cast<uint16_t>(
            min<int32_t>(510, m_chorusCenterFrames + chorusMod));
        const uint16_t chorusDelayRight = static_cast<uint16_t>(
            max<int32_t>(1, m_chorusCenterFrames - chorusMod));
        const uint16_t chorusWrite =
            m_chorusWriteIndex & (kChorusDelayFrames - 1);
        const int32_t chorusLeft = m_chorusDelay[
            (chorusWrite - chorusDelayLeft) & (kChorusDelayFrames - 1)];
        const int32_t chorusRight = m_chorusDelay[
            (chorusWrite - chorusDelayRight) & (kChorusDelayFrames - 1)];
        int32_t filteredChorusInput = chorusInput;
        if (m_chorusLowpassShift != 0) {
          m_chorusLowpassQ15 +=
              (filteredChorusInput - m_chorusLowpassQ15) >> m_chorusLowpassShift;
          filteredChorusInput = m_chorusLowpassQ15;
        } else {
          m_chorusLowpassQ15 = filteredChorusInput;
        }
        const int32_t chorusWriteValue = min<int32_t>(
            kQ15One, max<int32_t>(-kQ15One, filteredChorusInput +
                (((chorusLeft + chorusRight) * m_chorusFeedbackQ15) >> 16)));
        m_chorusDelay[chorusWrite] = static_cast<int16_t>(chorusWriteValue);
        m_chorusWriteIndex =
            (chorusWrite + 1u) & (kChorusDelayFrames - 1);
        leftQ15 += (chorusLeft * m_chorusReturnGainQ15) >> 15;
        rightQ15 += (chorusRight * m_chorusReturnGainQ15) >> 15;
        m_routedReverbPendingQ15 +=
            (((chorusLeft + chorusRight) >> 1) *
             m_chorusToReverbGainQ15) >> 15;

        m_chorusPhaseQ16 += m_chorusPhaseIncrement;
        if (m_chorusPhaseQ16 >= (4096u << 16)) {
          m_chorusPhaseQ16 -= (4096u << 16);
        }

        if (m_delayTailFrames > 0) {
        --m_delayTailFrames;
        // 1/4-rate mono delay: 2048 samples provide about 186ms at 44.1kHz.
        // Slightly different L/R taps produce a GS-style stereo/pan delay.
        const uint16_t delayTapLeft = static_cast<uint16_t>(
            (m_delayWriteIndex - m_delayTapFrames) & (kDelayFrames - 1));
        const uint16_t delayTapRight = static_cast<uint16_t>(
            (m_delayWriteIndex - max<uint16_t>(1, (m_delayTapFrames * 3u) / 4u)) &
            (kDelayFrames - 1));
        const int32_t delayLeft = m_delayBuffer[delayTapLeft];
        const int32_t delayRight = m_delayBuffer[delayTapRight];
        leftQ15 += (delayLeft * m_delayReturnGainQ15) >> 15;
        rightQ15 += (delayRight * m_delayReturnGainQ15) >> 15;
        m_routedReverbPendingQ15 +=
            (((delayLeft + delayRight) >> 1) * m_delayToReverbGainQ15) >> 15;
        m_delayInputAccum += min<int32_t>(
            kQ15One, max<int32_t>(-kQ15One, delayInput));
        if (++m_delayDownsamplePhase >= 4) {
          m_delayDownsamplePhase = 0;
          int32_t writeValue = m_delayInputAccum >> 2;
          m_delayInputAccum = 0;
          if (m_delayPreLpf != 0) {
            const uint8_t shift = static_cast<uint8_t>(
                1u + min<uint8_t>(6, m_delayPreLpf));
            m_delayLowpassQ15 += (writeValue - m_delayLowpassQ15) >> shift;
            writeValue = m_delayLowpassQ15;
          }
          writeValue += (((delayLeft + delayRight) >> 1) *
                         m_delayFeedbackQ15) >> 15;
          m_delayBuffer[m_delayWriteIndex] = static_cast<int16_t>(
              min<int32_t>(32767, max<int32_t>(-32768, writeValue)));
          m_delayWriteIndex = (m_delayWriteIndex + 1u) & (kDelayFrames - 1);
        }
        }
      }
      leftQ15 = min<int32_t>(kQ15One, max<int32_t>(-kQ15One, leftQ15));
      rightQ15 = min<int32_t>(kQ15One, max<int32_t>(-kQ15One, rightQ15));
      framesStereo[frame] = packStereoFrame(
          static_cast<int16_t>(leftQ15), static_cast<int16_t>(rightQ15));
  }
#if SYNTH_RENDER_PROFILE_CORE1_CLOCK_PROBE
  (void)esp_cpu_get_cycle_count();
#endif
#if SYNTH_RENDER_PROFILING
  const uint32_t profileFxoutCycles =
      RENDER_PROFILE_CCOUNT() - profileFxoutStartCycles;
#if SYNTH_RENDER_PROFILE_ACCUMULATION
  RenderProfileStats& renderProfile = rendererProfile.render;
  ++renderProfile.phaseCount;
  renderProfile.prepCycleTotal += profilePrepCycles;
  renderProfile.mainCycleTotal += mainCycles;
  renderProfile.waitCycleTotal += waitCycles;
  renderProfile.mergeCycleTotal += profileMergeCycles;
  renderProfile.fxoutCycleTotal += profileFxoutCycles;
  if (profilePrepCycles > renderProfile.prepCycleMax) {
    renderProfile.prepCycleMax = profilePrepCycles;
  }
  if (mainCycles > renderProfile.mainCycleMax) {
    renderProfile.mainCycleMax = mainCycles;
  }
  if (waitCycles > renderProfile.waitCycleMax) {
    renderProfile.waitCycleMax = waitCycles;
  }
  if (profileMergeCycles > renderProfile.mergeCycleMax) {
    renderProfile.mergeCycleMax = profileMergeCycles;
  }
  if (profileFxoutCycles > renderProfile.fxoutCycleMax) {
    renderProfile.fxoutCycleMax = profileFxoutCycles;
  }
#else
  (void)profileFxoutCycles;
#endif
#if SYNTH_RENDER_PROFILE_BANK_HANDSHAKE
  __atomic_store_n(
      &m_mainProfileWriterBank, kProfileWriterIdle, __ATOMIC_RELEASE);
#endif
#endif
  return frameCount;
}

int32_t App::fillAudioBuffer(uint8_t* data, int32_t len) {
  if (len <= 0) {
    return 0;
  }

  const uint32_t nowUs = micros();
  const uint32_t previousUs = m_btDataCbLastUs;
  m_btDataCbLastUs = nowUs;
  if (previousUs != 0) {
    const uint32_t gapUs = nowUs - previousUs;
    if (gapUs > m_btDataCbGapMaxUs) {
      m_btDataCbGapMaxUs = gapUs;
    }
    if (gapUs > 30000U) {
      ++m_btDataCbLateCount;
    } else if (gapUs < 2000U) {
      ++m_btDataCbBurstCount;
    }
  }
  ++m_btDataCbCount;
  m_btDataCbBytes += static_cast<uint32_t>(len);

  const int32_t frameCount = len / 4;
  uint32_t* __restrict samples = reinterpret_cast<uint32_t*>(data);

  const bool previewActive =
      m_previewVoiceIndex >= 0 &&
      m_previewVoiceIndex < kMaxVoices &&
      m_voices[m_previewVoiceIndex].hotCore.active;
  const bool expectStreaming =
      m_a2dpConnected &&
      m_audioStarted &&
      (previewActive || (m_playing && m_songLoaded));

  const size_t bufferedFrames = bufferedAudioFrames();
  const uint32_t bufferedFrames32 = static_cast<uint32_t>(bufferedFrames);
  if (bufferedFrames32 < m_btDataCbMinReadableFrames) {
    m_btDataCbMinReadableFrames = bufferedFrames32;
  }
  if (bufferedFrames32 > m_btDataCbMaxReadableFrames) {
    m_btDataCbMaxReadableFrames = bufferedFrames32;
  }

  const size_t readableFrames =
      min(static_cast<size_t>(frameCount), bufferedFrames);
  if (expectStreaming && readableFrames == 0) {
    ++m_audioUnderrunCount;
  } else if (expectStreaming && readableFrames < static_cast<size_t>(frameCount)) {
    ++m_audioUnderrunCount;
  }
  const size_t readFrame =
      __atomic_load_n(&m_audioRingReadFrame, __ATOMIC_RELAXED);
  const size_t firstFrames = min(readableFrames, kAudioRingFrames - readFrame);
  const size_t secondFrames = readableFrames - firstFrames;
  if (firstFrames > 0) {
    const uint32_t* __restrict firstSrc = &m_audioRingBuffer[readFrame];
#if APP_USE_32BIT_IRAM_AUDIO_BUFFERS
    for (size_t frame = 0; frame < firstFrames; ++frame) {
      samples[frame] = firstSrc[frame];
    }
#else
    memcpy(samples, firstSrc, firstFrames * sizeof(uint32_t));
#endif
    m_lastStreamFrame = firstSrc[firstFrames - 1];
  }
  if (secondFrames > 0) {
    const uint32_t* __restrict secondSrc = &m_audioRingBuffer[0];
#if APP_USE_32BIT_IRAM_AUDIO_BUFFERS
    for (size_t frame = 0; frame < secondFrames; ++frame) {
      samples[firstFrames + frame] = secondSrc[frame];
    }
#else
    memcpy(&samples[firstFrames], secondSrc, secondFrames * sizeof(uint32_t));
#endif
    m_lastStreamFrame = secondSrc[secondFrames - 1];
  }
  for (int32_t frame = static_cast<int32_t>(readableFrames); frame < frameCount; ++frame) {
    samples[frame] = m_lastStreamFrame;
  }
  __atomic_store_n(
      &m_audioRingReadFrame,
      (readFrame + readableFrames) & (kAudioRingFrames - 1),
      __ATOMIC_RELEASE);
  const size_t remainingFrames = bufferedFrames - readableFrames;
  if (remainingFrames <= kAudioRingLowWaterFrames &&
      m_renderTaskHandle != nullptr) {
    ++m_renderNotifyCount;
    xTaskNotifyGive(m_renderTaskHandle);
  }

  return len;
}