Convert AAC to WAV

The RIFF WAVE specification dates from 1991 and its virtue is dullness. The first chunk of the file states the format tag, the number of channels, the sample rate, the byte rate, the block alignment and the bits per sample; the next states how many bytes of audio follow. Everything a reader needs is there before a single sample is touched, and no decoder is required — the data chunk is the samples.

That is why the Python standard library ships a `wave` module and does not ship an AAC module, why `libsndfile` is the default dependency in half of scientific audio, and why an embedded device with 64 kilobytes of RAM can play a WAV off a card. The conversion on this page is not really about audio quality at all. It is about turning a stream into a file that announces its own shape.

AAC as standardised in ISO/IEC 13818-7 is a codec, and a bare `.aac` file is normally ADTS — a continuous run of frames, each with a seven-byte header describing that frame and nothing beyond it. The design target was broadcast, where a receiver may join a transmission halfway through and must be able to start decoding from wherever it lands. There is therefore no file-level header on purpose.

On a disk that becomes three separate problems. The duration is unknown, so software estimates it from the file size and the first frame's bitrate and is wrong whenever the encoder varied. There is no index, so seeking means hunting for a frame boundary. And there is no declared channel layout for the file as a whole, only per frame. A WAV replaces all three with fixed fields.

IP cameras and dashcams write ADTS because it can be cut at any point without a rewrite. DVRs and broadcast loggers do the same. HLS delivers audio as `.aac` segments, so anything that recorded a stream leaves a pile of them. Telephony and IVR platforms produce it. So do a number of Android recording libraries and command-line pipelines whose defaults nobody revisited.

The common thread is that a machine made the file for another machine, which is why the eventual reader is usually a script rather than a listener. That also means the audio is often not what a music file would be: mono is normal, 8,000 or 16,000 Hz is normal for speech systems, and 32,000 Hz appears in broadcast. All of it converts and all of it is preserved as it was.

The output is signed 16-bit little-endian PCM at the source sample rate and channel count. Sixteen bits is CD depth and is what every default assumes: `wave.open` returns it without configuration, `scipy.io.wavfile.read` returns an `int16` array, and hardware DACs are built around it.

Higher depths exist and would be pointless here. AAC decodes to floating-point samples internally, but the information content is fixed by what the encoder kept — writing 24 or 32 bits would enlarge the file by half or double without adding a single bit of real signal. If a later processing stage wants floats, it will convert on load, where it costs nothing on disk.

Sixteen-bit stereo at 44,100 Hz is 10.1 MB per minute. Mono halves it; a lower sample rate scales it proportionally, so an hour of 16,000 Hz mono speech is around 115 MB against 600 MB for the same hour at CD stereo. There is no quality setting, because WAV does not compress.

There is a hard limit worth knowing before you plan a pipeline around this. RIFF chunk sizes are 32-bit, which caps a WAV at 4 GB — roughly six and a half hours of stereo CD-rate audio, or about thirty-seven hours of 16 kHz mono. Long continuous captures exceed it, and the fix is to segment before converting rather than to discover the ceiling at the end of a batch.

If the ADTS file carried an ID3v2 block at the front — some recorders add one — the title, artist, album, track number, genre, date and comment map into the WAV's RIFF INFO chunk. Cover art, album artist, disc number, description and lyrics have no INFO equivalent and are dropped, and INFO values are limited to ISO 8859-1, so anything outside Latin-1 is left out rather than corrupted.

For this audience that is almost always irrelevant, and occasionally it is the point: a capture headed for analysis is better off carrying no descriptive metadata at all. Where the provenance matters, record it alongside the file in whatever your pipeline uses for manifests rather than relying on a chunk that half the tools will ignore.

Stream recorders get stopped mid-frame, and the resulting file ends in the middle of a packet. The conversion reads up to the damage and stops there, which normally gives a usable WAV a fraction of a second shorter than the source — a better outcome than refusing the file, and one worth knowing so that a slightly short duration does not look like a bug.

A different failure is a file that is not ADTS at all. Anything named `.aac` that is really an MP4 fragment, or an M4A renamed by hand, will not parse as a frame stream, and the conversion reports that the file could not be read rather than guessing at it. If that happens, try it as an M4A — an MP4 demuxer will open it, and you will have identified what you actually have.

AAC allows up to 48 channels and WAV up to 18, so ordinary surround material passes through as a multichannel WAV rather than being folded down. Sample rates are preserved exactly, including the unusual ones — 8,000, 11,025, 16,000, 22,050 and 32,000 all survive, which matters when the downstream model or DSP was trained or tuned at a specific rate.

The exception is a layout no path will accept, where the conversion falls back to two channels at 48,000 Hz rather than failing. That is a deliberate trade in favour of getting a file, and it is worth checking the header of the first output in a new batch — a script that assumed 16,000 Hz mono and received 48,000 Hz stereo will produce results that look plausible and are wrong.

This conversion downloads nothing extra. The AAC decoder is the one your device already contains, and writing a WAV is assembling a header and copying samples — the only target in the audio set that needs no encoder at all, which is why it is the fastest of them.

It also means nothing is uploaded, and for machine-generated audio that is less abstract than it sounds. Camera and telephony captures carry other people's voices, recorded in places with rules about where those recordings may be stored. A converter that keeps the file inside the tab does not create a copy on somebody else's infrastructure, and the network tab of your developer tools is the acceptance test rather than a promise on a page.