diff --git a/README.md b/README.md
index 6e8a298..1ba451f 100644
--- a/README.md
+++ b/README.md
@@ -30,6 +30,8 @@ Definitions and functions shared between [gortsplib](https://github.com/bluenvir
 |ISO 14496-3, Coding of audio-visual objects, Part 3, Audio|MPEG-4 Audio codec|
 |[RFC6716, Definition of the Opus Audio Codec](https://datatracker.ietf.org/doc/html/rfc6716)|Opus codec|
 |[Opus in MP4/ISOBMFF](https://opus-codec.org/docs/opus_in_isobmff.html)|Opus inside MP4|
+|[ATSC Standard: Digital Audio Compression (AC-3, E-AC-3)](http://www.atsc.org/wp-content/uploads/2015/03/A52-201212-17.pdf)|AC-3 codec|
+|[ETSI TS 102 366](https://www.etsi.org/deliver/etsi_ts/102300_102399/102366/01.04.01_60/ts_102366v010401p.pdf)|AC-3 inside MP4|
 |ISO 14496-1, Coding of audio-visual objects, Part 1, Systems|MP4 format|
 |ISO 14496-12, Coding of audio-visual objects, Part 12, ISO base media file format|MP4 format|
 |ISO 14496-14, Coding of audio-visual objects, Part 14, MP4 file format|MP4 format|
diff --git a/pkg/codecs/ac3/ac3.go b/pkg/codecs/ac3/ac3.go
new file mode 100644
index 0000000..e135201
--- /dev/null
+++ b/pkg/codecs/ac3/ac3.go
@@ -0,0 +1,7 @@
+// Package ac3 contains utilities to work with the AC-3 codec.
+package ac3
+
+const (
+	// SamplesPerFrame is the number of samples contained inside a frame.
+	SamplesPerFrame = 1536
+)
diff --git a/pkg/codecs/ac3/bsi.go b/pkg/codecs/ac3/bsi.go
new file mode 100644
index 0000000..41b2129
--- /dev/null
+++ b/pkg/codecs/ac3/bsi.go
@@ -0,0 +1,74 @@
+package ac3
+
+import (
+	"fmt"
+
+	"github.com/bluenviron/mediacommon/pkg/bits"
+)
+
+// BSI is a Bit Stream Information.
+// Specification: ATSC, AC-3, Table 5.2
+type BSI struct {
+	Bsid  uint8
+	Bsmod uint8
+	Acmod uint8
+	LfeOn bool
+}
+
+// Unmarshal decodes a BSI.
+func (b *BSI) Unmarshal(buf []byte) error {
+	if len(buf) < 2 {
+		return fmt.Errorf("not enough bits")
+	}
+
+	b.Bsid = buf[0] >> 3
+	if b.Bsid != 0x08 {
+		return fmt.Errorf("invalid bsid")
+	}
+
+	b.Bsmod = buf[0] & 0b111
+
+	buf = buf[1:]
+	pos := 0
+
+	tmp := bits.ReadBitsUnsafe(buf, &pos, 3)
+	b.Acmod = uint8(tmp)
+
+	if ((b.Acmod & 0x1) != 0) && (b.Acmod != 0x1) {
+		bits.ReadBitsUnsafe(buf, &pos, 2) // cmixlev
+	}
+
+	if (b.Acmod & 0x4) != 0 {
+		bits.ReadBitsUnsafe(buf, &pos, 2) // surmixlev
+	}
+
+	if b.Acmod == 0x2 {
+		bits.ReadBitsUnsafe(buf, &pos, 2) // dsurmod
+	}
+
+	b.LfeOn = bits.ReadFlagUnsafe(buf, &pos)
+
+	return nil
+}
+
+// ChannelCount returns the channel count.
+func (b BSI) ChannelCount() int {
+	var n int
+	switch b.Acmod {
+	case 0b001:
+		n = 1
+	case 0b010, 0b000:
+		n = 2
+	case 0b011, 0b100:
+		n = 3
+	case 0b101, 0b110:
+		n = 4
+	default:
+		n = 5
+	}
+
+	if b.LfeOn {
+		return n + 1
+	}
+	return n
+}
diff --git a/pkg/codecs/ac3/bsi_test.go b/pkg/codecs/ac3/bsi_test.go
new file mode 100644
index 0000000..4b153c0
--- /dev/null
+++ b/pkg/codecs/ac3/bsi_test.go
@@ -0,0 +1,25 @@
+package ac3
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestBSIUnmarshal(t *testing.T) {
+	for _, ca := range ac3Cases {
+		t.Run(ca.name, func(t *testing.T) {
+			var bsi BSI
+			err := bsi.Unmarshal(ca.enc[5:])
+			require.NoError(t, err)
+			require.Equal(t, ca.bsi, bsi)
+		})
+	}
+}
+
+func FuzzBSIUnmarshal(f *testing.F) {
+	f.Fuzz(func(t *testing.T, b []byte) {
+		var bsi BSI
+		bsi.Unmarshal(b) //nolint:errcheck
+	})
+}
diff --git a/pkg/codecs/ac3/sync_info.go b/pkg/codecs/ac3/sync_info.go
new file mode 100644
index 0000000..e6acf58
--- /dev/null
+++ b/pkg/codecs/ac3/sync_info.go
@@ -0,0 +1,94 @@
+package ac3
+
+import (
+	"fmt"
+)
+
+// ATSC, AC-3, Table 5.18
+var frameSizes = [][]int{
+	{64, 69, 96},
+	{64, 70, 96},
+	{80, 87, 120},
+	{80, 88, 120},
+	{96, 104, 144},
+	{96, 105, 144},
+	{112, 121, 168},
+	{112, 122, 168},
+	{128, 139, 192},
+	{128, 140, 192},
+	{160, 174, 240},
+	{160, 175, 240},
+	{192, 208, 288},
+	{192, 209, 288},
+	{224, 243, 336},
+	{224, 244, 336},
+	{256, 278, 384},
+	{256, 279, 384},
+	{320, 348, 480},
+	{320, 349, 480},
+	{384, 417, 576},
+	{384, 418, 576},
+	{448, 487, 672},
+	{448, 488, 672},
+	{512, 557, 768},
+	{512, 558, 768},
+	{640, 696, 960},
+	{640, 697, 960},
+	{768, 835, 1152},
+	{768, 836, 1152},
+	{896, 975, 1344},
+	{896, 976, 1344},
+	{1024, 1114, 1536},
+	{1024, 1115, 1536},
+	{1152, 1253, 1728},
+	{1152, 1254, 1728},
+	{1280, 1393, 1920},
+	{1280, 1394, 1920},
+}
+
+// SyncInfo is a synchronization information.
+// Specification: ATSC, AC-3, Table 5.1
+type SyncInfo struct {
+	Fscod      uint8
+	Frmsizecod uint8
+}
+
+// Unmarshal decodes a SyncInfo.
+func (s *SyncInfo) Unmarshal(frame []byte) error {
+	if len(frame) < 5 {
+		return fmt.Errorf("not enough bits")
+	}
+
+	if frame[0] != 0x0B || frame[1] != 0x77 {
+		return fmt.Errorf("invalid sync word")
+	}
+
+	s.Fscod = frame[4] >> 6
+	if s.Fscod >= 3 {
+		return fmt.Errorf("invalid fscod")
+	}
+
+	s.Frmsizecod = frame[4] & 0x3f
+	if s.Frmsizecod >= 38 {
+		return fmt.Errorf("invalid frmsizecod")
+	}
+
+	return nil
+}
+
+// FrameSize returns the frame size.
+func (s SyncInfo) FrameSize() int {
+	return frameSizes[s.Frmsizecod][s.Fscod] * 2
+}
+
+// SampleRate returns the frame sample rate.
+func (s SyncInfo) SampleRate() int {
+	switch s.Fscod {
+	case 0:
+		return 48000
+	case 1:
+		return 44100
+	default:
+		return 32000
+	}
+}
diff --git a/pkg/codecs/ac3/sync_info_test.go b/pkg/codecs/ac3/sync_info_test.go
new file mode 100644
index 0000000..2af68c3
--- /dev/null
+++ b/pkg/codecs/ac3/sync_info_test.go
@@ -0,0 +1,334 @@
+package ac3
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+var ac3Cases = []struct {
+	name       string
+	enc        []byte
+	syncInfo   SyncInfo
+	sampleRate int
+	bsi        BSI
+}{
+	{
+		"1 ch",
+		[]byte{
+			0x0b, 0x77, 0x47, 0x11, 0x0c, 0x40, 0x2f, 0x84,
+			0x2b, 0xc1, 0x07, 0x7a, 0xb0, 0xfa, 0xbb, 0xea,
+			0xef, 0x9f, 0x57, 0x7c, 0xf9, 0xf3, 0xf7, 0xcf,
+			0x9f, 0x3e, 0x32, 0xfe, 0xd5, 0xc1, 0x50, 0xde,
+			0xc5, 0x1e, 0x73, 0xd2, 0x6c, 0xa6, 0x94, 0x46,
+			0x4e, 0x92, 0x8c, 0x0f, 0xb9, 0xcf, 0xad, 0x07,
+			0x54, 0x4a, 0x2e, 0xf3, 0x7d, 0x07, 0x2e, 0xa4,
+			0x2f, 0xba, 0xbf, 0x39, 0xb5, 0xc9, 0x92, 0xa6,
+			0xe1, 0xb4, 0x70, 0xc5, 0xc4, 0xb5, 0xe6, 0x5d,
+			0x0f, 0xa8, 0x71, 0xa4, 0xcc, 0xc5, 0xbc, 0x75,
+			0x67, 0x92, 0x52, 0x4f, 0x7e, 0x62, 0x1c, 0xa9,
+			0xd9, 0xb5, 0x19, 0x6a, 0xd7, 0xb0, 0x44, 0x92,
+			0x30, 0x3b, 0xf7, 0x61, 0xd6, 0x49, 0x96, 0x66,
+			0x98, 0x28, 0x1a, 0x95, 0xa9, 0x42, 0xad, 0xb7,
+			0x50, 0x90, 0xad, 0x1c, 0x34, 0x80, 0xe2, 0xef,
+			0xcd, 0x41, 0x0b, 0xf0, 0x9d, 0x57, 0x62, 0x78,
+			0xfd, 0xc6, 0xc2, 0x19, 0x9e, 0x26, 0x31, 0xca,
+			0x1e, 0x75, 0xb1, 0x7a, 0x8e, 0xb5, 0x51, 0x3a,
+			0xfe, 0xe4, 0xf1, 0x0b, 0x4f, 0x14, 0x90, 0xdb,
+			0x9f, 0x44, 0x50, 0xbb, 0xef, 0x74, 0x00, 0x8c,
+			0x1f, 0x97, 0xa1, 0xa2, 0xfa, 0x72, 0x16, 0x47,
+			0xc6, 0xc0, 0xe5, 0xfe, 0x67, 0x03, 0x9c, 0xfe,
+			0x62, 0x01, 0xa1, 0x00, 0x5d, 0xff, 0xa5, 0x03,
+			0x59, 0xfa, 0xa8, 0x25, 0x5f, 0x6b, 0x83, 0x51,
+			0xf2, 0xc0, 0x44, 0xff, 0x2d, 0x05, 0x4b, 0xee,
+			0xe0, 0x54, 0x9e, 0xae, 0x86, 0x45, 0xf3, 0xbd,
+			0x0e, 0x42, 0xf2, 0xbf, 0x0f, 0x7f, 0xc6, 0x09,
+			0x07, 0xdc, 0x22, 0x11, 0x77, 0xbe, 0x31, 0x27,
+			0x5b, 0xa4, 0x13, 0x47, 0x07, 0x32, 0x9f, 0x1f,
+			0xcb, 0xb0, 0xdf, 0x3e, 0x7d, 0x0d, 0xf3, 0xe7,
+			0xcf, 0x9f, 0x3e, 0xae, 0xf9, 0xf3, 0xe7, 0xcf,
+			0x9f, 0x3e, 0x85, 0x5d, 0xf3, 0xe7, 0xcf, 0x9f,
+			0x3e, 0x7c, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3f,
+			0x53, 0x5d, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c,
+			0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c, 0xf9,
+			0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c, 0xf9, 0xf3,
+			0xe7, 0xcf, 0x9f, 0x3e, 0x00, 0x46, 0x28, 0x26,
+			0x20, 0x4a, 0x5a, 0xc0, 0x8a, 0xc5, 0xae, 0xa0,
+			0x55, 0x78, 0x82, 0x7a, 0x38, 0x10, 0x09, 0xc9,
+			0xb8, 0x0c, 0xfa, 0x5b, 0xc9, 0xd2, 0xec, 0x44,
+			0x25, 0xf8, 0x20, 0xf2, 0xc8, 0x8a, 0xe9, 0x40,
+			0x18, 0x06, 0xc6, 0x2b, 0xc8, 0xed, 0x8f, 0x33,
+			0x09, 0x92, 0x28, 0x1e, 0xc4, 0x24, 0xd8, 0x33,
+			0xa5, 0x00, 0xf5, 0xea, 0x18, 0xfa, 0x90, 0x97,
+			0x97, 0xe8, 0x39, 0x6a, 0xcf, 0xf1, 0xdd, 0xff,
+			0x9e, 0x8e, 0x04, 0x02, 0xae, 0x65, 0x87, 0x5c,
+			0x4e, 0x72, 0xfd, 0x3c, 0x01, 0x86, 0xfe, 0x56,
+			0x59, 0x74, 0x44, 0x3a, 0x40, 0x00, 0xec, 0xfc,
+		},
+		SyncInfo{
+			Frmsizecod: 12,
+		},
+		48000,
+		BSI{
+			Bsid:  8,
+			Acmod: 1,
+		},
+	},
+	{
+		"6 ch",
+		[]byte{
+			0x0b, 0x77, 0x1a, 0x01, 0x1e, 0x40, 0xeb, 0xf8,
+			0x40, 0x3e, 0xff, 0x99, 0xc5, 0x98, 0xb3, 0x16,
+			0x62, 0xcc, 0x59, 0xff, 0xfa, 0xd7, 0xae, 0xf9,
+			0x07, 0x7a, 0xb0, 0xfa, 0xbb, 0xea, 0xef, 0x9f,
+			0x57, 0x7c, 0xf9, 0xf3, 0xf7, 0xc2, 0x0e, 0xf5,
+			0x61, 0xf5, 0x77, 0xd5, 0xdf, 0x3e, 0xae, 0xf9,
+			0xf3, 0xe7, 0xef, 0x84, 0x1d, 0xea, 0xc3, 0xea,
+			0xef, 0xab, 0xbe, 0x7d, 0x5d, 0xf3, 0xe7, 0xcf,
+			0xdf, 0x08, 0x3b, 0xd5, 0x87, 0xd5, 0xdf, 0x57,
+			0x7c, 0xfa, 0xbb, 0xe7, 0xcf, 0x9f, 0xbe, 0x10,
+			0x77, 0xab, 0x0f, 0xab, 0xbe, 0xae, 0xf9, 0xf5,
+			0x77, 0xcf, 0x9f, 0x3f, 0x7c, 0x23, 0xc4, 0xf9,
+			0x7f, 0x66, 0xa5, 0x4a, 0x95, 0x2a, 0x54, 0xa9,
+			0x00, 0x54, 0x37, 0xb1, 0x4e, 0x73, 0xc9, 0xb3,
+			0x69, 0x45, 0x93, 0xa2, 0x8c, 0x3e, 0xe7, 0xfa,
+			0xd0, 0x75, 0x44, 0xa2, 0xef, 0x37, 0xd0, 0x72,
+			0xea, 0x42, 0xfb, 0xad, 0xce, 0x6d, 0x72, 0x65,
+			0x53, 0xe1, 0xa8, 0xe1, 0x8b, 0x89, 0x6b, 0xcc,
+			0xb4, 0x3e, 0xa1, 0xc6, 0xa6, 0x8c, 0x57, 0x8d,
+			0x5b, 0xca, 0x52, 0x4f, 0x7e, 0x62, 0x1c, 0xa9,
+			0xd9, 0xb5, 0x19, 0x6a, 0xd7, 0xb0, 0x44, 0x92,
+			0x30, 0x3b, 0xf7, 0x63, 0xb9, 0x2c, 0xb6, 0x73,
+			0x0a, 0x0d, 0x45, 0xa2, 0x8a, 0xbd, 0xc5, 0x02,
+			0x1b, 0x4e, 0x24, 0x81, 0xcb, 0xce, 0x74, 0x11,
+			0x7c, 0x2e, 0xb7, 0x65, 0x24, 0x6e, 0x6c, 0x46,
+			0x67, 0x89, 0x8c, 0x72, 0x87, 0x9d, 0x70, 0xca,
+			0x9d, 0x55, 0x0a, 0xaf, 0xdd, 0x38, 0x8b, 0x5e,
+			0x52, 0x87, 0xbb, 0xe9, 0x10, 0x5b, 0xfe, 0xd0,
+			0x04, 0xc3, 0xf1, 0xe8, 0x68, 0xbe, 0x9c, 0x85,
+			0x91, 0xf1, 0xb0, 0x39, 0x7f, 0x99, 0x82, 0x9d,
+			0xfd, 0x88, 0x0a, 0x00, 0x17, 0x7f, 0xa6, 0x05,
+			0x67, 0xea, 0xa0, 0x95, 0x7d, 0xae, 0x0d, 0x47,
+			0xcb, 0x01, 0x13, 0xfc, 0xb4, 0x15, 0x2f, 0xbb,
+			0x81, 0x52, 0x7a, 0xba, 0x19, 0x17, 0xab, 0xc1,
+			0xd0, 0xf9, 0xc0, 0x1d, 0xfe, 0x21, 0x21, 0xfe,
+			0x22, 0x21, 0xed, 0xe3, 0x25, 0xdd, 0xe4, 0x26,
+			0xa3, 0x2a, 0x32, 0xa3, 0x34, 0xe0, 0x26, 0x72,
+			0x58, 0x40, 0x95, 0x0d, 0xec, 0x53, 0x9c, 0xf2,
+			0x6c, 0xda, 0x51, 0x64, 0xe8, 0xa3, 0x0f, 0xb9,
+			0xfe, 0xb4, 0x1d, 0x51, 0x28, 0xbb, 0xcd, 0xf4,
+			0x1c, 0xba, 0x90, 0xbe, 0xeb, 0x73, 0x9b, 0x5c,
+			0x99, 0x54, 0xf8, 0x6a, 0x38, 0x62, 0xe2, 0x5a,
+			0xf3, 0x2d, 0x0f, 0xa8, 0x71, 0xa9, 0xa3, 0x15,
+			0xe3, 0x56, 0xf2, 0x94, 0x93, 0xdf, 0x98, 0x87,
+			0x2a, 0x76, 0x6d, 0x46, 0x5a, 0xb5, 0xec, 0x11,
+			0x24, 0x8c, 0x0e, 0xfd, 0xd8, 0xee, 0x4b, 0x2d,
+			0x9c, 0xc2, 0x83, 0x51, 0x68, 0xa2, 0xaf, 0x71,
+			0x40, 0x86, 0xd3, 0x89, 0x20, 0x72, 0xf3, 0x9d,
+			0x04, 0x5f, 0x0b, 0xad, 0xd9, 0x49, 0x1b, 0x9b,
+			0x11, 0x99, 0xe2, 0x63, 0x1c, 0xa1, 0xe7, 0x5c,
+			0x32, 0xa7, 0x55, 0x42, 0xab, 0xf7, 0x4e, 0x22,
+			0xd7, 0x94, 0xa1, 0xee, 0xfa, 0x44, 0x16, 0xff,
+			0xb4, 0x01, 0x30, 0xfc, 0x7a, 0x1a, 0x2f, 0xa7,
+			0x21, 0x64, 0x7c, 0x6c, 0x0e, 0x5f, 0xe6, 0x60,
+			0xa7, 0x7f, 0x62, 0x02, 0x80, 0x05, 0xdf, 0xe9,
+			0x81, 0x59, 0xfa, 0xa8, 0x25, 0x5f, 0x6b, 0x83,
+			0x51, 0xf2, 0xc0, 0x44, 0xff, 0x2d, 0x05, 0x4b,
+			0xee, 0xe0, 0x54, 0x9e, 0xae, 0x86, 0x45, 0xea,
+			0xf0, 0x74, 0x3e, 0x70, 0x07, 0x7f, 0x88, 0x48,
+			0x7f, 0x88, 0x88, 0x7b, 0x78, 0xc9, 0x77, 0x79,
+			0x09, 0x54, 0x37, 0xb1, 0x4e, 0x73, 0xc9, 0xb3,
+			0x69, 0x45, 0x93, 0xa2, 0x8c, 0x3e, 0xe7, 0xfa,
+			0xd0, 0x75, 0x44, 0xa2, 0xef, 0x37, 0xd0, 0x72,
+			0xea, 0x42, 0xfb, 0xad, 0xce, 0x6d, 0x72, 0x65,
+			0x53, 0xe1, 0xa8, 0xe1, 0x8b, 0x89, 0x6b, 0xcc,
+			0xb4, 0x3e, 0xa1, 0xc6, 0xa6, 0x8c, 0x57, 0x8d,
+			0x5b, 0xca, 0x52, 0x4f, 0x7e, 0x62, 0x1c, 0xa9,
+			0xd9, 0xb5, 0x19, 0x6a, 0xd7, 0xb0, 0x44, 0x92,
+			0x30, 0x3b, 0xf7, 0x63, 0xb9, 0x2c, 0xb6, 0x73,
+			0x0a, 0x0d, 0x45, 0xa2, 0x8a, 0xbd, 0xc5, 0x02,
+			0x1b, 0x4e, 0x24, 0x81, 0xcb, 0xce, 0x74, 0x11,
+			0x7c, 0x2e, 0xb7, 0x65, 0x24, 0x6e, 0x6c, 0x46,
+			0x67, 0x89, 0x8c, 0x72, 0x87, 0x9d, 0x70, 0xca,
+			0x9d, 0x55, 0x0a, 0xaf, 0xdd, 0x38, 0x8b, 0x5e,
+			0x52, 0x87, 0xbb, 0xe9, 0x10, 0x5b, 0xfe, 0xd0,
+			0x04, 0xc3, 0xf1, 0xe8, 0x68, 0xbe, 0x9c, 0x85,
+			0x91, 0xf1, 0xb0, 0x39, 0x7f, 0x99, 0x82, 0x9d,
+			0xfd, 0x88, 0x0a, 0x00, 0x17, 0x7f, 0xa6, 0x05,
+			0x67, 0xea, 0xa0, 0x95, 0x7d, 0xae, 0x0d, 0x47,
+			0xcb, 0x01, 0x13, 0xfc, 0xb4, 0x15, 0x2f, 0xbb,
+			0x81, 0x52, 0x7a, 0xba, 0x19, 0x17, 0xab, 0xc1,
+			0xd0, 0xf9, 0xc0, 0x1d, 0xfe, 0x21, 0x21, 0xfe,
+			0x22, 0x21, 0xed, 0xe3, 0x25, 0xdd, 0xe4, 0x25,
+			0x50, 0xde, 0xc5, 0x39, 0xcf, 0x26, 0xcd, 0xa5,
+			0x16, 0x4e, 0x8a, 0x30, 0xfb, 0x9f, 0xeb, 0x41,
+			0xd5, 0x12, 0x8b, 0xbc, 0xdf, 0x41, 0xcb, 0xa9,
+			0x0b, 0xee, 0xb7, 0x39, 0xb5, 0xc9, 0x95, 0x4f,
+			0x86, 0xa3, 0x86, 0x2e, 0x25, 0xaf, 0x32, 0xd0,
+			0xfa, 0x87, 0x1a, 0x9a, 0x31, 0x5e, 0x35, 0x6f,
+			0x29, 0x49, 0x3d, 0xf9, 0x88, 0x72, 0xa7, 0x66,
+			0xd4, 0x65, 0xab, 0x5e, 0xc1, 0x12, 0x48, 0xc0,
+			0xef, 0xdd, 0x8e, 0xe4, 0xb2, 0xd9, 0xcc, 0x28,
+			0x35, 0x16, 0x8a, 0x2a, 0xf7, 0x14, 0x08, 0x6d,
+			0x38, 0x92, 0x07, 0x2f, 0x39, 0xd0, 0x45, 0xf0,
+			0xba, 0xdd, 0x94, 0x91, 0xb9, 0xb1, 0x19, 0x9e,
+			0x26, 0x31, 0xca, 0x1e, 0x75, 0xc3, 0x2a, 0x75,
+			0x54, 0x2a, 0xbf, 0x74, 0xe2, 0x2d, 0x79, 0x4a,
+			0x1e, 0xef, 0xa4, 0x41, 0x6f, 0xfb, 0x40, 0x13,
+			0x0f, 0xc7, 0xa1, 0xa2, 0xfa, 0x72, 0x16, 0x47,
+			0xc6, 0xc0, 0xe5, 0xfe, 0x66, 0x0a, 0x77, 0xf6,
+			0x20, 0x28, 0x00, 0x5d, 0xfe, 0x98, 0x15, 0x9f,
+			0xaa, 0x82, 0x55, 0xf6, 0xb8, 0x35, 0x1f, 0x2c,
+			0x04, 0x4f, 0xf2, 0xd0, 0x54, 0xbe, 0xee, 0x05,
+			0x49, 0xea, 0xe8, 0x64, 0x5e, 0xaf, 0x07, 0x43,
+			0xe7, 0x00, 0x77, 0xf8, 0x84, 0x87, 0xf8, 0x88,
+			0x87, 0xb7, 0x8c, 0x97, 0x77, 0x90, 0x95, 0x43,
+			0x7b, 0x14, 0xe7, 0x3c, 0x9b, 0x36, 0x94, 0x59,
+			0x3a, 0x28, 0xc3, 0xee, 0x7f, 0xad, 0x07, 0x54,
+			0x4a, 0x2e, 0xf3, 0x7d, 0x07, 0x2e, 0xa4, 0x2f,
+			0xba, 0xdc, 0xe6, 0xd7, 0x26, 0x55, 0x3e, 0x1a,
+			0x8e, 0x18, 0xb8, 0x96, 0xbc, 0xcb, 0x43, 0xea,
+			0x1c, 0x6a, 0x68, 0xc5, 0x78, 0xd5, 0xbc, 0xa5,
+			0x24, 0xf7, 0xe6, 0x21, 0xca, 0x9d, 0x9b, 0x51,
+			0x96, 0xad, 0x7b, 0x04, 0x49, 0x23, 0x03, 0xbf,
+			0x76, 0x3b, 0x92, 0xcb, 0x67, 0x30, 0xa0, 0xd4,
+			0x5a, 0x28, 0xab, 0xdc, 0x50, 0x21, 0xb4, 0xe2,
+			0x48, 0x1c, 0xbc, 0xe7, 0x41, 0x17, 0xc2, 0xeb,
+			0x76, 0x52, 0x46, 0xe6, 0xc4, 0x66, 0x78, 0x98,
+			0xc7, 0x28, 0x79, 0xd7, 0x0c, 0xa9, 0xd5, 0x50,
+			0xaa, 0xfd, 0xd3, 0x88, 0xb5, 0xe5, 0x28, 0x7b,
+			0xbe, 0x91, 0x05, 0xbf, 0xed, 0x00, 0x4c, 0x3f,
+			0x1e, 0x86, 0x8b, 0xe9, 0xc8, 0x59, 0x1f, 0x1b,
+			0x03, 0x97, 0xf9, 0x98, 0x29, 0xdf, 0xd8, 0x80,
+			0xa0, 0x01, 0x77, 0xfa, 0x60, 0x56, 0x7e, 0xaa,
+			0x09, 0x57, 0xda, 0xe0, 0xd4, 0x7c, 0xb0, 0x11,
+			0x3f, 0xcb, 0x41, 0x52, 0xfb, 0xb8, 0x15, 0x27,
+			0xab, 0xa1, 0x91, 0x7a, 0xbc, 0x1d, 0x0f, 0x9c,
+			0x01, 0xdf, 0xe2, 0x12, 0x1f, 0xe2, 0x22, 0x1e,
+			0xde, 0x32, 0x5d, 0xde, 0x42, 0x55, 0x15, 0x8a,
+			0x9c, 0xf4, 0x9b, 0x33, 0x4a, 0x0c, 0x9d, 0x51,
+			0x80, 0x7c, 0x04, 0xaa, 0xa9, 0xf3, 0xe7, 0xcf,
+			0x9f, 0x3e, 0x73, 0x29, 0xf1, 0xfc, 0xbb, 0x0d,
+			0xf3, 0xe7, 0xd0, 0xdf, 0x3e, 0x7c, 0xf9, 0xf3,
+			0xea, 0xef, 0x9f, 0x3e, 0x7c, 0xf9, 0xf3, 0xe8,
+			0x55, 0xdf, 0x3e, 0x7c, 0xf9, 0xf3, 0xe7, 0xcf,
+			0x9f, 0x3e, 0x7c, 0xf9, 0xf3, 0xf5, 0x35, 0xdf,
+			0x3e, 0x7c, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e,
+			0x7c, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x1c,
+			0xca, 0x7c, 0x7f, 0x2e, 0xc3, 0x7c, 0xf9, 0xf4,
+			0x37, 0xcf, 0x9f, 0x3e, 0x7c, 0xfa, 0xbb, 0xe7,
+			0xcf, 0x9f, 0x3e, 0x7c, 0xfa, 0x15, 0x77, 0xcf,
+			0x9f, 0x3e, 0x7c, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f,
+			0x3e, 0x7c, 0xfd, 0x4d, 0x77, 0xcf, 0x9f, 0x3e,
+			0x7c, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c,
+			0xf9, 0xf3, 0xe7, 0xcf, 0x87, 0x32, 0x9f, 0x1f,
+			0xcb, 0xb0, 0xdf, 0x3e, 0x7d, 0x0d, 0xf3, 0xe7,
+			0xcf, 0x9f, 0x3e, 0xae, 0xf9, 0xf3, 0xe7, 0xcf,
+			0x9f, 0x3e, 0x85, 0x5d, 0xf3, 0xe7, 0xcf, 0x9f,
+			0x3e, 0x7c, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3f,
+			0x53, 0x5d, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c,
+			0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c, 0xf9,
+			0xf3, 0xe1, 0xcc, 0xa7, 0xc7, 0xf2, 0xec, 0x37,
+			0xcf, 0x9f, 0x43, 0x7c, 0xf9, 0xf3, 0xe7, 0xcf,
+			0xab, 0xbe, 0x7c, 0xf9, 0xf3, 0xe7, 0xcf, 0xa1,
+			0x57, 0x7c, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e,
+			0x7c, 0xf9, 0xf3, 0xe7, 0xcf, 0xd4, 0xd7, 0x7c,
+			0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c, 0xf9,
+			0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c, 0xf8, 0x73,
+			0x29, 0xf1, 0xfc, 0xbb, 0x0d, 0xf3, 0xe7, 0xd0,
+			0xdf, 0x3e, 0x7c, 0xf9, 0xf3, 0xea, 0xef, 0x9f,
+			0x3e, 0x7c, 0xf9, 0xf3, 0xe8, 0x55, 0xdf, 0x3e,
+			0x7c, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c,
+			0xf9, 0xf3, 0xf5, 0x35, 0xdf, 0x3e, 0x7c, 0xf9,
+			0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c, 0xf9, 0xf3,
+			0xe7, 0xcf, 0x9f, 0x3e, 0x00, 0x23, 0x28, 0x26,
+			0x20, 0x4a, 0x5a, 0xc2, 0x2b, 0x5a, 0xea, 0x05,
+			0x57, 0x88, 0x27, 0x47, 0x80, 0x11, 0x94, 0x13,
+			0x10, 0x25, 0x2d, 0x61, 0x15, 0xad, 0x75, 0x02,
+			0xab, 0xc4, 0x13, 0xa0, 0x8c, 0xa0, 0x98, 0x81,
+			0x29, 0x6b, 0x08, 0xad, 0x6b, 0xa8, 0x15, 0x5e,
+			0x20, 0x9d, 0x1e, 0x08, 0xca, 0x09, 0x88, 0x12,
+			0x96, 0xb0, 0x8a, 0xd6, 0xba, 0x81, 0x55, 0xe2,
+			0x09, 0xd0, 0x02, 0x32, 0x82, 0x62, 0x04, 0xa5,
+			0xac, 0x22, 0xb5, 0xae, 0xa0, 0x55, 0x78, 0x82,
+			0x74, 0x6e, 0x04, 0x85, 0x08, 0x81, 0x29, 0x6b,
+			0x08, 0xad, 0x6b, 0xa8, 0x15, 0x03, 0xe0, 0x00,
+			0x00, 0x09, 0xcb, 0x70, 0x19, 0xf4, 0xb7, 0x94,
+			0x97, 0x60, 0x84, 0xbf, 0x04, 0x1e, 0x59, 0x02,
+			0xbc, 0x6c, 0xe5, 0xb8, 0x0c, 0xfa, 0x5b, 0xca,
+			0x4b, 0xb0, 0x42, 0x5f, 0x82, 0x0f, 0x2c, 0x81,
+			0x67, 0x2d, 0xc0, 0x67, 0xd2, 0xde, 0x52, 0x5d,
+			0x82, 0x12, 0xfc, 0x10, 0x79, 0x64, 0x0a, 0xf2,
+			0x72, 0xdc, 0x06, 0x7d, 0x2d, 0xe5, 0x25, 0xd8,
+			0x21, 0x2f, 0xc1, 0x07, 0x96, 0x40, 0xac, 0x9c,
+			0xb7, 0x01, 0x9f, 0x4b, 0x79, 0x49, 0x76, 0x08,
+			0x4b, 0xf0, 0x41, 0xe5, 0x90, 0x2b, 0x7f, 0x3b,
+			0xee, 0x27, 0xd2, 0xde, 0x52, 0x5d, 0x82, 0x12,
+			0xfc, 0x10, 0x1f, 0x01, 0x80, 0x0a, 0xae, 0xf9,
+			0xf0, 0x18, 0x0d, 0x8c, 0x57, 0x91, 0xdb, 0x1d,
+			0x98, 0x52, 0x45, 0x03, 0xd8, 0x84, 0x9b, 0x0c,
+			0xf1, 0xac, 0x06, 0xc6, 0x2b, 0xc8, 0xed, 0x8e,
+			0xcc, 0x29, 0x22, 0x81, 0xec, 0x42, 0x4d, 0x86,
+			0x60, 0x36, 0x31, 0x5e, 0x47, 0x6c, 0x76, 0x61,
+			0x49, 0x14, 0x0f, 0x62, 0x12, 0x6c, 0x33, 0xc6,
+			0x03, 0x63, 0x15, 0xe4, 0x76, 0xc7, 0x66, 0x14,
+			0x91, 0x40, 0xf6, 0x21, 0x26, 0xc3, 0x31, 0x80,
+			0xd8, 0xc5, 0x79, 0x1d, 0xb1, 0xd9, 0x85, 0x24,
+			0x50, 0x3d, 0x88, 0x49, 0xb0, 0xcd, 0xc3, 0x07,
+			0xb2, 0x5e, 0x47, 0x6c, 0x76, 0x61, 0x49, 0x14,
+			0x0f, 0x60, 0x7c, 0x04, 0x00, 0x29, 0xf3, 0xe7,
+			0xcf, 0x9f, 0x3e, 0x07, 0xae, 0xa1, 0x8f, 0xa9,
+			0x09, 0x79, 0xfa, 0x0f, 0x6a, 0xcf, 0xf1, 0xdd,
+			0xff, 0xad, 0x1e, 0x03, 0xd7, 0x50, 0xc7, 0xd4,
+			0x84, 0xbc, 0xfd, 0x07, 0xb5, 0x67, 0xf8, 0xee,
+			0xff, 0xd6, 0x9e, 0xba, 0x86, 0x3e, 0xa4, 0x25,
+			0xe7, 0xe8, 0x3d, 0xab, 0x3f, 0xc7, 0x77, 0xfe,
+			0xb4, 0x79, 0xeb, 0xa8, 0x63, 0xea, 0x42, 0x5e,
+			0x7e, 0x83, 0xda, 0xb3, 0xfc, 0x77, 0x7f, 0xeb,
+			0x40, 0x7a, 0xea, 0x18, 0xfa, 0x90, 0x97, 0x9f,
+			0xa0, 0xf6, 0xac, 0xff, 0x1d, 0xdf, 0xfa, 0xd1,
+			0xbf, 0xf6, 0x14, 0x5e, 0xa4, 0x25, 0xe7, 0xe8,
+			0x3d, 0xab, 0x3f, 0xc6, 0x0f, 0x80, 0x00, 0x00,
+			0x2a, 0xec, 0xb0, 0xeb, 0x89, 0xce, 0x62, 0x9e,
+			0x03, 0x0d, 0xfc, 0xac, 0xb2, 0xe8, 0x90, 0xf1,
+			0xb5, 0x76, 0x58, 0x75, 0xc4, 0xe7, 0x31, 0x4f,
+			0x01, 0x86, 0xfe, 0x56, 0x59, 0x74, 0x48, 0xab,
+			0xb2, 0xc3, 0xae, 0x27, 0x39, 0x8a, 0x78, 0x0c,
+			0x37, 0xf2, 0xb2, 0xcb, 0xa2, 0x43, 0xca, 0xbb,
+			0x2c, 0x3a, 0xe2, 0x73, 0x98, 0xa7, 0x80, 0xc3,
+			0x7f, 0x2b, 0x2c, 0xba, 0x24, 0x32, 0xae, 0xcb,
+			0x0e, 0xb8, 0x9c, 0xe6, 0x29, 0xe0, 0x30, 0xdf,
+			0xca, 0xcb, 0x2e, 0x89, 0x0d, 0xfd, 0x67, 0x96,
+			0xae, 0x27, 0x39, 0x8a, 0x78, 0x0c, 0x37, 0xf2,
+			0xb0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe4, 0xa2,
+		},
+		SyncInfo{
+			Frmsizecod: 30,
+		},
+		48000,
+		BSI{
+			Bsid:  8,
+			Acmod: 7,
+			LfeOn: true,
+		},
+	},
+}
+
+func TestSyncInfoUnmarshal(t *testing.T) {
+	for _, ca := range ac3Cases {
+		t.Run(ca.name, func(t *testing.T) {
+			var syncInfo SyncInfo
+			err := syncInfo.Unmarshal(ca.enc)
+			require.NoError(t, err)
+			require.Equal(t, ca.syncInfo, syncInfo)
+			require.Equal(t, len(ca.enc), syncInfo.FrameSize())
+		})
+	}
+}
+
+func FuzzSyncInfoUnmarshal(f *testing.F) {
+	f.Fuzz(func(t *testing.T, b []byte) {
+		var syncInfo SyncInfo
+		syncInfo.Unmarshal(b) //nolint:errcheck
+	})
+}
diff --git a/pkg/codecs/ac3/testdata/fuzz/FuzzBSIUnmarshal/3c8832926b655ccb b/pkg/codecs/ac3/testdata/fuzz/FuzzBSIUnmarshal/3c8832926b655ccb
new file mode 100644
index 0000000..1b78e43
--- /dev/null
+++ b/pkg/codecs/ac3/testdata/fuzz/FuzzBSIUnmarshal/3c8832926b655ccb
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("AA")
diff --git a/pkg/codecs/ac3/testdata/fuzz/FuzzBSIUnmarshal/582528ddfad69eb5 b/pkg/codecs/ac3/testdata/fuzz/FuzzBSIUnmarshal/582528ddfad69eb5
new file mode 100644
index 0000000..a96f559
--- /dev/null
+++ b/pkg/codecs/ac3/testdata/fuzz/FuzzBSIUnmarshal/582528ddfad69eb5
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0")
diff --git a/pkg/codecs/ac3/testdata/fuzz/FuzzBSIUnmarshal/8727b16d337d7b81 b/pkg/codecs/ac3/testdata/fuzz/FuzzBSIUnmarshal/8727b16d337d7b81
new file mode 100644
index 0000000..e8000f3
--- /dev/null
+++ b/pkg/codecs/ac3/testdata/fuzz/FuzzBSIUnmarshal/8727b16d337d7b81
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("00")
diff --git a/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/06ba4bdb19de593e b/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/06ba4bdb19de593e
new file mode 100644
index 0000000..7fd7a20
--- /dev/null
+++ b/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/06ba4bdb19de593e
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0000")
diff --git a/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/582528ddfad69eb5 b/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/582528ddfad69eb5
new file mode 100644
index 0000000..a96f559
--- /dev/null
+++ b/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/582528ddfad69eb5
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("0")
diff --git a/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/65a9f0642bafc13e b/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/65a9f0642bafc13e
new file mode 100644
index 0000000..2bd1acb
--- /dev/null
+++ b/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/65a9f0642bafc13e
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("\vw00\xc7")
diff --git a/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/d3fcd860ad74180e b/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/d3fcd860ad74180e
new file mode 100644
index 0000000..c9d2674
--- /dev/null
+++ b/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/d3fcd860ad74180e
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("\vw000")
diff --git a/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/f55548b237b05cf1 b/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/f55548b237b05cf1
new file mode 100644
index 0000000..ae0291a
--- /dev/null
+++ b/pkg/codecs/ac3/testdata/fuzz/FuzzSyncInfoUnmarshal/f55548b237b05cf1
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("\vw00")
diff --git a/pkg/codecs/mpeg4audio/mpeg4_audio.go b/pkg/codecs/mpeg4audio/mpeg4_audio.go
index 83aa5ed..9d7ddcb 100644
--- a/pkg/codecs/mpeg4audio/mpeg4_audio.go
+++ b/pkg/codecs/mpeg4audio/mpeg4_audio.go
@@ -5,6 +5,6 @@ const (
 	// MaxAccessUnitSize is the maximum size of an access unit.
 	MaxAccessUnitSize = 5 * 1024
 
-	// SamplesPerAccessUnit is the number of samples contained by an access unit.
+	// SamplesPerAccessUnit is the number of samples contained inside an access unit.
 	SamplesPerAccessUnit = 1024
 )
diff --git a/pkg/formats/fmp4/boxes.go b/pkg/formats/fmp4/boxes.go
index 633cb64..2efa686 100644
--- a/pkg/formats/fmp4/boxes.go
+++ b/pkg/formats/fmp4/boxes.go
@@ -10,3 +10,26 @@ func BoxTypeMp4v() gomp4.BoxType { return gomp4.StrToBoxType("mp4v") }
 func init() {
 	gomp4.AddAnyTypeBoxDef(&gomp4.VisualSampleEntry{}, BoxTypeMp4v())
 }
+
+func BoxTypeAC3() gomp4.BoxType { return gomp4.StrToBoxType("ac-3") }
+func BoxTypeDA3() gomp4.BoxType { return gomp4.StrToBoxType("dac3") }
+
+type Dac3 struct {
+	gomp4.Box
+	Fscod       uint8 `mp4:"0,size=2"`
+	Bsid        uint8 `mp4:"1,size=5"`
+	Bsmod       uint8 `mp4:"2,size=3"`
+	Acmod       uint8 `mp4:"3,size=3"`
+	LfeOn       uint8 `mp4:"4,size=1"`
+	BitRateCode uint8 `mp4:"5,size=5"`
+	Reserved    uint8 `mp4:"6,size=5,const=0"`
+}
+
+func (Dac3) GetType() gomp4.BoxType {
+	return BoxTypeDA3()
+}
+
+func init() {
+	gomp4.AddAnyTypeBoxDef(&gomp4.AudioSampleEntry{}, BoxTypeAC3())
+	gomp4.AddBoxDef(&Dac3{})
+}
diff --git a/pkg/formats/fmp4/codec_ac3.go b/pkg/formats/fmp4/codec_ac3.go
new file mode 100644
index 0000000..7cb47fd
--- /dev/null
+++ b/pkg/formats/fmp4/codec_ac3.go
@@ -0,0 +1,20 @@
+package fmp4
+
+// CodecAC3 is the AC-3 codec.
+type CodecAC3 struct {
+	SampleRate   int
+	ChannelCount int
+	Fscod        uint8
+	Bsid         uint8
+	Bsmod        uint8
+	Acmod        uint8
+	LfeOn        bool
+	BitRateCode  uint8
+}
+
+// IsVideo implements Codec.
+func (CodecAC3) IsVideo() bool {
+	return false
+}
+
+func (CodecAC3) isCodec() {}
diff --git a/pkg/formats/fmp4/codec_av1.go b/pkg/formats/fmp4/codec_av1.go
index f53b2bd..43eae1b 100644
--- a/pkg/formats/fmp4/codec_av1.go
+++ b/pkg/formats/fmp4/codec_av1.go
@@ -1,6 +1,6 @@
 package fmp4
 
-// CodecAV1 is a AV1 codec.
+// CodecAV1 is the AV1 codec.
 type CodecAV1 struct {
 	SequenceHeader []byte
 }
diff --git a/pkg/formats/fmp4/codec_h264.go b/pkg/formats/fmp4/codec_h264.go
index 09ec02d..57d5be3 100644
--- a/pkg/formats/fmp4/codec_h264.go
+++ b/pkg/formats/fmp4/codec_h264.go
@@ -1,6 +1,6 @@
 package fmp4
 
-// CodecH264 is a H264 codec.
+// CodecH264 is the H264 codec.
 type CodecH264 struct {
 	SPS []byte
 	PPS []byte
diff --git a/pkg/formats/fmp4/codec_h265.go b/pkg/formats/fmp4/codec_h265.go
index 5c9fe10..730cdd6 100644
--- a/pkg/formats/fmp4/codec_h265.go
+++ b/pkg/formats/fmp4/codec_h265.go
@@ -1,6 +1,6 @@
 package fmp4
 
-// CodecH265 is a H265 codec.
+// CodecH265 is the H265 codec.
 type CodecH265 struct {
 	SPS []byte
 	PPS []byte
diff --git a/pkg/formats/fmp4/codec_opus.go b/pkg/formats/fmp4/codec_opus.go
index 1d4761c..9b0487e 100644
--- a/pkg/formats/fmp4/codec_opus.go
+++ b/pkg/formats/fmp4/codec_opus.go
@@ -1,6 +1,6 @@
 package fmp4
 
-// CodecOpus is a Opus codec.
+// CodecOpus is the Opus codec.
 type CodecOpus struct {
 	ChannelCount int
 }
diff --git a/pkg/formats/fmp4/codec_vp9.go b/pkg/formats/fmp4/codec_vp9.go
index e16a07c..e7191d7 100644
--- a/pkg/formats/fmp4/codec_vp9.go
+++ b/pkg/formats/fmp4/codec_vp9.go
@@ -1,6 +1,6 @@
 package fmp4
 
-// CodecVP9 is a VP9 codec.
+// CodecVP9 is the VP9 codec.
 type CodecVP9 struct {
 	Width             int
 	Height            int
diff --git a/pkg/formats/fmp4/init.go b/pkg/formats/fmp4/init.go
index 1369240..962be80 100644
--- a/pkg/formats/fmp4/init.go
+++ b/pkg/formats/fmp4/init.go
@@ -148,6 +148,7 @@ func (i *Init) Unmarshal(byts []byte) error {
 		waitingVideoEsds
 		waitingAudioEsds
 		waitingDOps
+		waitingDac3
 	)
 
 	state := waitingTrak
@@ -437,13 +438,43 @@ func (i *Init) Unmarshal(byts []byte) error {
 
 			state = waitingTrak
 
-		case "ac-3": // ac-3, not supported yet
+		case "ac-3":
 			if state != waitingCodec {
 				return nil, fmt.Errorf("unexpected box '%v'", h.BoxInfo.Type)
 			}
-			i.Tracks = i.Tracks[:len(i.Tracks)-1]
+
+			box, _, err := h.ReadPayload()
+			if err != nil {
+				return nil, err
+			}
+			ac3 := box.(*mp4.AudioSampleEntry)
+
+			sampleRate = int(ac3.SampleRate / 65536)
+			channelCount = int(ac3.ChannelCount)
+			state = waitingDac3
+
+		case "dac3":
+			if state != waitingDac3 {
+				return nil, fmt.Errorf("unexpected box '%v'", h.BoxInfo.Type)
+			}
+
+			box, _, err := h.ReadPayload()
+			if err != nil {
+				return nil, err
+			}
+			dac3 := box.(*Dac3)
+
+			curTrack.Codec = &CodecAC3{
+				SampleRate:   sampleRate,
+				ChannelCount: channelCount,
+				Fscod:        dac3.Fscod,
+				Bsid:         dac3.Bsid,
+				Bsmod:        dac3.Bsmod,
+				Acmod:        dac3.Acmod,
+				LfeOn:        dac3.LfeOn != 0,
+				BitRateCode:  dac3.BitRateCode,
+			}
 			state = waitingTrak
-			return nil, nil
 
 		case "ec-3": // ec-3, not supported yet
 			if state != waitingCodec {
diff --git a/pkg/formats/fmp4/init_test.go b/pkg/formats/fmp4/init_test.go
index beadf00..62330bd 100644
--- a/pkg/formats/fmp4/init_test.go
+++ b/pkg/formats/fmp4/init_test.go
@@ -990,6 +990,103 @@ var casesInit = []struct {
 			},
 		},
 	},
+	{
+		"ac-3",
+		[]byte{
+			0x00, 0x00, 0x00, 0x20, 0x66, 0x74, 0x79, 0x70,
+			0x6d, 0x70, 0x34, 0x32, 0x00, 0x00, 0x00, 0x01,
+			0x6d, 0x70, 0x34, 0x31, 0x6d, 0x70, 0x34, 0x32,
+			0x69, 0x73, 0x6f, 0x6d, 0x68, 0x6c, 0x73, 0x66,
+			0x00, 0x00, 0x02, 0x30, 0x6d, 0x6f, 0x6f, 0x76,
+			0x00, 0x00, 0x00, 0x6c, 0x6d, 0x76, 0x68, 0x64,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xe8,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+			0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x94,
+			0x74, 0x72, 0x61, 0x6b, 0x00, 0x00, 0x00, 0x5c,
+			0x74, 0x6b, 0x68, 0x64, 0x00, 0x00, 0x00, 0x03,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+			0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x01, 0x30, 0x6d, 0x64, 0x69, 0x61,
+			0x00, 0x00, 0x00, 0x20, 0x6d, 0x64, 0x68, 0x64,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x5f, 0x90,
+			0x00, 0x00, 0x00, 0x00, 0x55, 0xc4, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x2d, 0x68, 0x64, 0x6c, 0x72,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x73, 0x6f, 0x75, 0x6e, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x53, 0x6f, 0x75, 0x6e, 0x64, 0x48, 0x61, 0x6e,
+			0x64, 0x6c, 0x65, 0x72, 0x00, 0x00, 0x00, 0x00,
+			0xdb, 0x6d, 0x69, 0x6e, 0x66, 0x00, 0x00, 0x00,
+			0x10, 0x73, 0x6d, 0x68, 0x64, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x24, 0x64, 0x69, 0x6e, 0x66, 0x00, 0x00, 0x00,
+			0x1c, 0x64, 0x72, 0x65, 0x66, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+			0x0c, 0x75, 0x72, 0x6c, 0x20, 0x00, 0x00, 0x00,
+			0x01, 0x00, 0x00, 0x00, 0x9f, 0x73, 0x74, 0x62,
+			0x6c, 0x00, 0x00, 0x00, 0x53, 0x73, 0x74, 0x73,
+			0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x01, 0x00, 0x00, 0x00, 0x43, 0x61, 0x63, 0x2d,
+			0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x06, 0x00, 0x10, 0x00, 0x00, 0x00,
+			0x00, 0xbb, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x0b, 0x64, 0x61, 0x63, 0x33, 0x10, 0x3d, 0xe0,
+			0x00, 0x00, 0x00, 0x14, 0x62, 0x74, 0x72, 0x74,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xf7, 0x39,
+			0x00, 0x01, 0xf7, 0x39, 0x00, 0x00, 0x00, 0x10,
+			0x73, 0x74, 0x74, 0x73, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+			0x73, 0x74, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14,
+			0x73, 0x74, 0x73, 0x7a, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x10, 0x73, 0x74, 0x63, 0x6f,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x28, 0x6d, 0x76, 0x65, 0x78,
+			0x00, 0x00, 0x00, 0x20, 0x74, 0x72, 0x65, 0x78,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+			0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		},
+		Init{
+			Tracks: []*InitTrack{
+				{
+					ID:        1,
+					TimeScale: 90000,
+					Codec: &CodecAC3{
+						SampleRate:   48000,
+						ChannelCount: 6,
+						Fscod:        0x0,
+						Bsid:         0x8,
+						Bsmod:        0x0,
+						Acmod:        0x7,
+						LfeOn:        true,
+						BitRateCode:  0xf,
+					},
+				},
+			},
+		},
+	},
 	{
 		"h264 + mpeg4audio",
 		[]byte{
diff --git a/pkg/formats/fmp4/init_track.go b/pkg/formats/fmp4/init_track.go
index d2848ee..ca610f7 100644
--- a/pkg/formats/fmp4/init_track.go
+++ b/pkg/formats/fmp4/init_track.go
@@ -60,6 +60,9 @@ func (track *InitTrack) marshal(w *mp4Writer) error {
 				   - mp4a (MPEG-1 audio)
 					 - esds
 					 - btrt
+				   - ac-3 (AC-3)
+					 - dac3
+					 - btrt
 				 - stts
 				 - stsc
 				 - stsz
@@ -681,6 +684,39 @@ func (track *InitTrack) marshal(w *mp4Writer) error {
 		if err != nil {
 			return err
 		}
+
+	case *CodecAC3:
+		_, err = w.writeBoxStart(&mp4.AudioSampleEntry{ // <ac-3>
+			SampleEntry: mp4.SampleEntry{
+				AnyTypeBox: mp4.AnyTypeBox{
+					Type: BoxTypeAC3(),
+				},
+				DataReferenceIndex: 1,
+			},
+			ChannelCount: uint16(codec.ChannelCount),
+			SampleSize:   16,
+			SampleRate:   uint32(codec.SampleRate * 65536),
+		})
+		if err != nil {
+			return err
+		}
+
+		_, err = w.writeBox(&Dac3{ // <dac3/>
+			Fscod: codec.Fscod,
+			Bsid:  codec.Bsid,
+			Bsmod: codec.Bsmod,
+			Acmod: codec.Acmod,
+			LfeOn: func() uint8 {
+				if codec.LfeOn {
+					return 1
+				}
+				return 0
+			}(),
+			BitRateCode: codec.BitRateCode,
+		})
+		if err != nil {
+			return err
+		}
 	}
 
 	if track.Codec.IsVideo() {
diff --git a/pkg/formats/mpegts/codec_ac3.go b/pkg/formats/mpegts/codec_ac3.go
new file mode 100644
index 0000000..7f3d296
--- /dev/null
+++ b/pkg/formats/mpegts/codec_ac3.go
@@ -0,0 +1,24 @@
+package mpegts
+
+import (
+	"github.com/asticode/go-astits"
+)
+
+// CodecAC3 is an AC-3 codec.
+type CodecAC3 struct {
+	SampleRate   int
+	ChannelCount int
+}
+
+func (c CodecAC3) marshal(pid uint16) (*astits.PMTElementaryStream, error) {
+	return &astits.PMTElementaryStream{
+		ElementaryPID:               pid,
+		ElementaryStreamDescriptors: nil,
+		StreamType:                  astits.StreamTypeAC3Audio,
+	}, nil
+}
+
+// IsVideo implements Codec.
+func (CodecAC3) IsVideo() bool {
+	return true
+}
diff --git a/pkg/formats/mpegts/playback_reader.go b/pkg/formats/mpegts/playback_reader.go
index c88963f..3ff977d 100644
--- a/pkg/formats/mpegts/playback_reader.go
+++ b/pkg/formats/mpegts/playback_reader.go
@@ -10,12 +10,13 @@ type playbackReader struct {
 }
 
 func (r *playbackReader) Read(p []byte) (int, error) {
-	if len(r.buf) > 0 {
+	if r.buf != nil {
 		n := copy(p, r.buf)
-		r.buf = r.buf[n:]
 
-		if len(r.buf) == 0 { // release buf from memory
-			r.buf = nil
+		if len(r.buf) == n {
+			r.buf = nil // release buf from memory
+		} else {
+			r.buf = r.buf[n:]
 		}
 
 		return n, nil
diff --git a/pkg/formats/mpegts/reader.go b/pkg/formats/mpegts/reader.go
index ab242ad..7c10f83 100644
--- a/pkg/formats/mpegts/reader.go
+++ b/pkg/formats/mpegts/reader.go
@@ -7,6 +7,7 @@ import (
 
 	"github.com/asticode/go-astits"
 
+	"github.com/bluenviron/mediacommon/pkg/codecs/ac3"
 	"github.com/bluenviron/mediacommon/pkg/codecs/h264"
 	"github.com/bluenviron/mediacommon/pkg/codecs/mpeg1audio"
 	"github.com/bluenviron/mediacommon/pkg/codecs/mpeg4audio"
@@ -30,6 +31,9 @@ type ReaderOnDataMPEG4AudioFunc func(pts int64, aus [][]byte) error
 // ReaderOnDataMPEG1AudioFunc is the prototype of the callback passed to OnDataMPEG1Audio.
 type ReaderOnDataMPEG1AudioFunc func(pts int64, frames [][]byte) error
 
+// ReaderOnDataAC3Func is the prototype of the callback passed to OnDataAC3.
+type ReaderOnDataAC3Func func(pts int64, frame []byte) error
+
 func findPMT(dem *astits.Demuxer) (*astits.PMTData, error) {
 	for {
 		data, err := dem.NextData()
@@ -217,6 +221,31 @@ func (r *Reader) OnDataMPEG1Audio(track *Track, cb ReaderOnDataMPEG1AudioFunc) {
 	}
 }
 
+// OnDataAC3 sets a callback that is called when data from an AC-3 track is received.
+func (r *Reader) OnDataAC3(track *Track, cb ReaderOnDataAC3Func) {
+	r.onData[track.PID] = func(pts int64, dts int64, data []byte) error {
+		if pts != dts {
+			r.onDecodeError(fmt.Errorf("PTS is not equal to DTS"))
+			return nil
+		}
+
+		var syncInfo ac3.SyncInfo
+		err := syncInfo.Unmarshal(data)
+		if err != nil {
+			r.onDecodeError(err)
+			return nil
+		}
+		size := syncInfo.FrameSize()
+
+		if size != len(data) {
+			r.onDecodeError(fmt.Errorf("unexpected frame size: got %d, expected %d", len(data), size))
+			return nil
+		}
+
+		return cb(pts, data)
+	}
+}
+
 // Read reads data.
 func (r *Reader) Read() error {
 	data, err := r.dem.NextData()
diff --git a/pkg/formats/mpegts/reader_test.go b/pkg/formats/mpegts/reader_test.go
index a7e3cf8..16f1b1c 100644
--- a/pkg/formats/mpegts/reader_test.go
+++ b/pkg/formats/mpegts/reader_test.go
@@ -1,3 +1,4 @@
+//nolint:dupl
 package mpegts
 
 import (
@@ -489,11 +490,6 @@ var casesReadWriter = []struct {
 				30 * 90000,
 				[][]byte{{3}, {2}},
 			},
-			{
-				30*90000 + 2*90000,
-				30 * 90000,
-				[][]byte{{1}},
-			},
 		},
 		[]*astits.Packet{
 			{ // PMT
@@ -541,51 +537,6 @@ var casesReadWriter = []struct {
 					0x4c, 0x80, 0x01, 0x1f, 0xfc, 0x02,
 				},
 			},
-			{ // PMT
-				Header: astits.PacketHeader{
-					ContinuityCounter:         1,
-					HasPayload:                true,
-					PayloadUnitStartIndicator: true,
-					PID:                       0,
-				},
-				Payload: append([]byte{
-					0x00, 0x00, 0xb0, 0x0d, 0x00, 0x00, 0xc1, 0x00,
-					0x00, 0x00, 0x01, 0xf0, 0x00, 0x71, 0x10, 0xd8,
-					0x78,
-				}, bytes.Repeat([]byte{0xff}, 167)...),
-			},
-			{ // PAT
-				Header: astits.PacketHeader{
-					ContinuityCounter:         1,
-					HasPayload:                true,
-					PayloadUnitStartIndicator: true,
-					PID:                       4096,
-				},
-				Payload: append([]byte{
-					0x00, 0x02, 0xb0, 0x12, 0x00, 0x01, 0xc1, 0x00,
-					0x00, 0xe1, 0x01, 0xf0, 0x00, 0x0f, 0xe1, 0x01,
-					0xf0, 0x00, 0xec, 0xe2, 0xb0, 0x94,
-				}, bytes.Repeat([]byte{0xff}, 162)...),
-			},
-			{ // PES
-				AdaptationField: &astits.PacketAdaptationField{
-					Length:                161,
-					StuffingLength:        160,
-					RandomAccessIndicator: true,
-				},
-				Header: astits.PacketHeader{
-					ContinuityCounter:         1,
-					HasAdaptationField:        true,
-					HasPayload:                true,
-					PayloadUnitStartIndicator: true,
-					PID:                       257,
-				},
-				Payload: []byte{
-					0x00, 0x00, 0x01, 0xc0, 0x00, 0x10, 0x80, 0x80,
-					0x05, 0x21, 0x00, 0xaf, 0xe4, 0x01, 0xff, 0xf1,
-					0x4c, 0x80, 0x01, 0x1f, 0xfc, 0x01,
-				},
-			},
 		},
 	},
 	{
@@ -715,6 +666,189 @@ var casesReadWriter = []struct {
 			},
 		},
 	},
+	{
+		"ac-3",
+		&Track{
+			PID: 257,
+			Codec: &CodecAC3{
+				SampleRate:   48000,
+				ChannelCount: 1,
+			},
+		},
+		[]sample{
+			{
+				30 * 90000,
+				30 * 90000,
+				[][]byte{{
+					0x0b, 0x77, 0x47, 0x11, 0x0c, 0x40, 0x2f, 0x84,
+					0x2b, 0xc1, 0x07, 0x7a, 0xb0, 0xfa, 0xbb, 0xea,
+					0xef, 0x9f, 0x57, 0x7c, 0xf9, 0xf3, 0xf7, 0xcf,
+					0x9f, 0x3e, 0x32, 0xfe, 0xd5, 0xc1, 0x50, 0xde,
+					0xc5, 0x1e, 0x73, 0xd2, 0x6c, 0xa6, 0x94, 0x46,
+					0x4e, 0x92, 0x8c, 0x0f, 0xb9, 0xcf, 0xad, 0x07,
+					0x54, 0x4a, 0x2e, 0xf3, 0x7d, 0x07, 0x2e, 0xa4,
+					0x2f, 0xba, 0xbf, 0x39, 0xb5, 0xc9, 0x92, 0xa6,
+					0xe1, 0xb4, 0x70, 0xc5, 0xc4, 0xb5, 0xe6, 0x5d,
+					0x0f, 0xa8, 0x71, 0xa4, 0xcc, 0xc5, 0xbc, 0x75,
+					0x67, 0x92, 0x52, 0x4f, 0x7e, 0x62, 0x1c, 0xa9,
+					0xd9, 0xb5, 0x19, 0x6a, 0xd7, 0xb0, 0x44, 0x92,
+					0x30, 0x3b, 0xf7, 0x61, 0xd6, 0x49, 0x96, 0x66,
+					0x98, 0x28, 0x1a, 0x95, 0xa9, 0x42, 0xad, 0xb7,
+					0x50, 0x90, 0xad, 0x1c, 0x34, 0x80, 0xe2, 0xef,
+					0xcd, 0x41, 0x0b, 0xf0, 0x9d, 0x57, 0x62, 0x78,
+					0xfd, 0xc6, 0xc2, 0x19, 0x9e, 0x26, 0x31, 0xca,
+					0x1e, 0x75, 0xb1, 0x7a, 0x8e, 0xb5, 0x51, 0x3a,
+					0xfe, 0xe4, 0xf1, 0x0b, 0x4f, 0x14, 0x90, 0xdb,
+					0x9f, 0x44, 0x50, 0xbb, 0xef, 0x74, 0x00, 0x8c,
+					0x1f, 0x97, 0xa1, 0xa2, 0xfa, 0x72, 0x16, 0x47,
+					0xc6, 0xc0, 0xe5, 0xfe, 0x67, 0x03, 0x9c, 0xfe,
+					0x62, 0x01, 0xa1, 0x00, 0x5d, 0xff, 0xa5, 0x03,
+					0x59, 0xfa, 0xa8, 0x25, 0x5f, 0x6b, 0x83, 0x51,
+					0xf2, 0xc0, 0x44, 0xff, 0x2d, 0x05, 0x4b, 0xee,
+					0xe0, 0x54, 0x9e, 0xae, 0x86, 0x45, 0xf3, 0xbd,
+					0x0e, 0x42, 0xf2, 0xbf, 0x0f, 0x7f, 0xc6, 0x09,
+					0x07, 0xdc, 0x22, 0x11, 0x77, 0xbe, 0x31, 0x27,
+					0x5b, 0xa4, 0x13, 0x47, 0x07, 0x32, 0x9f, 0x1f,
+					0xcb, 0xb0, 0xdf, 0x3e, 0x7d, 0x0d, 0xf3, 0xe7,
+					0xcf, 0x9f, 0x3e, 0xae, 0xf9, 0xf3, 0xe7, 0xcf,
+					0x9f, 0x3e, 0x85, 0x5d, 0xf3, 0xe7, 0xcf, 0x9f,
+					0x3e, 0x7c, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3f,
+					0x53, 0x5d, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c,
+					0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c, 0xf9,
+					0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c, 0xf9, 0xf3,
+					0xe7, 0xcf, 0x9f, 0x3e, 0x00, 0x46, 0x28, 0x26,
+					0x20, 0x4a, 0x5a, 0xc0, 0x8a, 0xc5, 0xae, 0xa0,
+					0x55, 0x78, 0x82, 0x7a, 0x38, 0x10, 0x09, 0xc9,
+					0xb8, 0x0c, 0xfa, 0x5b, 0xc9, 0xd2, 0xec, 0x44,
+					0x25, 0xf8, 0x20, 0xf2, 0xc8, 0x8a, 0xe9, 0x40,
+					0x18, 0x06, 0xc6, 0x2b, 0xc8, 0xed, 0x8f, 0x33,
+					0x09, 0x92, 0x28, 0x1e, 0xc4, 0x24, 0xd8, 0x33,
+					0xa5, 0x00, 0xf5, 0xea, 0x18, 0xfa, 0x90, 0x97,
+					0x97, 0xe8, 0x39, 0x6a, 0xcf, 0xf1, 0xdd, 0xff,
+					0x9e, 0x8e, 0x04, 0x02, 0xae, 0x65, 0x87, 0x5c,
+					0x4e, 0x72, 0xfd, 0x3c, 0x01, 0x86, 0xfe, 0x56,
+					0x59, 0x74, 0x44, 0x3a, 0x40, 0x00, 0xec, 0xfc,
+				}},
+			},
+		},
+		[]*astits.Packet{
+			{ // PMT
+				Header: astits.PacketHeader{
+					HasPayload:                true,
+					PayloadUnitStartIndicator: true,
+					PID:                       0,
+				},
+				Payload: append([]byte{
+					0x00, 0x00, 0xb0, 0x0d, 0x00, 0x00, 0xc1, 0x00,
+					0x00, 0x00, 0x01, 0xf0, 0x00, 0x71, 0x10, 0xd8,
+					0x78,
+				}, bytes.Repeat([]byte{0xff}, 167)...),
+			},
+			{ // PAT
+				Header: astits.PacketHeader{
+					HasPayload:                true,
+					PayloadUnitStartIndicator: true,
+					PID:                       4096,
+				},
+				Payload: append([]byte{
+					0x00, 0x02, 0xb0, 0x12, 0x00, 0x01, 0xc1, 0x00,
+					0x00, 0xe1, 0x01, 0xf0, 0x00, 0x81, 0xe1, 0x01,
+					0xf0, 0x00, 0x12, 0x71, 0xfd, 0xb7,
+				}, bytes.Repeat([]byte{0xff}, 162)...),
+			},
+			{ // PES
+				AdaptationField: &astits.PacketAdaptationField{
+					Length:                7,
+					HasPCR:                true,
+					PCR:                   &astits.ClockReference{Base: 2691000},
+					RandomAccessIndicator: true,
+				},
+				Header: astits.PacketHeader{
+					HasAdaptationField:        true,
+					HasPayload:                true,
+					PayloadUnitStartIndicator: true,
+					PID:                       257,
+				},
+				Payload: []byte{
+					0x00, 0x00, 0x01, 0xc0, 0x01, 0x88, 0x80, 0x80,
+					0x05, 0x21, 0x00, 0xa5, 0x65, 0xc1, 0x0b, 0x77,
+					0x47, 0x11, 0x0c, 0x40, 0x2f, 0x84, 0x2b, 0xc1,
+					0x07, 0x7a, 0xb0, 0xfa, 0xbb, 0xea, 0xef, 0x9f,
+					0x57, 0x7c, 0xf9, 0xf3, 0xf7, 0xcf, 0x9f, 0x3e,
+					0x32, 0xfe, 0xd5, 0xc1, 0x50, 0xde, 0xc5, 0x1e,
+					0x73, 0xd2, 0x6c, 0xa6, 0x94, 0x46, 0x4e, 0x92,
+					0x8c, 0x0f, 0xb9, 0xcf, 0xad, 0x07, 0x54, 0x4a,
+					0x2e, 0xf3, 0x7d, 0x07, 0x2e, 0xa4, 0x2f, 0xba,
+					0xbf, 0x39, 0xb5, 0xc9, 0x92, 0xa6, 0xe1, 0xb4,
+					0x70, 0xc5, 0xc4, 0xb5, 0xe6, 0x5d, 0x0f, 0xa8,
+					0x71, 0xa4, 0xcc, 0xc5, 0xbc, 0x75, 0x67, 0x92,
+					0x52, 0x4f, 0x7e, 0x62, 0x1c, 0xa9, 0xd9, 0xb5,
+					0x19, 0x6a, 0xd7, 0xb0, 0x44, 0x92, 0x30, 0x3b,
+					0xf7, 0x61, 0xd6, 0x49, 0x96, 0x66, 0x98, 0x28,
+					0x1a, 0x95, 0xa9, 0x42, 0xad, 0xb7, 0x50, 0x90,
+					0xad, 0x1c, 0x34, 0x80, 0xe2, 0xef, 0xcd, 0x41,
+					0x0b, 0xf0, 0x9d, 0x57, 0x62, 0x78, 0xfd, 0xc6,
+					0xc2, 0x19, 0x9e, 0x26, 0x31, 0xca, 0x1e, 0x75,
+					0xb1, 0x7a, 0x8e, 0xb5, 0x51, 0x3a, 0xfe, 0xe4,
+					0xf1, 0x0b, 0x4f, 0x14, 0x90, 0xdb, 0x9f, 0x44,
+					0x50, 0xbb, 0xef, 0x74, 0x00, 0x8c, 0x1f, 0x97,
+				},
+			},
+			{ // PES
+				Header: astits.PacketHeader{
+					ContinuityCounter:         1,
+					HasPayload:                true,
+					PayloadUnitStartIndicator: false,
+					PID:                       257,
+				},
+				Payload: []byte{
+					0xa1, 0xa2, 0xfa, 0x72, 0x16, 0x47, 0xc6, 0xc0,
+					0xe5, 0xfe, 0x67, 0x03, 0x9c, 0xfe, 0x62, 0x01,
+					0xa1, 0x00, 0x5d, 0xff, 0xa5, 0x03, 0x59, 0xfa,
+					0xa8, 0x25, 0x5f, 0x6b, 0x83, 0x51, 0xf2, 0xc0,
+					0x44, 0xff, 0x2d, 0x05, 0x4b, 0xee, 0xe0, 0x54,
+					0x9e, 0xae, 0x86, 0x45, 0xf3, 0xbd, 0x0e, 0x42,
+					0xf2, 0xbf, 0x0f, 0x7f, 0xc6, 0x09, 0x07, 0xdc,
+					0x22, 0x11, 0x77, 0xbe, 0x31, 0x27, 0x5b, 0xa4,
+					0x13, 0x47, 0x07, 0x32, 0x9f, 0x1f, 0xcb, 0xb0,
+					0xdf, 0x3e, 0x7d, 0x0d, 0xf3, 0xe7, 0xcf, 0x9f,
+					0x3e, 0xae, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e,
+					0x85, 0x5d, 0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c,
+					0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3f, 0x53, 0x5d,
+					0xf3, 0xe7, 0xcf, 0x9f, 0x3e, 0x7c, 0xf9, 0xf3,
+					0xe7, 0xcf, 0x9f, 0x3e, 0x7c, 0xf9, 0xf3, 0xe7,
+					0xcf, 0x9f, 0x3e, 0x7c, 0xf9, 0xf3, 0xe7, 0xcf,
+					0x9f, 0x3e, 0x00, 0x46, 0x28, 0x26, 0x20, 0x4a,
+					0x5a, 0xc0, 0x8a, 0xc5, 0xae, 0xa0, 0x55, 0x78,
+					0x82, 0x7a, 0x38, 0x10, 0x09, 0xc9, 0xb8, 0x0c,
+					0xfa, 0x5b, 0xc9, 0xd2, 0xec, 0x44, 0x25, 0xf8,
+					0x20, 0xf2, 0xc8, 0x8a, 0xe9, 0x40, 0x18, 0x06,
+					0xc6, 0x2b, 0xc8, 0xed, 0x8f, 0x33, 0x09, 0x92,
+					0x28, 0x1e, 0xc4, 0x24, 0xd8, 0x33, 0xa5, 0x00,
+				},
+			},
+			{ // PES
+				AdaptationField: &astits.PacketAdaptationField{
+					Length:         145,
+					StuffingLength: 144,
+				},
+				Header: astits.PacketHeader{
+					ContinuityCounter:         2,
+					HasAdaptationField:        true,
+					HasPayload:                true,
+					PayloadUnitStartIndicator: false,
+					PID:                       257,
+				},
+				Payload: []byte{
+					0xf5, 0xea, 0x18, 0xfa, 0x90, 0x97, 0x97, 0xe8,
+					0x39, 0x6a, 0xcf, 0xf1, 0xdd, 0xff, 0x9e, 0x8e,
+					0x04, 0x02, 0xae, 0x65, 0x87, 0x5c, 0x4e, 0x72,
+					0xfd, 0x3c, 0x01, 0x86, 0xfe, 0x56, 0x59, 0x74,
+					0x44, 0x3a, 0x40, 0x00, 0xec, 0xfc,
+				},
+			},
+		},
+	},
 }
 
 func TestReader(t *testing.T) {
@@ -784,6 +918,14 @@ func TestReader(t *testing.T) {
 					return nil
 				})
 
+			case *CodecAC3:
+				r.OnDataAC3(ca.track, func(pts int64, frame []byte) error {
+					require.Equal(t, ca.samples[i].pts, pts)
+					require.Equal(t, ca.samples[i].data[0], frame)
+					i++
+					return nil
+				})
+
 			default:
 				t.Errorf("unexpected")
 			}
diff --git a/pkg/formats/mpegts/record_reader.go b/pkg/formats/mpegts/record_reader.go
index ef56a5d..3f880ac 100644
--- a/pkg/formats/mpegts/record_reader.go
+++ b/pkg/formats/mpegts/record_reader.go
@@ -22,7 +22,7 @@ func (r *recordReader) Read(p []byte) (int, error) {
 		return 0, errors.New("max buffer size exceeded")
 	}
 
-	r.buf = append(r.buf, p...)
+	r.buf = append(r.buf, p[:n]...)
 	r.size += n
 	return n, err
 }
diff --git a/pkg/formats/mpegts/track.go b/pkg/formats/mpegts/track.go
index 29cfe0b..f29e0f2 100644
--- a/pkg/formats/mpegts/track.go
+++ b/pkg/formats/mpegts/track.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	"github.com/asticode/go-astits"
+	"github.com/bluenviron/mediacommon/pkg/codecs/ac3"
 	"github.com/bluenviron/mediacommon/pkg/codecs/mpeg4audio"
 )
 
@@ -42,6 +43,33 @@ func findMPEG4AudioConfig(dem *astits.Demuxer, pid uint16) (*mpeg4audio.Config,
 	}
 }
 
+func findAC3Parameters(dem *astits.Demuxer, pid uint16) (int, int, error) {
+	for {
+		data, err := dem.NextData()
+		if err != nil {
+			return 0, 0, err
+		}
+
+		if data.PES == nil || data.PID != pid {
+			continue
+		}
+
+		var syncInfo ac3.SyncInfo
+		err = syncInfo.Unmarshal(data.PES.Data)
+		if err != nil {
+			return 0, 0, fmt.Errorf("invalid AC-3 frame: %s", err)
+		}
+
+		var bsi ac3.BSI
+		err = bsi.Unmarshal(data.PES.Data[5:])
+		if err != nil {
+			return 0, 0, fmt.Errorf("invalid AC-3 frame: %s", err)
+		}
+
+		return syncInfo.SampleRate(), bsi.ChannelCount(), nil
+	}
+}
+
 func findOpusRegistration(descriptors []*astits.Descriptor) bool {
 	for _, sd := range descriptors {
 		if sd.Registration != nil {
@@ -126,6 +154,18 @@ func (t *Track) unmarshal(dem *astits.Demuxer, es *astits.PMTElementaryStream) e
 		t.Codec = &CodecMPEG1Audio{}
 		return nil
 
+	case astits.StreamTypeAC3Audio:
+		sampleRate, channelCount, err := findAC3Parameters(dem, es.ElementaryPID)
+		if err != nil {
+			return err
+		}
+
+		t.Codec = &CodecAC3{
+			SampleRate:   sampleRate,
+			ChannelCount: channelCount,
+		}
+		return nil
+
 	case astits.StreamTypePrivateData:
 		codec := findOpusCodec(es.ElementaryStreamDescriptors)
 		if codec != nil {
diff --git a/pkg/formats/mpegts/writer.go b/pkg/formats/mpegts/writer.go
index 5ca3817..037ec59 100644
--- a/pkg/formats/mpegts/writer.go
+++ b/pkg/formats/mpegts/writer.go
@@ -442,3 +442,46 @@ func (w *Writer) WriteMPEG1Audio(
 	})
 	return err
 }
+
+// WriteAC3 writes a AC-3 frame.
+func (w *Writer) WriteAC3(
+	track *Track,
+	pts int64,
+	frame []byte,
+) error {
+	if !w.leadingTrackChosen {
+		w.leadingTrackChosen = true
+		track.isLeading = true
+		w.mux.SetPCRPID(track.PID)
+	}
+
+	af := &astits.PacketAdaptationField{
+		RandomAccessIndicator: true,
+	}
+
+	if track.isLeading {
+		if w.pcrCounter == 0 {
+			af.HasPCR = true
+			af.PCR = &astits.ClockReference{Base: pts - dtsPCRDiff}
+			w.pcrCounter = 3
+		}
+		w.pcrCounter--
+	}
+
+	_, err := w.mux.WriteData(&astits.MuxerData{
+		PID:             track.PID,
+		AdaptationField: af,
+		PES: &astits.PESData{
+			Header: &astits.PESHeader{
+				OptionalHeader: &astits.PESOptionalHeader{
+					MarkerBits:      2,
+					PTSDTSIndicator: astits.PTSDTSIndicatorOnlyPTS,
+					PTS:             &astits.ClockReference{Base: pts},
+				},
+				StreamID: streamIDAudio,
+			},
+			Data: frame,
+		},
+	})
+	return err
+}
diff --git a/pkg/formats/mpegts/writer_test.go b/pkg/formats/mpegts/writer_test.go
index 2bf4920..92245d7 100644
--- a/pkg/formats/mpegts/writer_test.go
+++ b/pkg/formats/mpegts/writer_test.go
@@ -60,6 +60,10 @@ func TestWriter(t *testing.T) {
 					err := w.WriteMPEG1Audio(ca.track, sample.pts, sample.data)
 					require.NoError(t, err)
 
+				case *CodecAC3:
+					err := w.WriteAC3(ca.track, sample.pts, sample.data[0])
+					require.NoError(t, err)
+
 				default:
 					t.Errorf("unexpected")
 				}