use std::time::Duration;
use prolink_proto::analysis::{self, Cue, PrefixWord};
use prolink_proto::dbserver::{Arguments, Field, MediaInfo, Message, MessageKind};
use prolink_rekordbox::FourCc;
use crate::serve::Medium;
pub(super) fn reply(
message: &Message,
medium: Option<&Medium>,
uptime: Duration,
) -> Option<Message> {
let kind = message.kind;
let transaction = message.transaction_id;
let track_id = match kind {
MessageKind::GET_WAVEFORM_PREVIEW => message.number(2),
_ => message.number(1),
}
.unwrap_or(0);
if kind == MessageKind::GET_ARTWORK {
let image = medium
.map(|medium| medium.artwork(track_id))
.unwrap_or_default();
return Message::binary_reply(transaction, MessageKind::ARTWORK, kind, image, &[]);
}
if kind == MessageKind::GET_CUE_POINTS {
return Some(cue_points(transaction, medium, track_id));
}
if kind == MessageKind::GET_MEDIA_INFO {
return Some(media_info(transaction, medium));
}
if let Some(medium) = medium
&& medium.is_plain()
{
return plain_analysis(transaction, kind);
}
let (response, payload, trailing) = match kind {
MessageKind::GET_VBR_INDEX => (
MessageKind::VBR_INDEX,
with_payload(medium, track_id, FourCc::PVBR, analysis::vbr_index),
[].as_slice(),
),
MessageKind::GET_BEAT_GRID => {
let prefix = PrefixWord::from_elapsed(uptime);
(
MessageKind::BEAT_GRID,
with_payload(medium, track_id, FourCc::PQTZ, |payload| {
analysis::beat_grid(payload, prefix)
}),
[0u32].as_slice(),
)
}
MessageKind::GET_WAVEFORM_PREVIEW => (
MessageKind::WAVEFORM_PREVIEW,
medium
.map(|medium| {
let parsed = medium.analysis(track_id);
let packed = parsed.payload(FourCc::PWAV);
if packed.is_empty() {
Vec::new()
} else {
analysis::waveform_preview(packed, parsed.payload(FourCc::PWV2))
}
})
.unwrap_or_default(),
[].as_slice(),
),
MessageKind::GET_WAVEFORM_DETAIL => {
let prefix = PrefixWord::from_elapsed(uptime);
(
MessageKind::WAVEFORM_DETAIL,
medium
.map(|medium| {
let parsed = medium.analysis(track_id);
let payload = parsed.payload(FourCc::PWV3);
if payload.is_empty() {
Vec::new()
} else {
analysis::waveform_detail(
payload,
entry_width(medium, track_id),
prefix,
)
}
})
.unwrap_or_default(),
[].as_slice(),
)
}
_ => return None,
};
Message::binary_reply(transaction, response, kind, payload, trailing)
}
const PLAIN_WAVEFORM_PREVIEW: usize = 900;
const PLAIN_VBR_INDEX: usize = 1604;
fn plain_analysis(transaction: u32, kind: MessageKind) -> Option<Message> {
let (response, payload) = match kind {
MessageKind::GET_WAVEFORM_PREVIEW => (
MessageKind::WAVEFORM_PREVIEW,
vec![0; PLAIN_WAVEFORM_PREVIEW],
),
MessageKind::GET_VBR_INDEX => (MessageKind::VBR_INDEX, vec![0; PLAIN_VBR_INDEX]),
MessageKind::GET_BEAT_GRID => (MessageKind::BEAT_GRID, Vec::new()),
MessageKind::GET_WAVEFORM_DETAIL => (MessageKind::WAVEFORM_DETAIL, Vec::new()),
_ => return None,
};
let trailing: &[u32] = if kind == MessageKind::GET_BEAT_GRID {
&[0]
} else {
&[]
};
Message::binary_reply(transaction, response, kind, payload, trailing)
}
fn media_info(transaction: u32, medium: Option<&Medium>) -> Message {
let description = medium.map(Medium::description).unwrap_or_default();
let body = MediaInfo {
volume_name: description.volume_name,
created: description.created,
track_count: description.track_count,
playlist_count: description.playlist_count,
total_bytes: description.total_bytes.unwrap_or(0),
free_bytes: description.free_bytes.unwrap_or(0),
plain: description.plain,
}
.encode();
Message::new(
transaction,
MessageKind::MEDIA_INFO,
[
Field::U32(MessageKind::GET_MEDIA_INFO.0.into()),
Field::U32(0),
Field::U32(u32::try_from(body.len()).unwrap_or(0)),
Field::Blob(body),
],
)
}
pub(super) fn is_binary_request(kind: MessageKind) -> bool {
matches!(
kind,
MessageKind::GET_ARTWORK
| MessageKind::GET_MEDIA_INFO
| MessageKind::GET_CUE_POINTS
| MessageKind::GET_VBR_INDEX
| MessageKind::GET_BEAT_GRID
| MessageKind::GET_WAVEFORM_PREVIEW
| MessageKind::GET_WAVEFORM_DETAIL
)
}
fn with_payload(
medium: Option<&Medium>,
track_id: u32,
fourcc: FourCc,
transform: impl FnOnce(&[u8]) -> Vec<u8>,
) -> Vec<u8> {
let Some(medium) = medium else {
return Vec::new();
};
let parsed = medium.analysis(track_id);
let payload = parsed.payload(fourcc);
if payload.is_empty() {
return Vec::new();
}
transform(payload)
}
fn entry_width(medium: &Medium, track_id: u32) -> u32 {
let parsed = medium.analysis(track_id);
parsed
.ext
.as_ref()
.and_then(|file| file.tag(FourCc::PWV3))
.map(prolink_rekordbox::Tag::header_extra)
.and_then(|extra| extra.get(..4))
.and_then(|word| <[u8; 4]>::try_from(word).ok())
.map_or(1, u32::from_be_bytes)
}
fn cue_points(transaction: u32, medium: Option<&Medium>, track_id: u32) -> Message {
let blobs = analysis::cue_points(&cues(medium, track_id));
let record_bytes = u32::try_from(blobs.records.len()).unwrap_or(u32::MAX);
let time_bytes = u32::try_from(blobs.times.len()).unwrap_or(u32::MAX);
let entry_size = u32::try_from(analysis::CUE_ENTRY_LEN).unwrap_or(u32::MAX);
Message::new(
transaction,
MessageKind::CUE_POINTS,
Arguments::from([
Field::U32(u32::from(MessageKind::GET_CUE_POINTS.0)),
Field::U32(0),
Field::U32(record_bytes),
Field::Blob(blobs.records),
Field::U32(entry_size),
Field::U32(blobs.count),
Field::U32(0),
Field::U32(time_bytes),
Field::Blob(blobs.times),
]),
)
}
fn cues(medium: Option<&Medium>, track_id: u32) -> Vec<Cue> {
let Some(medium) = medium else {
return Vec::new();
};
let parsed = medium.analysis(track_id);
let from_dat: Vec<Cue> = parsed
.dat
.as_ref()
.into_iter()
.flat_map(prolink_rekordbox::AnlzFile::cue_lists)
.flat_map(|list| list.cues.iter())
.map(|cue| Cue {
order: u16::from(cue.cue_type.0).saturating_mul(0x100),
hot_cue: u16::try_from(cue.hot_cue).unwrap_or(u16::MAX),
time_ms: cue.time,
loop_time_ms: cue.loop_time,
})
.collect();
if !from_dat.is_empty() {
return from_dat;
}
parsed
.ext
.as_ref()
.into_iter()
.flat_map(prolink_rekordbox::AnlzFile::extended_cue_lists)
.flat_map(|list| list.cues.iter())
.map(|cue| Cue {
order: u16::from(cue.cue_type.0).saturating_mul(0x100),
hot_cue: u16::try_from(cue.hot_cue).unwrap_or(u16::MAX),
time_ms: cue.time,
loop_time_ms: cue.loop_time,
})
.collect()
}