Adopt C++17 as the global Jamulus language-standard baseline

[coderabbitai]

Summary

Move Jamulus to a C++17 language-standard baseline on every supported platform.

The current configuration is inconsistent. Jamulus.pro enables C++17 for Windows and Android, but its Unix branch still enables C++11. The project documentation still requires C++11 compatibility.

This migration must be completed in a separate change from PR #3787.

Required changes

1. Update Jamulus.pro.

   • Replace the Unix CONFIG += c++11 setting at Lines 311-313 with C++17.
   • Remove the platform-specific C++17 selection at Lines 106-108 and Lines 271-274 if the global C++17 setting makes those branches redundant.
   • Keep all existing non-language-standard platform configuration unchanged.
   • Confirm that qmake passes the C++17 language-standard option for Windows, Linux, macOS, iOS, and Android.

2. Update the contributor policy.

   • Replace Maintain C++11 compatibility throughout the code. in CONTRIBUTING.md with the C++17 baseline requirement.
   • Replace the C++11/Android exception in AGENTS.md with the C++17 baseline requirement.

3. Review project-owned build instructions and automation.

   • Review COMPILING.md, platform deployment scripts, and GitHub Actions workflows.
   • Document any minimum compiler, Xcode, MSVC, Android NDK, or Qt toolchain version that is necessary for C++17.
   • Update the affected instructions and CI setup when an existing supported toolchain cannot compile C++17.
   • Do not modify language-standard settings inside vendored dependencies under libs/ unless a dependency build is directly invoked by Jamulus and requires an explicit compatible setting.

4. Validate the supported build matrix.

   • Run or confirm CI builds for Linux, Windows, macOS, iOS, and Android with the global C++17 setting.
   • Confirm both reverb-enabled and CONFIG+=noreverb configurations compile where applicable.
   • Record any platform that needs a separate compatibility decision.

Rationale

src/plugins/audioreverb.h in PR #3787 uses a C++17 inline variable. A global C++17 baseline removes the Unix language-standard mismatch and allows the project to use one documented standard.

Acceptance criteria

• Jamulus.pro selects C++17 for all Jamulus targets.
• No project-owned document states that C++11 compatibility is required.
• The supported-platform build documentation states the required C++17-capable toolchains.
• The CI matrix completes successfully on all supported platforms.
• Vendored dependency configuration remains unchanged unless it is necessary for a Jamulus build.

References

• PR Use MVerb by Martin Eastwood for reverberation #3787: Use MVerb by Martin Eastwood for reverberation #3787
• Review comment: Use MVerb by Martin Eastwood for reverberation #3787 (comment)
• Requested by @ann0see.

[ann0see]

There's probably way more than just upgrading Float2Short's handrolled parts to std::clamp in the code. Investigate where we can refactor @coderabbitai, @claude

[coderabbitai]

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '=== Issue `#3938` ==='
gh issue view 3938 --repo jamulussoftware/jamulus --comments

echo '=== Candidate source files ==='
fd -t f -e cpp -e h -e mm -e cxx . | sed -n '1,240p'

echo '=== Float2Short and existing std::clamp uses ==='
rg -n -C 5 --glob '*.{cpp,h,mm,cxx}' \
  '\bFloat2Short\b|\bstd::clamp\s*\(' .

echo '=== Likely manual clamp forms ==='
rg -n -C 3 --glob '*.{cpp,h,mm,cxx}' \
  '(\bqMin\s*\(|\bqMax\s*\(|\bstd::min\s*\(|\bstd::max\s*\(|\bMin\s*\(|\bMax\s*\(|\?.*:\s*|if\s*\([^)]*(>|<|>=|<=))' .

Length of output: 169747

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '=== Issue metadata ==='
gh issue view 3938 --repo jamulussoftware/jamulus --json number,title,body,url,comments \
  --jq '.number, .title, .url, .body, (.comments[] | "\(.author.login): \(.body)")'

echo '=== Declared C++ language standard ==='
rg -n -C 2 --glob 'CMakeLists.txt' --glob '*.cmake' \
  'CMAKE_CXX_STANDARD|cxx_std_|C\+\+17|C\+\+20|CXX_STANDARD' . \
  -g '!libs/**'

