diff --git a/Cargo.toml b/Cargo.toml
index f2064a5..27eb987 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "hevc_parser"
-version = "0.6.8"
+version = "0.6.9"
 authors = ["quietvoid"]
 edition = "2024"
 rust-version = "1.85.0"
@@ -10,12 +10,12 @@ repository = "https://github.com/quietvoid/hevc_parser"
 
 [dependencies]
 nom = "8.0.0"
-bitvec_helpers = { version = "3.1.6", default-features = false, features = ["bitstream-io"] }
-anyhow = "1.0.96"
+bitvec_helpers = { version = "4.0.0", default-features = false, features = ["bitstream-io"] }
+anyhow = "1.0.98"
 regex = { version = "1.11.1", optional = true }
 
 # Matroska support
-matroska-demuxer = { version = "0.6.0", optional = true }
+matroska-demuxer = { version = "0.7.0", optional = true }
 
 [features]
 hevc_io = ["dep:regex", "dep:matroska-demuxer"]
diff --git a/src/hevc/config.rs b/src/hevc/config.rs
index 1d819c9..d8674e7 100644
--- a/src/hevc/config.rs
+++ b/src/hevc/config.rs
@@ -28,36 +28,36 @@ pub struct HEVCDecoderConfigurationRecord {
 impl HEVCDecoderConfigurationRecord {
     pub fn parse(bs: &mut BsIoSliceReader) -> Result<Self> {
         let mut config = HEVCDecoderConfigurationRecord {
-            configuration_version: bs.get_n(8)?,
-            general_profile_space: bs.get_n(2)?,
-            general_tier_flag: bs.get()?,
-            general_profile_idc: bs.get_n(5)?,
-            general_profile_compatibility_flags: bs.get_n(32)?,
-            general_constraint_indicator_flags: bs.get_n(48)?,
-            general_level_idc: bs.get_n(8)?,
+            configuration_version: bs.read::<8, u8>()?,
+            general_profile_space: bs.read::<2, u8>()?,
+            general_tier_flag: bs.read_bit()?,
+            general_profile_idc: bs.read::<5, u8>()?,
+            general_profile_compatibility_flags: bs.read::<32, u32>()?,
+            general_constraint_indicator_flags: bs.read::<48, u64>()?,
+            general_level_idc: bs.read::<8, u8>()?,
             ..Default::default()
         };
 
         bs.skip_n(4)?; // reserved 4bits
-        config.min_spatial_segmentation_idc = bs.get_n(12)?;
+        config.min_spatial_segmentation_idc = bs.read::<12, u16>()?;
 
         bs.skip_n(6)?; // reserved 6 bits
-        config.parallelism_type = bs.get_n(2)?;
+        config.parallelism_type = bs.read::<2, u8>()?;
 
         bs.skip_n(6)?; // reserved 6 bits
-        config.chroma_format_idc = bs.get_n(2)?;
+        config.chroma_format_idc = bs.read::<2, u8>()?;
 
         bs.skip_n(5)?; // reserved 5 bits
-        config.bit_depth_luma_minus8 = bs.get_n(3)?;
+        config.bit_depth_luma_minus8 = bs.read::<3, u8>()?;
 
         bs.skip_n(5)?; // reserved 5 bits
-        config.bit_depth_chroma_minus8 = bs.get_n(3)?;
+        config.bit_depth_chroma_minus8 = bs.read::<3, u8>()?;
 
-        config.avg_frame_rate = bs.get_n(16)?;
-        config.constant_frame_rate = bs.get_n(2)?;
-        config.num_temporal_layers = bs.get_n(3)?;
-        config.temporal_id_nested = bs.get()?;
-        config.length_size_minus_one = bs.get_n(2)?;
+        config.avg_frame_rate = bs.read::<16, u16>()?;
+        config.constant_frame_rate = bs.read::<2, u8>()?;
+        config.num_temporal_layers = bs.read::<3, u8>()?;
+        config.temporal_id_nested = bs.read_bit()?;
+        config.length_size_minus_one = bs.read::<2, u8>()?;
 
         Ok(config)
     }
diff --git a/src/hevc/hrd_parameters.rs b/src/hevc/hrd_parameters.rs
index 91e9d93..d85062d 100644
--- a/src/hevc/hrd_parameters.rs
+++ b/src/hevc/hrd_parameters.rs
@@ -17,11 +17,11 @@ impl HrdParameters {
         let mut subpic_params_present = false;
 
         if common_inf_present {
-            nal_params_present = bs.get()?;
-            vcl_params_present = bs.get()?;
+            nal_params_present = bs.read_bit()?;
+            vcl_params_present = bs.read_bit()?;
 
             if nal_params_present || vcl_params_present {
-                subpic_params_present = bs.get()?;
+                subpic_params_present = bs.read_bit()?;
 
                 if subpic_params_present {
                     bs.skip_n(8)?; // tick_divisor_minus2
@@ -46,20 +46,20 @@ impl HrdParameters {
         for _ in 0..vps_max_sub_layers {
             let mut low_delay = false;
             let mut nb_cpb = 1;
-            let mut fixed_rate = bs.get()?;
+            let mut fixed_rate = bs.read_bit()?;
 
             if !fixed_rate {
-                fixed_rate = bs.get()?;
+                fixed_rate = bs.read_bit()?;
             }
 
             if fixed_rate {
-                bs.get_ue()?;
+                bs.read_ue()?;
             } else {
-                low_delay = bs.get()?;
+                low_delay = bs.read_bit()?;
             }
 
             if !low_delay {
-                nb_cpb = bs.get_ue()? + 1;
+                nb_cpb = bs.read_ue()? + 1;
             }
 
             if nal_params_present {
@@ -78,12 +78,12 @@ impl HrdParameters {
 impl SubLayerHrdParameter {
     pub fn parse(bs: &mut BsIoVecReader, nb_cpb: u64, subpic_params_present: bool) -> Result<()> {
         for _ in 0..nb_cpb {
-            bs.get_ue()?; // bit_rate_value_minus1
-            bs.get_ue()?; // cpb_size_value_minus1
+            bs.read_ue()?; // bit_rate_value_minus1
+            bs.read_ue()?; // cpb_size_value_minus1
 
             if subpic_params_present {
-                bs.get_ue()?; // cpb_size_du_value_minus1
-                bs.get_ue()?; // bit_rate_du_value_minus1
+                bs.read_ue()?; // cpb_size_du_value_minus1
+                bs.read_ue()?; // bit_rate_du_value_minus1
             }
 
             bs.skip_n(1)?; // cbr_flag
diff --git a/src/hevc/pps.rs b/src/hevc/pps.rs
index 44f7761..02632db 100644
--- a/src/hevc/pps.rs
+++ b/src/hevc/pps.rs
@@ -54,82 +54,82 @@ pub struct PPSNAL {
 impl PPSNAL {
     pub fn parse(bs: &mut BsIoVecReader) -> Result<PPSNAL> {
         let mut pps = PPSNAL {
-            pps_id: bs.get_ue()?,
-            sps_id: bs.get_ue()?,
+            pps_id: bs.read_ue()?,
+            sps_id: bs.read_ue()?,
             ..Default::default()
         };
 
-        pps.dependent_slice_segments_enabled_flag = bs.get()?;
-        pps.output_flag_present_flag = bs.get()?;
-        pps.num_extra_slice_header_bits = bs.get_n(3)?;
-        pps.sign_data_hiding_flag = bs.get()?;
-        pps.cabac_init_present_flag = bs.get()?;
-        pps.num_ref_idx_l0_default_active = bs.get_ue()? + 1;
-        pps.num_ref_idx_l1_default_active = bs.get_ue()? + 1;
-        pps.pic_init_qp_minus26 = bs.get_se()?;
-        pps.constrained_intra_pred_flag = bs.get()?;
-        pps.transform_skip_enabled_flag = bs.get()?;
-        pps.cu_qp_delta_enabled_flag = bs.get()?;
+        pps.dependent_slice_segments_enabled_flag = bs.read_bit()?;
+        pps.output_flag_present_flag = bs.read_bit()?;
+        pps.num_extra_slice_header_bits = bs.read::<3, u8>()?;
+        pps.sign_data_hiding_flag = bs.read_bit()?;
+        pps.cabac_init_present_flag = bs.read_bit()?;
+        pps.num_ref_idx_l0_default_active = bs.read_ue()? + 1;
+        pps.num_ref_idx_l1_default_active = bs.read_ue()? + 1;
+        pps.pic_init_qp_minus26 = bs.read_se()?;
+        pps.constrained_intra_pred_flag = bs.read_bit()?;
+        pps.transform_skip_enabled_flag = bs.read_bit()?;
+        pps.cu_qp_delta_enabled_flag = bs.read_bit()?;
 
         pps.diff_cu_qp_delta_depth = if pps.cu_qp_delta_enabled_flag {
-            bs.get_ue()?
+            bs.read_ue()?
         } else {
             0
         };
 
-        pps.cb_qp_offset = bs.get_se()?;
-        pps.cr_qp_offset = bs.get_se()?;
+        pps.cb_qp_offset = bs.read_se()?;
+        pps.cr_qp_offset = bs.read_se()?;
 
-        pps.pic_slice_level_chroma_qp_offsets_present_flag = bs.get()?;
-        pps.weighted_pred_flag = bs.get()?;
-        pps.weighted_bipred_flag = bs.get()?;
+        pps.pic_slice_level_chroma_qp_offsets_present_flag = bs.read_bit()?;
+        pps.weighted_pred_flag = bs.read_bit()?;
+        pps.weighted_bipred_flag = bs.read_bit()?;
 
-        pps.transquant_bypass_enable_flag = bs.get()?;
-        pps.tiles_enabled_flag = bs.get()?;
-        pps.entropy_coding_sync_enabled_flag = bs.get()?;
+        pps.transquant_bypass_enable_flag = bs.read_bit()?;
+        pps.tiles_enabled_flag = bs.read_bit()?;
+        pps.entropy_coding_sync_enabled_flag = bs.read_bit()?;
 
         if pps.tiles_enabled_flag {
-            pps.num_tile_columns = bs.get_ue()? + 1;
-            pps.num_tile_rows = bs.get_ue()? + 1;
+            pps.num_tile_columns = bs.read_ue()? + 1;
+            pps.num_tile_rows = bs.read_ue()? + 1;
 
-            pps.uniform_spacing_flag = bs.get()?;
+            pps.uniform_spacing_flag = bs.read_bit()?;
 
             if !pps.uniform_spacing_flag {
                 for _ in 0..pps.num_tile_columns - 1 {
-                    pps.column_widths.push(bs.get_ue()? + 1);
+                    pps.column_widths.push(bs.read_ue()? + 1);
                 }
 
                 for _ in 0..pps.num_tile_rows - 1 {
-                    pps.row_heights.push(bs.get_ue()? + 1);
+                    pps.row_heights.push(bs.read_ue()? + 1);
                 }
             }
 
-            pps.loop_filter_across_tiles_enabled_flag = bs.get()?;
+            pps.loop_filter_across_tiles_enabled_flag = bs.read_bit()?;
         }
 
-        pps.seq_loop_filter_across_slices_enabled_flag = bs.get()?;
-        pps.deblocking_filter_control_present_flag = bs.get()?;
+        pps.seq_loop_filter_across_slices_enabled_flag = bs.read_bit()?;
+        pps.deblocking_filter_control_present_flag = bs.read_bit()?;
 
         if pps.deblocking_filter_control_present_flag {
-            pps.deblocking_filter_override_enabled_flag = bs.get()?;
-            pps.disable_dbf = bs.get()?;
+            pps.deblocking_filter_override_enabled_flag = bs.read_bit()?;
+            pps.disable_dbf = bs.read_bit()?;
 
             if !pps.disable_dbf {
-                pps.beta_offset = 2 * bs.get_se()?;
-                pps.tc_offset = 2 * bs.get_se()?;
+                pps.beta_offset = 2 * bs.read_se()?;
+                pps.tc_offset = 2 * bs.read_se()?;
             }
         }
 
-        pps.scaling_list_data_present_flag = bs.get()?;
+        pps.scaling_list_data_present_flag = bs.read_bit()?;
         if pps.scaling_list_data_present_flag {
             pps.scaling_list_data = ScalingListData::parse(bs)?;
         }
 
-        pps.lists_modification_present_flag = bs.get()?;
-        pps.log2_parallel_merge_level = bs.get_ue()? + 2;
+        pps.lists_modification_present_flag = bs.read_bit()?;
+        pps.log2_parallel_merge_level = bs.read_ue()? + 2;
 
-        pps.slice_header_extension_present_flag = bs.get()?;
-        pps.pps_extension_present_flag = bs.get()?;
+        pps.slice_header_extension_present_flag = bs.read_bit()?;
+        pps.pps_extension_present_flag = bs.read_bit()?;
 
         Ok(pps)
     }
diff --git a/src/hevc/profile_tier_level.rs b/src/hevc/profile_tier_level.rs
index 148af64..b51c8ed 100644
--- a/src/hevc/profile_tier_level.rs
+++ b/src/hevc/profile_tier_level.rs
@@ -28,26 +28,26 @@ pub struct ProfileTierLevel {
 
 impl ProfileTierLevel {
     pub fn parse(&mut self, bs: &mut BsIoVecReader, max_sub_layers: u8) -> Result<()> {
-        self.general_profile_space = bs.get_n(2)?;
-        self.general_tier_flag = bs.get()?;
-        self.general_profile_idc = bs.get_n(5)?;
+        self.general_profile_space = bs.read::<2, u8>()?;
+        self.general_tier_flag = bs.read_bit()?;
+        self.general_profile_idc = bs.read::<5, u8>()?;
 
         for _ in 0..32 {
-            self.general_profile_compatibility_flag.push(bs.get()?);
+            self.general_profile_compatibility_flag.push(bs.read_bit()?);
         }
 
-        self.general_progressive_source_flag = bs.get()?;
-        self.general_interlaced_source_flag = bs.get()?;
-        self.general_non_packed_constraint_flag = bs.get()?;
-        self.general_frame_only_constraint_flag = bs.get()?;
+        self.general_progressive_source_flag = bs.read_bit()?;
+        self.general_interlaced_source_flag = bs.read_bit()?;
+        self.general_non_packed_constraint_flag = bs.read_bit()?;
+        self.general_frame_only_constraint_flag = bs.read_bit()?;
         bs.skip_n(32)?;
         bs.skip_n(12)?;
-        self.general_level_idc = bs.get_n(8)?;
+        self.general_level_idc = bs.read::<8, u8>()?;
 
         let max_sub_layers_minus1 = max_sub_layers - 1;
         for _ in 0..max_sub_layers_minus1 {
-            self.sub_layer_profile_present_flag.push(bs.get()?);
-            self.sub_layer_level_present_flag.push(bs.get()?);
+            self.sub_layer_profile_present_flag.push(bs.read_bit()?);
+            self.sub_layer_level_present_flag.push(bs.read_bit()?);
         }
 
         if max_sub_layers_minus1 > 0 {
@@ -58,25 +58,28 @@ impl ProfileTierLevel {
 
         for i in 0..max_sub_layers_minus1 as usize {
             if self.sub_layer_profile_present_flag[i] {
-                self.sub_layer_profile_space.push(bs.get_n(2)?);
-                self.sub_layer_tier_flag.push(bs.get()?);
-                self.sub_layer_profile_idc.push(bs.get_n(5)?);
+                self.sub_layer_profile_space.push(bs.read::<2, u8>()?);
+                self.sub_layer_tier_flag.push(bs.read_bit()?);
+                self.sub_layer_profile_idc.push(bs.read::<5, u8>()?);
 
                 for _ in 0..32 {
-                    self.sub_layer_profile_compatibility_flag.push(bs.get()?);
+                    self.sub_layer_profile_compatibility_flag
+                        .push(bs.read_bit()?);
                 }
 
-                self.sub_layer_progressive_source_flag.push(bs.get()?);
-                self.sub_layer_interlaced_source_flag.push(bs.get()?);
-                self.sub_layer_non_packed_constraint_flag.push(bs.get()?);
-                self.sub_layer_frame_only_constraint_flag.push(bs.get()?);
+                self.sub_layer_progressive_source_flag.push(bs.read_bit()?);
+                self.sub_layer_interlaced_source_flag.push(bs.read_bit()?);
+                self.sub_layer_non_packed_constraint_flag
+                    .push(bs.read_bit()?);
+                self.sub_layer_frame_only_constraint_flag
+                    .push(bs.read_bit()?);
 
                 bs.skip_n(32)?;
                 bs.skip_n(12)?;
             }
 
             if self.sub_layer_level_present_flag[i] {
-                self.sub_layer_level_idc.push(bs.get_n(8)?);
+                self.sub_layer_level_idc.push(bs.read::<8, u8>()?);
             } else {
                 self.sub_layer_level_idc.push(1);
             }
diff --git a/src/hevc/scaling_list_data.rs b/src/hevc/scaling_list_data.rs
index a20f2cd..a4f5ee0 100644
--- a/src/hevc/scaling_list_data.rs
+++ b/src/hevc/scaling_list_data.rs
@@ -32,22 +32,22 @@ impl ScalingListData {
             }
 
             for matrix_id in 0..matrix_size {
-                scl.scaling_list_pred_mode_flag[size_id][matrix_id] = bs.get()?;
+                scl.scaling_list_pred_mode_flag[size_id][matrix_id] = bs.read_bit()?;
 
                 if !scl.scaling_list_pred_mode_flag[size_id][matrix_id] {
-                    scl.scaling_list_pred_matrix_id_delta[size_id][matrix_id] = bs.get_ue()?;
+                    scl.scaling_list_pred_matrix_id_delta[size_id][matrix_id] = bs.read_ue()?;
                 } else {
                     let _next_coef = 8;
                     let coef_num = min(64, 1 << (4 + (size_id << 1)));
 
                     if size_id > 1 {
-                        scl.scaling_list_dc_coef_minus8[size_id - 2][matrix_id] = bs.get_se()?;
+                        scl.scaling_list_dc_coef_minus8[size_id - 2][matrix_id] = bs.read_se()?;
                     }
 
                     scl.scaling_list_delta_coef[size_id][matrix_id].resize(coef_num, 0);
 
                     for i in 0..coef_num {
-                        scl.scaling_list_delta_coef[size_id][matrix_id][i] = bs.get_se()?;
+                        scl.scaling_list_delta_coef[size_id][matrix_id][i] = bs.read_se()?;
                     }
                 }
             }
diff --git a/src/hevc/sei.rs b/src/hevc/sei.rs
index 0f41d47..88339cc 100644
--- a/src/hevc/sei.rs
+++ b/src/hevc/sei.rs
@@ -26,7 +26,7 @@ impl SeiMessage {
         // forbidden_zero_bit
         reader.skip_n(1)?;
 
-        let nal_type = reader.get_n::<u8>(6)?;
+        let nal_type = reader.read::<6, u8>()?;
 
         if nal_type != NAL_SEI_PREFIX && nal_type != NAL_SEI_SUFFIX {
             bail!("NAL type {} is not SEI", nal_type);
@@ -53,30 +53,30 @@ impl SeiMessage {
 
     fn parse_sei_message(reader: &mut BsIoSliceReader) -> Result<SeiMessage> {
         let mut msg = SeiMessage {
-            msg_offset: (reader.position()? / 8) as usize,
-            last_payload_type_byte: reader.get_n(8)?,
+            msg_offset: (reader.position_in_bits()? / 8) as usize,
+            last_payload_type_byte: reader.read::<8, u8>()?,
             ..Default::default()
         };
 
         while msg.last_payload_type_byte == 0xFF {
             msg.num_payload_type_ff_bytes += 1;
-            msg.last_payload_type_byte = reader.get_n(8)?;
+            msg.last_payload_type_byte = reader.read::<8, u8>()?;
 
             msg.payload_type += 255;
         }
 
         msg.payload_type += msg.last_payload_type_byte;
 
-        msg.last_payload_size_byte = reader.get_n(8)?;
+        msg.last_payload_size_byte = reader.read::<8, u8>()?;
         while msg.last_payload_size_byte == 0xFF {
             msg.num_payload_size_ff_bytes += 1;
-            msg.last_payload_size_byte = reader.get_n(8)?;
+            msg.last_payload_size_byte = reader.read::<8, u8>()?;
 
             msg.payload_size += 255;
         }
 
         msg.payload_size += msg.last_payload_size_byte as usize;
-        msg.payload_offset = (reader.position()? / 8) as usize;
+        msg.payload_offset = (reader.position_in_bits()? / 8) as usize;
 
         if msg.payload_size > reader.available()? as usize {
             bail!("Payload size is larger than NALU size");
diff --git a/src/hevc/short_term_rps.rs b/src/hevc/short_term_rps.rs
index 35bd8ac..cfc6cc0 100644
--- a/src/hevc/short_term_rps.rs
+++ b/src/hevc/short_term_rps.rs
@@ -32,18 +32,18 @@ impl ShortTermRPS {
         let mut rps = ShortTermRPS::default();
 
         if st_rps_idx > 0 && nb_st_rps > 0 {
-            rps.inter_ref_pic_set_prediction_flag = bs.get()?;
+            rps.inter_ref_pic_set_prediction_flag = bs.read_bit()?;
         }
 
         if rps.inter_ref_pic_set_prediction_flag {
             let ref_pic_sets = &sps.short_term_ref_pic_sets;
 
             if st_rps_idx == nb_st_rps as usize || is_slice_header {
-                rps.delta_idx = bs.get_ue()?;
+                rps.delta_idx = bs.read_ue()?;
             }
 
-            rps.delta_rps_sign = bs.get()?;
-            rps.abs_delta_rps = bs.get_ue()? + 1;
+            rps.delta_rps_sign = bs.read_bit()?;
+            rps.abs_delta_rps = bs.read_ue()? + 1;
 
             let ref_rps_idx = st_rps_idx - (rps.delta_idx as usize + 1);
             let mut num_delta_pocs: usize = 0;
@@ -63,24 +63,24 @@ impl ShortTermRPS {
             rps.use_delta_flags.resize(num_delta_pocs + 1, true);
 
             for i in 0..=num_delta_pocs {
-                rps.used_by_curr_pic_flags[i] = bs.get()?;
+                rps.used_by_curr_pic_flags[i] = bs.read_bit()?;
 
                 if !rps.used_by_curr_pic_flags[i] {
-                    rps.use_delta_flags[i] = bs.get()?;
+                    rps.use_delta_flags[i] = bs.read_bit()?;
                 }
             }
         } else {
-            rps.num_negative_pics = bs.get_ue()?;
-            rps.num_positive_pics = bs.get_ue()?;
+            rps.num_negative_pics = bs.read_ue()?;
+            rps.num_positive_pics = bs.read_ue()?;
 
             for _ in 0..rps.num_negative_pics {
-                rps.delta_poc_s0.push(bs.get_ue()? + 1);
-                rps.used_by_curr_pic_s0_flags.push(bs.get()?);
+                rps.delta_poc_s0.push(bs.read_ue()? + 1);
+                rps.used_by_curr_pic_s0_flags.push(bs.read_bit()?);
             }
 
             for _ in 0..rps.num_positive_pics {
-                rps.delta_poc_s1.push(bs.get_ue()? + 1);
-                rps.used_by_curr_pic_s1_flags.push(bs.get()?);
+                rps.delta_poc_s1.push(bs.read_ue()? + 1);
+                rps.used_by_curr_pic_s1_flags.push(bs.read_bit()?);
             }
         }
 
diff --git a/src/hevc/slice.rs b/src/hevc/slice.rs
index d36798d..3fa0185 100644
--- a/src/hevc/slice.rs
+++ b/src/hevc/slice.rs
@@ -28,7 +28,7 @@ impl SliceNAL {
         poc: &mut u64,
     ) -> Result<SliceNAL> {
         let mut slice = SliceNAL {
-            first_slice_in_pic_flag: bs.get()?,
+            first_slice_in_pic_flag: bs.read_bit()?,
             ..Default::default()
         };
 
@@ -37,7 +37,7 @@ impl SliceNAL {
             bs.skip_n(1)?; // no_output_of_prior_pics_flag
         }
 
-        slice.pps_id = bs.get_ue()?;
+        slice.pps_id = bs.read_ue()?;
         let pps = pps_list
             .get(slice.pps_id as usize)
             .ok_or_else(|| format_err!("Invalid PPS index"))?;
@@ -47,7 +47,7 @@ impl SliceNAL {
 
         if !slice.first_slice_in_pic_flag {
             if pps.dependent_slice_segments_enabled_flag {
-                slice.dependent_slice_segment_flag = bs.get()?;
+                slice.dependent_slice_segment_flag = bs.read_bit()?;
             } else {
                 slice.dependent_slice_segment_flag = false;
             }
@@ -55,7 +55,7 @@ impl SliceNAL {
             let pic_size = (sps.ctb_width * sps.ctb_height) as f64;
             let slice_address_length = pic_size.log2().ceil() as u32;
 
-            slice.slice_segment_addr = bs.get_n(slice_address_length)?;
+            slice.slice_segment_addr = bs.read_var(slice_address_length)?;
         } else {
             slice.dependent_slice_segment_flag = false;
         }
@@ -68,7 +68,7 @@ impl SliceNAL {
             bs.skip_n(1)?; // slice_reserved_undetermined_flag
         }
 
-        slice.slice_type = bs.get_ue()?;
+        slice.slice_type = bs.read_ue()?;
 
         if pps.output_flag_present_flag {
             bs.skip_n(1)?;
@@ -79,7 +79,7 @@ impl SliceNAL {
         }
 
         if !is_idr_nal(nal) {
-            slice.pic_order_cnt_lsb = bs.get_n(sps.log2_max_poc_lsb as u32)?;
+            slice.pic_order_cnt_lsb = bs.read_var(sps.log2_max_poc_lsb as u32)?;
             slice.output_picture_number = compute_poc(sps, *poc_tid0, slice.pic_order_cnt_lsb, nal);
         } else {
             slice.output_picture_number = 0;
diff --git a/src/hevc/sps.rs b/src/hevc/sps.rs
index 10e6fe0..a464aab 100644
--- a/src/hevc/sps.rs
+++ b/src/hevc/sps.rs
@@ -88,41 +88,41 @@ pub struct SPSNAL {
 impl SPSNAL {
     pub fn parse(bs: &mut BsIoVecReader) -> Result<SPSNAL> {
         let mut sps = SPSNAL {
-            vps_id: bs.get_n(4)?,
+            vps_id: bs.read::<4, u8>()?,
             ..Default::default()
         };
 
-        sps.max_sub_layers = bs.get_n::<u8>(3)? + 1;
-        sps.temporal_id_nesting_flag = bs.get()?;
+        sps.max_sub_layers = bs.read::<3, u8>()? + 1;
+        sps.temporal_id_nesting_flag = bs.read_bit()?;
 
         sps.ptl.parse(bs, sps.max_sub_layers)?;
 
-        sps.sps_id = bs.get_ue()?;
-        sps.chroma_format_idc = bs.get_ue()?;
+        sps.sps_id = bs.read_ue()?;
+        sps.chroma_format_idc = bs.read_ue()?;
 
         if sps.chroma_format_idc == 3 {
-            sps.separate_colour_plane_flag = bs.get()?;
+            sps.separate_colour_plane_flag = bs.read_bit()?;
         }
 
         if sps.separate_colour_plane_flag {
             sps.chroma_format_idc = 0;
         }
 
-        sps.width = bs.get_ue()?;
-        sps.height = bs.get_ue()?;
-        sps.pic_conformance_flag = bs.get()?;
+        sps.width = bs.read_ue()?;
+        sps.height = bs.read_ue()?;
+        sps.pic_conformance_flag = bs.read_bit()?;
 
         if sps.pic_conformance_flag {
-            sps.conf_win_left_offset = bs.get_ue()?;
-            sps.conf_win_right_offset = bs.get_ue()?;
-            sps.conf_win_top_offset = bs.get_ue()?;
-            sps.conf_win_bottom_offset = bs.get_ue()?;
+            sps.conf_win_left_offset = bs.read_ue()?;
+            sps.conf_win_right_offset = bs.read_ue()?;
+            sps.conf_win_top_offset = bs.read_ue()?;
+            sps.conf_win_bottom_offset = bs.read_ue()?;
         }
 
-        sps.bit_depth = bs.get_ue()? + 8;
-        sps.bit_depth_chroma = bs.get_ue()? + 8;
-        sps.log2_max_poc_lsb = bs.get_ue()? + 4;
-        sps.sublayer_ordering_info = bs.get()?;
+        sps.bit_depth = bs.read_ue()? + 8;
+        sps.bit_depth_chroma = bs.read_ue()? + 8;
+        sps.log2_max_poc_lsb = bs.read_ue()? + 4;
+        sps.sublayer_ordering_info = bs.read_bit()?;
 
         let start = if sps.sublayer_ordering_info {
             0
@@ -131,47 +131,47 @@ impl SPSNAL {
         };
 
         for _ in start..sps.max_sub_layers {
-            sps.max_dec_pic_buffering.push(bs.get_ue()? + 1);
-            sps.num_reorder_pics.push(bs.get_ue()?);
+            sps.max_dec_pic_buffering.push(bs.read_ue()? + 1);
+            sps.num_reorder_pics.push(bs.read_ue()?);
 
-            let mut max_latency_increase = bs.get_ue()?;
+            let mut max_latency_increase = bs.read_ue()?;
             max_latency_increase = max_latency_increase.saturating_sub(1);
 
             sps.max_latency_increase.push(max_latency_increase);
         }
 
-        sps.log2_min_cb_size = bs.get_ue()? + 3;
-        sps.log2_diff_max_min_coding_block_size = bs.get_ue()?;
-        sps.log2_min_tb_size = bs.get_ue()? + 2;
-        sps.log2_diff_max_min_transform_block_size = bs.get_ue()?;
+        sps.log2_min_cb_size = bs.read_ue()? + 3;
+        sps.log2_diff_max_min_coding_block_size = bs.read_ue()?;
+        sps.log2_min_tb_size = bs.read_ue()? + 2;
+        sps.log2_diff_max_min_transform_block_size = bs.read_ue()?;
 
-        sps.max_transform_hierarchy_depth_inter = bs.get_ue()?;
-        sps.max_transform_hierarchy_depth_intra = bs.get_ue()?;
+        sps.max_transform_hierarchy_depth_inter = bs.read_ue()?;
+        sps.max_transform_hierarchy_depth_intra = bs.read_ue()?;
 
-        sps.scaling_list_enabled_flag = bs.get()?;
+        sps.scaling_list_enabled_flag = bs.read_bit()?;
 
         if sps.scaling_list_enabled_flag {
-            sps.scaling_list_data_present_flag = bs.get()?;
+            sps.scaling_list_data_present_flag = bs.read_bit()?;
 
             if sps.scaling_list_data_present_flag {
                 sps.scaling_list_data = ScalingListData::parse(bs)?;
             }
         }
 
-        sps.amp_enabled_flag = bs.get()?;
-        sps.sao_enabled_flag = bs.get()?;
-        sps.pcm_enabled_flag = bs.get()?;
+        sps.amp_enabled_flag = bs.read_bit()?;
+        sps.sao_enabled_flag = bs.read_bit()?;
+        sps.pcm_enabled_flag = bs.read_bit()?;
 
         if sps.pcm_enabled_flag {
-            sps.pcm_bit_depth = bs.get_n::<u8>(4)? + 1;
-            sps.pcm_bit_depth_chroma = bs.get_n::<u8>(4)? + 1;
-            sps.pcm_log2_min_pcm_cb_size = bs.get_ue()? + 3;
-            sps.pcm_log2_max_pcm_cb_size = bs.get_ue()? + sps.pcm_log2_min_pcm_cb_size;
+            sps.pcm_bit_depth = bs.read::<4, u8>()? + 1;
+            sps.pcm_bit_depth_chroma = bs.read::<4, u8>()? + 1;
+            sps.pcm_log2_min_pcm_cb_size = bs.read_ue()? + 3;
+            sps.pcm_log2_max_pcm_cb_size = bs.read_ue()? + sps.pcm_log2_min_pcm_cb_size;
 
-            sps.pcm_loop_filter_disable_flag = bs.get()?;
+            sps.pcm_loop_filter_disable_flag = bs.read_bit()?;
         }
 
-        sps.nb_st_rps = bs.get_ue()?;
+        sps.nb_st_rps = bs.read_ue()?;
 
         sps.short_term_ref_pic_sets
             .resize_with(sps.nb_st_rps as usize, Default::default);
@@ -180,28 +180,28 @@ impl SPSNAL {
                 ShortTermRPS::parse(bs, &sps, i, sps.nb_st_rps, false)?;
         }
 
-        sps.long_term_ref_pics_present_flag = bs.get()?;
+        sps.long_term_ref_pics_present_flag = bs.read_bit()?;
 
         if sps.long_term_ref_pics_present_flag {
-            sps.num_long_term_ref_pics_sps = bs.get_ue()?;
+            sps.num_long_term_ref_pics_sps = bs.read_ue()?;
 
             for _ in 0..sps.num_long_term_ref_pics_sps {
                 sps.lt_ref_pic_poc_lsb_sps
-                    .push(bs.get_n(sps.log2_max_poc_lsb as u32)?);
-                sps.used_by_curr_pic_lt_sps_flag.push(bs.get()?);
+                    .push(bs.read_var(sps.log2_max_poc_lsb as u32)?);
+                sps.used_by_curr_pic_lt_sps_flag.push(bs.read_bit()?);
             }
         }
 
-        sps.sps_temporal_mvp_enabled_flag = bs.get()?;
-        sps.sps_strong_intra_smoothing_enable_flag = bs.get()?;
+        sps.sps_temporal_mvp_enabled_flag = bs.read_bit()?;
+        sps.sps_strong_intra_smoothing_enable_flag = bs.read_bit()?;
 
-        sps.vui_present = bs.get()?;
+        sps.vui_present = bs.read_bit()?;
 
         if sps.vui_present {
             sps.vui_parameters = VuiParameters::parse(bs, sps.max_sub_layers)?;
         }
 
-        sps.sps_extension_flag = bs.get()?;
+        sps.sps_extension_flag = bs.read_bit()?;
 
         // Computed values
         sps.log2_ctb_size = sps.log2_min_cb_size + sps.log2_diff_max_min_coding_block_size;
diff --git a/src/hevc/vps.rs b/src/hevc/vps.rs
index f11f18c..be2ee2b 100644
--- a/src/hevc/vps.rs
+++ b/src/hevc/vps.rs
@@ -29,23 +29,23 @@ pub struct VPSNAL {
 impl VPSNAL {
     pub fn parse(bs: &mut BsIoVecReader) -> Result<VPSNAL> {
         let mut vps = VPSNAL {
-            vps_id: bs.get_n(4)?,
+            vps_id: bs.read::<4, u8>()?,
             ..Default::default()
         };
 
         // vps_reserved_three_2bits
-        assert!(bs.get_n::<u8>(2)? == 3);
+        assert!(bs.read::<2, u8>()? == 3);
 
-        vps.vps_max_layers = bs.get_n::<u8>(6)? + 1;
-        vps.vps_max_sub_layers = bs.get_n::<u8>(3)? + 1;
-        vps.vps_temporal_id_nesting_flag = bs.get()?;
+        vps.vps_max_layers = bs.read::<6, u8>()? + 1;
+        vps.vps_max_sub_layers = bs.read::<3, u8>()? + 1;
+        vps.vps_temporal_id_nesting_flag = bs.read_bit()?;
 
         // vps_reserved_ffff_16bits
-        assert!(bs.get_n::<u32>(16)? == 0xFFFF);
+        assert!(bs.read::<16, u16>()? == 0xFFFF);
 
         vps.ptl.parse(bs, vps.vps_max_sub_layers)?;
 
-        vps.vps_sub_layer_ordering_info_present_flag = bs.get()?;
+        vps.vps_sub_layer_ordering_info_present_flag = bs.read_bit()?;
 
         let i = if vps.vps_sub_layer_ordering_info_present_flag {
             0
@@ -54,17 +54,17 @@ impl VPSNAL {
         };
 
         for _ in i..vps.vps_max_sub_layers {
-            vps.vps_max_dec_pic_buffering.push(bs.get_ue()? + 1);
-            vps.vps_num_reorder_pics.push(bs.get_ue()?);
+            vps.vps_max_dec_pic_buffering.push(bs.read_ue()? + 1);
+            vps.vps_num_reorder_pics.push(bs.read_ue()?);
 
-            let mut vps_max_latency_increase = bs.get_ue()?;
+            let mut vps_max_latency_increase = bs.read_ue()?;
             vps_max_latency_increase = vps_max_latency_increase.saturating_sub(1);
 
             vps.vps_max_latency_increase.push(vps_max_latency_increase);
         }
 
-        vps.vps_max_layer_id = bs.get_n(6)?;
-        vps.vps_num_layer_sets = bs.get_ue()? + 1;
+        vps.vps_max_layer_id = bs.read::<6, u8>()?;
+        vps.vps_num_layer_sets = bs.read_ue()? + 1;
 
         for _ in 1..vps.vps_num_layer_sets {
             for _ in 0..=vps.vps_max_layer_id {
@@ -72,25 +72,25 @@ impl VPSNAL {
             }
         }
 
-        vps.vps_timing_info_present_flag = bs.get()?;
+        vps.vps_timing_info_present_flag = bs.read_bit()?;
 
         if vps.vps_timing_info_present_flag {
-            vps.vps_num_units_in_tick = bs.get_n(32)?;
-            vps.vps_time_scale = bs.get_n(32)?;
-            vps.vps_poc_proportional_to_timing_flag = bs.get()?;
+            vps.vps_num_units_in_tick = bs.read::<32, u32>()?;
+            vps.vps_time_scale = bs.read::<32, u32>()?;
+            vps.vps_poc_proportional_to_timing_flag = bs.read_bit()?;
 
             if vps.vps_poc_proportional_to_timing_flag {
-                vps.vps_num_ticks_poc_diff_one = bs.get_ue()? + 1;
+                vps.vps_num_ticks_poc_diff_one = bs.read_ue()? + 1;
             }
 
-            vps.vps_num_hrd_parameters = bs.get_ue()?;
+            vps.vps_num_hrd_parameters = bs.read_ue()?;
 
             for i in 0..vps.vps_num_hrd_parameters {
                 let mut common_inf_present = false;
-                bs.get_ue()?; // hrd_layer_set_idx
+                bs.read_ue()?; // hrd_layer_set_idx
 
                 if i > 0 {
-                    common_inf_present = bs.get()?;
+                    common_inf_present = bs.read_bit()?;
                 }
 
                 HrdParameters::parse(bs, common_inf_present, vps.vps_max_sub_layers)?;
diff --git a/src/hevc/vui_parameters.rs b/src/hevc/vui_parameters.rs
index 1370afa..7df54e1 100644
--- a/src/hevc/vui_parameters.rs
+++ b/src/hevc/vui_parameters.rs
@@ -55,82 +55,82 @@ pub struct VuiParameters {
 impl VuiParameters {
     pub fn parse(bs: &mut BsIoVecReader, max_sub_layers: u8) -> Result<VuiParameters> {
         let mut vui = VuiParameters {
-            sar_present: bs.get()?,
+            sar_present: bs.read_bit()?,
             ..Default::default()
         };
 
         if vui.sar_present {
-            vui.sar_idx = bs.get_n(8)?;
+            vui.sar_idx = bs.read::<8, u8>()?;
 
             if vui.sar_idx == 255 {
-                vui.sar_num = bs.get_n(16)?;
-                vui.sar_den = bs.get_n(16)?;
+                vui.sar_num = bs.read::<16, u16>()?;
+                vui.sar_den = bs.read::<16, u16>()?;
             }
         }
 
-        vui.overscan_info_present_flag = bs.get()?;
+        vui.overscan_info_present_flag = bs.read_bit()?;
         if vui.overscan_info_present_flag {
-            vui.overscan_appropriate_flag = bs.get()?;
+            vui.overscan_appropriate_flag = bs.read_bit()?;
         }
 
-        vui.video_signal_type_present_flag = bs.get()?;
+        vui.video_signal_type_present_flag = bs.read_bit()?;
         if vui.video_signal_type_present_flag {
-            vui.video_format = bs.get_n(3)?;
-            vui.video_full_range_flag = bs.get()?;
-            vui.colour_description_present_flag = bs.get()?;
+            vui.video_format = bs.read::<3, u8>()?;
+            vui.video_full_range_flag = bs.read_bit()?;
+            vui.colour_description_present_flag = bs.read_bit()?;
 
             if vui.colour_description_present_flag {
-                vui.colour_primaries = bs.get_n(8)?;
-                vui.transfer_characteristic = bs.get_n(8)?;
-                vui.matrix_coeffs = bs.get_n(8)?;
+                vui.colour_primaries = bs.read::<8, u8>()?;
+                vui.transfer_characteristic = bs.read::<8, u8>()?;
+                vui.matrix_coeffs = bs.read::<8, u8>()?;
             }
         }
 
-        vui.chroma_loc_info_present_flag = bs.get()?;
+        vui.chroma_loc_info_present_flag = bs.read_bit()?;
         if vui.chroma_loc_info_present_flag {
-            vui.chroma_sample_loc_type_top_field = bs.get_ue()?;
-            vui.chroma_sample_loc_type_bottom_field = bs.get_ue()?;
+            vui.chroma_sample_loc_type_top_field = bs.read_ue()?;
+            vui.chroma_sample_loc_type_bottom_field = bs.read_ue()?;
         }
 
-        vui.neutral_chroma_indication_flag = bs.get()?;
-        vui.field_seq_flag = bs.get()?;
-        vui.frame_field_info_present_flag = bs.get()?;
-        vui.default_display_window_flag = bs.get()?;
+        vui.neutral_chroma_indication_flag = bs.read_bit()?;
+        vui.field_seq_flag = bs.read_bit()?;
+        vui.frame_field_info_present_flag = bs.read_bit()?;
+        vui.default_display_window_flag = bs.read_bit()?;
 
         if vui.default_display_window_flag {
-            vui.def_disp_win_left_offset = bs.get_ue()?;
-            vui.def_disp_win_right_offset = bs.get_ue()?;
-            vui.def_disp_win_top_offset = bs.get_ue()?;
-            vui.def_disp_win_bottom_offset = bs.get_ue()?;
+            vui.def_disp_win_left_offset = bs.read_ue()?;
+            vui.def_disp_win_right_offset = bs.read_ue()?;
+            vui.def_disp_win_top_offset = bs.read_ue()?;
+            vui.def_disp_win_bottom_offset = bs.read_ue()?;
         }
 
-        vui.vui_timing_info_present_flag = bs.get()?;
+        vui.vui_timing_info_present_flag = bs.read_bit()?;
         if vui.vui_timing_info_present_flag {
-            vui.vui_num_units_in_tick = bs.get_n(32)?;
-            vui.vui_time_scale = bs.get_n(32)?;
+            vui.vui_num_units_in_tick = bs.read::<32, u32>()?;
+            vui.vui_time_scale = bs.read::<32, u32>()?;
 
-            vui.vui_poc_proportional_to_timing_flag = bs.get()?;
+            vui.vui_poc_proportional_to_timing_flag = bs.read_bit()?;
             if vui.vui_poc_proportional_to_timing_flag {
-                vui.vui_num_ticks_poc_diff_one_minus1 = bs.get_ue()?;
+                vui.vui_num_ticks_poc_diff_one_minus1 = bs.read_ue()?;
             }
 
-            vui.vui_hrd_parameters_present_flag = bs.get()?;
+            vui.vui_hrd_parameters_present_flag = bs.read_bit()?;
             if vui.vui_hrd_parameters_present_flag {
                 HrdParameters::parse(bs, true, max_sub_layers)?;
             }
         }
 
-        vui.bitstream_restriction_flag = bs.get()?;
+        vui.bitstream_restriction_flag = bs.read_bit()?;
         if vui.bitstream_restriction_flag {
-            vui.tiles_fixed_structure_flag = bs.get()?;
-            vui.motion_vectors_over_pic_boundaries_flag = bs.get()?;
-            vui.restricted_ref_pic_lists_flag = bs.get()?;
-
-            vui.min_spatial_segmentation_idc = bs.get_ue()?;
-            vui.max_bytes_per_pic_denom = bs.get_ue()?;
-            vui.max_bits_per_min_cu_denom = bs.get_ue()?;
-            vui.log2_max_mv_length_horizontal = bs.get_ue()?;
-            vui.log2_max_mv_length_vertical = bs.get_ue()?;
+            vui.tiles_fixed_structure_flag = bs.read_bit()?;
+            vui.motion_vectors_over_pic_boundaries_flag = bs.read_bit()?;
+            vui.restricted_ref_pic_lists_flag = bs.read_bit()?;
+
+            vui.min_spatial_segmentation_idc = bs.read_ue()?;
+            vui.max_bytes_per_pic_denom = bs.read_ue()?;
+            vui.max_bits_per_min_cu_denom = bs.read_ue()?;
+            vui.log2_max_mv_length_horizontal = bs.read_ue()?;
+            vui.log2_max_mv_length_vertical = bs.read_ue()?;
         }
 
         Ok(vui)
diff --git a/src/lib.rs b/src/lib.rs
index 217ce64..d5598a8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -169,14 +169,14 @@ impl HevcParser {
 
     fn parse_nal_header(&mut self, nal: &mut NALUnit) -> Result<()> {
         // forbidden_zero_bit
-        self.reader.get()?;
+        self.reader.read_bit()?;
 
-        nal.nal_type = self.reader.get_n(6)?;
+        nal.nal_type = self.reader.read::<6, u8>()?;
 
         if self.reader.available()? < 9 && matches!(nal.nal_type, NAL_EOS_NUT | NAL_EOB_NUT) {
         } else {
-            nal.nuh_layer_id = self.reader.get_n(6)?;
-            nal.temporal_id = self.reader.get_n::<u8>(3)? - 1;
+            nal.nuh_layer_id = self.reader.read::<6, u8>()?;
+            nal.temporal_id = self.reader.read::<3, u8>()? - 1;
         }
 
         Ok(())
diff --git a/src/utils.rs b/src/utils.rs
index 5601821..05034b2 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -57,16 +57,16 @@ pub fn aud_for_frame(frame: &Frame, start_code: Option<NALUStartCode>) -> Result
 
     let mut writer = BitstreamIoWriter::with_capacity(24);
 
-    writer.write(false)?; // forbidden_zero_bit
+    writer.write_bit(false)?; // forbidden_zero_bit
 
-    writer.write_n(&NAL_AUD, 6)?; // nal_unit_type
-    writer.write_n(&0_u8, 6)?; // nuh_layer_id
-    writer.write_n(&1_u8, 3)?; // nuh_temporal_id_plus1
+    writer.write::<6, u8>(NAL_AUD)?; // nal_unit_type
+    writer.write_const::<6, 0>()?; // nuh_layer_id
+    writer.write_const::<3, 1>()?; // nuh_temporal_id_plus1
 
-    writer.write_n(&pic_type, 3)?; // pic_type
+    writer.write::<3, u8>(pic_type)?; // pic_type
 
     // rbsp_trailing_bits()
-    writer.write(true)?; // rbsp_stop_one_bit
+    writer.write_bit(true)?; // rbsp_stop_one_bit
 
     // rbsp_alignment_zero_bit
     writer.byte_align()?;