To turn stereo into mono, add -ac 1. You can also write the mix yourself with the pan filter, but some ways of writing it change the volume. Going mono does not always make the file smaller.

Stereo → mono: -ac 1

ffmpeg -i input.mp3 -ac 1 output.mp3

For a video, add -c:v copy. The picture is copied as it is, and only the audio changes.

ffmpeg -i input.mp4 -c:v copy -ac 1 -c:a aac output.mp4

-ac 1 adds the channels at 0.5 or about 0.707 each

The test file is stereo with the same sound on both sides (−19.1 dB). Each method turned it into a mono 16-bit WAV, and volumedetect (a filter that reports the volume) measured the mean volume.

Method Mean volume Change
Original stereo −19.1 dB —
-ac 1 −19.1 dB 0
pan=mono|c0=0.5*c0+0.5*c1 −19.1 dB 0
aformat=channel_layouts=mono −19.1 dB 0
pan=mono|c0<c0+c1 −19.1 dB 0
pan=mono|c0=c0+c1 −13.0 dB +6.1 dB

When you write 16-bit WAV or FLAC, -ac 1 gives the same result as adding L and R at 0.5 each ((L+R)/2), so the level does not change. When the audio is processed as floating-point numbers, as it is when you write AAC or re-encode MP3 to MP3, -ac 1 and aformat add L and R at about 0.707 each. Sound that is on both sides then comes out about 3 dB louder than with pan at 0.5 each (+3.0 dB for both MP3 and AAC on FFmpeg 8.1). c0+c1 in pan adds the two channels as they are, so sound that is on both sides comes out 6 dB louder.

c0+c1 clips

dBFS is a level scale on which 0 dBFS is the loudest sound digital audio can hold. On a stereo file that peaks at −0.1 dBFS (just below that limit), c0+c1 gave a maximum of 0.0 dB in volumedetect, with 310,400 of 441,000 samples (about 70%) in the 0 dB bin (within 1 dB of the limit). Most of the audio is pinned at the limit and distorted.

When you add channels in pan, keep the coefficients adding up to 1 or less (0.5*c0+0.5*c1), or write < instead of =.

ffmpeg -i input.mp3 -af "pan=mono|c0=0.5*c0+0.5*c1" output.mp3
ffmpeg -i input.mp3 -af "pan=mono|c0<c0+c1" output.mp3

With <, FFmpeg scales the coefficients so they add up to 1. In c0<c0+c1, each channel gets 0.5. Use this form when you want to keep the original level.

Keep only one channel

When the right channel is noisy, or the mic recorded only on the left, keep only the good channel.

ffmpeg -i input.mp3 -af "pan=mono|c0=c0" output.mp3

This makes a mono file from the left channel (c0) only. To keep the file stereo and play the left channel on both sides:

ffmpeg -i input.mp3 -af "pan=stereo|c0=c0|c1=c0" output.mp3

You can also use the channel names FL (front left) and FR (front right) instead of c0/c1 (pan=stereo|c0=FL|c1=FL). For a video, add -c:v copy.

ffmpeg -i input.mp4 -c:v copy -af "pan=stereo|c0=c0|c1=c0" -c:a aac output.mp4

Swap left and right

ffmpeg -i input.mp3 -af "pan=stereo|c0=c1|c1=c0" output.mp3

channelmap=map=FL-FR|FR-FL does the same, but it fails when the input has no FL and FR channels (a mono file, for example).

Mono → stereo

ffmpeg -i input.mp3 -ac 2 output.mp3

Both sides get the same sound, so the sound does not get any wider. With -ac 2, each side is about 3 dB quieter than the mono source. To keep the original level on both sides, use pan=stereo|c0=c0|c1=c0. At the same bitrate, the file size does not change (see “Mono file size” below). The extrastereo and stereotools filters can make stereo sound wider, but they do almost nothing to a source that was mono to begin with.

ffmpeg -i input.mp3 -af "extrastereo=m=2.5" output.mp3

extrastereo boosts the difference between L and R. m=1 leaves the sound as it is, m>1 makes it wider and m<1 makes it narrower. Use it to make a mix that is already stereo a little wider. If you push it too far, only the difference grows, so sounds in the centre (such as vocals) become quieter and thinner by comparison.

