LC3 stands for Low Complexity Communication Codec. It was designed by the Bluetooth SIG (originally for hearing aid applications) and is now the core audio codec for Bluetooth LE Audio. It can encode both speech and music across a wide range of bitrates and sampling frequencies.

Think of LC3 like this: you have raw audio coming in as PCM samples (the same raw format stored in WAV files). LC3 takes a small chunk of that audio (called a frame), compresses it into a small packet of bytes, and sends those bytes over Bluetooth. On the other end, the LC3 decoder reconstructs the audio from those bytes.

The key design goals of LC3 are: low delay, low CPU complexity, and high quality at low bitrates — all critical for battery-powered hearing aids and wireless earbuds.

LC3 processes audio in fixed-size frames. A frame is a block of PCM samples covering either 10 ms or 7.5 ms of audio. You choose one or the other at session setup — it cannot change mid-stream.

For a sampling rate of 44.1 kHz, LC3 uses the same frame size as 48 kHz, which means the actual frame duration is slightly longer: 10.884 ms instead of 10 ms, and 8.163 ms instead of 7.5 ms. This is an important detail when working with 44.1 kHz audio.

Note: 44.1 kHz uses 480/360 samples but the real-time duration is slightly longer because 480/44100 ≠ 10/1000.

The Total Codec Algorithmic Delay is the end-to-end delay introduced by encoding + decoding. It equals the frame duration plus an extra look-ahead window that the MDCT (the transform inside the encoder) needs to process a complete frame.

For real-time applications like hearing aids or Bluetooth calls, 11.5–12.5 ms total delay is excellent. Compare this to older codecs like SBC which can reach 20–30 ms.

LC3 does not have a fixed bitrate. Instead, the profile or application tells the encoder how many bytes to put in each compressed frame. This is called byte_count. The encoder always produces a payload of exactly that many bytes.

The LC3 payload does not include timestamps or sequence numbers. That is handled by the Bluetooth transport layer above it (e.g. the ISO channel in LE Audio).

The LC3 encoder works in two phases: session setup (done once at the beginning) and per-frame encoding (done for every audio frame). Here is what each phase requires.

These parameters are fixed for the entire session. Both the encoder and decoder must be configured with the same values (except bits_per_audio_sample which can differ).

The output payload size is always exactly byte_count — the encoder fills the payload to the exact byte boundary. There is no padding or variable-length framing inside the payload itself.

In BlueZ, the LC3 codec parameters (sampling rate, frame duration, bitrate) are exchanged through the BAP (Basic Audio Profile) codec configuration mechanism. When you register a codec via the BlueZ Media API, you supply a Capabilities structure that encodes these LC3 session parameters as LTV (Length-Type-Value) fields defined in the Bluetooth Assigned Numbers document.

Example: LC3 codec configuration structure used with BlueZ ISO sockets

/* LC3 Codec_Specific_Configuration LTV fields (Bluetooth Assigned Numbers) */
/* These are the session parameters passed to the LC3 encoder at init time   */

struct lc3_config {
    uint8_t  sampling_freq;      /* 0x01 = 8kHz, 0x03 = 16kHz, 0x05 = 24kHz,
                                    0x06 = 32kHz, 0x07 = 44.1kHz, 0x08 = 48kHz */
    uint8_t  frame_duration;     /* 0x00 = 7.5ms, 0x01 = 10ms                   */
    uint8_t  channel_alloc;      /* Audio channel allocation bitmask             */
    uint16_t octets_per_frame;   /* byte_count: 20 to 400                        */
    uint8_t  frames_per_sdu;     /* Number of LC3 frames per Bluetooth SDU       */
};

/* BlueZ ISO socket: set codec config via setsockopt before connect/bind */
struct bt_iso_qos qos = {
    .ucast = {
        .cig  = BT_ISO_QOS_CIG_UNSET,
        .cis  = BT_ISO_QOS_CIS_UNSET,
        .sdu  = 100,   /* octets_per_frame for 48kHz 10ms at ~80kbps */
        .phy  = BT_ISO_PHY_2M,
        .rtn  = 2,
    }
};
setsockopt(fd, SOL_BLUETOOTH, BT_ISO_QOS, &qos, sizeof(qos));

The octets_per_frame field in the codec config maps directly to the LC3 spec’s byte_count parameter — it is what the encoder reads each frame to know how many bytes to produce.