From 0e666b120737ff100b412f9564087de7a3819a95 Mon Sep 17 00:00:00 2001 From: G2-Games Date: Mon, 29 Jan 2024 19:04:30 -0600 Subject: [PATCH] Began porting to all async functions, fixed some issues --- Cargo.toml | 2 + minidisc-rs/src/netmd/base.rs | 75 ++++---- minidisc-rs/src/netmd/interface.rs | 283 +++++++++++++++-------------- src/main.rs | 29 +-- 4 files changed, 200 insertions(+), 189 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 5587ca2..bc5405a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,8 +9,10 @@ authors = ["G2 "] license = "AGPL-3.0" [dependencies] +futures = "0.3.30" hex = "0.4.3" nusb = "0.1.4" +tokio = { version = "1.35.1", features = ["full"] } translit = "0.5.0" [dependencies.minidisc-rs] diff --git a/minidisc-rs/src/netmd/base.rs b/minidisc-rs/src/netmd/base.rs index 3a4de06..9c85925 100644 --- a/minidisc-rs/src/netmd/base.rs +++ b/minidisc-rs/src/netmd/base.rs @@ -4,11 +4,9 @@ use std::error::Error; use std::time::Duration; // USB stuff -use nusb::transfer::{Control, ControlType, Recipient, RequestBuffer}; +use nusb::transfer::{Control, ControlType, Recipient, RequestBuffer, ControlIn}; use nusb::{Device, DeviceInfo, Interface}; -use futures_lite::future::block_on; - const DEFAULT_TIMEOUT: Duration = Duration::new(10000, 0); const BULK_WRITE_ENDPOINT: u8 = 0x02; @@ -98,7 +96,7 @@ impl NetMD { const READ_REPLY_RETRY_INTERVAL: u32 = 10; /// Creates a new interface to a NetMD device - pub fn new(device_info: &DeviceInfo) -> Result> { + pub async fn new(device_info: &DeviceInfo) -> Result> { let mut model = DeviceId { vendor_id: device_info.vendor_id(), product_id: device_info.product_id(), @@ -131,61 +129,64 @@ impl NetMD { } /// Gets the device name, this is limited to the devices in the list - pub fn device_name(&self) -> &Option { + pub async fn device_name(&self) -> &Option { &self.model.name } /// Gets the vendor id - pub fn vendor_id(&self) -> &u16 { + pub async fn vendor_id(&self) -> &u16 { &self.model.vendor_id } /// Gets the product id - pub fn product_id(&self) -> &u16 { + pub async fn product_id(&self) -> &u16 { &self.model.product_id } /// Poll the device to get either the result /// of the previous command, or the status - pub fn poll(&mut self) -> Result<(u16, [u8; 4]), Box> { + pub async fn poll(&mut self) -> Result<(u16, [u8; 4]), Box> { // Create an array to store the result of the poll - let mut poll_result = [0u8; 4]; - - let _status = match self.usb_interface.control_in_blocking( - Control { + let poll_result = match self.usb_interface.control_in( + ControlIn { control_type: ControlType::Vendor, recipient: Recipient::Interface, request: 0x01, value: 0, index: 0, - }, - &mut poll_result, - DEFAULT_TIMEOUT, - ) { + length: 4, + } + ).await.into_result() { Ok(size) => size, Err(error) => return Err(error.into()), }; - let length_bytes = [poll_result[2], poll_result[3]]; - Ok((u16::from_le_bytes(length_bytes), poll_result)) + let length_bytes = u16::from_le_bytes([poll_result[2], poll_result[3]]); + + let poll_result: [u8; 4] = match poll_result.try_into() { + Ok(val) => val, + Err(_) => return Err("could not convert result".into()), + }; + + Ok((length_bytes, poll_result)) } - pub fn send_command(&mut self, command: Vec) -> Result<(), Box> { - self._send_command(command, false) + pub async fn send_command(&mut self, command: Vec) -> Result<(), Box> { + self._send_command(command, false).await } - pub fn send_factory_command(&mut self, command: Vec) -> Result<(), Box> { - self._send_command(command, true) + pub async fn send_factory_command(&mut self, command: Vec) -> Result<(), Box> { + self._send_command(command, true).await } /// Send a control message to the device - fn _send_command( + async fn _send_command( &mut self, command: Vec, use_factory_command: bool, ) -> Result<(), Box> { // First poll to ensure the device is ready - match self.poll() { + match self.poll().await { Ok(buffer) => match buffer.1[2] { 0 => 0, _ => return Err("Device not ready!".into()), @@ -214,25 +215,25 @@ impl NetMD { } } - pub fn read_reply(&mut self, override_length: Option) -> Result, Box> { - self._read_reply(false, override_length) + pub async fn read_reply(&mut self, override_length: Option) -> Result, Box> { + self._read_reply(false, override_length).await } - pub fn read_factory_reply( + pub async fn read_factory_reply( &mut self, override_length: Option, ) -> Result, Box> { - self._read_reply(true, override_length) + self._read_reply(true, override_length).await } /// Poll to see if a message is ready, /// and if so, recieve it - fn _read_reply( + async fn _read_reply( &mut self, use_factory_command: bool, override_length: Option, ) -> Result, Box> { - let mut length = self.poll()?.0; + let mut length = self.poll().await?.0; let mut current_attempt = 0; while length == 0 { @@ -240,7 +241,7 @@ impl NetMD { * (u64::pow(2, current_attempt as u32 / 10) - 1); std::thread::sleep(std::time::Duration::from_millis(sleep_time)); - length = self.poll()?.0; + length = self.poll().await?.0; current_attempt += 1; } @@ -275,17 +276,17 @@ impl NetMD { // Default chunksize should be 0x10000 // TODO: Make these Async eventually - pub fn read_bulk( + pub async fn read_bulk( &mut self, length: usize, chunksize: usize, ) -> Result, Box> { - let result = self.read_bulk_to_array(length, chunksize)?; + let result = self.read_bulk_to_array(length, chunksize).await?; Ok(result) } - pub fn read_bulk_to_array( + pub async fn read_bulk_to_array( &mut self, length: usize, chunksize: usize, @@ -298,7 +299,7 @@ impl NetMD { done -= to_read; let buffer = RequestBuffer::new(to_read); - let res = match block_on(self.usb_interface.bulk_in(BULK_READ_ENDPOINT, buffer)) + let res = match self.usb_interface.bulk_in(BULK_READ_ENDPOINT, buffer).await .into_result() { Ok(result) => result, @@ -311,9 +312,9 @@ impl NetMD { Ok(final_result) } - pub fn write_bulk(&mut self, data: Vec) -> Result> { + pub async fn write_bulk(&mut self, data: Vec) -> Result> { Ok( - block_on(self.usb_interface.bulk_out(BULK_WRITE_ENDPOINT, data)) + self.usb_interface.bulk_out(BULK_WRITE_ENDPOINT, data).await .into_result()? .actual_length(), ) diff --git a/minidisc-rs/src/netmd/interface.rs b/minidisc-rs/src/netmd/interface.rs index a168f0d..6d46b53 100644 --- a/minidisc-rs/src/netmd/interface.rs +++ b/minidisc-rs/src/netmd/interface.rs @@ -202,8 +202,8 @@ impl NetMDInterface { const MAX_INTERIM_READ_ATTEMPTS: u8 = 4; const INTERIM_RESPONSE_RETRY_INTERVAL: u32 = 100; - pub fn new(device: &nusb::DeviceInfo) -> Result> { - let net_md_device = base::NetMD::new(device)?; + pub async fn new(device: &nusb::DeviceInfo) -> Result> { + let net_md_device = base::NetMD::new(device).await?; Ok(NetMDInterface { net_md_device }) } @@ -218,7 +218,7 @@ impl NetMDInterface { } // TODO: Finish proper implementation - fn disc_subunit_identifier(&mut self) -> Result> { + async fn disc_subunit_identifier(&mut self) -> Result> { self.change_descriptor_state( &Descriptor::DiscSubunitIdentifier, &DescriptorAction::OpenRead, @@ -226,7 +226,7 @@ impl NetMDInterface { let mut query = format_query("1809 00 ff00 0000 0000".to_string(), vec![])?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query( reply, @@ -314,8 +314,8 @@ impl NetMDInterface { } */ - fn net_md_level(&mut self) -> Result> { - let result = self.disc_subunit_identifier()?; + async fn net_md_level(&mut self) -> Result> { + let result = self.disc_subunit_identifier().await?; Ok(result) } @@ -333,20 +333,20 @@ impl NetMDInterface { } /// Send a query to the NetMD player - fn send_query( + async fn send_query( &mut self, query: &mut Vec, test: bool, accept_interim: bool, ) -> Result, Box> { - self.send_command(query, test)?; + self.send_command(query, test).await?; - let result = self.read_reply(accept_interim)?; + let result = self.read_reply(accept_interim).await?; Ok(result) } - fn send_command(&mut self, query: &mut Vec, test: bool) -> Result<(), Box> { + async fn send_command(&mut self, query: &mut Vec, test: bool) -> Result<(), Box> { let status_byte = match test { true => Status::GeneralInquiry, false => Status::Control, @@ -357,17 +357,17 @@ impl NetMDInterface { new_query.push(status_byte as u8); new_query.append(query); - self.net_md_device.send_command(new_query)?; + self.net_md_device.send_command(new_query).await?; Ok(()) } - fn read_reply(&mut self, accept_interim: bool) -> Result, Box> { + async fn read_reply(&mut self, accept_interim: bool) -> Result, Box> { let mut current_attempt = 0; let mut data; while current_attempt < Self::MAX_INTERIM_READ_ATTEMPTS { - data = match self.net_md_device.read_reply(None) { + data = match self.net_md_device.read_reply(None).await { Ok(reply) => reply, Err(error) => return Err(error), }; @@ -402,66 +402,66 @@ impl NetMDInterface { Err("The max retries is set to 0".into()) } - fn playback_control(&mut self, action: Action) -> Result<(), Box> { + async fn playback_control(&mut self, action: Action) -> Result<(), Box> { let mut query = format_query( "18c3 00 %b 000000".to_string(), vec![QueryValue::Number(action as i64)], )?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; scan_query(reply, "18c3 00 %b 000000".to_string())?; Ok(()) } - pub fn play(&mut self) -> Result<(), Box> { - self.playback_control(Action::Play) + pub async fn play(&mut self) -> Result<(), Box> { + self.playback_control(Action::Play).await } - pub fn fast_forward(&mut self) -> Result<(), Box> { - self.playback_control(Action::FastForward) + pub async fn fast_forward(&mut self) -> Result<(), Box> { + self.playback_control(Action::FastForward).await } - pub fn rewind(&mut self) -> Result<(), Box> { - self.playback_control(Action::Rewind) + pub async fn rewind(&mut self) -> Result<(), Box> { + self.playback_control(Action::Rewind).await } - pub fn pause(&mut self) -> Result<(), Box> { - self.playback_control(Action::Pause) + pub async fn pause(&mut self) -> Result<(), Box> { + self.playback_control(Action::Pause).await } //TODO: Implement fix for LAM-1 - pub fn stop(&mut self) -> Result<(), Box> { + pub async fn stop(&mut self) -> Result<(), Box> { let mut query = format_query("18c5 ff 00000000".to_string(), vec![])?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; scan_query(reply, "18c5 00 00000000".to_string())?; Ok(()) } - fn acquire(&mut self) -> Result<(), Box> { + async fn acquire(&mut self) -> Result<(), Box> { let mut query = format_query("ff 010c ffff ffff ffff ffff ffff ffff".to_string(), vec![])?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; scan_query(reply, "ff 010c ffff ffff ffff ffff ffff ffff".to_string())?; Ok(()) } - fn release(&mut self) -> Result<(), Box> { + async fn release(&mut self) -> Result<(), Box> { let mut query = format_query("ff 0100 ffff ffff ffff ffff ffff ffff".to_string(), vec![])?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; scan_query(reply, "ff 0100 ffff ffff ffff ffff ffff ffff".to_string())?; Ok(()) } - pub fn status(&mut self) -> Result, Box> { + pub async fn status(&mut self) -> Result, Box> { self.change_descriptor_state( &Descriptor::OperatingStatusBlock, &DescriptorAction::OpenRead, @@ -472,7 +472,7 @@ impl NetMDInterface { vec![], )?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query( reply, @@ -486,15 +486,15 @@ impl NetMDInterface { Ok(final_array) } - pub fn disc_present(&mut self) -> Result> { - let status = self.status()?; + pub async fn disc_present(&mut self) -> Result> { + let status = self.status().await?; println!("{:X?}", status); Ok(status[4] == 0x40) } - fn full_operating_status(&mut self) -> Result<(u8, u16), Box> { + async fn full_operating_status(&mut self) -> Result<(u8, u16), Box> { // WARNING: Does not work for all devices. See https://github.com/cybercase/webminidisc/issues/21 self.change_descriptor_state( &Descriptor::OperatingStatusBlock, @@ -505,7 +505,7 @@ impl NetMDInterface { vec![], ) .unwrap(); - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let result = scan_query( reply, @@ -527,13 +527,13 @@ impl NetMDInterface { Ok((status_mode, operating_status_number)) } - pub fn operating_status(&mut self) -> Result> { - let status = self.full_operating_status()?.1; + pub async fn operating_status(&mut self) -> Result> { + let status = self.full_operating_status().await?.1; Ok(status) } - fn playback_status_query(&mut self, p1: u32, p2: u32) -> Result, Box> { + async fn playback_status_query(&mut self, p1: u32, p2: u32) -> Result, Box> { self.change_descriptor_state( &Descriptor::OperatingStatusBlock, &DescriptorAction::OpenRead, @@ -544,7 +544,7 @@ impl NetMDInterface { ) .unwrap(); - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query( reply, @@ -556,15 +556,15 @@ impl NetMDInterface { Ok(res.unwrap()[0].to_vec().unwrap()) } - pub fn playback_status1(&mut self) -> Result, Box> { - self.playback_status_query(0x8801, 0x8807) + pub async fn playback_status1(&mut self) -> Result, Box> { + self.playback_status_query(0x8801, 0x8807).await } - pub fn playback_status2(&mut self) -> Result, Box> { - self.playback_status_query(0x8802, 0x8806) + pub async fn playback_status2(&mut self) -> Result, Box> { + self.playback_status_query(0x8802, 0x8806).await } - pub fn position(&mut self) -> Result<[u16; 5], Box> { + pub async fn position(&mut self) -> Result<[u16; 5], Box> { self.change_descriptor_state( &Descriptor::OperatingStatusBlock, &DescriptorAction::OpenRead, @@ -576,7 +576,7 @@ impl NetMDInterface { ) .unwrap(); - let reply = match self.send_query(&mut query, false, false) { + let reply = match self.send_query(&mut query, false, false).await { Ok(result) => result, Err(e) if e.to_string() == "Rejected" => Vec::new(), Err(e) => return Err(e), @@ -597,31 +597,31 @@ impl NetMDInterface { Ok(final_result) } - pub fn eject_disc(&mut self) -> Result<(), Box> { + pub async fn eject_disc(&mut self) -> Result<(), Box> { let mut query = format_query("18c1 ff 6000".to_string(), vec![]).unwrap(); - let _reply = self.send_query(&mut query, false, false)?; + let _reply = self.send_query(&mut query, false, false).await?; Ok(()) } - pub fn can_eject_disc(&mut self) -> Result> { + pub async fn can_eject_disc(&mut self) -> Result> { let mut query = format_query("18c1 ff 6000".to_string(), vec![]).unwrap(); - match self.send_query(&mut query, true, false) { + match self.send_query(&mut query, true, false).await { Ok(_) => Ok(true), Err(error) => Err(error), } } /* Track control */ - pub fn go_to_track(&mut self, track_number: u16) -> Result> { + pub async fn go_to_track(&mut self, track_number: u16) -> Result> { let mut query = format_query( "1850 ff010000 0000 %w".to_string(), vec![QueryValue::Number(track_number as i64)], ) .unwrap(); - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query(reply, "1850 00010000 0000 %w".to_string())?; @@ -630,7 +630,7 @@ impl NetMDInterface { Ok(value as u16) } - pub fn go_to_time( + pub async fn go_to_time( &mut self, track_number: u16, hour: u8, @@ -650,7 +650,7 @@ impl NetMDInterface { ) .unwrap(); - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query(reply, "1850 00000000 %?%? %w %B%B%B%B".to_string())?; @@ -659,14 +659,14 @@ impl NetMDInterface { Ok(value as u16) } - fn _track_change(&mut self, direction: Track) -> Result<(), Box> { + async fn track_change(&mut self, direction: Track) -> Result<(), Box> { let mut query = format_query( "1850 ff10 00000000 %w".to_string(), vec![QueryValue::Number(direction as i64)], ) .unwrap(); - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; scan_query(reply, "1850 0010 00000000 %?%?".to_string())?; @@ -674,35 +674,35 @@ impl NetMDInterface { } /// Change to the next track (skip forward) - pub fn next_track(&mut self) -> Result<(), Box> { - self._track_change(Track::Next) + pub async fn next_track(&mut self) -> Result<(), Box> { + self.track_change(Track::Next).await } /// Change to the next track (skip back) - pub fn previous_track(&mut self) -> Result<(), Box> { - self._track_change(Track::Next) + pub async fn previous_track(&mut self) -> Result<(), Box> { + self.track_change(Track::Next).await } /// Change to the next track (skip to beginning of track) - pub fn restart_track(&mut self) -> Result<(), Box> { - self._track_change(Track::Next) + pub async fn restart_track(&mut self) -> Result<(), Box> { + self.track_change(Track::Next).await } /* Content access and control */ - pub fn erase_disc(&mut self) -> Result<(), Box> { + pub async fn erase_disc(&mut self) -> Result<(), Box> { let mut query = format_query("1840 ff 0000".to_string(), vec![]).unwrap(); - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; scan_query(reply, "1840 00 0000".to_string())?; Ok(()) } // TODO: Ensure this is returning the correct value, it // looks like it actually might be a 16 bit integer - pub fn disc_flags(&mut self) -> Result> { + pub async fn disc_flags(&mut self) -> Result> { self.change_descriptor_state(&Descriptor::RootTD, &DescriptorAction::OpenRead); let mut query = format_query("1806 01101000 ff00 0001000b".to_string(), vec![]).unwrap(); - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query(reply, "1806 01101000 1000 0001000b %b".to_string()).unwrap(); @@ -712,13 +712,13 @@ impl NetMDInterface { } /// The number of tracks on the disc - pub fn track_count(&mut self) -> Result> { + pub async fn track_count(&mut self) -> Result> { self.change_descriptor_state(&Descriptor::AudioContentsTD, &DescriptorAction::OpenRead); let mut query = format_query("1806 02101001 3000 1000 ff00 00000000".to_string(), vec![]).unwrap(); - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query( reply, @@ -731,7 +731,7 @@ impl NetMDInterface { Ok(res[0].to_i64().unwrap() as u16) } - fn _disc_title(&mut self, wchar: bool) -> Result> { + async fn raw_disc_title(&mut self, wchar: bool) -> Result> { self.change_descriptor_state(&Descriptor::AudioContentsTD, &DescriptorAction::OpenRead); self.change_descriptor_state(&Descriptor::DiscTitleTD, &DescriptorAction::OpenRead); @@ -758,7 +758,7 @@ impl NetMDInterface { ) .unwrap(); - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; if remaining == 0 { let res = scan_query( @@ -794,8 +794,8 @@ impl NetMDInterface { } /// Gets the disc title - pub fn disc_title(&mut self, wchar: bool) -> Result> { - let mut title = self._disc_title(wchar)?; + pub async fn disc_title(&mut self, wchar: bool) -> Result> { + let mut title = self.raw_disc_title(wchar).await?; let delim = match wchar { true => "／／", @@ -820,16 +820,16 @@ impl NetMDInterface { } /// Gets all groups on the disc - pub fn track_group_list( + pub async fn track_group_list( &mut self, ) -> Result, Option, Vec)>, Box> { - let raw_title = self._disc_title(false)?; + let raw_title = self.raw_disc_title(false).await?; let group_list = raw_title.split("//"); let mut track_dict: HashMap = HashMap::new(); - let track_count = self.track_count()?; + let track_count = self.track_count().await?; let mut result: Vec<(Option, Option, Vec)> = Vec::new(); - let raw_full_title = self._disc_title(true)?; + let raw_full_title = self.raw_disc_title(true).await?; let mut full_width_group_list = raw_full_title.split("／／"); @@ -906,7 +906,7 @@ impl NetMDInterface { } /// Gets a list of track titles from a set - pub fn track_titles( + pub async fn track_titles( &mut self, tracks: Vec, wchar: bool, @@ -934,7 +934,7 @@ impl NetMDInterface { ) .unwrap(); - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query( reply, @@ -956,8 +956,8 @@ impl NetMDInterface { } /// Gets the title of a track at an index - pub fn track_title(&mut self, track: u16, wchar: bool) -> Result> { - let title = match self.track_titles([track].into(), wchar) { + pub async fn track_title(&mut self, track: u16, wchar: bool) -> Result> { + let title = match self.track_titles([track].into(), wchar).await { Ok(titles) => titles[0].clone(), Err(error) if error.to_string() == "Rejected" => String::new(), Err(error) => return Err(error), @@ -966,10 +966,10 @@ impl NetMDInterface { } // Sets the title of the disc - pub fn set_disc_title(&mut self, title: String, wchar: bool) -> Result<(), Box> { - let current_title = self._disc_title(wchar)?; + pub async fn set_disc_title(&mut self, title: String, wchar: bool) -> Result<(), Box> { + let current_title = self.raw_disc_title(wchar).await?; if current_title == title { - return Ok(()); + return Err("Title is already the same".into()); } let new_title: Vec; @@ -988,7 +988,7 @@ impl NetMDInterface { let new_len = new_title.len(); - if self.net_md_device.vendor_id() == &0x04dd { + if self.net_md_device.vendor_id().await == &0x04dd { self.change_descriptor_state(&Descriptor::AudioUTOC1TD, &DescriptorAction::OpenWrite) } else { self.change_descriptor_state(&Descriptor::DiscTitleTD, &DescriptorAction::Close); @@ -1007,7 +1007,7 @@ impl NetMDInterface { let _ = self.send_query(&mut query, false, false); - if self.net_md_device.vendor_id() == &0x04dd { + if self.net_md_device.vendor_id().await == &0x04dd { self.change_descriptor_state(&Descriptor::AudioUTOC1TD, &DescriptorAction::Close) } else { self.change_descriptor_state(&Descriptor::DiscTitleTD, &DescriptorAction::Close); @@ -1019,7 +1019,7 @@ impl NetMDInterface { } /// Sets the title of a track - pub fn set_track_title( + pub async fn set_track_title( &mut self, track: u16, title: String, @@ -1039,7 +1039,7 @@ impl NetMDInterface { let new_len = new_title.len(); - let old_len: u16 = match self.track_title(track, wchar) { + let old_len: u16 = match self.track_title(track, wchar).await { Ok(current_title) => { if title == current_title { return Ok(()); @@ -1061,7 +1061,7 @@ impl NetMDInterface { QueryValue::Array(new_title), ], )?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let _ = scan_query( reply, @@ -1073,19 +1073,19 @@ impl NetMDInterface { } /// Removes a track from the UTOC - pub fn erase_track(&mut self, track: u16) -> Result<(), Box> { + pub async fn erase_track(&mut self, track: u16) -> Result<(), Box> { let mut query = format_query( "1840 ff01 00 201001 %w".to_string(), vec![QueryValue::Number(track as i64)], )?; - let _ = self.send_query(&mut query, false, false); + let _result = self.send_query(&mut query, false, false).await; Ok(()) } /// Moves a track to another position on the disc - pub fn move_track(&mut self, source: u16, dest: u16) -> Result<(), Box> { + pub async fn move_track(&mut self, source: u16, dest: u16) -> Result<(), Box> { let mut query = format_query( "1843 ff00 00 201001 %w 201001 %w".to_string(), vec![ @@ -1094,12 +1094,12 @@ impl NetMDInterface { ], )?; - let _ = self.send_query(&mut query, false, false); + let _result = self.send_query(&mut query, false, false).await; Ok(()) } - fn _track_info(&mut self, track: u16, p1: i32, p2: i32) -> Result, Box> { + async fn raw_track_info(&mut self, track: u16, p1: i32, p2: i32) -> Result, Box> { self.change_descriptor_state(&Descriptor::AudioContentsTD, &DescriptorAction::OpenRead); let mut query = format_query( @@ -1111,7 +1111,7 @@ impl NetMDInterface { ], )?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query( reply, "1806 02201001 %?%? %?%? %?%? 1000 00%?0000 %x".to_string(), @@ -1123,7 +1123,7 @@ impl NetMDInterface { } /// Gets the length of tracks as a `std::time::Duration` from a set - pub fn track_lengths( + pub async fn track_lengths( &mut self, tracks: Vec, ) -> Result, Box> { @@ -1140,7 +1140,7 @@ impl NetMDInterface { ], )?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query( reply, @@ -1167,13 +1167,13 @@ impl NetMDInterface { } /// Gets the length of a track as a `std::time::Duration` - pub fn track_length(&mut self, track: u16) -> Result> { - Ok(self.track_lengths([track].into())?[0]) + pub async fn track_length(&mut self, track: u16) -> Result> { + Ok(self.track_lengths([track].into()).await?[0]) } /// Gets the encoding of a track (SP, LP2, LP4) - pub fn track_encoding(&mut self, track_number: u16) -> Result> { - let raw_value = self._track_info(track_number, 0x3080, 0x0700)?; + pub async fn track_encoding(&mut self, track_number: u16) -> Result> { + let raw_value = self.raw_track_info(track_number, 0x3080, 0x0700).await?; let result = scan_query(raw_value, "07 0004 0110 %b %b".to_string())?; let final_encoding = match result[0].to_i64() { @@ -1188,13 +1188,13 @@ impl NetMDInterface { } /// Gets a track's flags - pub fn track_flags(&mut self, track: u16) -> Result> { + pub async fn track_flags(&mut self, track: u16) -> Result> { self.change_descriptor_state(&Descriptor::AudioContentsTD, &DescriptorAction::OpenRead); let mut query = format_query( "1806 01201001 %w ff00 00010008".to_string(), vec![QueryValue::Number(track as i64)], )?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query(reply, "1806 01201001 %?%? 10 00 00010008 %b".to_string())?; @@ -1204,10 +1204,10 @@ impl NetMDInterface { } /// Gets the disc capacity as a `std::time::Duration` - pub fn disc_capacity(&mut self) -> Result<[std::time::Duration; 3], Box> { + pub async fn disc_capacity(&mut self) -> Result<[std::time::Duration; 3], Box> { self.change_descriptor_state(&Descriptor::RootTD, &DescriptorAction::OpenRead); let mut query = format_query("1806 02101000 3080 0300 ff00 00000000".to_string(), vec![])?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let mut result: [std::time::Duration; 3] = [std::time::Duration::from_secs(0); 3]; // 8003 changed to %?03 - Panasonic returns 0803 instead. This byte's meaning is unknown @@ -1233,7 +1233,7 @@ impl NetMDInterface { Ok(result) } - pub fn recording_parameters(&mut self) -> Result, Box> { + pub async fn recording_parameters(&mut self) -> Result, Box> { self.change_descriptor_state( &Descriptor::OperatingStatusBlock, &DescriptorAction::OpenRead, @@ -1243,7 +1243,7 @@ impl NetMDInterface { vec![], )?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query(reply, "1809 8001 0330 8801 0030 8805 0030 8807 00 1000 000e0000 000c 8805 0008 80e0 0110 %b %b 4000".to_string())?; @@ -1255,7 +1255,7 @@ impl NetMDInterface { /// Gets the bytes of a track /// /// This can only be executed on an MZ-RH1 / M200 - pub fn save_track_to_array( + pub async fn save_track_to_array( &mut self, track: u16, ) -> Result<(DiscFormat, u16, Vec), Box> { @@ -1264,7 +1264,7 @@ impl NetMDInterface { vec![QueryValue::Number((track + 1) as i64)], )?; - let reply = self.send_query(&mut query, false, true)?; + let reply = self.send_query(&mut query, false, true).await?; let res = scan_query( reply, @@ -1275,10 +1275,10 @@ impl NetMDInterface { let codec = res[1].to_i64().unwrap() as u8; let length = res[2].to_i64().unwrap() as usize; - let result = self.net_md_device.read_bulk(length, 0x10000)?; + let result = self.net_md_device.read_bulk(length, 0x10000).await?; scan_query( - self.read_reply(false)?, + self.read_reply(false).await?, "1800 080046 f003010330 0000 1001 %?%? %?%?".to_string(), )?; @@ -1295,50 +1295,51 @@ impl NetMDInterface { Ok((format, frames, result)) } - pub fn disable_new_track_protection(&mut self, val: u16) -> Result<(), Box> { + pub async fn disable_new_track_protection(&mut self, val: u16) -> Result<(), Box> { let mut query = format_query( "1800 080046 f0030103 2b ff %w".to_string(), vec![QueryValue::Number(val as i64)], )?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; scan_query(reply, "1800 080046 f0030103 2b 00 %?%?".to_string())?; Ok(()) } - pub fn enter_secure_session(&mut self) -> Result<(), Box> { + pub async fn enter_secure_session(&mut self) -> Result<(), Box> { let mut query = format_query("1800 080046 f0030103 80 ff".to_string(), vec![])?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; scan_query(reply, "1800 080046 f0030103 80 00".to_string())?; Ok(()) } - pub fn leave_secure_session(&mut self) -> Result<(), Box> { + pub async fn leave_secure_session(&mut self) -> Result<(), Box> { let mut query = format_query("1800 080046 f0030103 81 ff".to_string(), vec![])?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; scan_query(reply, "1800 080046 f0030103 81 00".to_string())?; Ok(()) } /** - Read the leaf ID of the present NetMD device. The leaf ID tells - which keys the device posesses, which is needed to find out which - parts of the EKB needs to be sent to the device for it to decrypt - the root key. - The leaf ID is a 8-byte constant + * Read the leaf ID of the present NetMD device. The leaf ID tells + * which keys the device posesses, which is needed to find out which + * parts of the EKB needs to be sent to the device for it to decrypt + * the root key. + * + * The leaf ID is a 8-byte constant **/ - pub fn leaf_id(&mut self) -> Result, Box> { + pub async fn leaf_id(&mut self) -> Result, Box> { let mut query = format_query("1800 080046 f0030103 11 ff".to_string(), vec![])?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query(reply, "1800 080046 f0030103 11 00 %*".to_string())?; Ok(res[0].to_vec().unwrap()) } - pub fn send_key_data( + pub async fn send_key_data( &mut self, ekbid: i32, keychain: Vec<[u8; 16]>, @@ -1370,7 +1371,7 @@ impl NetMDInterface { ], )?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query( reply, @@ -1380,7 +1381,7 @@ impl NetMDInterface { Ok(res[0].to_vec().unwrap()) } - pub fn session_key_exchange(&mut self, hostnonce: Vec) -> Result, Box> { + pub async fn session_key_exchange(&mut self, hostnonce: Vec) -> Result, Box> { if hostnonce.len() != 8 { return Err("Supplied host nonce length wrong".into()); } @@ -1389,23 +1390,23 @@ impl NetMDInterface { vec![QueryValue::Array(hostnonce)], )?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query(reply, "1800 080046 f0030103 20 %? 000000 %#".to_string())?; Ok(res[0].to_vec().unwrap()) } - pub fn session_key_forget(&mut self) -> Result<(), Box> { + pub async fn session_key_forget(&mut self) -> Result<(), Box> { let mut query = format_query("1800 080046 f0030103 21 ff 000000".to_string(), vec![])?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let _ = scan_query(reply, "1800 080046 f0030103 21 00 000000".to_string())?; Ok(()) } - pub fn setup_download( + pub async fn setup_download( &mut self, contentid: Vec, keyenckey: Vec, @@ -1432,14 +1433,14 @@ impl NetMDInterface { vec![QueryValue::Array(encryptedarg)], )?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; scan_query(reply, "1800 080046 f0030103 22 00 0000".to_string())?; Ok(()) } - pub fn commit_track( + pub async fn commit_track( &mut self, track_number: u16, hex_session_key: String, @@ -1459,14 +1460,14 @@ impl NetMDInterface { ], )?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; scan_query(reply, "1800 080046 f0030103 22 00 0000".to_string())?; Ok(()) } - pub fn send_track( + pub async fn send_track( &mut self, wireformat: u8, discformat: u8, @@ -1494,7 +1495,7 @@ impl NetMDInterface { QueryValue::Number(total_bytes as i64), ], )?; - let mut reply = self.send_query(&mut query, false, true)?; + let mut reply = self.send_query(&mut query, false, true).await?; scan_query( reply, "1800 080046 f0030103 28 00 000100 1001 %?%? 00 %*".to_string(), @@ -1511,12 +1512,12 @@ impl NetMDInterface { } else { data.clone() }; - self.net_md_device.write_bulk(binpack)?; + self.net_md_device.write_bulk(binpack).await?; _written_bytes += data.len(); } - reply = self.read_reply(false)?; - self.net_md_device.poll()?; + reply = self.read_reply(false).await?; + self.net_md_device.poll().await?; let res = scan_query( reply, "1800 080046 f0030103 28 00 000100 1001 %w 00 %?%? %?%?%?%? %?%?%?%? %*".to_string(), @@ -1535,21 +1536,21 @@ impl NetMDInterface { Ok((res[0].to_i64().unwrap(), part1, part2)) } - pub fn track_uuid(&mut self, track: u16) -> Result> { + pub async fn track_uuid(&mut self, track: u16) -> Result> { let mut query = format_query( "1800 080046 f0030103 23 ff 1001 %w".to_string(), vec![QueryValue::Number(track as i64)], )?; - let reply = self.send_query(&mut query, false, false)?; + let reply = self.send_query(&mut query, false, false).await?; let res = scan_query(reply, "1800 080046 f0030103 23 00 1001 %?%? %*".to_string())?; Ok(String::from_utf8_lossy(&res[0].to_vec().unwrap()).to_string()) } - pub fn terminate(&mut self) -> Result<(), Box> { + pub async fn terminate(&mut self) -> Result<(), Box> { let mut query = format_query("1800 080046 f0030103 2a ff00".to_string(), vec![])?; - self.send_query(&mut query, false, false)?; + self.send_query(&mut query, false, false).await?; Ok(()) } diff --git a/src/main.rs b/src/main.rs index bcece72..3ac00cb 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,14 +1,18 @@ use minidisc_rs::netmd::interface; use nusb; -fn main() { +#[tokio::main] +async fn main() { let devices = nusb::list_devices().unwrap(); for device in devices { // Ensure the player is a minidisc player and not some other random device - let mut player_controller = match interface::NetMDInterface::new(&device) { + let mut player_controller = match interface::NetMDInterface::new(&device).await { Ok(player) => player, - Err(_) => continue, + Err(err) => { + dbg!(err); + continue; + } }; println!( @@ -22,22 +26,25 @@ fn main() { player_controller .net_md_device .device_name() + .await .clone() .unwrap() ); let now = std::time::Instant::now(); + let half_title = player_controller.disc_title(false).await.unwrap_or("".to_string()); + let full_title = player_controller.disc_title(true).await.unwrap_or("".to_string()); println!( "Disc Title: {} | {}", - player_controller - .disc_title(false) - .unwrap_or("".to_string()), - player_controller.disc_title(true).unwrap_or("".to_string()) + half_title, + full_title ); - let track_count = player_controller.track_count().unwrap(); - let track_titles = player_controller.track_titles((0..track_count).collect(), false).unwrap(); - let track_titlesw = player_controller.track_titles((0..track_count).collect(), true).unwrap(); - let track_lengths = player_controller.track_lengths((0..track_count).collect()).unwrap(); + + let track_count = player_controller.track_count().await.unwrap(); + println!("{}", track_count); + let track_titles = player_controller.track_titles((0..track_count).collect(), false).await.unwrap(); + let track_titlesw = player_controller.track_titles((0..track_count).collect(), true).await.unwrap(); + let track_lengths = player_controller.track_lengths((0..track_count).collect()).await.unwrap(); for (i, track) in track_titles.iter().enumerate() { println!( "Track {i} Info:\n Title: {track} | {}\n Length: {:?}",