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,
(self.flags & mask) == value
}
+
+ fn belongs_to(&self, recording_id: u16) -> bool {
+ self.is_in_use() && self.recording_id == recording_id
+ }
}
#[derive(Clone, Copy)]
}
pub struct Logger<'a> {
- storage: &'a mut dyn Storage,
+ pub storage: &'a mut dyn Storage,
recording_id: u16, // Zero is considered invalid.
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
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
}
}
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);
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;
// 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;
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)
+ }
+ }
}
projects / gps-watch.git / blobdiff