mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2024-11-28 05:00:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
subsurface/core/cochran.c
Berthold Stoeger 9c253ee6c5 core: introduce divelog structure 
The parser API was very annoying, as a number of tables
to-be-filled were passed in as pointers. The goal of this
commit is to collect all these tables in a single struct.
This should make it (more or less) clear what is actually
written into the divelog files.

Moreover, it should now be rather easy to search for
instances, where the global logfile is accessed (and it
turns out that there are many!).

The divelog struct does not contain the tables as substructs,
but only collects pointers. The idea is that the "divelog.h"
file can be included without all the other files describing
the numerous tables.

To make it easier to use from C++ parts of the code, the
struct implements a constructor and a destructor. Sadly,
we can't use smart pointers, since the pointers are accessed
from C code. Therfore the constructor and destructor are
quite complex.

The whole commit is large, but was mostly an automatic
conversion.

One oddity of note: the divelog structure also contains
the "autogroup" flag, since that is saved in the divelog.
This actually fixes a bug: Before, when importing dives
from a different log, the autogroup flag was overwritten.
This was probably not intended and does not happen anymore.

Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2023-04-14 21:20:23 +02:00

838 lines
23 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0
#ifdef __clang__
// Clang has a bug on zero-initialization of C structs.
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
#endif
#include "ssrf.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "dive.h"
#include "file.h"
#include "sample.h"
#include "subsurface-time.h"
#include "units.h"
#include "sha1.h"
#include "gettext.h"
#include "cochran.h"
#include "divelist.h"
#include "divelog.h"
#include <libdivecomputer/parser.h>
#define POUND 0.45359237
#define FEET 0.3048
#define INCH 0.0254
#define GRAVITY 9.80665
#define ATM 101325.0
#define BAR 100000.0
#define FSW (ATM / 33.0)
#define MSW (BAR / 10.0)
#define PSI ((POUND * GRAVITY) / (INCH * INCH))
// Some say 0x4a14 and 0x4b14 are the right number for this offset
// This works with CAN files from Analyst 4.01v and computers
// such as Commander, Gemini, EMC-16, and EMC-20H
#define LOG_ENTRY_OFFSET 0x4914
enum cochran_type {
TYPE_GEMINI,
TYPE_COMMANDER,
TYPE_EMC
};
struct config {
enum cochran_type type;
unsigned int logbook_size;
unsigned int sample_size;
} config;
// Convert 4 bytes into an INT
#define array_uint16_le(p) ((unsigned int) (p)[0] \
+ ((p)[1]<<8) )
#define array_uint32_le(p) ((unsigned int) (p)[0] \
+ ((p)[1]<<8) + ((p)[2]<<16) \
+ ((p)[3]<<24))
/*
* The Cochran file format is designed to be annoying to read. It's roughly:
*
* 0x00000: room for 65534 4-byte words, giving the starting offsets
* of the dives themselves.
*
* 0x3fff8: the size of the file + 1
* 0x3ffff: 0 (high 32 bits of filesize? Bogus: the offsets into the file
* are 32-bit, so it can't be a large file anyway)
*
* 0x40000: byte 0x46
* 0x40001: "block 0": 256 byte encryption key
* 0x40101: the random modulus, or length of the key to use
* 0x40102: block 1: Version and date of Analyst and a feature string identifying
* the computer features and the features of the file
* 0x40138: Computer configuration page 1, 512 bytes
* 0x40338: Computer configuration page 2, 512 bytes
* 0x40538: Misc data (tissues) 1500 bytes
* 0x40b14: Ownership data 512 bytes ???
*
* 0x4171c: Ownership data 512 bytes ??? <copy>
*
* 0x45415: Time stamp 17 bytes
* 0x45426: Computer configuration page 1, 512 bytes <copy>
* 0x45626: Computer configuration page 2, 512 bytes <copy>
*
*/
static unsigned int partial_decode(unsigned int start, unsigned int end,
const unsigned char *decode, unsigned offset, unsigned mod,
const unsigned char *buf, unsigned int size, unsigned char *dst)
{
unsigned i, sum = 0;
for (i = start; i < end; i++) {
unsigned char d = decode[offset++];
if (i >= size)
break;
if (offset == mod)
offset = 0;
d += buf[i];
if (dst)
dst[i] = d;
sum += d;
}
return sum;
}
#ifdef COCHRAN_DEBUG
#define hexchar(n) ("0123456789abcdef"[(n) & 15])
static int show_line(unsigned offset, const unsigned char *data,
unsigned size, int show_empty)
{
unsigned char bits;
int i, off;
char buffer[120];
if (size > 16)
size = 16;
bits = 0;
memset(buffer, ' ', sizeof(buffer));
off = sprintf(buffer, "%06x ", offset);
for (i = 0; i < size; i++) {
char *hex = buffer + off + 3 * i;
char *asc = buffer + off + 50 + i;
unsigned char byte = data[i];
hex[0] = hexchar(byte >> 4);
hex[1] = hexchar(byte);
bits |= byte;
if (byte < 32 || byte > 126)
byte = '.';
asc[0] = byte;
asc[1] = 0;
}
if (bits) {
puts(buffer);
return 1;
}
if (show_empty)
puts("...");
return 0;
}
static void cochran_debug_write(const unsigned char *data, unsigned size)
{
return;
int show = 1, i;
for (i = 0; i < size; i += 16)
show = show_line(i, data + i, size - i, show);
}
static void cochran_debug_sample(const char *s, unsigned int sample_cnt)
{
switch (config.type) {
case TYPE_GEMINI:
switch (sample_cnt % 4) {
case 0:
printf("Hex: %02x %02x ", s[0], s[1]);
break;
case 1:
printf("Hex: %02x %02x ", s[0], s[1]);
break;
case 2:
printf("Hex: %02x %02x ", s[0], s[1]);
break;
case 3:
printf("Hex: %02x %02x ", s[0], s[1]);
break;
}
break;
case TYPE_COMMANDER:
switch (sample_cnt % 2) {
case 0:
printf("Hex: %02x %02x ", s[0], s[1]);
break;
case 1:
printf("Hex: %02x %02x ", s[0], s[1]);
break;
}
break;
case TYPE_EMC:
switch (sample_cnt % 2) {
case 0:
printf("Hex: %02x %02x %02x ", s[0], s[1], s[2]);
break;
case 1:
printf("Hex: %02x %02x %02x ", s[0], s[1], s[2]);
break;
}
break;
}
printf ("%02dh %02dm %02ds: Depth: %-5.2f, ", sample_cnt / 3660,
(sample_cnt % 3660) / 60, sample_cnt % 60, depth);
}
#endif // COCHRAN_DEBUG
static void cochran_parse_header(const unsigned char *decode, unsigned mod,
const unsigned char *in, unsigned size)
{
unsigned char *buf = malloc(size);
/* Do the "null decode" using a one-byte decode array of '\0' */
/* Copies in plaintext, will be overwritten later */
partial_decode(0, 0x0102, (const unsigned char *)"", 0, 1, in, size, buf);
/*
* The header scrambling is different form the dive
* scrambling. Oh yay!
*/
partial_decode(0x0102, 0x010e, decode, 0, mod, in, size, buf);
partial_decode(0x010e, 0x0b14, decode, 0, mod, in, size, buf);
partial_decode(0x0b14, 0x1b14, decode, 0, mod, in, size, buf);
partial_decode(0x1b14, 0x2b14, decode, 0, mod, in, size, buf);
partial_decode(0x2b14, 0x3b14, decode, 0, mod, in, size, buf);
partial_decode(0x3b14, 0x5414, decode, 0, mod, in, size, buf);
partial_decode(0x5414, size, decode, 0, mod, in, size, buf);
// Detect log type
switch (buf[0x133]) {
case '2': // Cochran Commander, version II log format
config.logbook_size = 256;
if (buf[0x132] == 0x10) {
config.type = TYPE_GEMINI;
config.sample_size = 2; // Gemini with tank PSI samples
} else {
config.type = TYPE_COMMANDER;
config.sample_size = 2; // Commander
}
break;
case '3': // Cochran EMC, version III log format
config.type = TYPE_EMC;
config.logbook_size = 512;
config.sample_size = 3;
break;
default:
printf ("Unknown log format v%c\n", buf[0x137]);
free(buf);
exit(1);
break;
}
#ifdef COCHRAN_DEBUG
puts("Header\n======\n\n");
cochran_debug_write(buf, size);
#endif
free(buf);
}
/*
* Bytes expected after a pre-dive event code
*/
static int cochran_predive_event_bytes(unsigned char code)
{
int x = 0;
int cmdr_event_bytes[15][2] = {{0x00, 16}, {0x01, 20}, {0x02, 17},
{0x03, 16}, {0x06, 18}, {0x07, 18},
{0x08, 18}, {0x09, 18}, {0x0a, 18},
{0x0b, 18}, {0x0c, 18}, {0x0d, 18},
{0x0e, 18}, {0x10, 20},
{-1, 0}};
int emc_event_bytes[15][2] = {{0x00, 18}, {0x01, 22}, {0x02, 19},
{0x03, 18}, {0x06, 20}, {0x07, 20},
{0x0a, 20}, {0x0b, 20}, {0x0f, 18},
{0x10, 20},
{-1, 0}};
switch (config.type) {
case TYPE_GEMINI:
case TYPE_COMMANDER:
while (cmdr_event_bytes[x][0] != code && cmdr_event_bytes[x][0] != -1)
x++;
return cmdr_event_bytes[x][1];
break;
case TYPE_EMC:
while (emc_event_bytes[x][0] != code && emc_event_bytes[x][0] != -1)
x++;
return emc_event_bytes[x][1];
break;
}
return 0;
}
int cochran_dive_event_bytes(unsigned char event)
{
return (event == 0xAD || event == 0xAB) ? 4 : 0;
}
static void cochran_dive_event(struct divecomputer *dc, const unsigned char *s,
unsigned int seconds, unsigned int *in_deco,
unsigned int *deco_ceiling, unsigned int *deco_time)
{
switch (s[0]) {
case 0xC5: // Deco obligation begins
*in_deco = 1;
add_event(dc, seconds, SAMPLE_EVENT_DECOSTOP,
SAMPLE_FLAGS_BEGIN, 0,
QT_TRANSLATE_NOOP("gettextFromC", "deco stop"));
break;
case 0xDB: // Deco obligation ends
*in_deco = 0;
add_event(dc, seconds, SAMPLE_EVENT_DECOSTOP,
SAMPLE_FLAGS_END, 0,
QT_TRANSLATE_NOOP("gettextFromC", "deco stop"));
break;
case 0xAD: // Raise deco ceiling 10 ft
*deco_ceiling -= 10; // ft
*deco_time = (array_uint16_le(s + 3) + 1) * 60;
break;
case 0xAB: // Lower deco ceiling 10 ft
*deco_ceiling += 10; // ft
*deco_time = (array_uint16_le(s + 3) + 1) * 60;
break;
case 0xA8: // Entered Post Dive interval mode (surfaced)
break;
case 0xA9: // Exited PDI mode (re-submierged)
break;
case 0xBD: // Switched to normal PO2 setting
break;
case 0xC0: // Switched to FO2 21% mode (generally upon surface)
break;
case 0xC1: // "Ascent rate alarm
add_event(dc, seconds, SAMPLE_EVENT_ASCENT,
SAMPLE_FLAGS_BEGIN, 0,
QT_TRANSLATE_NOOP("gettextFromC", "ascent"));
break;
case 0xC2: // Low battery warning
#ifdef SAMPLE_EVENT_BATTERY
add_event(dc, seconds, SAMPLE_EVENT_BATTERY,
SAMPLE_FLAGS_NONE, 0,
QT_TRANSLATE_NOOP("gettextFromC", "battery"));
#endif
break;
case 0xC3: // CNS warning
add_event(dc, seconds, SAMPLE_EVENT_OLF,
SAMPLE_FLAGS_BEGIN, 0,
QT_TRANSLATE_NOOP("gettextFromC", "OLF"));
break;
case 0xC4: // Depth alarm begin
add_event(dc, seconds, SAMPLE_EVENT_MAXDEPTH,
SAMPLE_FLAGS_BEGIN, 0,
QT_TRANSLATE_NOOP("gettextFromC", "maxdepth"));
break;
case 0xC8: // PPO2 alarm begin
add_event(dc, seconds, SAMPLE_EVENT_PO2,
SAMPLE_FLAGS_BEGIN, 0,
QT_TRANSLATE_NOOP("gettextFromC", "pO₂"));
break;
case 0xCC: // Low cylinder 1 pressure";
break;
case 0xCD: // Switch to deco blend setting
add_event(dc, seconds, SAMPLE_EVENT_GASCHANGE,
SAMPLE_FLAGS_NONE, 0,
QT_TRANSLATE_NOOP("gettextFromC", "gaschange"));
break;
case 0xCE: // NDL alarm begin
add_event(dc, seconds, SAMPLE_EVENT_RBT,
SAMPLE_FLAGS_BEGIN, 0,
QT_TRANSLATE_NOOP("gettextFromC", "rbt"));
break;
case 0xD0: // Breathing rate alarm begin
break;
case 0xD3: // Low gas 1 flow rate alarm begin";
break;
case 0xD6: // Ceiling alarm begin
add_event(dc, seconds, SAMPLE_EVENT_CEILING,
SAMPLE_FLAGS_BEGIN, 0,
QT_TRANSLATE_NOOP("gettextFromC", "ceiling"));
break;
case 0xD8: // End decompression mode
*in_deco = 0;
add_event(dc, seconds, SAMPLE_EVENT_DECOSTOP,
SAMPLE_FLAGS_END, 0,
QT_TRANSLATE_NOOP("gettextFromC", "deco stop"));
break;
case 0xE1: // Ascent alarm end
add_event(dc, seconds, SAMPLE_EVENT_ASCENT,
SAMPLE_FLAGS_END, 0,
QT_TRANSLATE_NOOP("gettextFromC", "ascent"));
break;
case 0xE2: // Low transmitter battery alarm
add_event(dc, seconds, SAMPLE_EVENT_TRANSMITTER,
SAMPLE_FLAGS_BEGIN, 0,
QT_TRANSLATE_NOOP("gettextFromC", "transmitter"));
break;
case 0xE3: // Switch to FO2 mode
break;
case 0xE5: // Switched to PO2 mode
break;
case 0xE8: // PO2 too low alarm
add_event(dc, seconds, SAMPLE_EVENT_PO2,
SAMPLE_FLAGS_BEGIN, 0,
QT_TRANSLATE_NOOP("gettextFromC", "pO₂"));
break;
case 0xEE: // NDL alarm end
add_event(dc, seconds, SAMPLE_EVENT_RBT,
SAMPLE_FLAGS_END, 0,
QT_TRANSLATE_NOOP("gettextFromC", "rbt"));
break;
case 0xEF: // Switch to blend 2
add_event(dc, seconds, SAMPLE_EVENT_GASCHANGE,
SAMPLE_FLAGS_NONE, 0,
QT_TRANSLATE_NOOP("gettextFromC", "gaschange"));
break;
case 0xF0: // Breathing rate alarm end
break;
case 0xF3: // Switch to blend 1 (often at dive start)
add_event(dc, seconds, SAMPLE_EVENT_GASCHANGE,
SAMPLE_FLAGS_NONE, 0,
QT_TRANSLATE_NOOP("gettextFromC", "gaschange"));
break;
case 0xF6: // Ceiling alarm end
add_event(dc, seconds, SAMPLE_EVENT_CEILING,
SAMPLE_FLAGS_END, 0,
QT_TRANSLATE_NOOP("gettextFromC", "ceiling"));
break;
default:
break;
}
}
/*
* Parse sample data, extract events and build a dive
*/
static void cochran_parse_samples(struct dive *dive, const unsigned char *log,
const unsigned char *samples, unsigned int size,
unsigned int *duration, double *max_depth,
double *avg_depth, double *min_temp)
{
const unsigned char *s;
unsigned int offset = 0, profile_period = 1, sample_cnt = 0;
double depth = 0, temp = 0, depth_sample = 0, psi = 0, sgc_rate = 0;
int ascent_rate = 0;
unsigned int ndl = 0;
unsigned int in_deco = 0, deco_ceiling = 0, deco_time = 0;
struct divecomputer *dc = &dive->dc;
struct sample *sample;
// Initialize stat variables
*max_depth = 0, *avg_depth = 0, *min_temp = 0xFF;
// Get starting depth and temp (tank PSI???)
switch (config.type) {
case TYPE_GEMINI:
depth = (double) (log[CMD_START_DEPTH]
+ log[CMD_START_DEPTH + 1] * 256) / 4;
temp = log[CMD_START_TEMP];
psi = log[CMD_START_PSI] + log[CMD_START_PSI + 1] * 256;
sgc_rate = (double)(log[CMD_START_SGC]
+ log[CMD_START_SGC + 1] * 256) / 2;
profile_period = log[CMD_PROFILE_PERIOD];
break;
case TYPE_COMMANDER:
depth = (double) (log[CMD_START_DEPTH]
+ log[CMD_START_DEPTH + 1] * 256) / 4;
temp = log[CMD_START_TEMP];
profile_period = log[CMD_PROFILE_PERIOD];
break;
case TYPE_EMC:
depth = (double) log [EMC_START_DEPTH] / 256
+ log[EMC_START_DEPTH + 1];
temp = log[EMC_START_TEMP];
profile_period = log[EMC_PROFILE_PERIOD];
break;
}
// Skip past pre-dive events
unsigned int x = 0;
unsigned int c;
while (x < size && (samples[x] & 0x80) == 0 && samples[x] != 0x40) {
c = cochran_predive_event_bytes(samples[x]) + 1;
#ifdef COCHRAN_DEBUG
printf("Predive event: ");
for (unsigned int y = 0; y < c && x + y < size; y++) printf("%02x ", samples[x + y]);
putchar('\n');
#endif
x += c;
}
// Now process samples
offset = x;
while (offset + config.sample_size < size) {
s = samples + offset;
// Start with an empty sample
sample = prepare_sample(dc);
sample->time.seconds = sample_cnt * profile_period;
// Check for event
if (s[0] & 0x80) {
cochran_dive_event(dc, s, sample_cnt * profile_period, &in_deco, &deco_ceiling, &deco_time);
offset += cochran_dive_event_bytes(s[0]) + 1;
continue;
}
// Depth is in every sample
depth_sample = (double)(s[0] & 0x3F) / 4 * (s[0] & 0x40 ? -1 : 1);
depth += depth_sample;
#ifdef COCHRAN_DEBUG
cochran_debug_sample(s, sample_cnt);
#endif
switch (config.type) {
case TYPE_COMMANDER:
switch (sample_cnt % 2) {
case 0: // Ascent rate
ascent_rate = (s[1] & 0x7f) * (s[1] & 0x80 ? 1: -1);
break;
case 1: // Temperature
temp = s[1] / 2 + 20;
break;
}
break;
case TYPE_GEMINI:
// Gemini with tank pressure and SAC rate.
switch (sample_cnt % 4) {
case 0: // Ascent rate
ascent_rate = (s[1] & 0x7f) * (s[1] & 0x80 ? 1 : -1);
break;
case 2: // PSI change
psi -= (double)(s[1] & 0x7f) * (s[1] & 0x80 ? 1 : -1) / 4;
break;
case 1: // SGC rate
sgc_rate -= (double)(s[1] & 0x7f) * (s[1] & 0x80 ? 1 : -1) / 2;
break;
case 3: // Temperature
temp = (double)s[1] / 2 + 20;
break;
}
break;
case TYPE_EMC:
switch (sample_cnt % 2) {
case 0: // Ascent rate
ascent_rate = (s[1] & 0x7f) * (s[1] & 0x80 ? 1: -1);
break;
case 1: // Temperature
temp = (double)s[1] / 2 + 20;
break;
}
// Get NDL and deco information
switch (sample_cnt % 24) {
case 20:
if (offset + 5 < size) {
if (in_deco) {
// Fist stop time
//first_deco_time = (s[2] + s[5] * 256 + 1) * 60; // seconds
ndl = 0;
} else {
// NDL
ndl = (s[2] + s[5] * 256 + 1) * 60; // seconds
deco_time = 0;
}
}
break;
case 22:
if (offset + 5 < size) {
if (in_deco) {
// Total stop time
deco_time = (s[2] + s[5] * 256 + 1) * 60; // seconds
ndl = 0;
}
}
break;
}
}
// Track dive stats
if (depth > *max_depth) *max_depth = depth;
if (temp < *min_temp) *min_temp = temp;
*avg_depth = (*avg_depth * sample_cnt + depth) / (sample_cnt + 1);
sample->depth.mm = lrint(depth * FEET * 1000);
sample->ndl.seconds = ndl;
sample->in_deco = in_deco;
sample->stoptime.seconds = deco_time;
sample->stopdepth.mm = lrint(deco_ceiling * FEET * 1000);
sample->temperature.mkelvin = F_to_mkelvin(temp);
sample->sensor[0] = 0;
sample->pressure[0].mbar = lrint(psi * PSI / 100);
finish_sample(dc);
offset += config.sample_size;
sample_cnt++;
}
UNUSED(ascent_rate); // mark the variable as unused
if (sample_cnt > 0)
*duration = sample_cnt * profile_period - 1;
}
static void cochran_parse_dive(const unsigned char *decode, unsigned mod,
const unsigned char *in, unsigned size,
struct dive_table *table)
{
unsigned char *buf = malloc(size);
struct dive *dive;
struct divecomputer *dc;
struct tm tm = {0};
uint32_t csum[5];
double max_depth, avg_depth, min_temp;
unsigned int duration = 0, corrupt_dive = 0;
/*
* The scrambling has odd boundaries. I think the boundaries
* match some data structure size, but I don't know. They were
* discovered the same way we dynamically discover the decode
* size: automatically looking for least random output.
*
* The boundaries are also this confused "off-by-one" thing,
* the same way the file size is off by one. It's as if the
* cochran software forgot to write one byte at the beginning.
*/
partial_decode(0, 0x0fff, decode, 1, mod, in, size, buf);
partial_decode(0x0fff, 0x1fff, decode, 0, mod, in, size, buf);
partial_decode(0x1fff, 0x2fff, decode, 0, mod, in, size, buf);
partial_decode(0x2fff, 0x48ff, decode, 0, mod, in, size, buf);
/*
* This is not all the descrambling you need - the above are just
* what appears to be the fixed-size blocks. The rest is also
* scrambled, but there seems to be size differences in the data,
* so this just descrambles part of it:
*/
if (size < 0x4914 + config.logbook_size) {
// Analyst calls this a "Corrupt Beginning Summary"
free(buf);
return;
}
// Decode log entry (512 bytes + random prefix)
partial_decode(0x48ff, 0x4914 + config.logbook_size, decode,
0, mod, in, size, buf);
unsigned int sample_size = size - 0x4914 - config.logbook_size;
int g;
unsigned int sample_pre_offset = 0, sample_end_offset = 0;
// Decode sample data
partial_decode(0x4914 + config.logbook_size, size, decode,
0, mod, in, size, buf);
#ifdef COCHRAN_DEBUG
// Display pre-logbook data
puts("\nPre Logbook Data\n");
cochran_debug_write(buf, 0x4914);
// Display log book
puts("\nLogbook Data\n");
cochran_debug_write(buf + 0x4914, config.logbook_size + 0x400);
// Display sample data
puts("\nSample Data\n");
#endif
dive = alloc_dive();
dc = &dive->dc;
unsigned char *log = (buf + 0x4914);
switch (config.type) {
case TYPE_GEMINI:
case TYPE_COMMANDER:
if (config.type == TYPE_GEMINI) {
cylinder_t cyl = empty_cylinder;
dc->model = "Gemini";
dc->deviceid = buf[0x18c] * 256 + buf[0x18d]; // serial no
fill_default_cylinder(dive, &cyl);
cyl.gasmix.o2.permille = (log[CMD_O2_PERCENT] / 256
+ log[CMD_O2_PERCENT + 1]) * 10;
cyl.gasmix.he.permille = 0;
add_cylinder(&dive->cylinders, 0, cyl);
} else {
dc->model = "Commander";
dc->deviceid = array_uint32_le(buf + 0x31e); // serial no
for (g = 0; g < 2; g++) {
cylinder_t cyl = empty_cylinder;
fill_default_cylinder(dive, &cyl);
cyl.gasmix.o2.permille = (log[CMD_O2_PERCENT + g * 2] / 256
+ log[CMD_O2_PERCENT + g * 2 + 1]) * 10;
cyl.gasmix.he.permille = 0;
add_cylinder(&dive->cylinders, g, cyl);
}
}
tm.tm_year = log[CMD_YEAR];
tm.tm_mon = log[CMD_MON] - 1;
tm.tm_mday = log[CMD_DAY];
tm.tm_hour = log[CMD_HOUR];
tm.tm_min = log[CMD_MIN];
tm.tm_sec = log[CMD_SEC];
tm.tm_isdst = -1;
dive->when = dc->when = utc_mktime(&tm);
dive->number = log[CMD_NUMBER] + log[CMD_NUMBER + 1] * 256 + 1;
dc->duration.seconds = (log[CMD_BT] + log[CMD_BT + 1] * 256) * 60;
dc->surfacetime.seconds = (log[CMD_SIT] + log[CMD_SIT + 1] * 256) * 60;
dc->maxdepth.mm = lrint((log[CMD_MAX_DEPTH] +
log[CMD_MAX_DEPTH + 1] * 256) / 4 * FEET * 1000);
dc->meandepth.mm = lrint((log[CMD_AVG_DEPTH] +
log[CMD_AVG_DEPTH + 1] * 256) / 4 * FEET * 1000);
dc->watertemp.mkelvin = F_to_mkelvin(log[CMD_MIN_TEMP]);
dc->surface_pressure.mbar = lrint(ATM / BAR * pow(1 - 0.0000225577
* (double) log[CMD_ALTITUDE] * 250 * FEET, 5.25588) * 1000);
dc->salinity = 10000 + 150 * log[CMD_WATER_CONDUCTIVITY];
SHA1(log + CMD_NUMBER, 2, (unsigned char *)csum);
dc->diveid = csum[0];
if (log[CMD_MAX_DEPTH] == 0xff && log[CMD_MAX_DEPTH + 1] == 0xff)
corrupt_dive = 1;
sample_pre_offset = array_uint32_le(log + CMD_PREDIVE_OFFSET);
sample_end_offset = array_uint32_le(log + CMD_END_OFFSET);
break;
case TYPE_EMC:
dc->model = "EMC";
dc->deviceid = array_uint32_le(buf + 0x31e); // serial no
for (g = 0; g < 4; g++) {
cylinder_t cyl = empty_cylinder;
fill_default_cylinder(dive, &cyl);
cyl.gasmix.o2.permille =
(log[EMC_O2_PERCENT + g * 2] / 256
+ log[EMC_O2_PERCENT + g * 2 + 1]) * 10;
cyl.gasmix.he.permille =
(log[EMC_HE_PERCENT + g * 2] / 256
+ log[EMC_HE_PERCENT + g * 2 + 1]) * 10;
add_cylinder(&dive->cylinders, g, cyl);
}
tm.tm_year = log[EMC_YEAR];
tm.tm_mon = log[EMC_MON] - 1;
tm.tm_mday = log[EMC_DAY];
tm.tm_hour = log[EMC_HOUR];
tm.tm_min = log[EMC_MIN];
tm.tm_sec = log[EMC_SEC];
tm.tm_isdst = -1;
dive->when = dc->when = utc_mktime(&tm);
dive->number = log[EMC_NUMBER] + log[EMC_NUMBER + 1] * 256 + 1;
dc->duration.seconds = (log[EMC_BT] + log[EMC_BT + 1] * 256) * 60;
dc->surfacetime.seconds = (log[EMC_SIT] + log[EMC_SIT + 1] * 256) * 60;
dc->maxdepth.mm = lrint((log[EMC_MAX_DEPTH] +
log[EMC_MAX_DEPTH + 1] * 256) / 4 * FEET * 1000);
dc->meandepth.mm = lrint((log[EMC_AVG_DEPTH] +
log[EMC_AVG_DEPTH + 1] * 256) / 4 * FEET * 1000);
dc->watertemp.mkelvin = F_to_mkelvin(log[EMC_MIN_TEMP]);
dc->surface_pressure.mbar = lrint(ATM / BAR * pow(1 - 0.0000225577
* (double) log[EMC_ALTITUDE] * 250 * FEET, 5.25588) * 1000);
dc->salinity = 10000 + 150 * (log[EMC_WATER_CONDUCTIVITY] & 0x3);
SHA1(log + EMC_NUMBER, 2, (unsigned char *)csum);
dc->diveid = csum[0];
if (log[EMC_MAX_DEPTH] == 0xff && log[EMC_MAX_DEPTH + 1] == 0xff)
corrupt_dive = 1;
sample_pre_offset = array_uint32_le(log + EMC_PREDIVE_OFFSET);
sample_end_offset = array_uint32_le(log + EMC_END_OFFSET);
break;
}
// Use the log information to determine actual profile sample size
// Otherwise we will get surface time at end of dive.
if (sample_pre_offset < sample_end_offset && sample_end_offset != 0xffffffff)
sample_size = sample_end_offset - sample_pre_offset;
cochran_parse_samples(dive, buf + 0x4914, buf + 0x4914
+ config.logbook_size, sample_size,
&duration, &max_depth, &avg_depth, &min_temp);
// Check for corrupt dive
if (corrupt_dive) {
dc->maxdepth.mm = lrint(max_depth * FEET * 1000);
dc->meandepth.mm = lrint(avg_depth * FEET * 1000);
dc->watertemp.mkelvin = F_to_mkelvin(min_temp);
dc->duration.seconds = duration;
}
record_dive_to_table(dive, table);
free(buf);
}
int try_to_open_cochran(const char *filename, struct memblock *mem, struct divelog *log)
{
UNUSED(filename);
unsigned int i;
unsigned int mod;
unsigned int *offsets, dive1, dive2;
unsigned char *decode = mem->buffer + 0x40001;
if (mem->size < 0x40000)
return 0;
offsets = (unsigned int *) mem->buffer;
dive1 = offsets[0];
dive2 = offsets[1];
if (dive1 < 0x40000 || dive2 < dive1 || dive2 > mem->size)
return 0;
mod = decode[0x100] + 1;
cochran_parse_header(decode, mod, mem->buffer + 0x40000, dive1 - 0x40000);
// Decode each dive
for (i = 0; i < 65534; i++) {
dive1 = offsets[i];
dive2 = offsets[i + 1];
if (dive2 < dive1)
break;
if (dive2 > mem->size)
break;
cochran_parse_dive(decode, mod, mem->buffer + dive1,
dive2 - dive1, log->dives);
}
return 1; // no further processing needed
}
Reference in a new issue View git blame Copy permalink