FlapJackApps/libdivecomputer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Simplified the download code.

Browse Source 
With a memory buffer that is large enough to store all profile data, 
there is no need to use an intermediate package buffer.
This commit is contained in:
Jef Driesen 2008-03-12 11:06:34 +00:00
parent feae81bd45
commit 8faae14591
1 changed files with 14 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
suunto_d9.c
View File

@ -367,7 +367,6 @@ suunto_d9_read_dives (d9 *device, dive_callback_t callback, void *userdata)
// Memory buffer to store all the dives.
unsigned int index = 0;
unsigned char data[SUUNTO_D9_MEMORY_SIZE - 0x019A - 2] = {0};
// Calculate the total amount of bytes.
@ -379,11 +378,8 @@ suunto_d9_read_dives (d9 *device, dive_callback_t callback, void *userdata)
// last package of a dive can contain data from more than one dive.
// Therefore, the remaining data of this package (and its size)
// needs to be preserved for the next dive.
// The package buffer also needs some extra space to store the
// pointer bytes (see later on for the reason).
unsigned int available = 0;
unsigned char package[SUUNTO_D9_PACKET_SIZE + 3] = {0};
// The ring buffer is traversed backwards to retrieve the most recent
// dives first. This allows you to download only the new dives. During
@ -397,27 +393,10 @@ suunto_d9_read_dives (d9 *device, dive_callback_t callback, void *userdata)
while (current != begin) {
// Calculate the size of the current dive.
unsigned int size = DISTANCE (previous, current);
message ("Pointers: dive=%u, current=%04x, previous=%04x, size=%u, remaining=%u\n", ndives + 1, current, previous, size, remaining);
assert (size >= 4);
message ("Pointers: dive=%u, current=%04x, previous=%04x, size=%u, remaining=%u, available=%u\n",
ndives + 1, current, previous, size, remaining, available);
// Check if the output buffer is large enough to store the entire
// dive. The output buffer does not need space for the previous and
// next pointers (4 bytes).
assert (sizeof (data) >= index + size - 4);
// If there is already some data available from downloading
// the previous dive, it is processed here.
if (available) {
// Calculate the offset to the package data.
unsigned int offset = 0;
if (available > size - 4)
offset = available - (size - 4);
// Prepend the package data to the output buffer.
unsigned int e = index + (size - 4);
unsigned int n = available - offset;
memcpy (data + e - n, package + offset, n);
}
assert (size >= 4 && size <= remaining);
unsigned int nbytes = available;
unsigned int address = current - available;
@ -433,41 +412,16 @@ suunto_d9_read_dives (d9 *device, dive_callback_t callback, void *userdata)
/*if (nbytes + len > size)
len = size - nbytes;*/ // End of dive (for testing only).
// Calculate the offset to the package data, skipping the
// previous and next pointers (4 bytes) and also the data
// from the next dive (if present). Thus, the offset is only
// non-zero for packages at the end of the dive.
unsigned int offset = 0;
if (nbytes + len > size - 4)
offset = nbytes + len - (size - 4);
message ("Pointers: address=%04x, len=%u, offset=%u\n", address - len, len, offset);
// The previous and next pointers can be split over multiple
// packages. If that is the case, we move those byte(s) from
// the start of the previous package to the end of the current
// package. With this approach, the pointers are preserved when
// reading the current package (in the next step) and they are
// again in a continuous memory area.
if (offset > len) {
message ("Pointers: dst=%u, src=%u, len=%u\n", len, 0, offset - len);
memmove (package + len, package, offset - len);
}
message ("Pointers: address=%04x, len=%u\n", address - len, len);
// Read the package.
rc = suunto_d9_read_memory (device, address - len, package, len);
unsigned char *p = data + remaining - nbytes;
rc = suunto_d9_read_memory (device, address - len, p - len, len);
if (rc != SUUNTO_SUCCESS) {
WARNING ("Cannot read memory.");
return rc;
}
// Prepend the package data to the output buffer.
if (offset < len) {
unsigned int e = index + (size - 4) - nbytes;
unsigned int n = len - offset;
memcpy (data + e - n, package + offset, n);
}
// Next package.
nbytes += len;
address -= len;
@ -475,37 +429,36 @@ suunto_d9_read_dives (d9 *device, dive_callback_t callback, void *userdata)
address = SUUNTO_D9_MEMORY_SIZE - 2;
}
message ("Pointers: nbytes=%u\n", nbytes);
// The last package of the current dive contains the previous and
// next pointers (in a continuous memory area). It can also contain
// a number of bytes from the next dive. The offset to the pointers
// is equal to the number of remaining (or "available") bytes.
// is equal to the number of bytes remaining after the current dive.
remaining -= size;
available = nbytes - size;
message ("Pointers: nbytes=%u, available=%u\n", nbytes, available);
unsigned int oprevious = package[available + 0x00] + (package[available + 0x01] << 8);
unsigned int onext = package[available + 0x02] + (package[available + 0x03] << 8);
unsigned int oprevious = data[remaining + 0] + (data[remaining + 1] << 8);
unsigned int onext = data[remaining + 2] + (data[remaining + 3] << 8);
message ("Pointers: previous=%04x, next=%04x\n", oprevious, onext);
assert (current == onext);
// Next dive.
current = previous;
previous = oprevious;
remaining -= size;
ndives++;
#ifndef NDEBUG
message ("D9Profile()=\"");
for (unsigned int i = 0; i < size - 4; ++i) {
message ("%02x", data[i + index]);
message ("%02x", data[remaining + 4 + i]);
}
message ("\"\n");
#endif
if (callback)
callback (data + index, size - 4, userdata);
index += size - 4;
callback (data + remaining + 4, size - 4, userdata);
}
assert (remaining == 0);
assert (available == 0);