chore: refactor some bitflags to bitfields

Author: nathanleiby

Cargo.lock

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+bitfields = "0.6.0"
 bitflags = "2.6.0"
 env_logger = "0.11.5"
 log = "0.4.22"

Cargo.toml

@@ -1,37 +1,40 @@
-use bitflags::bitflags;
-
-bitflags! {
-    /// PulseEnvelope
-    /// https://www.nesdev.org/wiki/APU_Envelope
-    struct PulseEnvelope: u8 {
-        /// Duty Cycle
-        const D = 0b1100_0000;
-        /// Envelope loop / length counter halt
-        const L = 0b0010_0000;
-        /// Constant volume/envelope flag
-        const C = 0b0001_0000;
-        /// Volume/envelope divider period
-        const V = 0b0000_1111;
-    }
+use bitfields::bitfield;
+
+/// https://www.nesdev.org/wiki/APU_Envelope
+#[bitfield(u8)]
+// #[derive(Copy, Clone)] // Attributes are passed to the struct.
+struct PulseEnvelope {
+    /// Duty Cycle
+    #[bits(2)]
+    D: u8,
+    /// Envelope loop / length counter halt
+    L: bool,
+    /// Constant volume/envelope flag
+    C: bool,
+    /// Volume/envelope divider period
+    #[bits(4)]
+    V: u8,
 }
 
-bitflags! {
-    /// PulseSweep
-    /// https://www.nesdev.org/wiki/APU_Sweep
-    struct PulseSweep: u8 {
-        /// Enabled flag
-        const E = 0b1000_0000;
-        /// Period
-        /// The divider's period is P + 1 half-frames
-        const P = 0b0111_0000;
-        /// Negate flag
-        /// 0: add to period, sweeping toward lower frequencies
-        /// 1: subtract from period, sweeping toward higher frequencies
-        const N = 0b0000_1000;
-        /// Shift count (number of bits).
-        /// If SSS is 0, then behaves like E=0.
-        const S = 0b0000_0111;
-    }
+/// PulseSweep
+/// https://www.nesdev.org/wiki/APU_Sweep
+#[bitfield(u8)]
+// #[derive(Copy, Clone)] // Attributes are passed to the struct.
+struct PulseSweep {
+    /// Enabled flag
+    E: bool,
+    /// Period
+    /// The divider's period is P + 1 half-frames
+    #[bits(3)]
+    P: u8,
+    /// Negate flag
+    /// 0: add to period, sweeping toward lower frequencies
+    /// 1: subtract from period, sweeping toward higher frequencies
+    N: bool,
+    /// Shift count (number of bits).
+    /// If SSS is 0, then behaves like E=0.
+    #[bits(3)]
+    S: u8,
 }
 
 /// https://www.nesdev.org/wiki/APU_Pulse
@@ -53,44 +56,38 @@ impl PulseRegister {
     // data[0]
 
     fn duty_cycle(&self) -> u8 {
-        let duty = (self.data[0] & PulseEnvelope::D.bits()) >> 6;
-        assert!(duty < 4);
-        duty
+        PulseEnvelope::from_bits(self.data[0]).D()
     }
 
     fn is_length_counter_halted(&self) -> bool {
-        PulseEnvelope::from_bits_truncate(self.data[0]).contains(PulseEnvelope::L)
+        PulseEnvelope::from_bits(self.data[0]).L()
     }
 
     fn is_constant_volume(&self) -> bool {
-        PulseEnvelope::from_bits_truncate(self.data[0]).contains(PulseEnvelope::C)
+        PulseEnvelope::from_bits(self.data[0]).C()
     }
 
     fn envelope_period(&self) -> u8 {
-        let pe = PulseEnvelope::from_bits_truncate(self.data[0]);
-        PulseEnvelope::V.intersection(pe).bits()
+        PulseEnvelope::from_bits(self.data[0]).V()
     }
 
     // data[1]
 
     fn is_sweep_enabled(&self) -> bool {
-        let ssc = self.sweep_shift_count();
-        let enabled = PulseSweep::from_bits_truncate(self.data[1]).contains(PulseSweep::E);
-        ssc > 0 && enabled
+        let s = PulseSweep::from_bits(self.data[1]);
+        s.E() && s.S() > 0
     }
 
     fn is_sweep_negated(&self) -> bool {
-        PulseSweep::from_bits_truncate(self.data[1]).contains(PulseSweep::N)
+        PulseSweep::from_bits(self.data[1]).N()
     }
 
     fn sweep_period(&self) -> u8 {
-        let s = PulseSweep::from_bits_truncate(self.data[1]);
-        PulseSweep::P.intersection(s).bits() >> 4
+        PulseSweep::from_bits(self.data[1]).P()
     }
 
     fn sweep_shift_count(&self) -> u8 {
-        let s = PulseSweep::from_bits_truncate(self.data[1]);
-        PulseSweep::S.intersection(s).bits()
+        PulseSweep::from_bits(self.data[1]).S()
     }
 
     // data[2] and data[3]