X-Git-Url: http://git.code-monkey.de/?a=blobdiff_plain;f=src%2Fcommon%2Flogger.rs;h=2ca2e22980f48b7867abddae91b2e09e1506c7d2;hb=241e581359f381c5aaa18cefa3dbcb7d46241267;hp=d83d2391bfe1a6261dc2bb312e2a6a288d26ba16;hpb=9c56bca3b719a7e44074225a99d9f97fd05466d3;p=gps-watch.git diff --git a/src/common/logger.rs b/src/common/logger.rs index d83d239..2ca2e22 100644 --- a/src/common/logger.rs +++ b/src/common/logger.rs @@ -25,12 +25,21 @@ use gps::TimeAndPos; use storage::Storage; use varint; use systick::elapsed_ms; +use buffer::Buffer; +use yencode::Yencode; +use fmt::*; +use time::Time; pub const MEMORY_SIZE: usize = 2 << 20; const SECTOR_SIZE: usize = 4 << 10; const NUM_SECTORS: usize = MEMORY_SIZE / SECTOR_SIZE; +#[derive(Clone, Copy, PartialEq, Debug)] +pub enum Error { + NoSuchRecording, +} + enum SectorFlag { InUse = 1 << 0, DataRecord = 1 << 1, @@ -72,6 +81,10 @@ impl SectorHeader { (self.flags & mask) == value } + + fn belongs_to(&self, recording_id: u16) -> bool { + self.is_in_use() && self.recording_id == recording_id + } } #[derive(Clone, Copy)] @@ -92,7 +105,7 @@ impl InFlight { } pub struct Logger<'a> { - storage: &'a mut dyn Storage, + pub storage: &'a mut dyn Storage, recording_id: u16, // Zero is considered invalid. @@ -131,10 +144,22 @@ fn cmp_sector_header_indices(a: u16, b: u16, let header_a = §or_header[a as usize]; let header_b = §or_header[b as usize]; - // Latest entries come first. - if header_a.start_time > header_b.start_time { + if header_a.starts_recording() && header_b.starts_recording() { + // Latest entries come first. + if header_a.start_time > header_b.start_time { + -1 + } else if header_a.start_time < header_b.start_time { + 1 + } else { + 0 + } + } else if header_a.starts_recording() { + -1 + } else if header_b.starts_recording() { + 1 + } else if a < b { -1 - } else if header_a.start_time < header_b.start_time { + } else if a > b { 1 } else { 0 @@ -174,73 +199,30 @@ impl<'a> SectorHeaderIter<'a> { indices: [0; NUM_SECTORS] }; - let mut num_used = 0; - - // Put the indices of the used directory entries at the beginning - // of the array. Ignore the unused ones since we are not going - // to sort them anyway. for i in 0..NUM_SECTORS { - let sector_header = &iter.sector_header[i]; - - if sector_header.starts_recording() { - iter.indices[num_used] = i as u16; - num_used += 1; - } + iter.indices[i] = i as u16; } - let num_elts_to_sort = num_used; + iter.sort(NUM_SECTORS); - if num_elts_to_sort != 0 { - // Sort the used directory entries. - for i in (1..((num_elts_to_sort + 1) / 2) + 1).rev() { - downheap(&mut iter.indices, i - 1, num_elts_to_sort - 1, - iter.sector_header); - } + // XXX: + // Need to handle those sectors that don't start recordings + // but that are still used. - for i in (1..num_elts_to_sort).rev() { - let t = iter.indices[0]; - iter.indices[0] = iter.indices[i]; - iter.indices[i] = t; + iter + } - downheap(&mut iter.indices, 0, i - 1, iter.sector_header); - } + fn sort(&mut self, num_elts_to_sort: usize) { + for i in (1..((num_elts_to_sort + 1) / 2) + 1).rev() { + downheap(&mut self.indices, i - 1, num_elts_to_sort - 1, + self.sector_header); } - // Now put the indices of the unused directory entries in the array. - if num_used == 0 { - for i in 0..NUM_SECTORS { - iter.indices[i] = i as u16; - } - } else { - let latest_used = iter.indices[0] as usize; - let mut offset_unused = num_used; - - // First put the entries that come after the latest one in use... - for i in (latest_used + 1)..NUM_SECTORS { - let sector_header = &iter.sector_header[i]; - - if !sector_header.is_in_use() { - iter.indices[offset_unused] = i as u16; - offset_unused += 1; - } - } + for i in (1..num_elts_to_sort).rev() { + self.indices.swap(0, i); - // ... then wrap around if necessary. - for i in 0..latest_used { - let sector_header = &iter.sector_header[i]; - - if !sector_header.is_in_use() { - iter.indices[offset_unused] = i as u16; - offset_unused += 1; - } - } + downheap(&mut self.indices, 0, i - 1, self.sector_header); } - - // XXX: - // Need to handle those sectors that don't start recordings - // but that are still used. - - iter } } @@ -329,7 +311,7 @@ impl<'a> Logger<'a> { fn read_sector_header(&mut self, sector_index: usize) { let address = sector_index * SECTOR_SIZE; - let mut chunk = [0u8; 4]; + let mut chunk = [0u8; 8]; self.storage.read(address, &mut chunk); @@ -418,8 +400,10 @@ impl<'a> Logger<'a> { let this_sector = self.first_sector + self.sectors_written; - self.storage.write(this_sector as usize * SECTOR_SIZE, - &self.write_buffer); + if self.storage.write(this_sector as usize * SECTOR_SIZE, + &self.write_buffer).is_err() { + // XXX + } self.sectors_written += 1; @@ -541,8 +525,10 @@ impl<'a> Logger<'a> { // our buffer with 0xff, so we don't need to do anything here. let this_sector = self.first_sector + self.sectors_written; - self.storage.write(this_sector as usize * SECTOR_SIZE, - &self.write_buffer); + if self.storage.write(this_sector as usize * SECTOR_SIZE, + &self.write_buffer).is_err() { + // XXX + } self.sectors_written += 1; @@ -557,4 +543,108 @@ impl<'a> Logger<'a> { self.write_buffer_offset += num_bytes_written; } + + /// + /// Write a listing of the stored recordings to @p tx_buf. + pub fn list_recordings(&mut self, tx_buf: &mut Buffer) { + for index in self.sector_header_iter().rev() { + let sector_header = &self.sector_header[index as usize]; + + if !sector_header.starts_recording() { + continue; + } + + let mut date_time_s = [b' '; 19]; + + if let Some(tm) = Time::from_unix_time(sector_header.start_time) { + tm.fmt_date(&mut date_time_s[0..]); + tm.fmt_time(&mut date_time_s[11..]); + } + + let mut recording_id_s = [b'0'; 9]; + let recording_id_s_len = + fmt_u32_pad(&mut recording_id_s, + sector_header.recording_id as u32, + 8, b' '); + + tx_buf.write(&date_time_s); + tx_buf.write(b" "); + tx_buf.write(&recording_id_s[0..recording_id_s_len]); + tx_buf.write(b"\n"); + + tx_buf.flush(); + } + } + + /// + /// Check whether or not recording @p recording_id exists. + pub fn has_recording(&mut self, recording_id: u16) -> bool { + if recording_id == 0 { + return false; + } + + self.sector_header_iter().find(|&index| { + let sector_header = &self.sector_header[index as usize]; + + sector_header.recording_id == recording_id && + sector_header.starts_recording() + }).is_some() + } + + /// + /// Retrieve recording @p recording_id and + /// write it to @p tx_buf in yencoded form. + pub fn get_recording(&mut self, recording_id: u16, + tx_buf: &mut Buffer) -> Result<(), Error> { + if recording_id == 0 { + return Err(Error::NoSuchRecording); + } + + if let Some(found_index) = self.sector_header_iter().find(|&index| { + let sector_header = &self.sector_header[index as usize]; + + sector_header.recording_id == recording_id && + sector_header.starts_recording() + }) { + let mut filename = [b' '; 29]; + + filename[0..].copy_from_slice(b"gps-watch-recording-XXXXX.bin"); + + fmt_u32_pad(&mut filename[20..], recording_id as u32, 5, b'0'); + + let mut yenc = Yencode::new(tx_buf); + + yenc.start(&filename); + + let format_version = 1u8; + yenc.data(&[format_version]); + + let mut next_sector = found_index as usize; + + for _ in 0..NUM_SECTORS { + let address = next_sector * SECTOR_SIZE; + let mut buf = [0u8; SECTOR_SIZE]; + + self.storage.read(address, &mut buf); + + // Skip flags and recording ID. + yenc.data(&buf[4..]); + + next_sector += 1; + next_sector &= NUM_SECTORS - 1; + + if !self.sector_header[next_sector].belongs_to(recording_id) { + break; + } + } + + yenc.finish(); + + tx_buf.flush(); + + Ok(()) + } else { + Err(Error::NoSuchRecording) + } + } }