Wave for CQ converter

While there is a lot of audio converter available to get audio file converted into compatible CQ USB playback settings, I developed mine.

It is simple, straight forward and no fancy setting or options (appart form 16 or 24 bits audio).
Just select your audio files and convert.

Available online here:

Or you can make it a local html, just copy the code below and save it as an .html file.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Studio WAV Converter β€’ 48 kHz</title>
  <style>
    :root {
      --bg-dark: #061326;
      --bg-mid: #0b2447;
      --glass-bg: rgba(16, 46, 88, 0.58);
      --glass-border: rgba(110, 185, 255, 0.28);
      --accent-cyan: #38bdf8;
      --accent-blue: #0284c7;
      --text-main: #f0f8ff;
      --text-muted: #93c5fd;
    }

    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
    }

    body {
      font-family: 'Segoe UI', system-ui, -apple-system, sans-serif;
      background: radial-gradient(circle at 20% 15%, #164e87 0%, var(--bg-mid) 45%, var(--bg-dark) 100%);
      color: var(--text-main);
      min-height: 100vh;
      display: flex;
      justify-content: center;
      align-items: center;
      padding: 20px 16px;
    }

    .container {
      width: 96vw;
      min-width: 420px;
      max-width: 1500px;
      resize: horizontal;
      overflow: auto;
      background: var(--glass-bg);
      backdrop-filter: blur(18px);
      -webkit-backdrop-filter: blur(18px);
      border: 1px solid var(--glass-border);
      border-radius: 24px;
      padding: 24px 28px;
      box-shadow:
        0 25px 50px -12px rgba(0, 0, 0, 0.65),
        inset 0 1px 1px rgba(255, 255, 255, 0.25);
    }

    header {
      text-align: center;
      margin-bottom: 16px;
    }

    h1 {
      font-size: 1.65rem;
      font-weight: 700;
      letter-spacing: -0.02em;
      background: linear-gradient(180deg, #ffffff 0%, #7dd3fc 100%);
      -webkit-background-clip: text;
      -webkit-text-fill-color: transparent;
      text-shadow: 0 2px 15px rgba(56, 189, 248, 0.3);
    }

    .subtitle {
      color: var(--text-muted);
      font-size: 0.84rem;
      margin-top: 3px;
    }

    /* Drop Zone */
    .drop-zone {
      border: 2px dashed rgba(56, 189, 248, 0.45);
      border-radius: 14px;
      padding: 14px 16px;
      text-align: center;
      cursor: pointer;
      background: linear-gradient(180deg, rgba(255, 255, 255, 0.06) 0%, rgba(2, 132, 199, 0.08) 100%);
      transition: all 0.25s ease;
    }

    .drop-zone:hover, .drop-zone.dragover {
      border-color: var(--accent-cyan);
      background: linear-gradient(180deg, rgba(56, 189, 248, 0.16) 0%, rgba(2, 132, 199, 0.22) 100%);
      box-shadow: 0 0 20px rgba(56, 189, 248, 0.22);
    }

    .drop-zone strong {
      color: #fff;
      font-size: 0.92rem;
      display: block;
    }

    .drop-zone span {
      display: block;
      font-size: 0.76rem;
      color: var(--text-muted);
      margin-top: 2px;
    }

    /* Online URL Bar */
    .url-bar {
      display: flex;
      gap: 10px;
      margin-top: 10px;
    }

    .url-input {
      flex: 1;
      padding: 8px 13px;
      border-radius: 11px;
      border: 1px solid rgba(125, 211, 252, 0.28);
      background: rgba(6, 22, 46, 0.65);
      color: #fff;
      font-size: 0.84rem;
      outline: none;
      transition: border-color 0.2s, box-shadow 0.2s;
    }

    .url-input::placeholder {
      color: rgba(147, 197, 253, 0.55);
    }

    .url-input:focus {
      border-color: var(--accent-cyan);
      box-shadow: 0 0 12px rgba(56, 189, 248, 0.25);
    }

    /* Controls Bar */
    .controls-bar {
      display: flex;
      flex-wrap: wrap;
      justify-content: space-between;
      align-items: center;
      gap: 12px;
      margin-top: 12px;
      padding: 10px 14px;
      background: rgba(6, 22, 46, 0.55);
      border: 1px solid rgba(125, 211, 252, 0.18);
      border-radius: 13px;
    }

    .bit-selector {
      display: flex;
      align-items: center;
      gap: 10px;
    }

    .bit-selector label {
      font-size: 0.82rem;
      color: var(--text-muted);
      font-weight: 500;
    }

    .segmented-control {
      display: inline-flex;
      background: rgba(0, 0, 0, 0.35);
      padding: 3px;
      border-radius: 10px;
      border: 1px solid rgba(255, 255, 255, 0.1);
    }

    .segmented-control input {
      display: none;
    }

    .segmented-control label {
      padding: 5px 12px;
      border-radius: 7px;
      cursor: pointer;
      font-size: 0.8rem;
      font-weight: 600;
      color: var(--text-muted);
      transition: all 0.2s ease;
    }

    .segmented-control input:checked + label {
      background: linear-gradient(180deg, #38bdf8 0%, #0284c7 100%);
      color: #fff;
      box-shadow:
        0 3px 10px rgba(2, 132, 199, 0.5),
        inset 0 1px 0 rgba(255, 255, 255, 0.45);
    }

    /* Glossy Buttons */
    .btn-group {
      display: flex;
      gap: 8px;
      flex-wrap: wrap;
    }

    .btn-glossy {
      border: none;
      border-radius: 10px;
      padding: 8px 15px;
      font-size: 0.82rem;
      font-weight: 600;
      color: #fff;
      cursor: pointer;
      position: relative;
      overflow: hidden;
      background: linear-gradient(180deg, #38bdf8 0%, #0284c7 52%, #0369a1 100%);
      box-shadow:
        0 5px 15px rgba(2, 132, 199, 0.42),
        inset 0 1px 1px rgba(255, 255, 255, 0.55);
      transition: all 0.2s ease;
      white-space: nowrap;
    }

    .btn-glossy::after {
      content: '';
      position: absolute;
      top: 0;
      left: 0;
      right: 0;
      height: 48%;
      background: linear-gradient(180deg, rgba(255, 255, 255, 0.28) 0%, rgba(255, 255, 255, 0.04) 100%);
      pointer-events: none;
    }

    .btn-glossy:hover:not(:disabled) {
      transform: translateY(-1px);
      box-shadow:
        0 7px 18px rgba(56, 189, 248, 0.55),
        inset 0 1px 1px rgba(255, 255, 255, 0.7);
    }

    .btn-glossy:disabled {
      opacity: 0.45;
      cursor: not-allowed;
      box-shadow: none;
    }

    .btn-secondary {
      background: linear-gradient(180deg, rgba(255, 255, 255, 0.14) 0%, rgba(255, 255, 255, 0.05) 100%);
      border: 1px solid rgba(125, 211, 252, 0.3);
      box-shadow: none;
    }

    /* Progress Bar */
    .progress-wrapper {
      display: none;
      margin-top: 10px;
      padding: 8px 12px;
      border-radius: 11px;
      background: rgba(6, 22, 46, 0.65);
      border: 1px solid rgba(56, 189, 248, 0.25);
    }

    .progress-wrapper.active {
      display: block;
    }

    .progress-info {
      display: flex;
      justify-content: space-between;
      font-size: 0.74rem;
      color: var(--text-muted);
      margin-bottom: 5px;
    }

    .progress-track {
      width: 100%;
      height: 7px;
      border-radius: 999px;
      background: rgba(255, 255, 255, 0.1);
      overflow: hidden;
    }

    .progress-fill {
      width: 0%;
      height: 100%;
      border-radius: 999px;
      background: linear-gradient(90deg, #0284c7 0%, #38bdf8 100%);
      box-shadow: 0 0 10px rgba(56, 189, 248, 0.5);
      transition: width 0.12s ease;
    }

    /* Single-Window Playlist Box */
    .playlist-header {
      display: flex;
      justify-content: space-between;
      align-items: center;
      margin: 14px 0 6px;
      padding: 0 4px;
    }

    .playlist-header h2 {
      font-size: 0.88rem;
      font-weight: 600;
      color: var(--text-muted);
    }

    .playlist-window {
      height: 880px;
      overflow-y: auto;
      background: rgba(4, 16, 35, 0.36);
      border: 1px solid rgba(125, 211, 252, 0.15);
      border-radius: 14px;
      padding: 4px 12px;
    }

    .playlist-window::-webkit-scrollbar {
      width: 7px;
    }

    .playlist-window::-webkit-scrollbar-track {
      background: rgba(6, 22, 46, 0.35);
      border-radius: 10px;
    }

    .playlist-window::-webkit-scrollbar-thumb {
      background: rgba(56, 189, 248, 0.38);
      border-radius: 10px;
    }

    .playlist {
      list-style: none;
      display: flex;
      flex-direction: column;
    }

    .playlist-empty {
      text-align: center;
      padding: 390px 12px;
      color: rgba(147, 197, 253, 0.6);
      font-size: 0.84rem;
    }

    /* Flat 2-Line Track Row */
    .track-item {
      display: flex;
      flex-direction: column;
      gap: 3px;
      padding: 7px 2px;
      border-bottom: 1px solid rgba(125, 211, 252, 0.11);
      transition: background 0.15s ease;
    }

    .track-item:last-child {
      border-bottom: none;
    }

    .track-item:hover {
      background: rgba(56, 189, 248, 0.05);
    }

    .track-row-top {
      display: flex;
      align-items: center;
      justify-content: space-between;
      gap: 8px;
    }

    .track-name {
      font-weight: 500;
      font-size: 0.78rem;
      white-space: nowrap;
      overflow: hidden;
      text-overflow: ellipsis;
      color: #e2f1ff;
    }

    .track-source-tag {
      font-size: 0.66rem;
      padding: 1px 6px;
      border-radius: 4px;
      background: rgba(56, 189, 248, 0.14);
      color: #7dd3fc;
      flex-shrink: 0;
    }

    .track-row-bottom {
      display: flex;
      align-items: center;
      justify-content: space-between;
      gap: 8px;
    }

    .track-meta {
      font-size: 0.7rem;
      color: rgba(147, 197, 253, 0.75);
      white-space: nowrap;
      overflow: hidden;
      text-overflow: ellipsis;
    }

    .track-actions {
      display: flex;
      align-items: center;
      gap: 6px;
      flex-shrink: 0;
    }

    /* Compact Status Badges */
    .badge {
      padding: 2px 7px;
      border-radius: 10px;
      font-size: 0.68rem;
      font-weight: 600;
      display: inline-flex;
      align-items: center;
      gap: 4px;
    }

    .badge-pending {
      background: rgba(148, 163, 184, 0.15);
      color: #cbd5e1;
    }

    .badge-processing {
      background: rgba(56, 189, 248, 0.18);
      color: #7dd3fc;
    }

    .badge-done {
      background: rgba(16, 185, 129, 0.18);
      color: #6ee7b7;
    }

    .badge-error {
      background: rgba(244, 63, 94, 0.18);
      color: #fda4af;
    }

    .spinner {
      width: 9px;
      height: 9px;
      border: 2px solid rgba(125, 211, 252, 0.3);
      border-top-color: #38bdf8;
      border-radius: 50%;
      animation: spin 0.8s linear infinite;
    }

    @keyframes spin {
      to { transform: rotate(360deg); }
    }

    .btn-dl {
      border: none;
      cursor: pointer;
      padding: 2px 8px;
      border-radius: 6px;
      font-size: 0.7rem;
      font-weight: 600;
      color: #fff;
      background: linear-gradient(180deg, #0ea5e9 0%, #0369a1 100%);
      transition: all 0.15s ease;
    }

    .btn-dl:hover {
      background: linear-gradient(180deg, #38bdf8 0%, #0284c7 100%);
    }

    .btn-remove {
      background: none;
      border: none;
      color: rgba(147, 197, 253, 0.5);
      cursor: pointer;
      font-size: 0.82rem;
      padding: 0 3px;
      line-height: 1;
      transition: color 0.15s;
    }

    .btn-remove:hover {
      color: #fda4af;
    }
  </style>
</head>
<body>

  <div class="container">
    <header>
      <h1>Studio WAV Converter</h1>
      <p class="subtitle">Local & Online Audio to PCM WAV β€’ 48 kHz</p>
    </header>

    <div class="drop-zone" id="dropZone">
      <strong>Drag & drop audio files here or click to browse</strong>
      <span>MP3, WAV, FLAC, OGG, M4A, AAC...</span>
      <input type="file" id="fileInput" accept="audio/*" multiple hidden>
    </div>

    <div class="url-bar">
      <input type="url" id="urlInput" class="url-input" placeholder="Paste online audio file URL (https://.../track.mp3)...">
      <button class="btn-glossy btn-secondary" id="addUrlBtn">+ Add URL</button>
    </div>

    <div class="controls-bar">
      <div class="bit-selector">
        <label>Output Format:</label>
        <div class="segmented-control">
          <input type="radio" name="bitDepth" id="bit16" value="16" checked>
          <label for="bit16">16-bit (S16LE)</label>

          <input type="radio" name="bitDepth" id="bit24" value="24">
          <label for="bit24">24-bit (S24LE)</label>
        </div>
      </div>

      <div class="btn-group">
        <button class="btn-glossy btn-secondary" id="clearBtn" disabled>Clear</button>
        <button class="btn-glossy btn-secondary" id="convertAllBtn" disabled>Convert All</button>
        <button class="btn-glossy" id="convertAndSaveBtn" disabled>Convert & Save...</button>
      </div>
    </div>

    <div class="progress-wrapper" id="progressWrapper">
      <div class="progress-info">
        <span id="progressLabel">Ready</span>
        <span id="progressPercent">0%</span>
      </div>
      <div class="progress-track">
        <div class="progress-fill" id="progressFill"></div>
      </div>
    </div>

    <div class="playlist-header">
      <h2 id="playlistTitle">Playlist (0 files)</h2>
      <button class="btn-glossy btn-secondary" id="downloadAllBtn" style="display:none; padding: 4px 11px; font-size: 0.74rem;">
        πŸ“ Save All to Folder...
      </button>
    </div>

    <div class="playlist-window">
      <ul class="playlist" id="playlist">
        <li class="playlist-empty">No files in the playlist yet.</li>
      </ul>
    </div>
  </div>

  <script>
    const dropZone = document.getElementById('dropZone');
    const fileInput = document.getElementById('fileInput');
    const urlInput = document.getElementById('urlInput');
    const addUrlBtn = document.getElementById('addUrlBtn');
    const playlistEl = document.getElementById('playlist');
    const playlistTitle = document.getElementById('playlistTitle');
    const convertAllBtn = document.getElementById('convertAllBtn');
    const convertAndSaveBtn = document.getElementById('convertAndSaveBtn');
    const clearBtn = document.getElementById('clearBtn');
    const downloadAllBtn = document.getElementById('downloadAllBtn');
    const progressWrapper = document.getElementById('progressWrapper');
    const progressLabel = document.getElementById('progressLabel');
    const progressPercent = document.getElementById('progressPercent');
    const progressFill = document.getElementById('progressFill');

    let tracks = [];

    function setProgress(current, total, text) {
      progressWrapper.classList.add('active');
      const pct = total > 0 ? Math.min(100, Math.round((current / total) * 100)) : 0;
      progressFill.style.width = `${pct}%`;
      progressPercent.textContent = `${pct}%`;
      progressLabel.textContent = text || `${current} / ${total}`;
    }

    function hideProgress() {
      progressWrapper.classList.remove('active');
      progressFill.style.width = '0%';
      progressPercent.textContent = '0%';
    }

    dropZone.addEventListener('click', () => fileInput.click());
    dropZone.addEventListener('dragover', (e) => {
      e.preventDefault();
      dropZone.classList.add('dragover');
    });
    dropZone.addEventListener('dragleave', () => dropZone.classList.remove('dragover'));
    dropZone.addEventListener('drop', (e) => {
      e.preventDefault();
      dropZone.classList.remove('dragover');
      addLocalFiles(e.dataTransfer.files);
    });
    fileInput.addEventListener('change', (e) => {
      addLocalFiles(e.target.files);
      fileInput.value = '';
    });

    addUrlBtn.addEventListener('click', addUrlTrack);
    urlInput.addEventListener('keydown', (e) => {
      if (e.key === 'Enter') addUrlTrack();
    });

    function addLocalFiles(fileList) {
      for (const file of fileList) {
        tracks.push({
          id: crypto.randomUUID(),
          sourceType: 'local',
          name: file.name,
          file,
          url: null,
          status: 'pending',
          blob: null,
          outputName: '',
          outputSize: '',
          savedToDisk: false,
          errorMsg: ''
        });
      }
      renderPlaylist();
    }

    function addUrlTrack() {
      const rawUrl = urlInput.value.trim();
      if (!rawUrl) return;

      let parsedName = 'online_audio';
      try {
        const u = new URL(rawUrl);
        const lastPart = decodeURIComponent(u.pathname.split('/').pop() || '');
        if (lastPart) parsedName = lastPart;
      } catch {}

      tracks.push({
        id: crypto.randomUUID(),
        sourceType: 'url',
        name: parsedName,
        file: null,
        url: rawUrl,
        status: 'pending',
        blob: null,
        outputName: '',
        outputSize: '',
        savedToDisk: false,
        errorMsg: ''
      });

      urlInput.value = '';
      renderPlaylist();
    }

    function removeTrack(id) {
      tracks = tracks.filter(t => t.id !== id);
      renderPlaylist();
    }

    clearBtn.addEventListener('click', () => {
      tracks = [];
      hideProgress();
      renderPlaylist();
    });

    function formatBytes(bytes) {
      if (!bytes) return '0 B';
      const k = 1024;
      const sizes = ['B', 'KB', 'MB', 'GB'];
      const i = Math.floor(Math.log(bytes) / Math.log(k));
      return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
    }

    function renderPlaylist() {
      playlistTitle.textContent = `Playlist (${tracks.length} file${tracks.length !== 1 ? 's' : ''})`;
      const hasTracks = tracks.length > 0;
      convertAllBtn.disabled = !hasTracks;
      convertAndSaveBtn.disabled = !hasTracks;
      clearBtn.disabled = !hasTracks;

      const unsavedDoneTracks = tracks.filter(t => t.status === 'done' && t.blob && !t.savedToDisk);
      downloadAllBtn.style.display = unsavedDoneTracks.length > 1 ? 'inline-block' : 'none';

      if (tracks.length === 0) {
        playlistEl.innerHTML = '<li class="playlist-empty">No files in the playlist yet.</li>';
        return;
      }

      playlistEl.innerHTML = '';
      tracks.forEach(track => {
        const li = document.createElement('li');
        li.className = 'track-item';

        let badgeHtml = '';
        if (track.status === 'pending') {
          badgeHtml = '<span class="badge badge-pending">Pending</span>';
        } else if (track.status === 'processing') {
          badgeHtml = '<span class="badge badge-processing"><span class="spinner"></span> Converting</span>';
        } else if (track.status === 'done') {
          badgeHtml = track.savedToDisk
            ? '<span class="badge badge-done">βœ” Saved</span>'
            : '<span class="badge badge-done">βœ” Done</span>';
        } else if (track.status === 'error') {
          badgeHtml = `<span class="badge badge-error" title="${track.errorMsg}">βœ– Error</span>`;
        }

        const downloadHtml = (track.status === 'done' && track.blob)
          ? `<button class="btn-dl" onclick="saveSingleTrack('${track.id}')">⬇ Save</button>`
          : '';

        const sourceBadge = track.sourceType === 'url'
          ? '<span class="track-source-tag" title="' + track.url + '">URL</span>'
          : '<span class="track-source-tag">Local</span>';

        const metaText = track.status === 'done'
          ? `WAV: ${track.outputSize} β€’ 48 kHz${track.savedToDisk ? ' β€’ Saved to folder' : ''}`
          : (track.status === 'error'
              ? track.errorMsg
              : (track.sourceType === 'local' ? `Size: ${formatBytes(track.file.size)}` : track.url));

        li.innerHTML = `
          <div class="track-row-top">
            <div class="track-name" title="${track.name}">${track.name}</div>
            ${sourceBadge}
          </div>
          <div class="track-row-bottom">
            <div class="track-meta" title="${metaText}">${metaText}</div>
            <div class="track-actions">
              ${badgeHtml}
              ${downloadHtml}
              <button class="btn-remove" title="Remove" onclick="removeTrack('${track.id}')">βœ•</button>
            </div>
          </div>
        `;
        playlistEl.appendChild(li);
      });
    }

    function fallbackDownload(blob, filename) {
      const url = URL.createObjectURL(blob);
      const a = document.createElement('a');
      a.href = url;
      a.download = filename;
      a.click();
      setTimeout(() => URL.revokeObjectURL(url), 1200);
    }

    async function saveSingleTrack(id) {
      const track = tracks.find(t => t.id === id);
      if (!track || !track.blob) return;

      if ('showSaveFilePicker' in window) {
        try {
          const handle = await window.showSaveFilePicker({
            suggestedName: track.outputName,
            types: [{
              description: 'WAV Audio File',
              accept: { 'audio/wav': ['.wav'] }
            }]
          });
          const writable = await handle.createWritable();
          await writable.write(track.blob);
          await writable.close();
          track.savedToDisk = true;
          renderPlaylist();
        } catch (err) {
          if (err.name !== 'AbortError') {
            fallbackDownload(track.blob, track.outputName);
          }
        }
      } else {
        fallbackDownload(track.blob, track.outputName);
      }
    }

    async function writeTrackToDir(dirHandle, track) {
      const fileHandle = await dirHandle.getFileHandle(track.outputName, { create: true });
      const writable = await fileHandle.createWritable();
      await writable.write(track.blob);
      await writable.close();
      track.savedToDisk = true;
    }

    downloadAllBtn.addEventListener('click', async () => {
      const doneTracks = tracks.filter(t => t.status === 'done' && t.blob && !t.savedToDisk);
      const total = doneTracks.length;
      if (!total) return;

      if ('showDirectoryPicker' in window) {
        try {
          const dirHandle = await window.showDirectoryPicker({ mode: 'readwrite' });
          downloadAllBtn.disabled = true;
          convertAllBtn.disabled = true;
          convertAndSaveBtn.disabled = true;
          clearBtn.disabled = true;

          let savedCount = 0;
          const concurrency = 4;
          setProgress(0, total, `Saving files... (0 / ${total})`);
          downloadAllBtn.textContent = `Saving 0 / ${total}...`;

          for (let i = 0; i < total; i += concurrency) {
            const batch = doneTracks.slice(i, i + concurrency);
            await Promise.all(batch.map(async (track) => {
              await writeTrackToDir(dirHandle, track);
              track.blob = null; // Free memory once written
              savedCount++;
              setProgress(savedCount, total, `Saving to folder... (${savedCount} / ${total})`);
              downloadAllBtn.textContent = `Saving ${savedCount} / ${total}...`;
            }));
          }

          renderPlaylist();
          setProgress(total, total, `All ${total} WAV files saved!`);
          downloadAllBtn.textContent = 'βœ” Saved!';
          setTimeout(() => {
            downloadAllBtn.textContent = 'πŸ“ Save All to Folder...';
            downloadAllBtn.disabled = false;
            convertAllBtn.disabled = false;
            convertAndSaveBtn.disabled = false;
            clearBtn.disabled = false;
          }, 2000);
        } catch (err) {
          downloadAllBtn.disabled = false;
          convertAllBtn.disabled = false;
          convertAndSaveBtn.disabled = false;
          clearBtn.disabled = false;
          downloadAllBtn.textContent = 'πŸ“ Save All to Folder...';
          if (err.name !== 'AbortError') {
            setProgress(0, total, 'Error saving files to folder.');
            alert('Unable to write to the selected folder.');
          } else {
            hideProgress();
          }
        }
      } else {
        setProgress(0, total, `Downloading files... (0 / ${total})`);
        doneTracks.forEach((track, index) => {
          setTimeout(() => {
            fallbackDownload(track.blob, track.outputName);
            const done = index + 1;
            setProgress(done, total, `Downloading... (${done} / ${total})`);
            if (done === total) {
              setTimeout(hideProgress, 2000);
            }
          }, index * 120);
        });
      }
    });

    async function getSourceArrayBuffer(track) {
      if (track.sourceType === 'local') {
        return await track.file.arrayBuffer();
      }
      const response = await fetch(track.url);
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }
      return await response.arrayBuffer();
    }

    async function convertSingleTrack(track, audioCtx, bitDepth) {
      const arrayBuffer = await getSourceArrayBuffer(track);
      const audioBuffer = await audioCtx.decodeAudioData(arrayBuffer);

      const targetRate = 48000;
      const length = Math.ceil(audioBuffer.duration * targetRate);
      const offlineCtx = new OfflineAudioContext(audioBuffer.numberOfChannels, length, targetRate);

      const source = offlineCtx.createBufferSource();
      source.buffer = audioBuffer;
      source.connect(offlineCtx.destination);
      source.start();

      const renderedBuffer = await offlineCtx.startRendering();
      const wavBlob = encodeWavPCM(renderedBuffer, bitDepth);

      track.outputName = track.name.replace(/\.[^/.]+$/, '') + `_48k_${bitDepth}bit.wav`;
      track.outputSize = formatBytes(wavBlob.size);
      track.blob = wavBlob;
      track.status = 'done';
    }

    convertAllBtn.addEventListener('click', async () => {
      const bitDepth = parseInt(document.querySelector('input[name="bitDepth"]:checked').value, 10);
      const total = tracks.length;
      convertAllBtn.disabled = true;
      convertAndSaveBtn.disabled = true;
      clearBtn.disabled = true;
      downloadAllBtn.disabled = true;

      const audioCtx = new AudioContext();
      let processedCount = 0;
      setProgress(0, total, `Converting... (0 / ${total})`);

      for (let idx = 0; idx < tracks.length; idx++) {
        const track = tracks[idx];
        track.blob = null;
        track.savedToDisk = false;
        track.status = 'processing';
        setProgress(processedCount, total, `Converting: ${track.name} (${processedCount + 1} / ${total})`);

        if (total <= 15 || idx % 5 === 0) {
          renderPlaylist();
        }

        try {
          await convertSingleTrack(track, audioCtx, bitDepth);
        } catch (err) {
          track.status = 'error';
          track.errorMsg = track.sourceType === 'url'
            ? 'CORS blocked, unreachable URL, or unsupported audio format'
            : 'Audio format not supported by this browser';
        }

        processedCount++;
        setProgress(processedCount, total, `Converted ${processedCount} / ${total}`);
      }

      renderPlaylist();
      await audioCtx.close();
      setProgress(total, total, `Conversion complete (${total} / ${total})`);
      convertAllBtn.disabled = false;
      convertAndSaveBtn.disabled = false;
      clearBtn.disabled = false;
      downloadAllBtn.disabled = false;
    });

    convertAndSaveBtn.addEventListener('click', async () => {
      const bitDepth = parseInt(document.querySelector('input[name="bitDepth"]:checked').value, 10);
      const total = tracks.length;
      if (!total) return;

      let dirHandle = null;
      if ('showDirectoryPicker' in window) {
        try {
          dirHandle = await window.showDirectoryPicker({ mode: 'readwrite' });
        } catch (err) {
          if (err.name === 'AbortError') return;
        }
      }

      convertAllBtn.disabled = true;
      convertAndSaveBtn.disabled = true;
      clearBtn.disabled = true;
      downloadAllBtn.disabled = true;

      const audioCtx = new AudioContext();
      let doneCount = 0;
      setProgress(0, total, `Converting & saving... (0 / ${total})`);

      for (let idx = 0; idx < tracks.length; idx++) {
        const track = tracks[idx];
        track.blob = null;
        track.savedToDisk = false;
        track.status = 'processing';
        setProgress(doneCount, total, `Converting & saving: ${track.name} (${idx + 1} / ${total})`);

        if (total <= 15 || idx % 5 === 0) {
          renderPlaylist();
        }

        try {
          await convertSingleTrack(track, audioCtx, bitDepth);
          if (dirHandle) {
            await writeTrackToDir(dirHandle, track);
            track.blob = null; // Release RAM immediately after saving to folder
          } else {
            fallbackDownload(track.blob, track.outputName);
            track.savedToDisk = true;
          }
        } catch (err) {
          track.status = 'error';
          track.errorMsg = track.sourceType === 'url'
            ? 'CORS blocked, unreachable URL, or unsupported audio format'
            : 'Audio format not supported by this browser';
        }

        doneCount++;
        setProgress(doneCount, total, `Converted & saved ${doneCount} / ${total}`);
      }

      renderPlaylist();
      await audioCtx.close();
      setProgress(total, total, `Done! (${total} / ${total})`);
      convertAllBtn.disabled = false;
      convertAndSaveBtn.disabled = false;
      clearBtn.disabled = false;
      downloadAllBtn.disabled = false;
    });

    function encodeWavPCM(buffer, bitDepth) {
      const numChannels = buffer.numberOfChannels;
      const sampleRate = buffer.sampleRate;
      const numSamples = buffer.length;
      const bytesPerSample = bitDepth / 8;
      const dataSize = numSamples * numChannels * bytesPerSample;
      const arrayBuffer = new ArrayBuffer(44 + dataSize);
      const view = new DataView(arrayBuffer);
      const uint8 = new Uint8Array(arrayBuffer);

      const writeStr = (offset, str) => {
        for (let i = 0; i < str.length; i++) uint8[offset + i] = str.charCodeAt(i);
      };

      writeStr(0, 'RIFF');
      view.setUint32(4, 36 + dataSize, true);
      writeStr(8, 'WAVE');
      writeStr(12, 'fmt ');
      view.setUint32(16, 16, true);
      view.setUint16(20, 1, true);
      view.setUint16(22, numChannels, true);
      view.setUint32(24, sampleRate, true);
      view.setUint32(28, sampleRate * numChannels * bytesPerSample, true);
      view.setUint16(32, numChannels * bytesPerSample, true);
      view.setUint16(34, bitDepth, true);
      writeStr(36, 'data');
      view.setUint32(40, dataSize, true);

      let offset = 44;
      const channels = [];
      for (let c = 0; c < numChannels; c++) {
        channels.push(buffer.getChannelData(c));
      }

      for (let i = 0; i < numSamples; i++) {
        for (let c = 0; c < numChannels; c++) {
          let clamped = channels[c][i];
          if (clamped > 1) clamped = 1;
          else if (clamped < -1) clamped = -1;

          if (bitDepth === 16) {
            const sample = clamped < 0 ? (clamped * 0x8000) | 0 : (clamped * 0x7FFF) | 0;
            uint8[offset] = sample & 0xFF;
            uint8[offset + 1] = (sample >>> 8) & 0xFF;
            offset += 2;
          } else if (bitDepth === 24) {
            const sample = clamped < 0 ? (clamped * 0x800000) | 0 : (clamped * 0x7FFFFF) | 0;
            uint8[offset] = sample & 0xFF;
            uint8[offset + 1] = (sample >>> 8) & 0xFF;
            uint8[offset + 2] = (sample >>> 16) & 0xFF;
            offset += 3;
          }
        }
      }

      return new Blob([arrayBuffer], { type: 'audio/wav' });
    }
  </script>
</body>
</html>

Made with the help of AI.