echo '=== Float2Short definitions and uses ==='
rg -n -C 8 --glob '*.{cpp,h,mm,cxx}' '\bFloat2Short\b' . -g '!libs/**'

echo '=== Two-sided min/max clamps ==='
rg -n -C 5 --glob '*.{cpp,h,mm,cxx}' \
  '(std::min\s*\([^;\n]*std::max|std::max\s*\([^;\n]*std::min|qMin\s*\([^;\n]*qMax|qMax\s*\([^;\n]*qMin)' \
  . -g '!libs/**'

echo '=== Adjacent assignment-bound pairs ==='
rg -n -U -C 2 --glob '*.{cpp,h,mm,cxx}' \
  'if\s*\([^)]*>\s*[^)]*\)\s*\{\s*\n\s*[A-Za-z_][A-Za-z0-9_]*\s*=\s*[^;]+;\s*\n\s*\}\s*\n\s*if\s*\([^)]*<\s*[^)]*\)' \
  . -g '!libs/**'

echo '=== Upper or lower bound assignment candidates ==='
rg -n -C 4 --glob '*.{cpp,h,mm,cxx}' \
  '(if\s*\([^)]*(>|<)=?\s*[^)]*\)\s*\{\s*$|=\s*(MAX_|MIN_|[A-Za-z_][A-Za-z0-9_]*\.(lMaxSize|lMinSize)))' \
  src -g '!libs/**'

Length of output: 4623

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '=== qmake language standard settings ==='
rg -n -C 3 'CONFIG\s*\+=\s*c\+\+|QMAKE_CXXFLAGS.*std=' Jamulus.pro || true

echo '=== Float2Short ==='
rg -n -C 10 --glob '*.{cpp,h,mm,cxx}' '\bFloat2Short\b' src || true

echo '=== Nested standard/Qt min-max clamps in first-party code ==='
rg -n -C 6 --glob '*.{cpp,h,mm,cxx}' \
  '(std::min\s*\([^;\n]*std::max|std::max\s*\([^;\n]*std::min|qMin\s*\([^;\n]*qMax|qMax\s*\([^;\n]*qMin)' \
  src || true

echo '=== Named limit assignments in first-party code ==='
rg -n -C 6 --glob '*.{cpp,h,mm,cxx}' \
  '(=\s*(MAX|MIN)_[A-Z0-9_]+|=\s*[A-Za-z_][A-Za-z0-9_]*\.(lMaxSize|lMinSize))' \
  src || true

echo '=== Manual extrema updates in first-party code ==='
rg -n -C 4 --glob '*.{cpp,h,mm,cxx}' \
  'if\s*\(\s*[A-Za-z_][A-Za-z0-9_]*\s*(>|<)=?\s*[A-Za-z_][A-Za-z0-9_]*\s*\)\s*$' \
  src || true

echo '=== Manual bound assignment contexts in audio backends ==='
sed -n '180,215p;340,440p;700,790p' src/sound/asio/sound.cpp
sed -n '485,515p' src/sound/coreaudio-mac/sound.cpp

Length of output: 77497

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '=== Float2Short implementation and includes ==='
sed -n '1,145p' src/util.h

echo '=== First-party min/max calls ==='
rg -n -C 5 --glob '*.{cpp,h,mm,cxx}' \
  '\b(std::min|std::max|fmin|fmax|qMin|qMax)\s*\(' src || true

echo '=== Exact candidate implementations ==='
sed -n '505,535p;590,615p;890,920p' src/client.cpp
sed -n '165,205p' src/util.cpp
sed -n '550,590p;1600,1630p' src/audiomixerboard.cpp

Length of output: 25260

---

@ann0see, I found several project-owned C++17 refactor candidates. Do not modify libs/opus; it is vendored code and Issue #3938 excludes it.

Use std::clamp

• src/util.h:116: Replace the two bound checks in Float2Short with std::clamp before the short conversion.
• src/channel.cpp:341: Replace the nested std::min and std::max pan bound with std::clamp ( fNewPan, 0.0f, 1.0f ).
• src/audiomixerboard.cpp:1726: Replace fmin ( fmax ( newFaderLevel, 0.0f ), ... ) with std::clamp.

