LC3 sits between the Bluetooth audio profile (like BAP — Basic Audio Profile) and the Bluetooth LE link layer. The profile defines byte_count — the compressed frame size in bytes that the LC3 encoder shall produce. As long as byte_count is within the link layer’s maximum frame size, the payload is transmitted over the air.

On the receiver side, the LC3 decoder gets the received payload (payloadRX) plus the same byte_count — it needs to know how many bytes to expect for correct decoding. It also receives a BFI (Bad Frame Indication) flag. If BFI = 1, the payload has bit errors and the decoder should not attempt to decode it.

This is the simplest case. The same byte_count is used for every single frame throughout the session. Both encoder and decoder use the same bits_per_audio_sample setting (though they are allowed to differ).

Encoder side (Transmitter):

• Receives InputPCM buffer of size Nf × bits_per_audio_sample/8 bytes.
• Compresses to exactly byte_count bytes → payloadTX.
• Transmits over the Bluetooth LE ISO channel.

Decoder side (Receiver):

• Receives payloadRX of size byte_count bytes.
• If bit errors are detected → set BFI = 1, otherwise BFI = 0.
• If BFI = 0: decode normally → produce OutputPCM.
• If BFI ≠ 0: skip decoding, use Packet Loss Concealment (PLC) to generate substitute audio.

LC3 also supports external rate control — where the profile can change byte_count per frame and per channel. This is used for things like dynamic bitrate adjustment without tearing down the stream.

Key rules in multi-channel variable bitrate mode:

Allowing different bits_per_audio_sample_enc and bits_per_audio_sample_dec means a decoder with only 16-bit capability can still decode a 24-bit or 32-bit encoded stream — it just outputs 16-bit samples.

The Bad Frame Indication (BFI) flag is set externally by the Bluetooth link layer or the application — not by the LC3 decoder itself. It is a binary signal:

LC3 also defines internal BEC (Bit Error Condition) fields within the bitstream itself. These allow the encoder to mark its own payload as corrupt, and the decoder can detect invalid bitstream states during parsing and trigger PLC automatically.

Note: The LC3 payload has no timestamps, no sequence numbers. Timing and ordering is handled entirely by the Bluetooth LE ISO transport.

Like the encoder, the decoder requires a one-time session configuration. These must match the encoder except for bits_per_audio_sample_dec.

When reading LC3 audio data from a BlueZ ISO socket, the kernel delivers an ancillary message indicating whether the received Bluetooth SDU had errors. This maps directly to the BFI flag that you pass to the LC3 decoder.

/* Reading from BlueZ ISO socket and extracting BFI from the cmsg   */
/* The BT_SCM_PKT_STATUS ancillary message carries the packet status */

struct msghdr  msg = {};
struct iovec   iov;
struct cmsghdr *cmsg;
uint8_t        payload[400];    /* max LC3 byte_count per channel    */
uint8_t        control[64];
uint8_t        bfi = 0;         /* default: good frame               */

iov.iov_base = payload;
iov.iov_len  = sizeof(payload);

msg.msg_iov        = &iov;
msg.msg_iovlen     = 1;
msg.msg_control    = control;
msg.msg_controllen = sizeof(control);

ssize_t len = recvmsg(iso_fd, &msg, 0);
if (len < 0) { perror("recvmsg"); return; }

/* Walk control messages to find packet status */
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
    if (cmsg->cmsg_level == SOL_BLUETOOTH &&
        cmsg->cmsg_type  == BT_SCM_PKT_STATUS) {
        uint8_t pkt_status = *(uint8_t *)CMSG_DATA(cmsg);
        /* 0x00 = valid, 0x01 = possibly invalid, 0x02 = no data  */
        bfi = (pkt_status != 0x00) ? 1 : 0;
    }
}

/* Now pass payload and bfi to the LC3 decoder */
lc3_decode(decoder, payload, (int)len, LC3_PCM_FORMAT_S16,
           pcm_output, /* stride */ 1);
/* For a real implementation you would check bfi first:
   if (bfi) { run_plc(decoder, pcm_output); }
   else      { lc3_decode(decoder, payload, len, ...); }
*/