Enjoying this project? It is built and tested in my free time. A small donation helps buy test hardware and keeps the development going. Thank you! ❤️

Wireless 5.1 / 7.1 surround sound from an Apple TV, built from low-cost ESP32-S3 boards: one Gateway, and one board per speaker.

The Apple TV sees one AirPlay 2 speaker: the Gateway. The Gateway takes the complete surround stream and passes it on, unchanged, to up to eight speaker boards over your Wi-Fi. Every speaker decodes only its own channel (Front Left, Centre, Subwoofer, Rear Right, …) and plays it through any amplifier and speaker you like. All speakers share one clock taken from the Wi-Fi access point itself, so they play each sample at the same moment. No cables between the speakers, no AV receiver, one web page for the whole system.

• 🎬 5.1 and 7.1 AAC (Apple Music Dolby Atmos, films and series from the Apple TV apps).
• 🎵 Stereo too: ALAC 44.1 kHz/16-bit and lossless 48 kHz/24-bit, AAC 44.1 / 48 kHz, from any AirPlay 2 sender. A stereo song plays on the front pair and the subwoofer, as on an AV receiver.
• 📡 One AirPlay target. You pick the Gateway, not eight speakers. Pairing, RTSP and the Apple TV's clock are handled once, by the Gateway.
• ⏱️ Microsecond clock alignment between speakers through the access point's beacon timer (TSF). No extra hardware, no cables.
• 🎤 Room calibration with an optional INMP441 microphone on the Gateway: distance, delay and level of every speaker measured from your seat, applied with one click.
• 🎛️ One page for all speakers: role, level and delay of every speaker, and a live view of what each one plays. Each speaker keeps its own 2 × 24-band parametric EQ / crossover, loudness and latency settings.
• 🔀 Format changes on the fly: the Apple TV can switch between stereo and surround from track to track; the speakers follow without reconnecting.
• ⚡ About a third of one CPU core per speaker for 7.1, thanks to a patched Fraunhofer FDK AAC decoder that synthesises just one channel.
• 🔗 Speakers belong to the system: a speaker is not an AirPlay receiver of its own and never shows up on an iPhone; it just follows the Gateway. (A board that is its own AirPlay receiver is the standalone branch.)

• Gallery
• How it works
• What you need
• Assembly and wiring
• Installation
• First start
• Settings
• Technical details
• Measuring sync
• Limitations
• Troubleshooting and logs
• Licenses and credits

Click an image to open it full size.

Simplest speaker: ESP32-S3 + MAX98357A I2S amplifier + one speaker	Active 2-way speaker: ESP32-S3 + PCM5102A DAC + 2-channel amplifier, woofer + tweeter
One board in every speaker, all fed wirelessly through the Gateway
Gateway speakers page: the room map shows which positions play	One tile per speaker: role, level, delay and live sync

The Apple TV sends surround sound over AirPlay 2 only to a receiver that says it accepts it. The Gateway says so, receives the whole multichannel stream and shares it with the speakers:

1. The Gateway is the only AirPlay receiver. It announces 5.1 and 7.1, so the Apple TV sends it the full multichannel stream. mDNS, HAP pairing, RTSP and the Apple TV's PTP clock all run there.
2. It forwards, it does not decode. Every instruction from the Apple TV (format, key, start, flush, pause, volume, timing) is passed to the speakers over a small control protocol, and every encrypted audio packet is copied byte for byte to each speaker. The slowest speaker paces the stream through TCP, so the Gateway needs no audio buffer of its own.
3. Every speaker decodes only its own channel. One ESP32-S3 cannot decode all eight channels in real time, and it does not need to. A speaker is not an AirPlay receiver: it finds the Gateway by mDNS, decrypts the stream with the key the Gateway passed on and plays its channel on both outputs of its DAC or amplifier (L = R), so you can drive one speaker, two drivers (woofer + tweeter) or a subwoofer amplifier.
4. One clock for all. Every board on the same Wi-Fi access point keeps a copy of the access point's beacon timer (TSF). Eight times a second the Gateway tells the speakers "the Apple TV's time P is TSF T". Each speaker converts T to its own clock and plays every sample at the moment the Apple TV scheduled it.