Simplify one-sided bounds with std::min

• src/sound/asio/sound.cpp:199-205: Limit input and output channel counts with std::min.
• src/sound/coreaudio-mac/sound.cpp:502-508: Apply the same refactor for CoreAudio channel counts.
• src/sound/asio/sound.cpp:431-434: Replace the final upper-bound correction for iTrialBufSize with std::min.

Simplify extrema updates

• src/client.cpp:525-528 and src/client.cpp:606-609: Use std::min and std::max for minGainOrPanId and maxGainOrPanId.
• src/connectdlg.cpp:905-908: Use std::min for the minimum ping-time update.
• src/util.cpp:191-198: Return std::max ( dCurLevel, dMax ) after smoothing.

Keep the existing specialized logic

Do not replace the full ASIO buffer-size block at src/sound/asio/sound.cpp:353-437. Its outer checks are a clamp, but the remaining code selects a valid size from ASIO granularity rules. A direct std::clamp replacement would lose that behavior.

Also review fmin and fmax replacements separately. fmin and fmax define NaN behavior that differs from std::min, std::max, and std::clamp. The fader clamp is a clear candidate. The group-level fmin and fmax operations in src/audiomixerboard.cpp need an explicit NaN-input decision before conversion.

src/util.h already includes <algorithm>. Other changed translation units may need that include.

You are interacting with an AI system.

[ann0see]

@coderabbitai please have a look at more than just those std::clamp changes. There are probably more possibilities to clean up. State clearly what the gains are. Read the full codebase.

[coderabbitai]

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '=== Repository and build-language settings ==='
git status --short
printf '\n-- C++ standard settings --\n'
rg -n -C 3 --glob 'CMakeLists.txt' --glob '*.cmake' --glob '*.pro' \
  'CMAKE_CXX_STANDARD|CXX_STANDARD|cxx_std_|CONFIG\s*\+=\s*c\+\+' \
  . -g '!libs/**' || true

echo '=== Complete first-party source inventory ==='
python3 - <<'PY'
from pathlib import Path
from collections import Counter
root = Path('.')
excluded = {'libs', '.git', 'build', 'dist', 'node_modules'}
exts = {'.cpp', '.cc', '.cxx', '.h', '.hpp', '.mm', '.m', '.c'}
files = sorted(
    p for p in root.rglob('*')
    if p.is_file() and p.suffix.lower() in exts
    and not any(part in excluded for part in p.parts)
)
counts = Counter(p.suffix.lower() for p in files)
lines = 0
for p in files:
    try:
        lines += sum(1 for _ in p.open(encoding='utf-8', errors='replace'))
    except OSError:
        pass
print(f'files={len(files)} lines={lines} extensions={dict(sorted(counts.items()))}')
for p in files:
    print(p.as_posix())
PY

echo '=== Source outlines (complete first-party source directory) ==='
ast-grep outline src --items all --type class,struct,function,interface,enum --view compact 2>/dev/null || true