Split L / R into separate files and back

channelsplit has two outputs, so it goes in -filter_complex, not -af. -af accepts only filters with one input and one output, so there it fails with an error.

ffmpeg -i input.mp3 -filter_complex "channelsplit=channel_layout=stereo[left][right]" -map "[left]" left.wav -map "[right]" right.wav

To turn the two mono files back into stereo, use join.

ffmpeg -i left.wav -i right.wav -filter_complex "[0:a][1:a]join=inputs=2:channel_layout=stereo[a]" -map "[a]" output.wav

amerge also combines them. If the inputs’ channel positions (FL, FR and so on) do not overlap, it orders the channels by position (the left and right files from channelsplit come out as L then R, whatever order you give them in). If they overlap (two ordinary mono files, for example), it puts the channels in input order and gives the output the default layout for that number of channels (stereo for two mono files). Use this split and join when one channel needs different processing from the other, for example removing noise from the left channel only.

Fine-tune a stereo image (bleed a little L into R)

Some old recordings put each part on one side only, for example vocals on the left and guitar on the right. To make them easier to listen to, mix a little of each side into the other.

ffmpeg -i input.mp3 -af "pan=stereo|c0=0.8*c0+0.2*c1|c1=0.2*c0+0.8*c1" output.mp3

If the coefficients for each output channel add up to 1.0, the mix does not clip. The level stays the same where both sides carry the same sound, and drops where they differ.

Downmix 5.1 to stereo

For 5.1 audio such as a film soundtrack, -ac 2 mixes the channels down to stereo with FFmpeg’s built-in coefficients. Dialogue in the centre channel can end up quiet. To bring it forward, write the coefficients yourself with pan.

ffmpeg -i input.mkv -c:v copy -af "pan=stereo|FL=0.5*FC+0.3*FL+0.2*BL|FR=0.5*FC+0.3*FR+0.2*BR" -c:a aac output.mp4

FC (centre) goes to both sides at 0.5, the front channels at 0.3 and the surrounds at 0.2, so the centre is about 4 dB louder than the front channels. The coefficients on each side add up to 1, so the output does not clip, but it can sound quieter than with -ac 2. LFE (bass) is left out.

FFmpeg reads 5.1 AC-3 and E-AC-3 as 5.1(side), with the surrounds on SL/SR instead of BL/BR. With such input, the BL/BR terms in the command above are ignored without a warning, and the surrounds are lost. If ffprobe shows 5.1(side), change BL/BR to SL/SR.

Mono file size

A 10 s CBR (constant bitrate) 128 kbps MP3, converted to mono with -b:a 128k, came out at 160,958 bytes, exactly the same size as before. Bitrate is the amount of data per second, so fewer channels at the same bitrate give the same size. Without -b:a, -ac 1 alone lets libmp3lame (FFmpeg’s MP3 encoder) pick a mono bitrate (64 kbps for a 44.1 kHz or 48 kHz source), so the file is about half the size.

To save space, lower the bitrate or use VBR (variable bitrate). Mono needs roughly half the bitrate for the same quality, so set -b:a 64k or -q:a 5.

ffmpeg -i input.mp3 -ac 1 -b:a 64k output.mp3

FAQ

-ac 1 or pan=mono|c0=0.5*c0+0.5*c1?

They give the same result when you write 16-bit WAV or FLAC. When you write AAC, or re-encode MP3 to MP3, -ac 1 comes out about 3 dB louder. For a plain mono conversion, -ac 1 is enough. When you combine it with other filters such as loudnorm, pan inside -af lets you control the order.

Mixing to mono makes the sound disappear

If L and R carry the same sound with opposite polarity (the wave flipped upside down on one side), adding them together cancels out to silence. You can create such a file with pan=stereo|c0=c0|c1=-1*c0. It happens with old “pseudo-stereo” recordings. Keep one channel instead (pan=mono|c0=c0).

What’s the difference between stereotools and pan?

pan sets which input channel goes to which output, and at what gain. stereotools works like the stereo tool in a DAW (music production software): Mid/Side conversion (splitting the sound into a centre part and a side part), phase inversion, balance and stereo width. stereotools=mode=lr>ms converts L/R to Mid/Side. For ordinary channel conversion, pan is all you need.