use std::fmt;
use std::net::Ipv4Addr;
use std::time::Duration;
use crate::beat::{BeatInBar, Pitch};
use crate::dbserver::TrackType;
use crate::device::{DeviceName, DeviceNumber};
use crate::status_templates as templates;
use crate::{Error, MAGIC, Result, Slot};
pub const STATUS_INTERVAL: Duration = Duration::from_millis(200);
pub(crate) const OFF_NAME: usize = 0x0b;
pub(crate) const OFF_CONST_ONE: usize = 0x1f;
pub(crate) const OFF_SUBTYPE: usize = 0x20;
pub(crate) const OFF_SENDER: usize = 0x21;
pub(crate) const OFF_BODY_LEN: usize = 0x22;
const BODY_START: usize = 0x24;
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct StatusKind(pub u8);
impl StatusKind {
pub const MEDIA_QUERY: Self = Self(0x05);
pub const MEDIA_RESPONSE: Self = Self(0x06);
pub const CDJ_STATUS: Self = Self(0x0a);
pub const MIXER_STATUS: Self = Self(0x29);
pub const SETTINGS_QUERY: Self = Self(0x35);
pub const SETTINGS_RESPONSE: Self = Self(0x36);
pub fn name(self) -> Option<&'static str> {
Some(match self {
Self::MEDIA_QUERY => "media_query",
Self::MEDIA_RESPONSE => "media_response",
Self::CDJ_STATUS => "cdj_status",
Self::MIXER_STATUS => "mixer_status",
Self::SETTINGS_QUERY => "settings_query",
Self::SETTINGS_RESPONSE => "settings_response",
_ => return None,
})
}
}
impl fmt::Debug for StatusKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.name() {
Some(name) => f.write_str(name),
None => write!(f, "StatusKind({:#04x})", self.0),
}
}
}
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct MediaState(pub u8);
impl MediaState {
pub const LOADED: Self = Self(0x00);
pub const UNMOUNTING: Self = Self(0x02);
pub const UNMOUNTING_ALT: Self = Self(0x03);
pub const EMPTY: Self = Self(0x04);
pub const fn has_media(self) -> bool {
self.0 == Self::LOADED.0
}
}
impl fmt::Debug for MediaState {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
Self::LOADED => f.write_str("loaded"),
Self::UNMOUNTING => f.write_str("unmounting"),
Self::UNMOUNTING_ALT => f.write_str("unmounting_alt"),
Self::EMPTY => f.write_str("empty"),
Self(raw) => write!(f, "MediaState({raw:#04x})"),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Packet {
CdjStatus(CdjStatus),
MediaQuery(MediaQuery),
MediaResponse(MediaResponse),
SettingsQuery(SettingsQuery),
SettingsResponse(SettingsResponse),
Other {
kind: StatusKind,
raw: Vec<u8>,
},
}
impl Packet {
pub fn kind(&self) -> StatusKind {
match self {
Self::CdjStatus(_) => StatusKind::CDJ_STATUS,
Self::MediaQuery(_) => StatusKind::MEDIA_QUERY,
Self::MediaResponse(_) => StatusKind::MEDIA_RESPONSE,
Self::SettingsQuery(_) => StatusKind::SETTINGS_QUERY,
Self::SettingsResponse(_) => StatusKind::SETTINGS_RESPONSE,
Self::Other { kind, .. } => *kind,
}
}
}
pub fn decode(data: &[u8]) -> Result<Packet> {
if data.get(..MAGIC.len()) != Some(MAGIC.as_slice()) {
let got = data.get(..MAGIC.len()).unwrap_or(data);
return Err(Error::BadMagic {
expected: MAGIC.as_slice().into(),
got: got.into(),
});
}
let Some(&raw_kind) = data.get(MAGIC.len()) else {
return Err(Error::Truncated {
need: MAGIC.len() + 1,
at: 0,
have: data.len(),
});
};
let kind = StatusKind(raw_kind);
let other = || Packet::Other {
kind,
raw: data.to_vec(),
};
Ok(match kind {
StatusKind::CDJ_STATUS => {
CdjStatus::parse(data).map_or_else(|_| other(), Packet::CdjStatus)
}
StatusKind::MEDIA_QUERY => {
MediaQuery::parse(data).map_or_else(|_| other(), Packet::MediaQuery)
}
StatusKind::MEDIA_RESPONSE => {
MediaResponse::parse(data).map_or_else(|_| other(), Packet::MediaResponse)
}
StatusKind::SETTINGS_QUERY => {
SettingsQuery::parse(data).map_or_else(|_| other(), Packet::SettingsQuery)
}
StatusKind::SETTINGS_RESPONSE => {
SettingsResponse::parse(data).map_or_else(|_| other(), Packet::SettingsResponse)
}
_ => other(),
})
}
pub(crate) fn byte_at(raw: &[u8], offset: usize) -> Option<u8> {
raw.get(offset).copied()
}
pub(crate) fn be_u16_at(raw: &[u8], offset: usize) -> Option<u16> {
let bytes = raw.get(offset..offset.checked_add(2)?)?;
Some(u16::from_be_bytes(bytes.try_into().ok()?))
}
pub(crate) fn be_u32_at(raw: &[u8], offset: usize) -> Option<u32> {
let bytes = raw.get(offset..offset.checked_add(4)?)?;
Some(u32::from_be_bytes(bytes.try_into().ok()?))
}
pub(crate) fn be_u64_at(raw: &[u8], offset: usize) -> Option<u64> {
let bytes = raw.get(offset..offset.checked_add(8)?)?;
Some(u64::from_be_bytes(bytes.try_into().ok()?))
}
fn utf16be_at(raw: &[u8], offset: usize, len: usize) -> String {
let Some(field) = raw.get(offset..offset.saturating_add(len)) else {
return String::new();
};
let units: Vec<u16> = field
.chunks_exact(2)
.map(|pair| {
u16::from_be_bytes([
pair.first().copied().unwrap_or(0),
pair.get(1).copied().unwrap_or(0),
])
})
.take_while(|&unit| unit != 0)
.collect();
String::from_utf16_lossy(&units)
}
fn write_header(out: &mut [u8], kind: StatusKind, name: DeviceName, sender: u8) {
write_shared_header(out, kind.0, name, sender);
}
pub(crate) fn write_shared_header(out: &mut [u8], kind: u8, name: DeviceName, sender: u8) {
let total = out.len();
if let Some(magic) = out.get_mut(..MAGIC.len()) {
magic.copy_from_slice(&MAGIC);
}
if let Some(slot) = out.get_mut(MAGIC.len()) {
*slot = kind;
}
if let Some(field) = out.get_mut(OFF_NAME..OFF_NAME + DeviceName::LEN) {
field.copy_from_slice(&name.0);
}
if let Some(slot) = out.get_mut(OFF_CONST_ONE) {
*slot = 0x01;
}
if let Some(slot) = out.get_mut(OFF_SENDER) {
*slot = sender;
}
if let Some(field) = out.get_mut(OFF_BODY_LEN..OFF_BODY_LEN + 2) {
let body = u16::try_from(total.saturating_sub(BODY_START)).unwrap_or(u16::MAX);
field.copy_from_slice(&body.to_be_bytes());
}
}
macro_rules! header_accessors {
() => {
pub fn as_bytes(&self) -> &[u8] {
&self.raw
}
pub fn into_bytes(self) -> Vec<u8> {
self.raw
}
pub fn name(&self) -> DeviceName {
let mut field = [0u8; DeviceName::LEN];
if let Some(bytes) = self.raw.get(OFF_NAME..OFF_NAME + DeviceName::LEN) {
field.copy_from_slice(bytes);
}
DeviceName(field)
}
pub fn subtype(&self) -> u8 {
byte_at(&self.raw, OFF_SUBTYPE).unwrap_or(0)
}
pub fn sender(&self) -> Option<DeviceNumber> {
DeviceNumber::new(byte_at(&self.raw, OFF_SENDER).unwrap_or(0))
}
pub fn body_length(&self) -> u16 {
be_u16_at(&self.raw, OFF_BODY_LEN).unwrap_or(0)
}
};
}
const NO_TEMPO: u16 = 0xffff;
const NO_YIELD: u8 = 0xff;
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct StatusFlags(pub u8);
impl StatusFlags {
pub const PLAYING: u8 = 0x40;
pub const TEMPO_MASTER: u8 = 0x20;
pub const SYNC: u8 = 0x10;
pub const ON_AIR: u8 = 0x08;
pub fn is_playing(self) -> bool {
self.0 & Self::PLAYING != 0
}
pub fn is_tempo_master(self) -> bool {
self.0 & Self::TEMPO_MASTER != 0
}
pub fn is_synced(self) -> bool {
self.0 & Self::SYNC != 0
}
pub fn is_on_air(self) -> bool {
self.0 & Self::ON_AIR != 0
}
}
impl fmt::Debug for StatusFlags {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut set = f.debug_set();
for (bit, name) in [
(Self::PLAYING, "playing"),
(Self::TEMPO_MASTER, "master"),
(Self::SYNC, "sync"),
(Self::ON_AIR, "on_air"),
] {
if self.0 & bit != 0 {
set.entry(&name);
}
}
set.finish()
}
}
#[derive(Clone, PartialEq, Eq)]
pub struct CdjStatus {
raw: Vec<u8>,
}
impl CdjStatus {
pub const MIN_LEN: usize = 0x76;
const OFF_DEVICE_2: usize = 0x24;
const OFF_SOURCE_PLAYER: usize = 0x28;
const OFF_SOURCE_SLOT: usize = 0x29;
const OFF_TRACK_TYPE: usize = 0x2a;
const OFF_TRACK_ID: usize = 0x2c;
const OFF_USB_STATE: usize = 0x6f;
const OFF_SD_STATE: usize = 0x73;
const OFF_LINK_AVAILABLE: usize = 0x75;
const OFF_PLAY_STATE: usize = 0x7b;
const OFF_FIRMWARE: usize = 0x7c;
const OFF_BROWSE_LIST_SIZE: usize = 0x46;
const OFF_FLAGS: usize = 0x89;
const OFF_PLAY_STATE_3: usize = 0x8b;
const OFF_LOADED_AND_PLAYING: usize = 0x9d;
const LOADED_BIT: u8 = 0x01;
const PLAYING_BIT: u8 = 0x08;
const OFF_TEMPO_VALID: usize = 0x90;
const OFF_PITCH: usize = 0x8c;
const OFF_BPM: usize = 0x92;
const OFF_MASTER_MEANINGFUL: usize = 0x9e;
const OFF_YIELDING_TO: usize = 0x9f;
const OFF_BEAT_NUMBER: usize = 0xa0;
const OFF_BEAT_IN_BAR: usize = 0xa6;
const OFF_PACKET_COUNTER: usize = 0xc8;
const OFF_PITCH_COPIES: [usize; 4] = [0x8c, 0x98, 0xc0, 0xc4];
const NO_BEAT_NUMBER: u32 = 0xffff_ffff;
pub fn parse(data: &[u8]) -> Result<Self> {
check(data, StatusKind::CDJ_STATUS, Self::MIN_LEN)?;
Ok(Self { raw: data.to_vec() })
}
header_accessors!();
pub fn builder() -> CdjStatusBuilder {
CdjStatusBuilder::default()
}
pub fn source_player(&self) -> Option<DeviceNumber> {
DeviceNumber::new(self.guaranteed(Self::OFF_SOURCE_PLAYER))
}
pub fn source_slot(&self) -> Slot {
Slot(self.guaranteed(Self::OFF_SOURCE_SLOT))
}
pub fn track_type(&self) -> u8 {
self.guaranteed(Self::OFF_TRACK_TYPE)
}
pub fn track_id(&self) -> u32 {
be_u32_at(&self.raw, Self::OFF_TRACK_ID).unwrap_or(0)
}
pub fn usb_state(&self) -> MediaState {
MediaState(self.guaranteed(Self::OFF_USB_STATE))
}
pub fn sd_state(&self) -> MediaState {
MediaState(self.guaranteed(Self::OFF_SD_STATE))
}
pub fn slot_state(&self, slot: Slot) -> Option<MediaState> {
match slot {
Slot::USB => Some(self.usb_state()),
Slot::SD => Some(self.sd_state()),
_ => None,
}
}
pub fn link_available(&self) -> bool {
self.guaranteed(Self::OFF_LINK_AVAILABLE) != 0
}
pub fn play_state(&self) -> Option<u8> {
byte_at(&self.raw, Self::OFF_PLAY_STATE)
}
pub fn firmware(&self) -> Option<String> {
let field = self.raw.get(Self::OFF_FIRMWARE..Self::OFF_FIRMWARE + 4)?;
Some(
field
.iter()
.copied()
.take_while(|&b| b != 0)
.map(char::from)
.collect(),
)
}
pub fn browse_list_size(&self) -> Option<u16> {
be_u16_at(&self.raw, Self::OFF_BROWSE_LIST_SIZE).filter(|size| *size != 0)
}
pub fn flags(&self) -> Option<StatusFlags> {
byte_at(&self.raw, Self::OFF_FLAGS).map(StatusFlags)
}
pub fn pitch(&self) -> Option<Pitch> {
be_u32_at(&self.raw, Self::OFF_PITCH).map(Pitch)
}
pub fn bpm_centi(&self) -> Option<u16> {
be_u16_at(&self.raw, Self::OFF_BPM).filter(|&raw| raw != NO_TEMPO)
}
pub fn bpm(&self) -> Option<f64> {
self.bpm_centi().map(|centi| f64::from(centi) / 100.0)
}
pub fn effective_bpm(&self) -> Option<f64> {
Some(self.bpm()? * self.pitch()?.multiplier())
}
pub fn is_tempo_master(&self) -> Option<bool> {
byte_at(&self.raw, Self::OFF_MASTER_MEANINGFUL).map(|byte| byte != 0)
}
pub fn yielding_to(&self) -> Option<DeviceNumber> {
let target = byte_at(&self.raw, Self::OFF_YIELDING_TO)?;
if target == NO_YIELD {
return None;
}
DeviceNumber::new(target)
}
pub fn beat_number(&self) -> Option<u32> {
be_u32_at(&self.raw, Self::OFF_BEAT_NUMBER).filter(|&raw| raw != Self::NO_BEAT_NUMBER)
}
pub fn beat_in_bar(&self) -> Option<BeatInBar> {
BeatInBar::new(byte_at(&self.raw, Self::OFF_BEAT_IN_BAR)?)
}
pub fn packet_counter(&self) -> Option<u32> {
be_u32_at(&self.raw, Self::OFF_PACKET_COUNTER)
}
fn guaranteed(&self, offset: usize) -> u8 {
debug_assert!(
offset < Self::MIN_LEN,
"offset {offset:#x} is past the guaranteed prefix"
);
byte_at(&self.raw, offset).unwrap_or(0)
}
}
impl fmt::Debug for CdjStatus {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("CdjStatus")
.field("sender", &self.sender())
.field("name", &self.name())
.field("usb", &self.usb_state())
.field("sd", &self.sd_state())
.field("link_available", &self.link_available())
.field("track_id", &self.track_id())
.field("bytes", &self.raw.len())
.finish()
}
}
fn put(raw: &mut [u8], offset: usize, value: u8) {
if let Some(slot) = raw.get_mut(offset) {
*slot = value;
}
}
fn put_u16(raw: &mut [u8], offset: usize, value: u16) {
if let Some(field) = raw.get_mut(offset..offset.saturating_add(2)) {
field.copy_from_slice(&value.to_be_bytes());
}
}
fn put_u32(raw: &mut [u8], offset: usize, value: u32) {
if let Some(field) = raw.get_mut(offset..offset.saturating_add(4)) {
field.copy_from_slice(&value.to_be_bytes());
}
}
#[derive(Clone, Debug)]
#[allow(clippy::struct_excessive_bools)]
pub struct CdjStatusBuilder {
device_number: u8,
name: DeviceName,
usb_state: MediaState,
sd_state: MediaState,
link_available: bool,
play_state: u8,
firmware: String,
packet_counter: u32,
bpm_centi: Option<u16>,
pitch: Pitch,
playing: bool,
on_air: bool,
synced: bool,
tempo_master: bool,
yielding_to: Option<DeviceNumber>,
beat_number: Option<u32>,
beat_in_bar: Option<BeatInBar>,
loaded_track: Option<LoadedTrack>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct LoadedTrack {
pub source_player: DeviceNumber,
pub slot: Slot,
pub id: u32,
pub track_type: TrackType,
}
impl Default for CdjStatusBuilder {
fn default() -> Self {
Self {
device_number: 0,
name: DeviceName::default(),
usb_state: MediaState::EMPTY,
sd_state: MediaState::EMPTY,
link_available: false,
play_state: 0x00,
firmware: "1.44".to_owned(),
packet_counter: 0,
bpm_centi: None,
pitch: Pitch::UNITY,
playing: false,
on_air: false,
synced: false,
tempo_master: false,
yielding_to: None,
beat_number: None,
beat_in_bar: None,
loaded_track: None,
}
}
}
impl CdjStatusBuilder {
#[must_use]
pub fn device_number(mut self, number: DeviceNumber) -> Self {
self.device_number = number.get();
self
}
#[must_use]
pub fn name(mut self, name: DeviceName) -> Self {
self.name = name;
self
}
#[must_use]
pub fn slot_state(mut self, slot: Slot, state: MediaState) -> Self {
match slot {
Slot::USB => self.usb_state = state,
Slot::SD => self.sd_state = state,
_ => {}
}
self
}
#[must_use]
pub fn link_available(mut self, available: bool) -> Self {
self.link_available = available;
self
}
#[must_use]
pub fn play_state(mut self, state: u8) -> Self {
self.play_state = state;
self
}
#[must_use]
pub fn firmware(mut self, firmware: &str) -> Self {
firmware.clone_into(&mut self.firmware);
self
}
#[must_use]
pub fn packet_counter(mut self, counter: u32) -> Self {
self.packet_counter = counter;
self
}
#[must_use]
pub fn tempo(mut self, bpm_centi: Option<u16>, pitch: Pitch) -> Self {
self.bpm_centi = bpm_centi.filter(|¢i| centi != NO_TEMPO);
self.pitch = pitch;
self
}
#[must_use]
pub fn playing(mut self, playing: bool) -> Self {
self.playing = playing;
self
}
#[must_use]
pub fn on_air(mut self, on_air: bool) -> Self {
self.on_air = on_air;
self
}
#[must_use]
pub fn synced(mut self, synced: bool) -> Self {
self.synced = synced;
self
}
#[must_use]
pub fn tempo_master(mut self, master: bool) -> Self {
self.tempo_master = master;
self
}
#[must_use]
pub fn yielding_to(mut self, successor: Option<DeviceNumber>) -> Self {
self.yielding_to = successor;
self
}
#[must_use]
pub fn loaded_track(mut self, track: Option<LoadedTrack>) -> Self {
self.loaded_track = track;
self
}
#[must_use]
pub fn beat(mut self, number: Option<u32>, in_bar: Option<BeatInBar>) -> Self {
self.beat_number = number;
self.beat_in_bar = in_bar;
self
}
fn write_transport(&self, raw: &mut [u8]) {
put(raw, CdjStatus::OFF_PLAY_STATE, self.play_state);
put(
raw,
CdjStatus::OFF_PLAY_STATE_3,
if self.playing { 0xfa } else { 0xfe },
);
put_u16(
raw,
CdjStatus::OFF_TEMPO_VALID,
if self.bpm_centi.is_some() {
0x8000
} else {
0x7fff
},
);
let mut flags = raw.get(CdjStatus::OFF_FLAGS).copied().unwrap_or(0x84);
for (bit, set) in [
(StatusFlags::PLAYING, self.playing),
(StatusFlags::TEMPO_MASTER, self.tempo_master),
(StatusFlags::SYNC, self.synced),
(StatusFlags::ON_AIR, self.on_air),
] {
if set {
flags |= bit;
} else {
flags &= !bit;
}
}
put(raw, CdjStatus::OFF_FLAGS, flags);
put(
raw,
CdjStatus::OFF_MASTER_MEANINGFUL,
u8::from(self.tempo_master),
);
put(
raw,
CdjStatus::OFF_YIELDING_TO,
self.yielding_to.map_or(NO_YIELD, DeviceNumber::get),
);
for offset in CdjStatus::OFF_PITCH_COPIES {
put_u32(raw, offset, self.pitch.0);
}
put_u32(
raw,
CdjStatus::OFF_BEAT_NUMBER,
self.beat_number.unwrap_or(CdjStatus::NO_BEAT_NUMBER),
);
put_u16(raw, CdjStatus::OFF_BPM, self.bpm_centi.unwrap_or(NO_TEMPO));
put(
raw,
CdjStatus::OFF_BEAT_IN_BAR,
self.beat_in_bar.map_or(0, BeatInBar::get),
);
put(
raw,
CdjStatus::OFF_SOURCE_PLAYER,
self.loaded_track
.map_or(0, |track| track.source_player.get()),
);
put(
raw,
CdjStatus::OFF_SOURCE_SLOT,
self.loaded_track.map_or(0, |track| track.slot.0),
);
put(
raw,
CdjStatus::OFF_TRACK_TYPE,
self.loaded_track.map_or(0, |track| track.track_type.0),
);
put_u32(
raw,
CdjStatus::OFF_TRACK_ID,
self.loaded_track.map_or(0, |track| track.id),
);
let mut loaded_and_playing = 0u8;
if self.loaded_track.is_some() || self.bpm_centi.is_some() {
loaded_and_playing |= CdjStatus::LOADED_BIT;
}
if self.playing {
loaded_and_playing |= CdjStatus::PLAYING_BIT;
}
put(raw, CdjStatus::OFF_LOADED_AND_PLAYING, loaded_and_playing);
}
pub fn build(&self) -> CdjStatus {
let mut raw = templates::CDJ_STATUS.to_vec();
write_header(
&mut raw,
StatusKind::CDJ_STATUS,
self.name,
self.device_number,
);
put(&mut raw, CdjStatus::OFF_DEVICE_2, self.device_number);
put(&mut raw, CdjStatus::OFF_USB_STATE, self.usb_state.0);
put(&mut raw, CdjStatus::OFF_SD_STATE, self.sd_state.0);
put(
&mut raw,
CdjStatus::OFF_LINK_AVAILABLE,
u8::from(self.link_available),
);
for (index, byte) in self.firmware.bytes().take(4).enumerate() {
put(&mut raw, CdjStatus::OFF_FIRMWARE + index, byte);
}
put_u32(&mut raw, CdjStatus::OFF_PACKET_COUNTER, self.packet_counter);
self.write_transport(&mut raw);
CdjStatus { raw }
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct MediaQuery {
pub requester: DeviceNumber,
pub requester_ip: Ipv4Addr,
pub target: DeviceNumber,
pub slot: Slot,
}
impl MediaQuery {
pub const LEN: usize = 0x30;
const OFF_REQUESTER_IP: usize = 0x24;
const OFF_TARGET: usize = 0x28;
const OFF_SLOT: usize = 0x2c;
pub fn parse(data: &[u8]) -> Result<Self> {
check(data, StatusKind::MEDIA_QUERY, Self::LEN)?;
let requester = DeviceNumber::new(byte_at(data, OFF_SENDER).unwrap_or(0))
.ok_or_else(|| Error::malformed(OFF_SENDER, "media query from device 0"))?;
let target = be_u32_at(data, Self::OFF_TARGET)
.and_then(|raw| u8::try_from(raw).ok())
.and_then(DeviceNumber::new)
.ok_or_else(|| Error::malformed(Self::OFF_TARGET, "media query for device 0"))?;
let slot = be_u32_at(data, Self::OFF_SLOT)
.and_then(|raw| u8::try_from(raw).ok())
.map(Slot)
.ok_or_else(|| Error::malformed(Self::OFF_SLOT, "slot number out of range"))?;
let mut octets = [0u8; 4];
if let Some(bytes) = data.get(Self::OFF_REQUESTER_IP..Self::OFF_REQUESTER_IP + 4) {
octets.copy_from_slice(bytes);
}
Ok(Self {
requester,
requester_ip: Ipv4Addr::from(octets),
target,
slot,
})
}
pub fn encode(&self, name: DeviceName) -> Vec<u8> {
let mut raw = vec![0u8; Self::LEN];
write_header(
&mut raw,
StatusKind::MEDIA_QUERY,
name,
self.requester.get(),
);
if let Some(field) = raw.get_mut(Self::OFF_REQUESTER_IP..Self::OFF_REQUESTER_IP + 4) {
field.copy_from_slice(&self.requester_ip.octets());
}
if let Some(field) = raw.get_mut(Self::OFF_TARGET..Self::OFF_TARGET + 4) {
field.copy_from_slice(&u32::from(self.target.get()).to_be_bytes());
}
if let Some(field) = raw.get_mut(Self::OFF_SLOT..Self::OFF_SLOT + 4) {
field.copy_from_slice(&u32::from(self.slot.0).to_be_bytes());
}
raw
}
}
#[derive(Clone, PartialEq, Eq)]
pub struct MediaResponse {
raw: Vec<u8>,
}
impl MediaResponse {
pub const MIN_LEN: usize = 0xb0;
const OFF_DEVICE: usize = 0x24;
const OFF_SLOT: usize = 0x28;
const OFF_VOLUME_NAME: usize = 0x2c;
const LEN_VOLUME_NAME: usize = 0x40;
const OFF_CREATED: usize = 0x6c;
const LEN_CREATED: usize = 0x18;
const OFF_TEXT_84: usize = 0x84;
const OFF_TRACK_COUNT: usize = 0xa4;
const OFF_LIBRARY_KIND: usize = 0xaa;
const OFF_PLAYLIST_COUNT: usize = 0xac;
const OFF_TOTAL_BYTES: usize = 0xb0;
const OFF_FREE_BYTES: usize = 0xb8;
pub fn parse(data: &[u8]) -> Result<Self> {
check(data, StatusKind::MEDIA_RESPONSE, Self::MIN_LEN)?;
Ok(Self { raw: data.to_vec() })
}
header_accessors!();
pub fn builder() -> MediaResponseBuilder {
MediaResponseBuilder::default()
}
pub fn device(&self) -> Option<DeviceNumber> {
be_u32_at(&self.raw, Self::OFF_DEVICE)
.and_then(|raw| u8::try_from(raw).ok())
.and_then(DeviceNumber::new)
}
pub fn slot(&self) -> Slot {
Slot(u8::try_from(be_u32_at(&self.raw, Self::OFF_SLOT).unwrap_or(0) & 0xff).unwrap_or(0))
}
pub fn volume_name(&self) -> String {
utf16be_at(&self.raw, Self::OFF_VOLUME_NAME, Self::LEN_VOLUME_NAME)
}
pub fn created(&self) -> String {
utf16be_at(&self.raw, Self::OFF_CREATED, Self::LEN_CREATED)
}
pub fn track_count(&self) -> u32 {
be_u32_at(&self.raw, Self::OFF_TRACK_COUNT).unwrap_or(0)
}
pub fn is_plain(&self) -> bool {
byte_at(&self.raw, Self::OFF_LIBRARY_KIND) == Some(2)
}
pub fn playlist_count(&self) -> u32 {
be_u32_at(&self.raw, Self::OFF_PLAYLIST_COUNT).unwrap_or(0)
}
pub fn total_bytes(&self) -> Option<u64> {
be_u64_at(&self.raw, Self::OFF_TOTAL_BYTES)
}
pub fn free_bytes(&self) -> Option<u64> {
be_u64_at(&self.raw, Self::OFF_FREE_BYTES)
}
}
impl fmt::Debug for MediaResponse {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("MediaResponse")
.field("device", &self.device())
.field("slot", &self.slot())
.field("volume_name", &self.volume_name())
.field("tracks", &self.track_count())
.field("playlists", &self.playlist_count())
.field("total_bytes", &self.total_bytes())
.field("free_bytes", &self.free_bytes())
.finish()
}
}
#[derive(Clone, Debug, Default)]
pub struct MediaResponseBuilder {
device_number: u8,
slot: u8,
name: DeviceName,
volume_name: String,
track_count: u32,
playlist_count: u32,
total_bytes: u64,
free_bytes: u64,
plain: bool,
}
impl MediaResponseBuilder {
#[must_use]
pub fn device_number(mut self, number: DeviceNumber) -> Self {
self.device_number = number.get();
self
}
#[must_use]
pub fn slot(mut self, slot: Slot) -> Self {
self.slot = slot.0;
self
}
#[must_use]
pub fn name(mut self, name: DeviceName) -> Self {
self.name = name;
self
}
#[must_use]
pub fn volume_name(mut self, label: &str) -> Self {
label.clone_into(&mut self.volume_name);
self
}
#[must_use]
pub fn counts(mut self, tracks: u32, playlists: u32) -> Self {
self.track_count = tracks;
self.playlist_count = playlists;
self
}
#[must_use]
pub fn plain(mut self, plain: bool) -> Self {
self.plain = plain;
self
}
#[must_use]
pub fn size(mut self, total_bytes: u64, free_bytes: u64) -> Self {
self.total_bytes = total_bytes;
self.free_bytes = free_bytes;
self
}
pub fn build(&self) -> MediaResponse {
let mut raw = templates::MEDIA_RESPONSE.to_vec();
write_header(
&mut raw,
StatusKind::MEDIA_RESPONSE,
self.name,
self.device_number,
);
{
let mut put = |offset: usize, value: &[u8]| {
if let Some(field) = raw.get_mut(offset..offset + value.len()) {
field.copy_from_slice(value);
}
};
put(
MediaResponse::OFF_DEVICE,
&u32::from(self.device_number).to_be_bytes(),
);
put(MediaResponse::OFF_SLOT, &u32::from(self.slot).to_be_bytes());
put(
MediaResponse::OFF_TRACK_COUNT,
&self.track_count.to_be_bytes(),
);
put(
MediaResponse::OFF_PLAYLIST_COUNT,
&self.playlist_count.to_be_bytes(),
);
put(
MediaResponse::OFF_TOTAL_BYTES,
&self.total_bytes.to_be_bytes(),
);
put(
MediaResponse::OFF_FREE_BYTES,
&self.free_bytes.to_be_bytes(),
);
if self.plain {
put(MediaResponse::OFF_CREATED, &[0; MediaResponse::LEN_CREATED]);
put(
MediaResponse::OFF_TEXT_84,
&[0; MediaResponse::OFF_TRACK_COUNT - MediaResponse::OFF_TEXT_84],
);
put(MediaResponse::OFF_LIBRARY_KIND, &[0x02, 0x00]);
}
}
if let Some(field) = raw.get_mut(
MediaResponse::OFF_VOLUME_NAME
..MediaResponse::OFF_VOLUME_NAME + MediaResponse::LEN_VOLUME_NAME,
) {
field.fill(0);
for (pair, unit) in field
.chunks_exact_mut(2)
.zip(self.volume_name.encode_utf16())
{
pair.copy_from_slice(&unit.to_be_bytes());
}
}
MediaResponse { raw }
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SettingsQuery {
pub requester: DeviceNumber,
pub sender: DeviceNumber,
pub slot: Slot,
}
impl SettingsQuery {
pub const LEN: usize = 0x28;
const OFF_REQUESTER: usize = 0x24;
const OFF_SLOT: usize = 0x25;
pub fn parse(data: &[u8]) -> Result<Self> {
check(data, StatusKind::SETTINGS_QUERY, Self::LEN)?;
let requester = DeviceNumber::new(byte_at(data, Self::OFF_REQUESTER).unwrap_or(0))
.ok_or_else(|| Error::malformed(Self::OFF_REQUESTER, "settings query from device 0"))?;
let sender = DeviceNumber::new(byte_at(data, OFF_SENDER).unwrap_or(0)).unwrap_or(requester);
Ok(Self {
requester,
sender,
slot: Slot(byte_at(data, Self::OFF_SLOT).unwrap_or(0)),
})
}
pub fn encode(&self, name: DeviceName) -> Vec<u8> {
let mut raw = vec![0u8; Self::LEN];
write_header(
&mut raw,
StatusKind::SETTINGS_QUERY,
name,
self.sender.get(),
);
if let Some(slot) = raw.get_mut(Self::OFF_REQUESTER) {
*slot = self.requester.get();
}
if let Some(slot) = raw.get_mut(Self::OFF_SLOT) {
*slot = self.slot.0;
}
raw
}
}
#[derive(Clone, PartialEq, Eq)]
pub struct SettingsResponse {
raw: Vec<u8>,
}
impl SettingsResponse {
pub const LEN: usize = 0x50;
pub const PAYLOAD_LEN: usize = 32;
pub const MAGIC: u32 = 0x1234_5678;
const OFF_REQUESTER: usize = 0x24;
const OFF_SLOT: usize = 0x25;
const OFF_MAGIC: usize = 0x28;
const OFF_UNKNOWN: usize = 0x2c;
const OFF_PAYLOAD: usize = 0x30;
pub fn parse(data: &[u8]) -> Result<Self> {
check(data, StatusKind::SETTINGS_RESPONSE, Self::LEN)?;
Ok(Self { raw: data.to_vec() })
}
header_accessors!();
pub fn requester(&self) -> Option<DeviceNumber> {
DeviceNumber::new(byte_at(&self.raw, Self::OFF_REQUESTER).unwrap_or(0))
}
pub fn slot(&self) -> Slot {
Slot(byte_at(&self.raw, Self::OFF_SLOT).unwrap_or(0))
}
pub fn payload(&self) -> &[u8] {
self.raw
.get(Self::OFF_PAYLOAD..Self::OFF_PAYLOAD + Self::PAYLOAD_LEN)
.unwrap_or(&[])
}
pub fn build(
name: DeviceName,
sender: DeviceNumber,
requester: DeviceNumber,
slot: Slot,
settings: &[u8],
) -> Self {
let mut raw = vec![0u8; Self::LEN];
write_header(&mut raw, StatusKind::SETTINGS_RESPONSE, name, sender.get());
if let Some(byte) = raw.get_mut(Self::OFF_REQUESTER) {
*byte = requester.get();
}
if let Some(byte) = raw.get_mut(Self::OFF_SLOT) {
*byte = slot.0;
}
if let Some(field) = raw.get_mut(Self::OFF_MAGIC..Self::OFF_MAGIC + 4) {
field.copy_from_slice(&Self::MAGIC.to_be_bytes());
}
if let Some(field) = raw.get_mut(Self::OFF_UNKNOWN..Self::OFF_UNKNOWN + 4) {
field.copy_from_slice(&2u32.to_be_bytes());
}
if let Some(field) = raw.get_mut(Self::OFF_PAYLOAD..Self::OFF_PAYLOAD + Self::PAYLOAD_LEN) {
for (byte, value) in field.iter_mut().zip(settings.iter().copied()) {
*byte = value;
}
}
Self { raw }
}
}
impl fmt::Debug for SettingsResponse {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SettingsResponse")
.field("sender", &self.sender())
.field("requester", &self.requester())
.field("slot", &self.slot())
.field("payload_len", &self.payload().len())
.finish()
}
}
fn check(data: &[u8], kind: StatusKind, min_len: usize) -> Result<()> {
check_header(data, kind.0, min_len).map_err(|error| match error {
Error::Malformed { at, .. } if at == MAGIC.len() => Error::malformed(
at,
format!(
"expected {kind:?} ({:#04x}), got {:#04x}",
kind.0,
byte_at(data, MAGIC.len()).unwrap_or(0)
),
),
other => other,
})
}
pub(crate) fn check_header(data: &[u8], kind: u8, min_len: usize) -> Result<()> {
if data.get(..MAGIC.len()) != Some(MAGIC.as_slice()) {
let got = data.get(..MAGIC.len()).unwrap_or(data);
return Err(Error::BadMagic {
expected: MAGIC.as_slice().into(),
got: got.into(),
});
}
match byte_at(data, MAGIC.len()) {
Some(actual) if actual == kind => {}
Some(actual) => {
return Err(Error::malformed(
MAGIC.len(),
format!("expected kind {kind:#04x}, got {actual:#04x}"),
));
}
None => {
return Err(Error::Truncated {
need: MAGIC.len() + 1,
at: 0,
have: data.len(),
});
}
}
if data.len() < min_len {
return Err(Error::Truncated {
need: min_len,
at: 0,
have: data.len(),
});
}
Ok(())
}
#[cfg(test)]
mod tests {
#[test]
fn the_browse_list_size_is_a_menu_count_the_sender_was_told() {
let Some(corpus) = prolink_capture::Corpus::locate() else {
return;
};
let mut sizes = std::collections::BTreeSet::new();
let mut zero = 0usize;
for path in corpus.captures() {
let Ok(capture) = prolink_capture::Capture::open(&path) else {
continue;
};
for packet in capture.udp_to(crate::STATUS_PORT).flatten() {
let Ok(status) = CdjStatus::parse(&packet.payload) else {
continue;
};
match status.browse_list_size() {
Some(size) => {
sizes.insert(size);
}
None => zero += 1,
}
}
}
if sizes.is_empty() && zero == 0 {
return;
}
assert!(zero > 1000, "the field is usually zero; {zero} were");
assert!(sizes.contains(&651), "651 is missing from {sizes:?}");
assert!(sizes.contains(&40), "40 is missing from {sizes:?}");
assert!(
sizes.iter().all(|size| *size <= 1000),
"a list size should be a plausible menu count: {sizes:?}"
);
}
use super::*;
fn device(number: u8) -> DeviceNumber {
DeviceNumber::new(number).expect("a non-zero device number")
}
#[test]
fn a_built_status_parses_back() {
let built = CdjStatus::builder()
.device_number(device(5))
.name(DeviceName::new("CDJ-2000nexus"))
.slot_state(Slot::USB, MediaState::LOADED)
.slot_state(Slot::SD, MediaState::EMPTY)
.link_available(true)
.packet_counter(0x0102_0304)
.build();
assert_eq!(
built.as_bytes().len(),
284,
"the length a firmware-1.44 deck sends"
);
let parsed = CdjStatus::parse(built.as_bytes()).unwrap();
assert_eq!(parsed.sender(), Some(device(5)));
assert_eq!(parsed.name().as_str(), "CDJ-2000nexus");
assert_eq!(parsed.usb_state(), MediaState::LOADED);
assert_eq!(parsed.sd_state(), MediaState::EMPTY);
assert!(parsed.link_available());
assert_eq!(parsed.firmware().as_deref(), Some("1.44"));
assert_eq!(parsed.packet_counter(), Some(0x0102_0304));
}
#[test]
fn a_status_differs_from_its_skeleton_only_where_we_substituted() {
let built = CdjStatus::builder()
.device_number(device(3))
.slot_state(Slot::USB, MediaState::LOADED)
.link_available(true)
.build();
let differing: Vec<usize> = built
.as_bytes()
.iter()
.zip(templates::CDJ_STATUS.iter())
.enumerate()
.filter(|(_, (ours, theirs))| ours != theirs)
.map(|(offset, _)| offset)
.collect();
let substituted: Vec<usize> = (OFF_NAME..OFF_NAME + DeviceName::LEN)
.chain([
OFF_CONST_ONE,
OFF_SENDER,
CdjStatus::OFF_DEVICE_2,
CdjStatus::OFF_USB_STATE,
CdjStatus::OFF_SD_STATE,
CdjStatus::OFF_LINK_AVAILABLE,
CdjStatus::OFF_PLAY_STATE,
CdjStatus::OFF_FLAGS,
CdjStatus::OFF_MASTER_MEANINGFUL,
CdjStatus::OFF_BEAT_IN_BAR,
CdjStatus::OFF_PLAY_STATE_3,
CdjStatus::OFF_LOADED_AND_PLAYING,
CdjStatus::OFF_SOURCE_PLAYER,
CdjStatus::OFF_SOURCE_SLOT,
CdjStatus::OFF_TRACK_TYPE,
])
.chain(CdjStatus::OFF_FIRMWARE..CdjStatus::OFF_FIRMWARE + 4)
.chain(CdjStatus::OFF_PACKET_COUNTER..CdjStatus::OFF_PACKET_COUNTER + 4)
.chain(CdjStatus::OFF_BPM..CdjStatus::OFF_BPM + 2)
.chain(CdjStatus::OFF_TEMPO_VALID..CdjStatus::OFF_TEMPO_VALID + 2)
.chain(CdjStatus::OFF_BEAT_NUMBER..CdjStatus::OFF_BEAT_NUMBER + 4)
.chain(CdjStatus::OFF_TRACK_ID..CdjStatus::OFF_TRACK_ID + 4)
.chain(
CdjStatus::OFF_PITCH_COPIES
.into_iter()
.flat_map(|offset| offset..offset + 4),
)
.chain(OFF_BODY_LEN..OFF_BODY_LEN + 2)
.collect();
let unexpected: Vec<usize> = differing
.iter()
.copied()
.filter(|offset| !substituted.contains(offset))
.collect();
assert!(
unexpected.is_empty(),
"disturbed bytes we do not understand: {unexpected:x?}"
);
}
#[test]
fn the_three_play_state_bytes_agree_with_each_other() {
let playing = CdjStatus::builder()
.play_state(0x03)
.playing(true)
.tempo(Some(14_110), Pitch::UNITY)
.build();
assert_eq!(byte_at(playing.as_bytes(), 0x8b), Some(0xfa));
assert_eq!(be_u16_at(playing.as_bytes(), 0x90), Some(0x8000));
let idle = CdjStatus::builder().build();
assert_eq!(byte_at(idle.as_bytes(), 0x8b), Some(0xfe));
assert_eq!(be_u16_at(idle.as_bytes(), 0x90), Some(0x7fff));
let paused = CdjStatus::builder()
.play_state(0x05)
.tempo(Some(14_110), Pitch::UNITY)
.build();
assert_eq!(byte_at(paused.as_bytes(), 0x8b), Some(0xfe));
assert_eq!(be_u16_at(paused.as_bytes(), 0x90), Some(0x8000));
}
#[test]
fn a_tempo_always_comes_with_a_track_it_belongs_to() {
let playing = CdjStatus::builder()
.device_number(device(4))
.tempo(Some(14_110), Pitch::UNITY)
.playing(true)
.loaded_track(Some(LoadedTrack {
source_player: device(2),
slot: Slot::USB,
id: 1234,
track_type: TrackType::REKORDBOX,
}))
.build();
let parsed = CdjStatus::parse(playing.as_bytes()).expect("our own packet");
assert_eq!(parsed.source_player(), Some(device(2)));
assert_eq!(parsed.source_slot(), Slot::USB);
assert_eq!(parsed.track_type(), 1, "a rekordbox track");
assert_eq!(parsed.track_id(), 1234);
assert_eq!(byte_at(parsed.as_bytes(), 0x9d), Some(0x09));
let idle = CdjStatus::builder().device_number(device(4)).build();
assert_eq!(idle.source_player(), None);
assert_eq!(idle.track_id(), 0);
assert_eq!(idle.track_type(), 0);
assert_eq!(byte_at(idle.as_bytes(), 0x9d), Some(0x00));
let paused = CdjStatus::builder()
.device_number(device(4))
.tempo(Some(14_110), Pitch::UNITY)
.loaded_track(Some(LoadedTrack {
source_player: device(4),
slot: Slot::SD,
id: 7,
track_type: TrackType::UNANALYSED,
}))
.build();
assert_eq!(byte_at(paused.as_bytes(), 0x9d), Some(0x01));
assert_eq!(paused.source_slot(), Slot::SD);
assert_eq!(paused.track_type(), 2, "a plain file");
}
#[test]
fn a_deck_with_no_track_sends_sentinels_rather_than_zeros() {
let idle = CdjStatus::builder()
.device_number(device(2))
.tempo(None, Pitch::UNITY)
.beat(None, None)
.build();
assert_eq!(idle.bpm_centi(), None);
assert_eq!(idle.beat_number(), None);
assert_eq!(idle.beat_in_bar(), None);
assert_eq!(idle.is_tempo_master(), Some(false));
assert_eq!(
idle.flags().map(StatusFlags::is_playing),
Some(false),
"an idle deck is not playing"
);
}
#[test]
fn a_playing_master_round_trips_its_tempo_and_its_place_in_the_bar() {
let playing = CdjStatus::builder()
.device_number(device(1))
.play_state(0x03)
.tempo(Some(13_201), Pitch(0x000f_8312))
.playing(true)
.tempo_master(true)
.beat(Some(67), BeatInBar::new(3))
.build();
let parsed = CdjStatus::parse(playing.as_bytes()).expect("our own packet parses");
assert_eq!(parsed.bpm_centi(), Some(13_201));
assert_eq!(parsed.pitch(), Some(Pitch(0x000f_8312)));
assert_eq!(parsed.beat_number(), Some(67));
assert_eq!(parsed.beat_in_bar(), BeatInBar::new(3));
assert_eq!(parsed.is_tempo_master(), Some(true));
let flags = parsed.flags().expect("flags");
assert!(flags.is_tempo_master());
assert!(flags.is_playing());
assert!(!flags.is_synced());
let effective = parsed.effective_bpm().expect("an effective tempo");
assert!(
(effective - 128.0).abs() < 0.5,
"132.01 BPM at -3.05% is about 128, not {effective}"
);
}
#[test]
fn the_pitch_is_written_to_every_copy_a_deck_writes() {
let built = CdjStatus::builder()
.tempo(Some(14_500), Pitch(0x0010_8000))
.build();
for offset in CdjStatus::OFF_PITCH_COPIES {
assert_eq!(
be_u32_at(built.as_bytes(), offset),
Some(0x0010_8000),
"pitch copy at {offset:#x}"
);
}
}
#[test]
fn a_media_query_round_trips() {
let query = MediaQuery {
requester: device(2),
requester_ip: Ipv4Addr::new(169, 254, 1, 2),
target: device(4),
slot: Slot::SD,
};
let raw = query.encode(DeviceName::default());
assert_eq!(raw.len(), MediaQuery::LEN);
assert_eq!(be_u16_at(&raw, OFF_BODY_LEN), Some(0x0c));
assert_eq!(MediaQuery::parse(&raw).unwrap(), query);
}
#[test]
fn a_media_response_carries_the_counts_a_deck_needs() {
let built = MediaResponse::builder()
.device_number(device(4))
.slot(Slot::USB)
.volume_name("MY STICK")
.counts(692, 35)
.size(64_023_183_360, 5_368_709_120)
.build();
let parsed = MediaResponse::parse(built.as_bytes()).unwrap();
assert_eq!(parsed.device(), Some(device(4)));
assert_eq!(parsed.slot(), Slot::USB);
assert_eq!(parsed.volume_name(), "MY STICK");
assert_eq!(parsed.track_count(), 692);
assert_eq!(parsed.playlist_count(), 35);
assert_eq!(parsed.total_bytes(), Some(64_023_183_360));
assert_eq!(parsed.free_bytes(), Some(5_368_709_120));
}
const S13_F98: &str = concat!(
"5173707431576d4a4f4c0643444a2d323030306e657875730000000000000001",
"0001009c00000001000000030000000000000000000000000000000000000000",
"0000000000000000000000000000000000000000000000000000000000000000",
"0000000000000000000000000032003000320036002d00300031002d00300034",
"0000000000310030003000300000000000000000000000000000000000000000",
"000000000000028b00000101000000010000000728ca800000000005439f8000",
);
#[test]
fn a_media_responses_sizes_are_eight_bytes_wide() {
let raw: Vec<u8> = (0..S13_F98.len())
.step_by(2)
.map(|at| u8::from_str_radix(&S13_F98[at..at + 2], 16).unwrap())
.collect();
let response = MediaResponse::parse(&raw).unwrap();
assert_eq!(response.track_count(), 651);
assert_eq!(response.total_bytes(), Some(30_749_130_752));
assert_eq!(response.free_bytes(), Some(22_609_362_944));
}
#[test]
fn a_plain_medium_is_described_as_a_cdj_describes_plainmp3() {
let built = MediaResponse::builder()
.volume_name("PLAINMP3")
.plain(true)
.size(1_070_579_712, 1_040_375_808)
.build();
let raw = built.as_bytes();
assert!(built.is_plain());
assert_eq!(built.created(), "");
assert!(raw[0x6c..0xa4].iter().all(|&byte| byte == 0));
assert_eq!(&raw[0xa8..0xac], &[0, 0, 2, 0]);
assert_eq!(
&raw[0xb0..0xc0],
&[
0, 0, 0, 0, 0x3f, 0xcf, 0xc0, 0, 0, 0, 0, 0, 0x3e, 0x02, 0xe0, 0
]
);
assert_eq!(built.track_count(), 0);
let rekordbox = MediaResponse::builder().counts(141, 4).build();
assert!(!rekordbox.is_plain());
assert_eq!(&rekordbox.as_bytes()[0xa8..0xac], &[0, 0, 1, 1]);
}
#[test]
fn a_media_response_announces_no_size_it_was_not_given() {
let built = MediaResponse::builder().counts(1, 0).build();
assert_eq!(built.total_bytes(), Some(0));
assert_eq!(built.free_bytes(), Some(0));
}
#[test]
fn a_volume_name_survives_non_ascii() {
let built = MediaResponse::builder().volume_name("カガミ").build();
assert_eq!(
MediaResponse::parse(built.as_bytes())
.unwrap()
.volume_name(),
"カガミ"
);
}
#[test]
fn a_settings_query_round_trips() {
let query = SettingsQuery {
requester: device(1),
sender: device(1),
slot: Slot::USB,
};
let raw = query.encode(DeviceName::default());
assert_eq!(raw.len(), SettingsQuery::LEN);
assert_eq!(SettingsQuery::parse(&raw).unwrap(), query);
}
#[test]
fn a_settings_response_carries_the_medium_bytes_verbatim() {
let settings: Vec<u8> = (0..32u8).collect();
let built = SettingsResponse::build(
DeviceName::default(),
device(4),
device(2),
Slot::USB,
&settings,
);
let parsed = SettingsResponse::parse(built.as_bytes()).unwrap();
assert_eq!(parsed.payload(), settings.as_slice());
assert_eq!(parsed.requester(), Some(device(2)));
assert_eq!(parsed.sender(), Some(device(4)));
assert_ne!(parsed.requester(), parsed.sender());
}
#[test]
fn a_short_settings_block_is_padded_not_rejected() {
let built =
SettingsResponse::build(DeviceName::default(), device(4), device(2), Slot::USB, &[]);
assert_eq!(built.payload(), [0u8; 32]);
}
#[test]
fn decoding_dispatches_on_the_kind_byte() {
let status = CdjStatus::builder().device_number(device(1)).build();
assert!(matches!(
decode(status.as_bytes()),
Ok(Packet::CdjStatus(_))
));
let mut mangled = status.into_bytes();
if let Some(byte) = mangled.get_mut(MAGIC.len()) {
*byte = StatusKind::MIXER_STATUS.0;
}
let decoded = decode(&mangled).unwrap();
assert_eq!(decoded.kind(), StatusKind::MIXER_STATUS);
assert!(matches!(decoded, Packet::Other { .. }));
}
#[test]
fn a_keep_alive_is_not_a_media_response() {
let keep_alive = crate::djl::Packet::new(
DeviceName::default(),
crate::DeviceKind::CDJ,
crate::djl::Body::KeepAlive {
device_number: 2,
was_first_on_network: 1,
mac: crate::MacAddress::default(),
ip: Ipv4Addr::UNSPECIFIED,
peer_count: 1,
pad_31: [0; 3],
flags: 1,
trailing: 0,
},
)
.encode();
assert!(matches!(decode(&keep_alive), Ok(Packet::Other { .. })));
assert!(MediaResponse::parse(&keep_alive).is_err());
}
}