echo '=== Candidate cleanup patterns, excluding vendored code ==='
for label in \
  'C-style casts' \
  'NULL or zero null pointers' \
  'new/delete ownership' \
  'C arrays and sizeof-length calculations' \
  'manual loops with index variables' \
  'Qt foreach macro' \
  'manual lock/unlock' \
  'manual min/max bounds' \
  'duplicate literal string candidates' \
  'deprecated Qt containers or APIs'; do
  echo
  echo "--- $label ---"
  case "$label" in
    'C-style casts')
      rg -n -C 2 --glob '*.{cpp,cc,cxx,h,hpp,mm,m,c}' \
        '(?:\([[:alnum:]_:<>]+(?:\s*\*)?\)\s*[[:alnum:]_])' src -g '!libs/**' || true ;;
    'NULL or zero null pointers')
      rg -n -C 2 --glob '*.{cpp,cc,cxx,h,hpp,mm,m,c}' \
        '\bNULL\b|(?:==|!=|=)\s*0\s*(?:;|\)|,)' src -g '!libs/**' || true ;;
    'new/delete ownership')
      rg -n -C 3 --glob '*.{cpp,cc,cxx,h,hpp,mm,m,c}' \
        '\b(new|delete|delete\[\])\b' src -g '!libs/**' || true ;;
    'C arrays and sizeof-length calculations')
      rg -n -C 2 --glob '*.{cpp,cc,cxx,h,hpp,mm,m,c}' \
        'sizeof\s*\(|\[[A-Z_][A-Z0-9_]*\]' src -g '!libs/**' || true ;;
    'manual loops with index variables')
      rg -n -C 2 --glob '*.{cpp,cc,cxx,h,hpp,mm,m,c}' \
        '\b(for|while)\s*\([^)]*(int|unsigned|size_t|quint[0-9]+)\s+[A-Za-z_][A-Za-z0-9_]*\s*=' src -g '!libs/**' || true ;;
    'Qt foreach macro')
      rg -n -C 2 --glob '*.{cpp,cc,cxx,h,hpp,mm,m,c}' \
        '\bforeach\s*\(' src -g '!libs/**' || true ;;
    'manual lock/unlock')
      rg -n -C 3 --glob '*.{cpp,cc,cxx,h,hpp,mm,m,c}' \
        '\.(lock|unlock)\s*\(' src -g '!libs/**' || true ;;
    'manual min/max bounds')
      rg -n -C 2 --glob '*.{cpp,cc,cxx,h,hpp,mm,m,c}' \
        '\b(fmin|fmax|qMin|qMax|std::min|std::max)\s*\(|if\s*\([^)]*(<|>)=?[^)]*\)' src -g '!libs/**' || true ;;
    'duplicate literal string candidates')
      python3 - <<'PY'
from pathlib import Path
from collections import defaultdict
import re
d = defaultdict(list)
for p in Path('src').rglob('*'):
    if p.suffix not in {'.cpp','.cc','.cxx','.h','.hpp','.mm','.m','.c'} or not p.is_file():
        continue
    for n, line in enumerate(p.read_text(encoding='utf-8', errors='replace').splitlines(), 1):
        for s in re.findall(r'"([^"\\]*(?:\\.[^"\\]*)*)"', line):
            if len(s) >= 12:
                d[s].append((p.as_posix(), n))
for s, locs in sorted(d.items(), key=lambda x: (-len(x[1]), x[0])):
    if len(locs) >= 3:
        print(f'{len(locs)}x {s!r}: ' + ', '.join(f'{p}:{n}' for p,n in locs[:8]))
PY
      ;;
    'deprecated Qt containers or APIs')
      rg -n -C 2 --glob '*.{cpp,cc,cxx,h,hpp,mm,m,c}' \
        '\b(QLinkedList|QMutableListIterator|QDesktopWidget|QRegExp|QStringRef|QTime|qSort|qrand|qsrand)\b' src -g '!libs/**' || true ;;
  esac
done

Length of output: 141126

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '=== First-party source-tree totals ==='
python3 - <<'PY'
from pathlib import Path
from collections import Counter
exts={'.cpp','.cc','.cxx','.h','.hpp','.mm','.m','.c'}
files=sorted(p for p in Path('src').rglob('*') if p.is_file() and p.suffix.lower() in exts)
print(f'files: {len(files)}')
print(f'lines: {sum(sum(1 for _ in p.open(encoding="utf-8", errors="replace")) for p in files)}')
print('by extension:', dict(sorted(Counter(p.suffix.lower() for p in files).items())))
PY

echo '=== Lock scopes and QMutexLocker availability ==='
rg -n -C 10 --glob '*.{cpp,h,mm}' \
  '(QMutexLocker|Mutex(Channel|SocketBuf)?\.lock|ASIOMutex\.lock|ListViewMutex\.lock|Mutex\.lock)' \
  src/channel.cpp src/protocol.cpp src/serverdlg.cpp src/sound/asio/sound.cpp src/client.cpp || true

echo '=== CLI option parsing and settings serialization ==='
sed -n '180,720p' src/main.cpp
sed -n '1120,1250p' src/settings.cpp

echo '=== Duplicated update-server requests and window state restoration ==='
sed -n '410,475p;600,630p' src/clientdlg.cpp
sed -n '420,530p' src/serverdlg.cpp

echo '=== QTime deadline loops ==='
sed -n '875,925p' src/util.cpp
sed -n '1090,1130p' src/client.cpp
rg -n -C 3 --glob '*.{cpp,h,mm}' '\bQElapsedTimer\b|\bQDeadlineTimer\b' src || true

echo '=== CoreAudio opaque-handle null checks and initialization ==='
sed -n '55,110p;725,820p;870,900p;1100,1130p' src/sound/coreaudio-mac/sound.cpp
sed -n '1,220p' src/sound/coreaudio-mac/sound.h

echo '=== QObject allocation ownership contexts ==='
rg -n -C 8 --glob '*.{cpp,h,mm}' '\bnew\s+(Q[A-Za-z0-9_]+|C[A-Za-z0-9_]+)\s*\(' \
  src -g '!src/sound/asio/**' || true

echo '=== Exact and near-exact repeated first-party code blocks ==='
python3 - <<'PY'
from pathlib import Path
from collections import defaultdict
import re
exts={'.cpp','.cc','.cxx','.h','.hpp','.mm','.m','.c'}
blocks=defaultdict(list)
for p in Path('src').rglob('*'):
    if not p.is_file() or p.suffix.lower() not in exts:
        continue
    lines=p.read_text(encoding='utf-8', errors='replace').splitlines()
    # Five contiguous substantive lines. Normalize identifiers, numbers, and strings,
    # but retain calls/operators to locate structurally similar code.
    substantive=[(i+1,l.strip()) for i,l in enumerate(lines)
                 if l.strip() and not l.lstrip().startswith('//')]
    for j in range(len(substantive)-4):
        ns=[x[0] for x in substantive[j:j+5]]
        if ns[-1]-ns[0] > 12:
            continue
        text='\n'.join(x[1] for x in substantive[j:j+5])
        norm=re.sub(r'"(?:\\.|[^"])*"', '"S"', text)
        norm=re.sub(r'\b\d+(?:\.\d+)?\b', 'N', norm)
        norm=re.sub(r'\b[a-zA-Z_]\w*\b', lambda m: m.group(0) if m.group(0) in {
            'if','else','for','while','return','const','static','auto','true','false',
            'nullptr','new','delete','emit','sizeof','class','struct'} else 'ID', norm)
        blocks[norm].append((p.as_posix(), ns[0], ns[-1], text))
for _, group in sorted(blocks.items(), key=lambda item:(-len(item[1]), item[1][0][0])):
    locations={(p,a,b) for p,a,b,_ in group}
    files={p for p,_,_,_ in locations}
    if len(files) >= 2 and len(locations) >= 2:
        print(f'-- {len(locations)} occurrences in {len(files)} files --')
        for p,a,b,text in list(locations)[:5]:
            print(f'{p}:{a}-{b}\n{text}')
        print()
PY

Length of output: 147457

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '=== Recorder ownership declarations and implementations ==='
ast-grep outline src/recorder --items all --type class,struct,function --view compact 2>/dev/null || true
rg -n -C 12 --glob '*.{cpp,h}' \
  '(CJamClient::CJamClient|CJamClient::~CJamClient|CJamSession::CJamSession|CJamSession::~CJamSession|CJamRecorder::|wavFile|CWaveStream|currentSession|vecptrJamClients|jamClientConnections)' \
  src/recorder || true

