diff --git a/rust/bt-common/Cargo.toml b/rust/bt-common/Cargo.toml
index 0b1c788..497acbb 100644
--- a/rust/bt-common/Cargo.toml
+++ b/rust/bt-common/Cargo.toml
@@ -4,10 +4,10 @@
 edition = "2021"
 license = "BSD-2-Clause"
 
-[dependencies.uuid]
-version = "1.4.1"
-features = ["macro-diagnostics"]
-
 [dependencies]
 bitflags = "2.4.0"
 thiserror = "1.0"
+
+[dependencies.uuid]
+version = "1.4.1"
+features = ["macro-diagnostics"]
diff --git a/rust/bt-common/src/company_id.rs b/rust/bt-common/src/company_id.rs
new file mode 100644
index 0000000..78addec
--- /dev/null
+++ b/rust/bt-common/src/company_id.rs
@@ -0,0 +1,28 @@
+// Copyright 2023 Google LLC
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+/// A Bluetooth Company ID, which is assigned by the Bluetotoh SIG.
+/// Company identifiers are unique numbers assigned by the Bluetooth SIG to
+/// member companies requesting one. Referenced in the Bluetooth Core Spec in
+/// many commands and formats. See the Assigned Number Document for a reference.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct CompanyId(u16);
+
+impl From<u16> for CompanyId {
+    fn from(value: u16) -> Self {
+        Self(value)
+    }
+}
+
+impl From<CompanyId> for u16 {
+    fn from(value: CompanyId) -> Self {
+        value.0
+    }
+}
+
+impl core::fmt::Display for CompanyId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Company (ID {:02x})", self.0)
+    }
+}
diff --git a/rust/bt-common/src/core.rs b/rust/bt-common/src/core.rs
index 16bb6ec..f7d8c7b 100644
--- a/rust/bt-common/src/core.rs
+++ b/rust/bt-common/src/core.rs
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+/// Traits and utilities to handle length-type-value structures.
+pub mod ltv;
+
 use crate::packet_encoding::{Encodable, Error as PacketError};
 
 /// Represents the Advertising Set ID which is 1 byte long.
@@ -45,6 +48,74 @@
     }
 }
 