You choose each speaker's role (Front Left, Centre, Subwoofer, …) on the Gateway's page, even while music is playing. Start with two or three speakers and add the rest later.

                       ┌─────────────────────────────┐
   Apple TV ──AirPlay──►  Gateway (ESP32-S3)          │
   (PTP clock)         │  pairing · RTSP · PTP        │
                       │  no decoder, no audio output │
                       └─────┬──────────────┬─────────┘
              control + time │              │ the same audio packets,
              (TCP, port 7100)              │ unchanged, to every speaker
         ┌──────────┬────────┴─┬────────────┴┬────────────┐
         ▼          ▼          ▼             ▼            ▼
       ESP32      ESP32      ESP32         ESP32        ESP32    (… up to 8)
      Front L    Front R    Centre       Subwoofer    Rear L/R
         │          │          │             │            │
        amp        amp        amp           amp          amp
         │          │          │             │            │
      speaker    speaker    speaker      subwoofer     speaker

The time messages carry a TSF timestamp rather than "now", so how long they take over Wi-Fi does not enter the result.

With stereo the subwoofer gets the full-range mix; a low-pass on its EQ page (or the subwoofer amplifier's own crossover) keeps the bass.

A channel without a speaker is simply not played. The centre carries most of the dialogue, so build it early.

• An Apple TV for 5.1 / 7.1 (surround is sent only by the Apple TV; an iPhone, iPad or Mac sends stereo, which the speakers play as well).
• A 2.4 GHz Wi-Fi network with good coverage at every speaker (the ESP32-S3 has no 5 GHz radio).
• All boards on the same access point. The shared clock is that access point's beacon timer: each access point, and each node of a mesh system, has its own. A speaker on another access point logs a warning and stays silent.

The Gateway needs no wiring (only the optional calibration microphone, see What you need). Everything below is for the speakers.

• Speaker to SPK+ / SPK− (4–8 Ω).
• Leave SD and GAIN unconnected (default: (L+R)/2 output, 9 dB gain). Because both I2S slots carry the same channel, the result is that channel at full level.
• At full volume the amplifier draws up to ~1 A from 5 V: use a good USB supply and short power wires.

On the common purple PCM5102A module check the solder jumpers on the back: FLT = L, DEMP = L, XSMT = H (otherwise the DAC stays muted), FMT = L (I2S).

The DAC's L OUT and R OUT carry the same speaker channel, which lets you use any amplifier, small or powerful, one- or two-channel:

Active 2-way crossover (one example, adjust to your drivers):

1. Open http://<speaker-ip>/eq and tick Enable EQ and preamp.
2. Left Output Filters (woofer): two LP filters at the crossover frequency (e.g. 2500 Hz), Q 0.707 each. Two stacked Butterworth filters make a 24 dB/oct Linkwitz-Riley slope.
3. Right Output Filters (tweeter): two HP filters at the same frequency, Q 0.707 each.
4. Tweeters are usually louder: lower the Right preamp until both drivers sound balanced. Add peak or shelf filters to correct each driver's response.
5. Apply & Save: the change is live and stored, no restart needed.

Power: the ESP32-S3 and the DAC run from USB 5 V; a larger amplifier gets its own supply (e.g. 12 V ≥ 2 A). Connect the grounds of the DAC and the amplifier (the signal ground), and keep the amplifier's power wires away from the I2S wires.

The firmware is built with ESP-IDF v6.0.2. Follow Espressif's installation guide, then open a terminal with the ESP-IDF environment loaded (source ~/esp-idf/export.sh, or the path where you installed it).

The Gateway is the main branch of the surround repository (the earlier design, where every board is its own AirPlay receiver, is the standalone branch):

git clone https://github.com/Kristian8606/esp32-airplay2-surround.git
cd esp32-airplay2-surround

Both use the shared settings in sdkconfig.defaults; the Gateway adds sdkconfig.defaults.gateway. Each is an ordinary ESP-IDF project: go into its folder and run idf.py as usual.

Run idf.py menuconfig in the folder of the firmware you configure (the repository folder for the Gateway, speaker/ for the speakers). Both show the same menus; some options matter for one firmware only:

Every speaker runs the same firmware: its role is set later on the Gateway's page.

Connect a board over USB.

Speakers (repeat for every speaker):

cd speaker
idf.py -p /dev/cu.usbmodem101 build flash monitor

Gateway, from the repository folder:

idf.py -p /dev/cu.usbmodem101 build flash monitor

On macOS list the ports with ls /dev/cu.*; on Windows the port is COMx, on Linux usually /dev/ttyACM0. Every board's log goes to its USB port (USB Serial/JTAG, so idf.py monitor shows it) and to its /logs page.

Later versions are installed over Wi-Fi:

• Gateway: on its main page, Firmware Update → choose build/airplay-gateway_<version>.bin → Upload Firmware.
• Speakers, all at once: on the Gateway's speakers page, panel Speaker firmware → Choose .bin → speaker/build/airplay-speaker_<version>.bin → Upload. The Gateway keeps it in its otherwise unused storage partition (1.9 MB) and every speaker with another build installs it by itself: one at a time and right away, also a speaker that was switched off and comes back later. A speaker that is playing stops its stream for the update (the others play on), checks size and SHA-256 and restarts into the new firmware at once; in a buffered stream (music, films) it plays again from the next track, skip or seek, in a realtime stream at once. Nothing waits for the playback to end; only a running room calibration holds the update back. Each tile shows will update, updating… or update failed (after three tries). If a speaker restarts and does not come back with the new build within 3 minutes, the update stops there (update stopped) instead of going on to the next speaker; check that speaker, then upload the firmware again to continue. A new speaker firmware that cannot reach the Gateway (crashes at boot, no link) goes back to the previous one at its next restart (app rollback). The rollback needs the bootloader of v4.5.11 or later: flash every speaker once over USB (idf.py flash in speaker/).
• One speaker by hand: its own main page, Firmware Update, as for the Gateway.

The web interface is part of the firmware and is updated with it.

1. Connect every board to Wi-Fi. A new board opens the access point ESP32-AirPlay-Setup. Join it with a phone or laptop; the setup page opens by itself (or go to http://192.168.4.1/). Choose your network, enter the password, Connect to WiFi.
2. Name the boards. Find each IP address in your router (or the serial log), open http://<board-ip>/ and set its name (AirPlay Device Name on the Gateway, Speaker Name on a speaker). The Gateway's name is what the Apple TV shows; clear speaker names (Front Left, Centre, …) make the speakers page easy to read.
3. Speakers connect by themselves. A speaker finds the Gateway on the network and shows up on the Gateway's speakers page; there is nothing to switch on.
4. Give every speaker its role. Open the Gateway's page http://<gateway-ip>/speakers (or Open Speakers on its main page), pick a role, level and delay for each speaker, Save.
5. Choose the Gateway on the Apple TV. Open Control Center, select the AirPlay / audio output icon and tick only the Gateway. The speakers are not listed there; they follow the Gateway.
6. Play something in surround (Apple Music Dolby Atmos or a film). The speakers page shows what every speaker plays right now, e.g. AAC · 48 kHz · 24-bit · 7.1 · plays: Front Left.

Everything is configured in the browser.

The Gateway has no audio output, so it has no EQ or latency cards.

At the top, a room map seen from above: the screen at the top, you in the middle and all eight positions around you. An empty position is dashed, a position with a speaker is outlined, and a speaker that is playing glows. Two speakers on the same position are marked orange. Click a position to jump to its speaker. Above the map: what is playing now (AAC · 48 kHz · Stereo) and how many positions are taken.

Below it, one tile per connected speaker, side by side:

Every speaker keeps its settings in its own flash and applies a change at once, also while playing. A warning shows when two speakers have the same role.

An optional INMP441 microphone on the Gateway (wiring in The Gateway) measures every speaker from your seat and suggests its delay and level, in about 2 s per speaker:

1. Put the Gateway with its microphone at your listening seat, at ear height (a power bank will do). Keep the room quiet.
2. Test mic checks the microphone and shows the room noise; −60 dBFS or quieter is good. Music may keep playing meanwhile.
3. Calibrate: if the Apple TV is connected, it is disconnected for the measurement (the speakers can only chirp between streams); afterwards pick the Gateway again as its audio output. Each speaker in turn plays four short chirps (300 Hz–8 kHz, 20 ms; the subwoofer 30–150 Hz, 200 ms) through its own EQ, so a 2-way speaker's crossover protects the tweeter: at −30 dBFS first, louder (up to −12 dBFS) only if the microphone does not hear them clearly.
4. The table shows every speaker's distance, suggested delay (the farthest gets 0 ms, the others 2.9 ms per metre they are closer) and level (the quietest gets 0 dB, the others are turned down to it). Apply to speakers saves them like a manual edit; Discard changes nothing.

Two runs in a quiet room should agree within a few centimetres and about 0.5 dB; if they do not, measure again before applying.

How it measures:

• Travel time without cables. A speaker plays its chirps when it can and reports when each one left it, on the access point's TSF (its output latency included); the Gateway timestamps its recording on the same TSF. The difference is the sound's travel time.
• The direct sound, not an echo. The arrival is the first correlation peak within 6 dB of the strongest one: the direct sound always comes first, while a reflection off a wall can be louder.
• Level as the ear hears it: the RMS of the chirp and the next 10 ms of the room (full-range speakers above 200 Hz), the median of the four.

No signal from the microphone: check its wiring means the Gateway clocks the microphone but reads a constant value: check VDD → 3V3, GND, L/R → GND (otherwise it sends on the other channel), SD → GPIO 4, SCK → GPIO 5, WS → GPIO 6. Without a microphone signal the speakers still play their chirps one after another (so you hear that each one works), and the panel says nothing was measured.

• /logs: live log of the board over WebSocket.
• /speedtest: ping, download and upload between the browser and the board, to check Wi-Fi at the speaker's (or the Gateway's) position.

Security: with a Web UI admin password set in menuconfig, firmware updates, restart, Wi-Fi and name changes and the latency test require the user admin and that password.

The Gateway advertises these formats and the Apple TV chooses one per stream; the speakers decode whatever the Gateway passes on:

• The Apple TV decides the format from the formats the Gateway announces and, for each track, from what the content offers. An "Atmos" label in Apple Music does not guarantee a 7.1 stream; some tracks arrive as stereo. YouTube sends stereo only.
• Format changes mid-stream. Every audio packet carries its format in the RTP SSRC. A speaker switches codec, channels, bit depth or rate per packet, without a new SETUP. A codec or channel change at the same rate keeps the queued audio; a rate change (44.1 ↔ 48 kHz) restarts I2S at the right moment with a short gap, and the timeline stays continuous. AirPlay labels AAC "F24"; that is the stream profile, not the source's depth.

5.1 and 7.1 arrive as AAC-LC with channel configuration 6 or 7. A speaker reads the channel labels of every stream and finds its role by name, so one setting works for 5.1 and 7.1 and survives format changes.

With 5.1 the Rear positions play Side L / R, so a 7.1 set of speakers also works with 5.1 content.

With a stereo stream every speaker decodes both channels and takes what its role needs: Front L / R play left / right, Subwoofer and Mono mix play (L + R) / 2, Centre, Side and Rear stay silent. 5.1 and 7.1 streams are never touched by this.

1. AAC is decoded with Fraunhofer FDK AAC, patched to synthesise only the selected channel: the bits of all channels are read, but only the element that holds the selected speaker is inverse quantised, filtered and transformed. Output is signed 32-bit, straight to float, without a 16-bit step. ALAC uses Espressif's decoder; 24-bit samples also go straight to float.
2. DSP in 32-bit float: stereo routing, EQ / crossover, loudness, volume (the Apple TV's volume, then the speaker's level trim).
3. I2S with 32-bit samples at the stream's rate: 44.1 or 48 kHz for stereo, 48 kHz for surround. The selected speaker goes to both slots (L = R).

The Apple TV schedules every packet on its PTP clock: each packet carries an RTP timestamp and an instruction says which PTP time belongs to which timestamp. Only the Gateway takes part in PTP. The speakers get the Apple TV's time through the access point:

1. Every Wi-Fi station keeps a copy of its access point's TSF, a microsecond timer carried in every beacon. Each board reads its TSF together with its own clock and fits a line through the last 64 such readings (outliers dropped), which averages out the reading jitter.
2. Eight times a second the Gateway sends TIME: a straight line on the TSF, "the Apple TV's time is P at TSF T and runs at 1 + rate", with the clock's identity and state.
3. A speaker looks up its own local time at that TSF and gets the offset to the Apple TV's clock, and carries it forward on the rate until the next message. Because the message names a TSF moment rather than "now", its delay over Wi-Fi does not matter.

One smooth line for all speakers. While the Gateway relays audio most of the Apple TV's PTP Syncs reach it 5 to 100 ms late, and even the best of a few seconds scatter by 3 to 6 ms. A Sync is never early, so every sample lies on or below the true sender time. The speakers get a line fitted to the raw Syncs (main/gw_timeline.c): the best Sync of each second over the last ten minutes, and the edge of their upper envelope (convex hull) over the middle of that window, the lowest line above all of them. Its rate comes from timely Syncs minutes apart (a few ppm); late Syncs never count, and nothing guesses clock steps from them. The published line follows it on that rate, takes a difference back at most 100 µs per second and bends at most 5 ppm per second. A Sync more than 1 s below the fit, or the first one after 5 s without any (the Apple TV restarted), starts the fit again at once. The line steps only for a new sender clock, a restarted access point or a jump beyond 20 ms; after a step it follows the fit directly for 10 s. Every speaker evaluates the same line, so all of them play the same time even when one receives an update later than another. The Gateway logs the line every 10 s: TIME … | line epoch N rate … ppm (fitted), envelope … ms from it over … s, PTP filter … ms from it. 4. From there each speaker runs the playback engine of an AirPlay 2 receiver: it plays every sample at the scheduled time, minus its output latency, plus its delay from the speakers page, and tunes its I2S clock live to follow the Apple TV. The line's rate on the speaker's own clock is exactly the I2S correction needed, so the I2S clock runs at it directly and only the remaining phase is steered (back over 10 s): a new track, a reboot or a bend of the line needs no relearning. The speaker logs SERVO LINE: line … ppm, sync … ms -> I2S … ppm every 10 s.

Wi-Fi dropouts. During a stream a speaker carries the last line forward for up to 30 s, and both sides wait 20 s (instead of 6 s) before they give a silent link up. A dropout of a few seconds costs nothing: the speaker plays on from its buffer, in step, and logs Gateway silent … and TIME again after … ms. Only a longer one ends that speaker's stream; it joins again at the next pause, seek or track.

A speaker that connects in the middle of a session gets the session's settings replayed (format, key, volume, timing). With a buffered stream it waits for the next flush (skip or seek), because it can only start decoding at a point every speaker starts from; with a realtime stream it joins at once.

The FDK changes (single-channel synthesis, 32-bit output, hardware bit counting on the ESP32-S3, element skipping, smaller buffers, lazy limiter) are listed in speaker/components/fdk_aac/MODIFICATIONS.md.

1. Enable Surround Build Role → Sync test pulse on the Gateway and on two speakers (GPIO 9 by default). Each board raises the pin for 10 ms at every whole second of the Apple TV's clock, as it sees it, and logs PULSE … interrupt late avg … max ….

2. Put the three pins on an oscilloscope, trigger on the Gateway, play anything. Gateway → speaker is a speaker's clock error; speaker → speaker is the difference the listener would hear before playback adds its own.

3. For the full chain give both speakers the role Mono mix, play a click track and compare the two DAC outputs:

   ffmpeg -f lavfi -i "aevalsrc='if(lt(mod(t,1),0.001),0.8*sin(2*PI*4000*t),0)':s=48000" -t 600 -ac 2 -c:a aac -b:a 256k clicks.m4a

• Experimental. Tested with one Apple TV, a Gateway and two speakers playing together (three connected): 7.1 and stereo AAC, skip, seek, pause, volume, role and level changes while playing, a second sender taking over.
• Room calibration is tested with an INMP441 and up to six speakers. An echo more than 6 dB louder than the direct sound (a speaker behind an obstacle) still misleads its timing, and the subwoofer's level is left to the ear.
• Not yet tested: realtime (screen mirroring, system audio) through the Gateway, the stereo routing to front pair and subwoofer, oscilloscope measurements, more than three speakers, a weak Wi-Fi signal.
• Late joins: a speaker that connects during a film waits for the next skip or seek; until then it stays silent.
• One access point. All boards must be associated with the same access point (on a mesh, the same node).
• Playout servo: each speaker holds its own playout within ±0.4 ms; two speakers differ by 0.1–0.3 ms. That is inaudible as an echo but could be tightened for a perfectly fixed stereo centre.
• No bass management: with 5.1 / 7.1 the Subwoofer plays only LFE.
• The 7.1 Front / Side naming is not yet confirmed (see Channels).
• Mono mix decodes all channels and may not keep up with 7.1.
• A switch between 44.1 and 48 kHz has a short silence while I2S is reconfigured.
• Rear and side channels are often nearly silent in music; they come alive with films and Atmos mixes.
• Some video apps take 20–30 s from the start of AirPlay to the first audio (seen with HBO); that is the sender.

Every board streams its log to http://<board-ip>/logs. Useful lines:

For deeper debugging enable AirPlay Logs and Diagnostics → Log every RTSP request and response in menuconfig on the Gateway (verbose; turn it off afterwards).

• Fraunhofer FDK AAC (speaker/components/fdk_aac/fdk-aac) is under the Fraunhofer FDK license, NOTICE. The copy here is a Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android; the changes and their dates are listed in MODIFICATIONS.md. The license allows redistribution in source and binary form without copyright fees but grants no patent rights: AAC patent licenses are available through Via Licensing or the patent owners.
• The rest of this repository has no license file yet, so no license is granted for it beyond viewing it on GitHub.
• Other components (ESP-IDF, esp_audio_codec, libsodium, mDNS, cJSON, led_strip) come through the ESP-IDF component manager under their own licenses.

Grows out of the standalone branch of esp32-airplay2-surround, where every board is its own AirPlay receiver playing one channel, and airplay-esp32, the stereo AirPlay 2 receiver for the ESP32-S3. AAC decoding through fdk-aac.

AirPlay, Apple TV and HomePod are trademarks of Apple Inc. This project is not affiliated with or endorsed by Apple.

If this project helped you build your surround system, please consider supporting it. 🙏