echo '=== Client/server common base and update-request API ==='
rg -n -C 8 --glob '*.{cpp,h}' \
  '(class C(Client|Server)|class CClientServer|CreateCLServerListReqVerAndOSMes|IsIPv6Available)' \
  src/client.h src/server.h src/client.cpp src/server.cpp src/*.h || true

echo '=== Complete manual QMutex lock inventory ==='
python3 - <<'PY'
from pathlib import Path
import re
for p in sorted(Path('src').rglob('*')):
    if p.suffix not in {'.cpp','.h','.mm'} or not p.is_file():
        continue
    lines=p.read_text(encoding='utf-8',errors='replace').splitlines()
    locks=[]
    for n,line in enumerate(lines,1):
        m=re.search(r'\b([A-Za-z_]\w*)\.(lock|tryLock)\s*\(',line)
        if m:
            locks.append((n,m.group(1),m.group(2)))
    if locks:
        print(p)
        for n,name,kind in locks:
            end=min(n+70,len(lines))
            unlock=next((i for i in range(n,end+1) if re.search(rf'\b{re.escape(name)}\.unlock\s*\(',lines[i-1])),None)
            returns=[i for i in range(n,(unlock or end)+1) if re.search(r'\b(return|throw)\b',lines[i-1])]
            print(f'  Line {n}: {name}.{kind}; unlock={unlock}; exits_before_unlock={returns}')
PY

echo '=== MIDI mapping duplication and custom-event casts ==='
sed -n '235,310p;1110,1130p' src/sound/soundbase.cpp
sed -n '1645,1670p' src/server.cpp
rg -n -C 4 --glob '*.{cpp,h,mm}' \
  '\([A-Za-z_][A-Za-z0-9_:<>]*\s*\*\)\s*[A-Za-z_][A-Za-z0-9_]*' src -g '!libs/**' || true

echo '=== Corrected cross-file repeated code report ==='
python3 - <<'PY'
from pathlib import Path
from collections import defaultdict
import re
exts={'.cpp','.cc','.cxx','.h','.hpp','.mm','.m','.c'}
blocks=defaultdict(list)
keywords={'if','else','for','while','return','const','static','auto','true','false','nullptr','new','delete','emit','sizeof','class','struct'}
for p in Path('src').rglob('*'):
    if not p.is_file() or p.suffix.lower() not in exts:
        continue
    rows=[(i+1,l.strip()) for i,l in enumerate(p.read_text(encoding='utf-8',errors='replace').splitlines())
          if l.strip() and not l.lstrip().startswith('//')]
    for j in range(len(rows)-5):
        group=rows[j:j+6]
        if group[-1][0]-group[0][0]>14:
            continue
        text='\n'.join(line for _,line in group)
        norm=re.sub(r'"(?:\\.|[^"])*"', '"S"', text)
        norm=re.sub(r'\b\d+(?:\.\d+)?\b', 'N', norm)
        norm=re.sub(r'\b[a-zA-Z_]\w*\b', lambda m:m.group(0) if m.group(0) in keywords else 'ID', norm)
        blocks[norm].append((p.as_posix(),group[0][0],group[-1][0],text))
shown=0
for group in sorted(blocks.values(),key=lambda g:(-len(g),g[0][0])):
    files={p for p,_,_,_ in group}
    if len(files)<2:
        continue
    if len(group)>12:
        continue
    print(f'-- {len(group)} occurrences in {len(files)} files --')
    for p,a,b,text in group[:4]:
        print(f'{p}:Line {a}-Line {b}\n{text}')
    print()
    shown+=1
    if shown==20:
        break
PY

Length of output: 117637

---

@ann0see, I reviewed the complete first-party src tree: 81 C++/Objective-C++ files and 39,350 lines. I excluded vendored code in libs.

The best cleanup work is not limited to std::clamp.

High-value cleanup items

1. Use monotonic timers for finite waits

Replace the QTime::currentTime() deadline loops with QElapsedTimer in:

• src/util.cpp, NetworkUtil::ParseNetworkAddressSrv
• src/client.cpp, CClient::Stop

QTime wraps at midnight. A wait that starts near midnight can end too early or run for almost a day.

Keep the existing QCoreApplication::processEvents() calls. Only replace the deadline calculation.

Gain: Correct duration behavior across midnight. This prevents rare but severe connection and DNS-resolution failures.

---

2. Replace manual mutex ownership with QMutexLocker

Convert paired lock() and unlock() regions where the lock is held for one lexical scope:

• src/channel.cpp: socket-buffer, conversion-buffer, and channel-state regions.
• src/protocol.cpp: send-queue and message-counter regions.
• src/serverdlg.cpp, CServerDlg::OnTimer.
• src/sound/asio/sound.cpp, CSound::Init.

These files already use QMutexLocker in nearby code. Keep the current lock order unchanged.

Do not mechanically change locks that are intentionally released before later work. In particular, review the ASIO audio callback separately because it is real-time code.

Gain: RAII releases the mutex on every exit path. It reduces deadlock risk if later edits add a return or throw an exception. It also removes lock/unlock boilerplate.

---

3. Make recorder ownership exception-safe

src/recorder/jamrecorder.cpp and src/recorder/jamrecorder.h use raw owning pointers for:

• CJamClient::wavFile
• CJamClient::out
• CJamSession::vecptrJamClients
• CJamSession::jamClientConnections
• CJamRecorder::currentSession

The immediate correctness case is CJamClient::CJamClient. It allocates wavFile, then throws when QFile::open() fails. The partially constructed CJamClient destructor does not run, so the allocated QFile leaks.

Use std::unique_ptr for ownership. If Qt 5 container support prevents move-only values in existing QVector and QList members, use std::vector and std::list for the owning containers, or retain the Qt containers with a scoped-owner design.

Gain: No resource leak on constructor failure. Ownership becomes explicit. Manual delete loops become unnecessary. Future changes have fewer lifetime hazards.

---

4. Factor the repeated MIDI-controller mapping loop

CSoundBase::SetMIDIControllerMapping in src/sound/soundbase.cpp repeats the same range-check and assignment loop for:

• Fader
• Pan
• Solo
• Mute

Add a local helper that accepts the controller type, offset, and count. Keep the MuteMyself single-controller case separate.

Gain: One implementation enforces the MIDI CC range and channel-count limits. This reduces the chance that one control type later receives different validation.

---

5. Centralize update-server version requests

src/clientdlg.cpp and src/serverdlg.cpp contain the same logic to query both update servers.

CClient and CServer have the required methods but no common base type. A small template helper or two-argument callback helper can avoid a new inheritance layer. The helper should receive:

• IPv6 availability
• a function that sends CreateCLServerListReqVerAndOSMes

Gain: The two-server redundancy policy exists in one location. A future update-server change cannot affect client and server mode differently.

---

6. Replace safe C-style casts outside audio hot paths

Use static_cast for the downcast in:

• src/server.cpp, CServer::customEvent

The event-type check precedes the cast, so the existing precondition remains unchanged.

Do not broadly replace casts in ASIO, JACK, or CoreAudio callbacks without platform-specific review. Several casts there are required for byte-addressed driver buffers and C APIs.

Gain: The cast states its intended conversion. Compiler diagnostics become more useful. The change has no runtime cost.

---

Small C++17 cleanups

These are safe, localized improvements:

• Replace the remaining manual bounds and extrema updates with std::clamp, std::min, or std::max.
• Replace legacy foreach in src/recorder/jamrecorder.cpp with range-based for.
• Use std::array where fixed-size local C arrays do not cross a C API boundary.
• Replace QTime use for elapsed intervals. Do not replace QTime when the application displays wall-clock time, such as chat timestamps.

Gain: Smaller code, clearer intent, and less duplicated boundary logic.

---

Work that should be separate from this issue

Command-line parser

src/main.cpp contains a long sequence of option-specific if blocks. A table-driven parser could reduce duplication between parsing, option tracking, help text, and settings precedence.

This is a larger behavior change because aliases, deprecated options, client-only/server-only validation, and compatibility persistence interact. It needs focused tests and should be a separate issue.

CoreAudio handle checks

Do not blindly replace all NULL values in src/sound/coreaudio-mac/sound.cpp with nullptr. CoreMIDI handle types can be integer-like opaque identifiers. Use the API’s documented zero sentinel for those types.

Real-time audio conversion

Do not refactor the ASIO/JACK/CoreAudio callback loops for style alone. Their memory layout, allocations, branch behavior, and lock duration can affect audio reliability.

Priority order

1. Monotonic timeout handling.
2. Recorder RAII ownership.
3. QMutexLocker conversion outside callback-sensitive regions.
4. MIDI mapping helper.
5. Shared update-server request helper.
6. std::clamp and small C++17 style cleanup.

The first two items improve runtime correctness. The next three reduce future maintenance and defect risk. The final item mainly improves readability and consistency.

You are interacting with an AI system.

[ann0see]

Quite a huge task. So we should split it into first mechanically doing the small gains and then refactor step by step.

[pljones]

@coderabbitai should we move to Qt6 on Android and drop the legacy Windows support before updating the C++ build?

[coderabbitai]

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '=== Issue `#3938` ==='
gh issue view 3938 --repo jamulussoftware/jamulus --json number,title,body,comments,url \
  --jq '{number,title,url,body,comments:[.comments[]|{author:.author.login,body:.body}]}'

echo '=== Build and CI files ==='
fd -t f -HI \
  -e pro -e pri -e cmake -e yml -e yaml -e md -e txt \
  . | sort | sed -n '1,320p'

echo '=== Qt, Android, Windows, compiler-standard, and legacy-support references ==='
rg -n -i -C 3 \
  '(qt\s*[56]|Qt[56]|android|windows|win(32|64|7|8|10|11)|mingw|msvc|visual studio|c\+\+\s*(11|14|17|20|23)|cxx_standard|cxx_std_|qmake|cmake)' \
  README.md CONTRIBUTING.md Jamulus.pro .github src 2>/dev/null || true

echo '=== CI workflow platform and Qt setup ==='
if [ -d .github ]; then
  rg -n -i -C 5 \
    '(qt|android|windows|mingw|msvc|cmake|qmake|c\+\+)' \
    .github || true
fi

echo '=== Top-level build definitions ==='
for f in Jamulus.pro CMakeLists.txt; do
  if [ -f "$f" ]; then
    echo "--- $f ---"
    sed -n '1,280p' "$f"
  fi
done

echo '=== Android- and Windows-specific project configuration ==='
rg -n -i -C 8 \
  '(android|win32|windows|mingw|msvc|QT\s*\+=|CONFIG\s*\+=|QMAKE|ANDROID_)' \
  --glob '*.{pro,pri,cmake,txt,md,yml,yaml}' \
  . 2>/dev/null || true

Length of output: 177443

---

@pljones, yes for the support-policy decisions, but no for combining the implementation work.

The current build has two relevant legacy constraints:

• Android uses Qt 5.15.2, qtandroidextras, NDK r21d, API level 30, and Java 8.
• Windows builds both 32-bit Qt 5.15.2/MSVC 2019 and 64-bit Qt 6.10.2/MSVC 2022.

Removing the 32-bit Windows build will simplify the Windows matrix. It removes a Qt 5 Windows target. Moving Android to Qt 6 will remove another Qt 5 target and modernize its Android toolchain.

However, these changes do not by themselves allow a project-wide C++17 baseline. Linux and iOS still use Qt 5. The documented project policy also requires Qt 5.12.2 and C++11 compatibility. A C++17 build update therefore requires a complete supported-platform decision.

Recommended order:

1. Agree the support policy first. Define the replacement for 32-bit Windows and the supported Android API, NDK, Java, and Qt versions.
2. Migrate Android to Qt 6 in its own work item. Replace QtAndroidExtras usage and update the Android deployment and toolchain configuration. Validate on devices.
3. Drop legacy Windows support in a separate release-scoped change. Remove the 32-bit Qt 5/MSVC 2019 build, installer path, and CI artifact only after maintainers approve the compatibility break.
4. Update the project C++ standard after all supported targets permit it. Include Linux and iOS in that decision. Then remove obsolete Qt 5 compatibility code in focused follow-up changes.
5. Keep Issue #3938 limited to mechanical cleanups that preserve C++11. Do not block low-risk fixes such as RAII, timer corrections, or existing-compatible cleanup on the platform migration.

This order limits each failure investigation to one platform or one compatibility change. It also avoids using a C++17 requirement as an accidental mechanism for dropping supported users.

You are interacting with an AI system.

[pljones]

src/main.cpp contains a long sequence of option-specific if blocks. A table-driven parser could reduce duplication between parsing, option tracking, help text, and settings precedence.

I've got one of those on a branch... and yes, it's a big change and it didn't get looked at because it was too big. I think that was fair at the time but we're getting better. I might have another look through (with AI help now!) and see if it can be cleaned up.

[ann0see]

So qt5 does not support C++ 17? This would need to be verified as iOS is incompatible with Qt6 (black screen issue) @coderabbitai