+/// Coding Format as defined by the Assigned Numbers Document. Section 2.11.
+/// Referenced in the Core Spec 5.3, Volume 4, Part E, Section 7 as well as
+/// various other profile specifications.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum CodingFormat {
+    MuLawLog,
+    ALawLog,
+    Cvsd,
+    Transparent,
+    LinearPcm,
+    Msbc,
+    Lc3,
+    G729a,
+    VendorSpecific,
+    Unrecognized(u8),
+}
+
+impl From<u8> for CodingFormat {
+    fn from(value: u8) -> Self {
+        match value {
+            0x00 => Self::MuLawLog,
+            0x01 => Self::ALawLog,
+            0x02 => Self::Cvsd,
+            0x03 => Self::Transparent,
+            0x04 => Self::LinearPcm,
+            0x05 => Self::Msbc,
+            0x06 => Self::Lc3,
+            0x07 => Self::G729a,
+            0xFF => Self::VendorSpecific,
+            x => Self::Unrecognized(x),
+        }
+    }
+}
+
+impl From<CodingFormat> for u8 {
+    fn from(value: CodingFormat) -> Self {
+        match value {
+            CodingFormat::MuLawLog => 0x00,
+            CodingFormat::ALawLog => 0x01,
+            CodingFormat::Cvsd => 0x02,
+            CodingFormat::Transparent => 0x03,
+            CodingFormat::LinearPcm => 0x04,
+            CodingFormat::Msbc => 0x05,
+            CodingFormat::Lc3 => 0x06,
+            CodingFormat::G729a => 0x07,
+            CodingFormat::VendorSpecific => 0xFF,
+            CodingFormat::Unrecognized(x) => x,
+        }
+    }
+}
+
+impl core::fmt::Display for CodingFormat {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CodingFormat::MuLawLog => write!(f, "µ-law log"),
+            CodingFormat::ALawLog => write!(f, "A-law log"),
+            CodingFormat::Cvsd => write!(f, "CVSD"),
+            CodingFormat::Transparent => write!(f, "Transparent"),
+            CodingFormat::LinearPcm => write!(f, "Linear PCM"),
+            CodingFormat::Msbc => write!(f, "mSBC"),
+            CodingFormat::Lc3 => write!(f, "LC3"),
+            CodingFormat::G729a => write!(f, "G.729A"),
+            CodingFormat::VendorSpecific => write!(f, "Vendor Specific"),
+            CodingFormat::Unrecognized(x) => write!(f, "Unrecognized ({x})"),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -60,7 +131,7 @@
 
     #[test]
     fn encode_pa_interval_fails() {
-        let mut buf = [0; 1];  // Not enough buffer space.
+        let mut buf = [0; 1]; // Not enough buffer space.
         let interval = PaInterval(0x1004);
 
         interval.encode(&mut buf[..]).expect_err("should fail");
diff --git a/rust/bt-common/src/core/ltv.rs b/rust/bt-common/src/core/ltv.rs
new file mode 100644
index 0000000..5baab7d
--- /dev/null
+++ b/rust/bt-common/src/core/ltv.rs
@@ -0,0 +1,313 @@
+// Copyright 2023 Google LLC
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use crate::packet_encoding::{Decodable, Encodable};
+
+/// Implement Ltv when a collection of types is represented in the Bluetooth
+/// specifications as a length-type-value structure.  They should have an
+/// associated type which can be retrieved from a type byte.
+pub trait LtValue: Sized {
+    type Type: Into<u8> + Copy;
+
+    const NAME: &'static str;
+
+    /// Given a type octet, return the associated Type if it is possible.
+    /// Returns None if the value is unrecognized.
+    fn type_from_octet(x: u8) -> Option<Self::Type>;
+
+    /// Returns length bounds for the type indicated, **including** the type
+    /// byte. Note that the assigned numbers from the Bluetooth SIG include
+    /// the type byte in their Length specifications.
+    // TODO: use impl std::ops::RangeBounds when RPITIT is sufficiently stable
+    fn length_range_from_type(ty: Self::Type) -> std::ops::RangeInclusive<u8>;
+
+    /// Retrieve the type of the current value.
+    fn into_type(&self) -> Self::Type;
+
+    /// The length of the encoded value, without the length and type byte.
+    /// This cannot be 255 in practice, as the length byte is only one octet
+    /// long.
+    fn value_encoded_len(&self) -> u8;
+
+    /// Decodes the value from a buffer, which does not include the type or
+    /// length bytes. The `buf` slice length is exactly what was specified
+    /// for this value in the encoded source.
+    fn decode_value(ty: &Self::Type, buf: &[u8]) -> Result<Self, crate::packet_encoding::Error>;
+
+    /// Encodes a value into `buf`, which is verified to be the correct length
+    /// as indicated by [LtValue::value_encoded_len].
+    fn encode_value(&self, buf: &mut [u8]) -> Result<(), crate::packet_encoding::Error>;
+
+    /// Decode a collection of LtValue structures that are present in a buffer.
+    /// If it is possible to continue decoding after encountering an error, does
+    /// so and includes the error. If an unrecoverable error occurs, does
+    /// not consume the final item and the last element in the result is the
+    /// error.
+    fn decode_all(buf: &[u8]) -> (Vec<Result<Self, crate::packet_encoding::Error>>, usize) {
+        let mut results = Vec::new();
+        let mut total_consumed = 0;
+        loop {
+            if buf.len() <= total_consumed {
+                return (results, std::cmp::min(buf.len(), total_consumed));
+            }
+            let indicated_len = buf[total_consumed] as usize;
+            match Self::decode(&buf[total_consumed..=total_consumed + indicated_len]) {
+                Ok((item, consumed)) => {
+                    results.push(Ok(item));
+                    total_consumed += consumed;
+                }
+                Err(e @ crate::packet_encoding::Error::UnexpectedDataLength) => {
+                    results.push(Err(e));
+                    return (results, total_consumed);
+                }
+                Err(e) => {
+                    results.push(Err(e));
+                    // Consume the bytes
+                    total_consumed += indicated_len + 1;
+                }
+            }
+        }
+    }
+}
+
+impl<T: LtValue> Encodable for T {
+    type Error = crate::packet_encoding::Error;
+
+    fn encoded_len(&self) -> core::primitive::usize {
+        2 + self.value_encoded_len() as usize
+    }
+
+    fn encode(&self, buf: &mut [u8]) -> core::result::Result<(), Self::Error> {
+        if buf.len() < self.encoded_len() {
+            return Err(crate::packet_encoding::Error::BufferTooSmall);
+        }
+        buf[0] = self.value_encoded_len() + 1;
+        buf[1] = self.into_type().into();
+        self.encode_value(&mut buf[2..self.encoded_len()])?;
+        Ok(())
+    }
+}
+
+impl<T: LtValue> Decodable for T {
+    type Error = crate::packet_encoding::Error;
+
+    fn decode(buf: &[u8]) -> core::result::Result<(Self, usize), Self::Error> {
+        if buf.len() < 2 {
+            return Err(crate::packet_encoding::Error::UnexpectedDataLength);
+        }
+        let indicated_len = buf[0] as usize;
+        if buf.len() < indicated_len + 1 {
+            return Err(crate::packet_encoding::Error::UnexpectedDataLength);
+        }
+
+        let Some(ty) = Self::type_from_octet(buf[1]) else {
+            return Err(crate::packet_encoding::Error::UnrecognizedType(
+                Self::NAME.to_owned(),
+                buf[1],
+            ));
+        };
+
+        if !Self::length_range_from_type(ty).contains(&((buf.len() - 1) as u8)) {
+            return Err(crate::packet_encoding::Error::UnexpectedDataLength);
+        }
+
+        Ok((Self::decode_value(&ty, &buf[2..=indicated_len])?, indicated_len + 1))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[derive(Copy, Clone, PartialEq, Debug)]
+    enum TestType {
+        OneByte,
+        TwoBytes,
+        TwoBytesLittleEndian,
+        UnicodeString,
+        AlwaysError,
+    }
+
+    impl From<TestType> for u8 {
+        fn from(value: TestType) -> Self {
+            match value {
+                TestType::OneByte => 1,
+                TestType::TwoBytes => 2,
+                TestType::TwoBytesLittleEndian => 3,
+                TestType::UnicodeString => 4,
+                TestType::AlwaysError => 0xFF,
+            }
+        }
+    }
+
+    #[derive(PartialEq, Debug)]
+    enum TestValues {
+        OneByte(u8),
+        TwoBytes(u16),
+        TwoBytesLittleEndian(u16),
+        UnicodeString(String),
+        AlwaysError,
+    }
+
+    impl LtValue for TestValues {
+        type Type = TestType;
+
+        const NAME: &'static str = "TestValues";
+
+        fn type_from_octet(x: u8) -> Option<Self::Type> {
+            match x {
+                1 => Some(TestType::OneByte),
+                2 => Some(TestType::TwoBytes),
+                3 => Some(TestType::TwoBytesLittleEndian),
+                4 => Some(TestType::UnicodeString),
+                0xFF => Some(TestType::AlwaysError),
+                _ => None,
+            }
+        }
+
+        fn length_range_from_type(ty: Self::Type) -> std::ops::RangeInclusive<u8> {
+            match ty {
+                TestType::OneByte => 2..=2,
+                TestType::TwoBytes => 3..=3,
+                TestType::TwoBytesLittleEndian => 3..=3,
+                TestType::UnicodeString => 2..=255,
+                // AlwaysError fields can be any length (value will be thrown away)
+                TestType::AlwaysError => 1..=255,
+            }
+        }
+
+        fn into_type(&self) -> Self::Type {
+            match self {
+                TestValues::TwoBytes(_) => TestType::TwoBytes,
+                TestValues::TwoBytesLittleEndian(_) => TestType::TwoBytesLittleEndian,
+                TestValues::OneByte(_) => TestType::OneByte,
+                TestValues::UnicodeString(_) => TestType::UnicodeString,
+                TestValues::AlwaysError => TestType::AlwaysError,
+            }
+        }
+
+        fn value_encoded_len(&self) -> u8 {
+            match self {
+                TestValues::TwoBytes(_) => 2,
+                TestValues::TwoBytesLittleEndian(_) => 2,
+                TestValues::OneByte(_) => 1,
+                TestValues::UnicodeString(s) => s.len() as u8,
+                TestValues::AlwaysError => 0,
+            }
+        }
+
+        fn decode_value(
+            ty: &Self::Type,
+            buf: &[u8],
+        ) -> Result<Self, crate::packet_encoding::Error> {
+            match ty {
+                TestType::OneByte => Ok(TestValues::OneByte(buf[0])),
+                TestType::TwoBytes => {
+                    Ok(TestValues::TwoBytes(u16::from_be_bytes([buf[0], buf[1]])))
+                }
+                TestType::TwoBytesLittleEndian => {
+                    Ok(TestValues::TwoBytesLittleEndian(u16::from_le_bytes([buf[0], buf[1]])))
+                }
+                TestType::UnicodeString => {
+                    Ok(TestValues::UnicodeString(String::from_utf8_lossy(buf).into_owned()))
+                }
+                TestType::AlwaysError => Err(crate::packet_encoding::Error::OutOfRange),
+            }
+        }
+
+        fn encode_value(&self, buf: &mut [u8]) -> Result<(), crate::packet_encoding::Error> {
+            match self {
+                TestValues::TwoBytes(x) => {
+                    [buf[0], buf[1]] = x.to_be_bytes();
+                }
+                TestValues::TwoBytesLittleEndian(x) => {
+                    [buf[0], buf[1]] = x.to_le_bytes();
+                }
+                TestValues::OneByte(x) => buf[0] = *x,
+                TestValues::UnicodeString(s) => {
+                    buf.copy_from_slice(s.as_bytes());
+                }
+                TestValues::AlwaysError => {
+                    return Err(crate::packet_encoding::Error::InvalidParameter("test".to_owned()));
+                }
+            }
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn decode_twobytes() {
+        let encoded = [0x03, 0x02, 0x10, 0x01, 0x03, 0x03, 0x10, 0x01];
+        let (decoded, consumed) = TestValues::decode_all(&encoded);
+        assert_eq!(consumed, encoded.len());
+        assert_eq!(decoded[0], Ok(TestValues::TwoBytes(4097)));
+        assert_eq!(decoded[1], Ok(TestValues::TwoBytesLittleEndian(272)));
+    }
+
+    #[test]
+    fn decode_unrecognized() {
+        let encoded = [0x03, 0x02, 0x10, 0x01, 0x03, 0x06, 0x10, 0x01];
+        let (decoded, consumed) = TestValues::decode_all(&encoded);
+        assert_eq!(consumed, encoded.len());
+        assert_eq!(decoded[0], Ok(TestValues::TwoBytes(4097)));
+        assert_eq!(
+            decoded[1],
+            Err(crate::packet_encoding::Error::UnrecognizedType("TestValues".to_owned(), 6))
+        );
+    }
+
+    #[track_caller]
+    fn u8char(c: char) -> u8 {
+        c.try_into().unwrap()
+    }
+
+    #[test]
+    fn decode_variable_lengths() {
+        let encoded = [
+            0x03,
+            0x02,
+            0x10,
+            0x01,
+            0x0A,
+            0x04,
+            u8char('B'),
+            u8char('l'),
+            u8char('u'),
+            u8char('e'),
+            u8char('t'),
+            u8char('o'),
+            u8char('o'),
+            u8char('t'),
+            u8char('h'),
+            0x02,
+            0x01,
+            0x01,
+        ];
+        let (decoded, consumed) = TestValues::decode_all(&encoded);
+        assert_eq!(consumed, encoded.len());
+        assert_eq!(decoded[0], Ok(TestValues::TwoBytes(4097)));
+        assert_eq!(decoded[1], Ok(TestValues::UnicodeString("Bluetooth".to_owned())));
+        assert_eq!(decoded[2], Ok(TestValues::OneByte(1)));
+    }
+
+    #[test]
+    fn decode_with_error() {
+        let encoded = [0x03, 0x02, 0x10, 0x01, 0x02, 0xFF, 0xFF, 0x02, 0x01, 0x03];
+        let (decoded, consumed) = TestValues::decode_all(&encoded);
+        assert_eq!(consumed, encoded.len());
+        assert_eq!(decoded[0], Ok(TestValues::TwoBytes(4097)));
+        assert_eq!(decoded[1], Err(crate::packet_encoding::Error::OutOfRange),);
+        assert_eq!(decoded[2], Ok(TestValues::OneByte(3)));
+    }
+
+    #[test]
+    fn encode_with_error() {
+        let mut buf = [0; 10];
+        let value = TestValues::AlwaysError;
+        assert!(matches!(
+            value.encode(&mut buf),
+            Err(crate::packet_encoding::Error::InvalidParameter(_)),
+        ));
+    }
+}
diff --git a/rust/bt-common/src/generic_audio.rs b/rust/bt-common/src/generic_audio.rs
index 904506c..c2f72f0 100644
--- a/rust/bt-common/src/generic_audio.rs
+++ b/rust/bt-common/src/generic_audio.rs
@@ -2,4 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+pub mod codec_capabilities;
+
 pub mod metadata_ltv;
diff --git a/rust/bt-common/src/generic_audio/codec_capabilities.rs b/rust/bt-common/src/generic_audio/codec_capabilities.rs
new file mode 100644
index 0000000..eeff6cd
--- /dev/null
+++ b/rust/bt-common/src/generic_audio/codec_capabilities.rs
@@ -0,0 +1,256 @@
+// Copyright 2023 Google LLC
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use std::collections::HashSet;
+use std::ops::RangeBounds;
+
+use crate::core::ltv::LtValue;
+
+#[derive(Copy, Clone, Hash, PartialEq, Eq, Debug)]
+pub enum CodecCapabilityType {
+    SupportedSamplingFrequencies,
+    SupportedFrameDurations,
+    SupportedAudioChannelCounts,
+    SupportedOctetsPerCodecFrame,
+    SupportedMaxCodecFramesPerSdu,
+}
+
+impl From<CodecCapabilityType> for u8 {
+    fn from(value: CodecCapabilityType) -> Self {
+        match value {
+            CodecCapabilityType::SupportedSamplingFrequencies => 1,
+            CodecCapabilityType::SupportedFrameDurations => 2,
+            CodecCapabilityType::SupportedAudioChannelCounts => 3,
+            CodecCapabilityType::SupportedOctetsPerCodecFrame => 4,
+            CodecCapabilityType::SupportedMaxCodecFramesPerSdu => 5,
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+pub enum FrameDurationSupport {
+    SevenFiveMs,
+    TenMs,
+    BothNoPreference,
+    PreferSevenFiveMs,
+    PreferTenMs,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+pub enum SamplingFrequency {
+    F8000Hz,
+    F11025Hz,
+    F16000Hz,
+    F22050Hz,
+    F24000Hz,
+    F32000Hz,
+    F44100Hz,
+    F48000Hz,
+    F88200Hz,
+    F96000Hz,
+    F176400Hz,
+    F192000Hz,
+    F384000Hz,
+}
+
+impl SamplingFrequency {
+    fn bitpos(&self) -> u8 {
+        match self {
+            SamplingFrequency::F8000Hz => 0,
+            SamplingFrequency::F11025Hz => 1,
+            SamplingFrequency::F16000Hz => 2,
+            SamplingFrequency::F22050Hz => 3,
+            SamplingFrequency::F24000Hz => 4,
+            SamplingFrequency::F32000Hz => 5,
+            SamplingFrequency::F44100Hz => 6,
+            SamplingFrequency::F48000Hz => 7,
+            SamplingFrequency::F88200Hz => 8,
+            SamplingFrequency::F96000Hz => 9,
+            SamplingFrequency::F176400Hz => 10,
+            SamplingFrequency::F192000Hz => 11,
+            SamplingFrequency::F384000Hz => 12,
+        }
+    }
+
+    fn from_bitpos(value: u8) -> Option<Self> {
+        match value {
+            0 => Some(SamplingFrequency::F8000Hz),
+            1 => Some(SamplingFrequency::F11025Hz),
+            2 => Some(SamplingFrequency::F16000Hz),
+            3 => Some(SamplingFrequency::F22050Hz),
+            4 => Some(SamplingFrequency::F24000Hz),
+            5 => Some(SamplingFrequency::F32000Hz),
+            6 => Some(SamplingFrequency::F44100Hz),
+            7 => Some(SamplingFrequency::F48000Hz),
+            8 => Some(SamplingFrequency::F88200Hz),
+            9 => Some(SamplingFrequency::F96000Hz),
+            10 => Some(SamplingFrequency::F176400Hz),
+            11 => Some(SamplingFrequency::F192000Hz),
+            12 => Some(SamplingFrequency::F384000Hz),
+            _ => None,
+        }
+    }
+}
+
+/// Codec Capability LTV Structures
+///
+/// Defined in Assigned Numbers Section 6.12.4.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum CodecCapability {
+    SupportedSamplingFrequencies(std::collections::HashSet<SamplingFrequency>),
+    SupportedFrameDurations(FrameDurationSupport),
+    SupportedAudioChannelCounts(std::collections::HashSet<u8>),
+    SupportedMaxCodecFramesPerSdu(u8),
+    SupportedOctetsPerCodecFrame { min: u16, max: u16 },
+}
+
+impl LtValue for CodecCapability {
+    type Type = CodecCapabilityType;
+
+    const NAME: &'static str = "Codec Compatability";
+
+    fn type_from_octet(x: u8) -> Option<Self::Type> {
+        match x {
+            1 => Some(CodecCapabilityType::SupportedSamplingFrequencies),
+            2 => Some(CodecCapabilityType::SupportedFrameDurations),
+            3 => Some(CodecCapabilityType::SupportedAudioChannelCounts),
+            4 => Some(CodecCapabilityType::SupportedOctetsPerCodecFrame),
+            5 => Some(CodecCapabilityType::SupportedMaxCodecFramesPerSdu),
+            _ => None,
+        }
+    }
+
+    fn length_range_from_type(ty: Self::Type) -> std::ops::RangeInclusive<u8> {
+        match ty {
+            CodecCapabilityType::SupportedAudioChannelCounts => 2..=2,
+            CodecCapabilityType::SupportedFrameDurations => 2..=2,
+            CodecCapabilityType::SupportedMaxCodecFramesPerSdu => 2..=2,
+            CodecCapabilityType::SupportedOctetsPerCodecFrame => 5..=5,
+            CodecCapabilityType::SupportedSamplingFrequencies => 3..=3,
+        }
+    }
+
+    fn into_type(&self) -> Self::Type {
+        match self {
+            CodecCapability::SupportedAudioChannelCounts(_) => {
+                CodecCapabilityType::SupportedAudioChannelCounts
+            }
+            CodecCapability::SupportedFrameDurations(_) => {
+                CodecCapabilityType::SupportedFrameDurations
+            }
+            CodecCapability::SupportedMaxCodecFramesPerSdu(_) => {
+                CodecCapabilityType::SupportedMaxCodecFramesPerSdu
+            }
+            CodecCapability::SupportedOctetsPerCodecFrame { .. } => {
+                CodecCapabilityType::SupportedOctetsPerCodecFrame
+            }
+            CodecCapability::SupportedSamplingFrequencies(_) => {
+                CodecCapabilityType::SupportedSamplingFrequencies
+            }
+        }
+    }
+
+    fn value_encoded_len(&self) -> u8 {
+        // All the CodecCapabilities are constant length. Remove the type octet.
+        let range = Self::length_range_from_type(self.into_type());
+        let std::ops::Bound::Included(len) = range.start_bound() else {
+            unreachable!();
+        };
+        (len - 1).into()
+    }
+
+    fn encode_value(&self, buf: &mut [u8]) -> Result<(), crate::packet_encoding::Error> {
+        match self {
+            CodecCapability::SupportedAudioChannelCounts(counts) => {
+                buf[0] = counts
+                    .iter()
+                    .fold(0, |acc, count| if *count > 8 { acc } else { acc | (1 << (*count - 1)) });
+            }
+            CodecCapability::SupportedFrameDurations(support) => {
+                buf[0] = match support {
+                    FrameDurationSupport::SevenFiveMs => 0b000001,
+                    FrameDurationSupport::TenMs => 0b000010,
+                    FrameDurationSupport::BothNoPreference => 0b000011,
+                    FrameDurationSupport::PreferSevenFiveMs => 0b010011,
+                    FrameDurationSupport::PreferTenMs => 0b100011,
+                };
+            }
+            CodecCapability::SupportedMaxCodecFramesPerSdu(max) => {
+                buf[0] = *max;
+            }
+            CodecCapability::SupportedOctetsPerCodecFrame { min, max } => {
+                let min_bytes = min.to_le_bytes();
+                buf[0..=1].copy_from_slice(&min_bytes);
+
+                let max_bytes = max.to_le_bytes();
+                buf[2..=3].copy_from_slice(&max_bytes);
+            }
+            CodecCapability::SupportedSamplingFrequencies(supported) => {
+                let sup_bytes = supported
+                    .iter()
+                    .fold(0u16, |acc, freq| acc | (1 << freq.bitpos()))
+                    .to_le_bytes();
+                buf[0..=1].copy_from_slice(&sup_bytes)
+            }
+        };
+        Ok(())
+    }
+
+    fn decode_value(
+        ty: &CodecCapabilityType,
+        buf: &[u8],
+    ) -> Result<Self, crate::packet_encoding::Error> {
+        match ty {
+            CodecCapabilityType::SupportedAudioChannelCounts => {
+                let mut supported = HashSet::new();
+                for bitpos in 0..8 {
+                    if (buf[0] & (1 << bitpos)) != 0 {
+                        supported.insert(bitpos + 1);
+                    }
+                }
+                Ok(Self::SupportedAudioChannelCounts(supported))
+            }
+            CodecCapabilityType::SupportedFrameDurations => {
+                let support = match buf[0] & 0b110011 {
+                    0b000001 => FrameDurationSupport::SevenFiveMs,
+                    0b000010 => FrameDurationSupport::TenMs,
+                    0b000011 => FrameDurationSupport::BothNoPreference,
+                    0b010011 => FrameDurationSupport::PreferSevenFiveMs,
+                    0b100011 => FrameDurationSupport::PreferTenMs,
+                    _ => {
+                        return Err(crate::packet_encoding::Error::InvalidParameter(format!(
+                            "Unrecognized bit pattern: {:#b}",
+                            buf[0]
+                        )));
+                    }
+                };
+                Ok(Self::SupportedFrameDurations(support))
+            }
+            CodecCapabilityType::SupportedMaxCodecFramesPerSdu => {
+                Ok(Self::SupportedMaxCodecFramesPerSdu(buf[0]))
+            }
+            CodecCapabilityType::SupportedOctetsPerCodecFrame => {
+                let min = u16::from_le_bytes([buf[0], buf[1]]);
+                let max = u16::from_le_bytes([buf[2], buf[3]]);
+                Ok(Self::SupportedOctetsPerCodecFrame { min, max })
+            }
+            CodecCapabilityType::SupportedSamplingFrequencies => {
+                let bitflags = u16::from_le_bytes([buf[0], buf[1]]);
+                let mut supported = HashSet::new();
+                for bitpos in 0..13 {
+                    if bitflags & (1 << bitpos) != 0 {
+                        let Some(f) = SamplingFrequency::from_bitpos(bitpos) else {
+                            continue;
+                        };
+                        let _ = supported.insert(f);
+                    }
+                }
+                Ok(Self::SupportedSamplingFrequencies(supported))
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {}
diff --git a/rust/bt-common/src/generic_audio/metadata_ltv.rs b/rust/bt-common/src/generic_audio/metadata_ltv.rs
index e29b636..3630f4e 100644
--- a/rust/bt-common/src/generic_audio/metadata_ltv.rs
+++ b/rust/bt-common/src/generic_audio/metadata_ltv.rs
@@ -31,10 +31,10 @@
         } else {
             Err(PacketError::UnexpectedDataLength)
         }
-     }
+    }
 
-     // Total size range including all Length, Type, and Value parameters.
-     fn total_size_range(&self) -> std::ops::Range<usize> {
+    // Total size range including all Length, Type, and Value parameters.
+    fn total_size_range(&self) -> std::ops::Range<usize> {
         match self {
             Type::PreferredAudioContexts | Type::StreamingAudioContexts => 4..5,
             Type::ProgramInfo | Type::CCIDList | Type::ProgramInfoURI => 2..usize::MAX,
@@ -44,7 +44,7 @@
             Type::AudioActiveState => 3..4,
             Type::BroadcastAudioImmediateRenderingFlag => 2..3,
         }
-     }
+    }
 }
 
 impl TryFrom<u8> for Type {
@@ -92,13 +92,13 @@
     BroadcastAudioImmediateRenderingFlag,
 }
 
-
 impl Metadatum {
     const LENGTH_BYTE_SIZE: usize = 1;
     const TYPE_BYTE_SIZE: usize = 1;
     const MIN_PACKET_SIZE: usize = Self::LENGTH_BYTE_SIZE + Self::TYPE_BYTE_SIZE;
 
-    // Size of this metadatum's Value parameter. Does not include the Length or Type size.
+    // Size of this metadatum's Value parameter. Does not include the Length or Type
+    // size.
     pub fn value_encoded_len(&self) -> usize {
         match self {
             Metadatum::PreferredAudioContexts(_) => 2,
@@ -124,10 +124,12 @@
             Metadatum::CCIDList(_) => Type::CCIDList,
             Metadatum::ParentalRating(_) => Type::ParentalRating,
             Metadatum::ProgramInfoURI(_) => Type::ProgramInfoURI,
-            Metadatum::ExtendedMetadata{..} => Type::ExtendedMetadata,
-            Metadatum::VendorSpecific{..} => Type::VendorSpecific,
+            Metadatum::ExtendedMetadata { .. } => Type::ExtendedMetadata,
+            Metadatum::VendorSpecific { .. } => Type::VendorSpecific,
             Metadatum::AudioActiveState(_) => Type::AudioActiveState,
-            Metadatum::BroadcastAudioImmediateRenderingFlag => Type::BroadcastAudioImmediateRenderingFlag,
+            Metadatum::BroadcastAudioImmediateRenderingFlag => {
+                Type::BroadcastAudioImmediateRenderingFlag
+            }
         }
     }
 }
@@ -148,15 +150,17 @@
         let _ = type_.length_check(total_len)?;
         let m: Metadatum = match type_ {
             Type::PreferredAudioContexts | Type::StreamingAudioContexts => {
-                let context_type = ContextType::try_from(u16::from_le_bytes(buf[2..4].try_into().unwrap()))?;
+                let context_type =
+                    ContextType::try_from(u16::from_le_bytes(buf[2..4].try_into().unwrap()))?;
                 if type_ == Type::PreferredAudioContexts {
                     Self::PreferredAudioContexts(context_type)
-                }  else {
+                } else {
                     Self::StreamingAudioContexts(context_type)
                 }
-            },
+            }
             Type::ProgramInfo | Type::ProgramInfoURI => {
-                let value = String::from_utf8(buf[2..total_len].to_vec()).map_err(|e| PacketError::InvalidParameter(format!("{e}")))?;
+                let value = String::from_utf8(buf[2..total_len].to_vec())
+                    .map_err(|e| PacketError::InvalidParameter(format!("{e}")))?;
                 if type_ == Type::ProgramInfo {
                     Self::ProgramInfo(value)
                 } else {
@@ -164,55 +168,49 @@
                 }
             }
             Type::Language => {
-                let code = String::from_utf8(buf[2..total_len].to_vec()).map_err(|e| PacketError::InvalidParameter(format!("{e}")))?;
+                let code = String::from_utf8(buf[2..total_len].to_vec())
+                    .map_err(|e| PacketError::InvalidParameter(format!("{e}")))?;
                 Self::LanguageCode(code)
-            },
+            }
             Type::CCIDList => Self::CCIDList(buf[2..total_len].to_vec()),
-            Type::ParentalRating => {
-                Self::ParentalRating(Rating::decode(&buf[2..3])?.0)
-            },
+            Type::ParentalRating => Self::ParentalRating(Rating::decode(&buf[2..3])?.0),
             Type::ExtendedMetadata | Type::VendorSpecific => {
                 let type_or_id = u16::from_le_bytes(buf[2..4].try_into().unwrap());
-                let data = if buf.len() >= 5 {
-                    buf[4..total_len].to_vec()
-                } else {
-                    vec![]
-                };
+                let data = if buf.len() >= 5 { buf[4..total_len].to_vec() } else { vec![] };
                 if type_ == Type::ExtendedMetadata {
-                    Self::ExtendedMetadata{
-                        type_: type_or_id,
-                        metadata: data,
-                    }
+                    Self::ExtendedMetadata { type_: type_or_id, metadata: data }
                 } else {
-                    Self::VendorSpecific{
-                        company_id: type_or_id,
-                        metadata: data,
-                    }
+                    Self::VendorSpecific { company_id: type_or_id, metadata: data }
                 }
-            },
+            }
             Type::AudioActiveState => {
                 if buf[2] > 1 {
                     return Err(PacketError::UnexpectedDataLength);
                 }
                 Self::AudioActiveState(buf[2] != 0)
-            },
-            Type::BroadcastAudioImmediateRenderingFlag => Self::BroadcastAudioImmediateRenderingFlag,
+            }
+            Type::BroadcastAudioImmediateRenderingFlag => {
+                Self::BroadcastAudioImmediateRenderingFlag
+            }
         };
-        return Ok((m, total_len))
+        return Ok((m, total_len));
     }
 }
 
 impl Encodable for Metadatum {
     type Error = PacketError;
 
-    /// Encodes the object into a provided buffer in a Metadata LTV structure. Bytes are in LSO.
-    // See Assigned Numbers section 6.12.6 for details about Metadata LTV structures.
+    /// Encodes the object into a provided buffer in a Metadata LTV structure.
+    /// Bytes are in LSO.
+    // See Assigned Numbers section 6.12.6 for details about Metadata LTV
+    // structures.
     fn encode(&self, buf: &mut [u8]) -> core::result::Result<(), Self::Error> {
         if buf.len() < self.encoded_len() {
             return Err(PacketError::BufferTooSmall);
         }
 
-        // Length parameter value excludes the length of Length parameter itself (which is 1 byte).
+        // Length parameter value excludes the length of Length parameter itself (which
+        // is 1 byte).
         buf[0] = (self.encoded_len() - 1)
             .try_into()
             .map_err(|_| PacketError::InvalidParameter("Metadata too big".to_string()))?;
@@ -231,7 +229,7 @@
             Self::LanguageCode(value) => buf[2..5].copy_from_slice(&value.as_bytes()[..3]),
             Self::CCIDList(value) => buf[2..2 + value.len()].copy_from_slice(&value.as_slice()),
             Self::ParentalRating(value) => buf[2] = value.into(),
-            Self::ExtendedMetadata{type_, metadata} => {
+            Self::ExtendedMetadata { type_, metadata } => {
                 buf[2..4].copy_from_slice(&type_.to_le_bytes());
                 buf[4..4 + metadata.len()].copy_from_slice(&metadata.as_slice());
             }
@@ -261,7 +259,7 @@
             Metadatum::CCIDList(v) => write!(f, "CCID List: {v:?}"),
             Metadatum::ParentalRating(v) => write!(f, "Parental Rating: {v:?}"),
             Metadatum::ProgramInfoURI(v) => write!(f, "Program Info URI: {v:?}"),
-            Metadatum::ExtendedMetadata{type_, metadata} => {
+            Metadatum::ExtendedMetadata { type_, metadata } => {
                 write!(f, "Extended Metadata: type(0x{type_:02x}) metadata({metadata:?})")
             }
             Metadatum::VendorSpecific { company_id, metadata } => {
@@ -303,7 +301,6 @@
         }
         Ok(ContextType::from_bits_truncate(value))
     }
-
 }
 
 /// Represents recommended minimum age of the viewer.
@@ -337,7 +334,9 @@
 
     pub fn min_recommended(age: u8) -> Result<Self, PacketError> {
         if age < Self::MIN_RECOMMENDED_AGE {
-            return Err(PacketError::InvalidParameter(format!("minimum recommended age must be at least 5. Got {age}")));
+            return Err(PacketError::InvalidParameter(format!(
+                "minimum recommended age must be at least 5. Got {age}"
+            )));
         }
         Ok(Rating::Age(age))
     }
@@ -364,10 +363,9 @@
             0x00 => Rating::NoRating,
             0x01 => Rating::AllAge,
             value => {
-                let age = value.checked_add(Self::AGE_OFFSET)
-                    .ok_or(PacketError::OutOfRange)?;
+                let age = value.checked_add(Self::AGE_OFFSET).ok_or(PacketError::OutOfRange)?;
                 Rating::min_recommended(age).unwrap()
-            },
+            }
         };
         Ok((rating, 1))
     }
@@ -482,7 +480,7 @@
     #[test]
     fn metadatum_vendor_specific() {
         // Encoding.
-        let test = Metadatum::VendorSpecific{company_id: 0x00E0, metadata: vec![0x01, 0x02]};
+        let test = Metadatum::VendorSpecific { company_id: 0x00E0, metadata: vec![0x01, 0x02] };
         assert_eq!(test.encoded_len(), 0x06);
         let mut buf = vec![0; test.encoded_len()];
         let _ = test.encode(&mut buf[..]).expect("should not fail");
diff --git a/rust/bt-common/src/lib.rs b/rust/bt-common/src/lib.rs
index 67e9360..232ec7d 100644
--- a/rust/bt-common/src/lib.rs
+++ b/rust/bt-common/src/lib.rs
@@ -4,22 +4,33 @@
 
 extern crate core as rust_core;
 
-/// Peers are identified by ids, which should be treated as opaque by service libraries.
-/// Stack implementations should ensure that each PeerId identifies a single peer over a single
-/// instance of the stack - a [`bt_gatt::Central::connect`] should always attempt to connect to the
-/// same peer as long as the PeerId was retrieved after the `Central` was instantiated.
-/// PeerIds can be valid longer than that (often if the peer is bonded)
+/// Peers are identified by ids, which should be treated as opaque by service
+/// libraries. Stack implementations should ensure that each PeerId identifies a
+/// single peer over a single instance of the stack - a
+/// [`bt_gatt::Central::connect`] should always attempt to connect to the
+/// same peer as long as the PeerId was retrieved after the `Central` was
+/// instantiated. PeerIds can be valid longer than that (often if the peer is
+/// bonded)
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct PeerId(pub u64);
 
 impl rust_core::fmt::Display for PeerId {
-    fn fmt(&self, f: &mut rust_core::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut rust_core::fmt::Formatter<'_>,
+    ) -> std::result::Result<(), std::fmt::Error> {
         write!(f, "{:x}", self.0)
     }
 }
 
 pub mod core;
+
+pub mod company_id;
+pub use company_id::CompanyId;
+
 pub mod generic_audio;
+
 pub mod packet_encoding;
+
 pub mod uuid;
 pub use crate::uuid::Uuid;
diff --git a/rust/bt-common/src/packet_encoding.rs b/rust/bt-common/src/packet_encoding.rs
index fa01309..978430b 100644
--- a/rust/bt-common/src/packet_encoding.rs
+++ b/rust/bt-common/src/packet_encoding.rs
@@ -9,12 +9,13 @@
 pub trait Decodable: ::core::marker::Sized {
     type Error;
 
-    /// Decodes into a new object with the number of bytes that were decoded, or returns an error.
+    /// Decodes into a new object with the number of bytes that were decoded, or
+    /// returns an error.
     fn decode(buf: &[u8]) -> ::core::result::Result<(Self, usize), Self::Error>;
 }
 
 /// An encodable type can write itself into a byte buffer.
-pub trait Encodable: ::core::marker::Sized {
+pub trait Encodable {
     type Error;
 
     /// Returns the number of bytes necessary to encode |self|.
@@ -38,4 +39,7 @@
 
     #[error("Buffer being decoded is invalid length")]
     UnexpectedDataLength,
+
+    #[error("Unrecognized type for {0}: {1}")]
+    UnrecognizedType(String, u8),
 }
diff --git a/rust/bt-common/src/uuid.rs b/rust/bt-common/src/uuid.rs
index a47f790..2f11ed8 100644
--- a/rust/bt-common/src/uuid.rs
+++ b/rust/bt-common/src/uuid.rs
@@ -7,7 +7,8 @@
 pub struct Uuid(uuid::Uuid);
 
 impl Uuid {
-    // Non-changing parts of the Bluetooth Base UUID, for easy comparison and construction.
+    // Non-changing parts of the Bluetooth Base UUID, for easy comparison and
+    // construction.
     const BASE_UUID_B_PART: u16 = 0x0000;
     const BASE_UUID_C_PART: u16 = 0x1000;
     const BASE_UUID_D_PART: [u8; 8] = [0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB];