use super::*;
pub(crate) fn decode_raw_record(src: &bam::Record) -> std::io::Result<RecordBuf> {
let mut dst = RecordBuf::default();
*dst.name_mut() = src.name().map(Into::into);
*dst.flags_mut() = src.flags();
*dst.reference_sequence_id_mut() = src.reference_sequence_id().transpose()?;
*dst.alignment_start_mut() = src.alignment_start().transpose()?;
*dst.mapping_quality_mut() = src.mapping_quality();
let cigar = dst.cigar_mut().as_mut();
cigar.clear();
for result in src.cigar().iter() {
cigar.push(result?);
}
*dst.mate_reference_sequence_id_mut() = src.mate_reference_sequence_id().transpose()?;
*dst.mate_alignment_start_mut() = src.mate_alignment_start().transpose()?;
*dst.template_length_mut() = src.template_length();
let sequence = src.sequence();
*dst.sequence_mut() = unpack_bases(sequence.as_bytes(), sequence.len()).into();
*dst.quality_scores_mut() = src.quality_scores().into();
*dst.data_mut() = decode_data(src.data().as_bytes())?;
Ok(dst)
}
fn unpack_bases(packed: &[u8], len: usize) -> Vec<u8> {
const PAIRS: [[u8; 2]; 256] = {
const BASES: &[u8; 16] = b"=ACMGRSVTWYHKDBN";
let mut pairs = [[0; 2]; 256];
let mut i = 0;
while i < 256 {
pairs[i] = [BASES[i >> 4], BASES[i & 0x0f]];
i += 1;
}
pairs
};
let mut bases: Vec<u8> = packed.iter().flat_map(|&b| PAIRS[usize::from(b)]).collect();
bases.truncate(len);
bases
}
fn decode_data(aux: &[u8]) -> io::Result<noodles_sam::alignment::record_buf::Data> {
fn values<const N: usize, T>(bytes: &[u8], f: impl Fn([u8; N]) -> T) -> Vec<T> {
bytes.as_chunks::<N>().0.iter().map(|&c| f(c)).collect()
}
let mut data = noodles_sam::alignment::record_buf::Data::default();
let mut pos = 0;
while pos < aux.len() {
let field = next_field(aux, pos)?;
pos = field.bytes.end;
let raw = &aux[field.bytes.start + 3..field.bytes.end];
let value = match field.ty {
b'A' => Value::Character(raw[0]),
b'c' => Value::Int8(raw[0] as i8),
b'C' => Value::UInt8(raw[0]),
b's' => Value::Int16(i16::from_le_bytes([raw[0], raw[1]])),
b'S' => Value::UInt16(u16::from_le_bytes([raw[0], raw[1]])),
b'i' => Value::Int32(i32::from_le_bytes([raw[0], raw[1], raw[2], raw[3]])),
b'I' => Value::UInt32(u32::from_le_bytes([raw[0], raw[1], raw[2], raw[3]])),
b'f' => Value::Float(f32::from_le_bytes([raw[0], raw[1], raw[2], raw[3]])),
b'Z' => Value::String(raw[..raw.len() - 1].into()),
b'H' => Value::Hex(raw[..raw.len() - 1].into()),
_ => Value::Array(match raw[0] {
b'c' => Array::Int8(raw[5..].iter().map(|&b| b as i8).collect()),
b'C' => Array::UInt8(raw[5..].to_vec()),
b's' => Array::Int16(values(&raw[5..], i16::from_le_bytes)),
b'S' => Array::UInt16(values(&raw[5..], u16::from_le_bytes)),
b'i' => Array::Int32(values(&raw[5..], i32::from_le_bytes)),
b'I' => Array::UInt32(values(&raw[5..], u32::from_le_bytes)),
_ => Array::Float(values(&raw[5..], f32::from_le_bytes)),
}),
};
let tag = Tag::new(field.tag[0], field.tag[1]);
if data.insert(tag, value).is_some() {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
format!("duplicate tag: {tag:?}"),
));
}
}
Ok(data)
}
#[derive(Debug, Clone, Copy)]
pub(crate) struct Window {
pub start: usize,
pub end: usize,
pub idx: usize,
pub total: usize,
}
pub(super) fn window_edit<'a>(
src: &RecordBuf,
window: Window,
mod_block: ModBlock,
indexed: Option<&IndexedMods>,
moves: Option<&MoveIndex<'_>>,
remove: &'a TagRemoval,
) -> Option<RecordEdit<'a>> {
let Window {
start, end, total, ..
} = window;
let seq = src.sequence().as_ref();
let qual = src.quality_scores().as_ref();
let orig_len = seq.len();
let trimmed = start != 0 || end != orig_len;
let split = total > 1;
if !trimmed
&& !split
&& remove.is_empty()
&& matches!(mod_block, ModBlock::Absent | ModBlock::Consistent)
{
return None;
}
let platform = platform(src);
let name = (trimmed || split).then(|| {
let name: &[u8] = src.name().map(AsRef::as_ref).unwrap_or_default();
let coords = query_span(src).map(|(qs0, _)| window_coords(qs0, start, end));
segment_name(platform, name, window, coords)
});
let mut updates: TagUpdates = Vec::new();
match mod_block {
ModBlock::Absent => {},
ModBlock::Malformed => updates.extend(MOD_TAGS.map(|t| (t, None))),
ModBlock::Consistent | ModBlock::MissingMn => {
if let Some((mm, ml)) = mod_tags(src) {
let (mm, ml) = rebuild_mods(mm, ml, seq, start, end, indexed);
updates.push((Tag::BASE_MODIFICATIONS, Some(Value::String(mm.into()))));
updates.push((
Tag::BASE_MODIFICATION_PROBABILITIES,
ml.map(|ml| Value::Array(Array::UInt8(ml))),
));
updates.push((
Tag::BASE_MODIFICATION_SEQUENCE_LENGTH,
Some(Value::Int32((end - start) as i32)),
));
}
},
}
updates.extend(window_tag_updates(src, qual, window, platform, moves));
let sa = Tag::new(RLE_COVERAGE_TAG[0], RLE_COVERAGE_TAG[1]);
if trimmed
&& let Some(value) = src.data().get(&sa)
&& let Some(sliced) = windowed_value(RLE_COVERAGE_TAG, value, orig_len, start, end)
{
updates.push((sa, Some(sliced)));
}
Some(RecordEdit {
start,
end,
name,
updates,
remove,
reason: None,
})
}
pub(super) struct PreparedRead<'a> {
pub(super) seq: &'a [u8],
pub(super) qual: &'a [u8],
pub(super) mod_block: ModBlock,
pub(super) barcode: Option<(usize, usize)>,
}
pub(super) fn prepare_read<'a>(
rec: &'a RecordBuf,
cfg: &Config,
counters: &Counters,
) -> anyhow::Result<PreparedRead<'a>> {
crate::io::bam::ensure_trimmable(rec)?;
let seq = rec.sequence().as_ref();
let qual = rec.quality_scores().as_ref();
if qual.len() != seq.len() || crate::io::bam::quality_absent(qual) {
anyhow::bail!(
"read {}: BAM record SEQ length {} != QUAL length {} \
(records without per-base quality are not supported)",
crate::io::bam::display_name(rec.name().map(AsRef::as_ref)),
seq.len(),
qual.len()
);
}
let mod_block = inspect_mod_block(rec, seq.len());
if mod_block == ModBlock::Malformed {
counters.malformed_mod_reads.fetch_add(1, Ordering::Relaxed);
}
if has_malformed_perbase_tag(rec, seq.len()) {
counters.malformed_tag_reads.fetch_add(1, Ordering::Relaxed);
}
let barcode = match cfg.adapters.as_ref() {
Some(adapters) => match barcode_window(rec, seq.len()) {
BarcodeSpan::Spans { front, rear } => {
let (window, unverified) = verified_barcode_window(rec, seq, adapters, front, rear);
if unverified {
counters
.barcode_tag_unverified_reads
.fetch_add(1, Ordering::Relaxed);
}
window
},
BarcodeSpan::Absent => None,
BarcodeSpan::Malformed => {
counters
.barcode_tag_malformed_reads
.fetch_add(1, Ordering::Relaxed);
None
},
},
None => None,
};
Ok(PreparedRead {
seq,
qual,
mod_block,
barcode,
})
}
pub(super) fn render_windows(
rec: &RecordBuf,
cfg: &Config,
counters: &Counters,
render: impl FnMut(Window, ModBlock, Option<&IndexedMods>, Option<Reason>) -> anyhow::Result<()>,
) -> anyhow::Result<()> {
let PreparedRead {
seq,
qual,
mod_block,
barcode,
} = prepare_read(rec, cfg, counters)?;
let _read = crate::workflow::read_span(rec.name().map(|n| n.as_ref()).unwrap_or(b"<unnamed>"));
let _read = _read.enter();
let produced = trim::apply(seq, qual, &cfg.trim, cfg.adapters.as_ref(), barcode);
let indexed =
if matches!(mod_block, ModBlock::Consistent | ModBlock::MissingMn) && produced.len() > 1 {
mod_tags(rec).map(|(mm, ml)| IndexedMods::new(mods::parse(mm, ml.unwrap_or(&[])), seq))
} else {
None
};
let mut survivors: Vec<(usize, usize)> = Vec::new();
let render = std::cell::RefCell::new(render);
process_read_segments(
&produced,
seq,
qual,
&cfg.filter,
counters,
|idx, total, start, end| {
survivors.push((start, end));
render.borrow_mut()(
Window {
start,
end,
idx,
total,
},
mod_block,
indexed.as_ref(),
None,
)
},
|rejection| {
if !counters.wants_rejects() {
return Ok(());
}
let (window, reason) = match rejection {
Rejection::Segment {
idx,
total,
start,
end,
reason,
} => (
Window {
start,
end,
idx,
total,
},
Reason::Dropped(reason),
),
Rejection::Whole => (
Window {
start: 0,
end: seq.len(),
idx: 0,
total: 1,
},
Reason::TrimmedToNothing,
),
};
render.borrow_mut()(window, mod_block, indexed.as_ref(), Some(reason))
},
)?;
count_dropped_read_tags(counters, rec, seq.len(), &survivors);
Ok(())
}
pub(super) fn render_bam_read(
header: &sam::Header,
raw: &bam::Record,
rec: &RecordBuf,
cfg: &Config,
counters: &Counters,
mut emit: impl FnMut(Option<Vec<u8>>) -> io::Result<()>,
) -> anyhow::Result<()> {
let direction = if cfg.update_moves {
signal_reversed(header, rec)
} else {
None
};
let moves: std::cell::OnceCell<Option<MoveIndex<'_>>> = std::cell::OnceCell::new();
let seq = rec.sequence().as_ref();
render_windows(rec, cfg, counters, |window, mod_block, indexed, reason| {
let partial = window.start != 0 || window.end != seq.len();
if cfg.update_moves
&& direction.is_none()
&& partial
&& rec.data().get(&Tag::new(b'm', b'v')).is_some()
{
anyhow::bail!(
"read {}: --update-moves requires a DNA or RNA basecall_model in the @RG description",
crate::io::bam::display_name(rec.name().map(AsRef::as_ref))
);
}
let moves = if partial {
moves
.get_or_init(|| direction.and_then(|reverse| MoveIndex::new(rec, reverse)))
.as_ref()
} else {
None
};
let edit = window_edit(rec, window, mod_block, indexed, moves, &cfg.remove_tags);
match (edit, reason) {
(None, None) => Ok(emit(None)?),
(Some(edit), None) => Ok(emit(Some(build_record(raw, edit)?))?),
(edit, Some(reason)) => {
let mut edit =
edit.unwrap_or_else(|| RecordEdit::unchanged(seq.len(), &cfg.remove_tags));
edit.reason = Some(reason);
counters.reject(RejectItem::Bam(build_record(raw, edit)?))
},
}
})
}