struct fit_record_data *search_for_data(int record_num, int *data_nelms) {
switch(record_num) {
case FITFILE_MSGTYPE_FILE_ID:
*data_nelms = SIZEOFARRAY(file_info_data);
return file_info_data;
case FITFILE_MSGTYPE_FILE_CREATOR:
*data_nelms = SIZEOFARRAY(file_creator_data);
return file_creator_data;
case FITFILE_MSGTYPE_EVENT:
*data_nelms = SIZEOFARRAY(event_data);
return event_data;
case FITFILE_MSGTYPE_DEVICE_INFO:
*data_nelms = SIZEOFARRAY(device_info_data);
return device_info_data;
case FITFILE_MSGTYPE_RECORD:
*data_nelms = SIZEOFARRAY(record_data);
return record_data;
case FITFILE_MSGTYPE_LAP:
*data_nelms = SIZEOFARRAY(lap_data);
return lap_data;
case FITFILE_MSGTYPE_SESSION:
*data_nelms = SIZEOFARRAY(session_data);
return session_data;
case FITFILE_MSGTYPE_ACTIVITY:
*data_nelms = SIZEOFARRAY(activity_data);
return activity_data;
default:
//fprintf(stdout, "Unknown record type %d\n", record_num);
return NULL;
}
}
// allocate a small chunk of memory.
void * kmalloc(size_t size, int gfp_flags) {
int i;
void * p;
for(i=0;i<SIZEOFARRAY(_pools);i++)
if( ( gfp_flags & _pools[i].gfp_flags ) == _pools[i].gfp_flags )
if( _pools[i].chunk_size >= size ) {
// create the mem_cache if it does not exist.
if(!_pools_mem_cache[i])
if( 0 != mem_cache_new(
&(_pools_mem_cache[i]),
_pools[i].pages,
_pools[i].chunk_size,
_pools[i].gfp_flags) )
return NULL; // OUT OF MEMORY!
// allocate the requested memory.
p = mem_cache_alloc( _pools_mem_cache[i] );
if(p && (gfp_flags & GFP_ZERO ) )
memset(p, 0, size);
return p;
}
// bad size or gfp_flags!
return NULL;
}
int kfree(const void * mem) {
int i;
if(!mem)
return 0;
for(i=0;i<SIZEOFARRAY(_pools);i++)
if( _pools_mem_cache[i] )
if( mem_cache_free(_pools_mem_cache[i], mem) == 0 )
return 0;
return -1;
}
int fit_process_file(void) {
int nelms;
/* Check the file is a correct .FIT file by the header */
struct fit_header hdr;
if ((nelms = fread(&hdr, sizeof(hdr), 1, fp)) != 1) {
exit(1);
}
//nbytes += sizeof(hdr);
//print_header(&hdr);
if (check_header(&hdr)) {
exit(1);
}
print_xml_header();
while (nbytes < hdr.file_size) {
uint8_t record_hdr;
if ((nelms = fread(&record_hdr, sizeof(record_hdr), 1, fp)) != 1) {
}
nbytes += sizeof(record_hdr);
//print_record_hdr(record_hdr);
if (record_hdr & RECORD_DEFINITION_MESSAGE_HDR) {
/* The record first contains a definition */
fetch_record_definition(record_hdr & RECORD_TYPE_MASK);
continue;
}
/* Fetch the definition */
struct fit_definition *def;
def = search_for_def(record_hdr & RECORD_TYPE_MASK);
if (!def) {
fprintf(stdout, "Unable to find definition for message type\n");
exit(1);
}
/* Search for the data definition */
struct fit_record_data *data;
int data_len;
data = search_for_data(record_hdr & RECORD_TYPE_MASK, &data_len);
uint8_t array[def->record_size];
read_data(array, sizeof(array), def, data, data_len);
/* Read the record out */
switch(record_hdr & RECORD_TYPE_MASK) {
case FITFILE_MSGTYPE_RECORD:
{
//struct fit_record *record = (struct fit_record *) array;
if (display == DISPLAY_RECORDS) {
print_xml_open_tag("record", stdout, 1);
printf("\n");
print_xml_record_data(array, record_data,
SIZEOFARRAY(record_data), stdout, 2);
print_xml_close_tag("record", stdout, 1);
printf("\n");
//print_record_data(array, record_data,
}
}
break;
case FITFILE_MSGTYPE_LAP:
{
//struct fit_lap *lap = (struct fit_lap *) array;
if (display == DISPLAY_LAPS) {
print_xml_open_tag("lap", stdout, 1);
printf("\n");
print_xml_record_data(array, lap_data,
SIZEOFARRAY(lap_data), stdout, 2);
print_xml_close_tag("lap", stdout, 1);
printf("\n");
}
}
break;
case FITFILE_MSGTYPE_SESSION:
{
//struct fit_session *session = (struct fit_session *) array;
if (display == DISPLAY_SESSIONS) {
print_xml_open_tag("session", stdout, 1);
printf("\n");
print_xml_record_data(array, session_data,
SIZEOFARRAY(session_data), stdout, 2);
print_xml_close_tag("session", stdout, 1);
printf("\n");
}
}
break;
default:
//fprintf(stdout, "Unknown record type %d\n", record_hdr & RECORD_TYPE_MASK);
break;
}
#if 0
switch(record_hdr & RECORD_TYPE_MASK) {
case FITFILE_MSGTYPE_FILE_ID:
printf("FILE_ID\n");
print_record_data(array, file_info_data,
SIZEOFARRAY(file_info_data));
break;
case FITFILE_MSGTYPE_FILE_CREATOR:
printf("FILE_CREATOR\n");
print_record_data(array, file_creator_data,
SIZEOFARRAY(file_creator_data));
break;
case FITFILE_MSGTYPE_EVENT:
{
printf("EVENT\n");
print_record_data(array, event_data,
SIZEOFARRAY(event_data));
//struct fit_event *event = (struct fit_event *) array;
}
break;
case FITFILE_MSGTYPE_DEVICE_INFO:
{
printf("DEVICE_INFO\n");
print_record_data(array, device_info_data,
SIZEOFARRAY(device_info_data));
//struct fit_device_info *device_info = (struct fit_device_info *) array;
}
break;
case FITFILE_MSGTYPE_RECORD:
{
printf("RECORD\n");
print_record_data(array, record_data,
SIZEOFARRAY(record_data));
//struct fit_record *record = (struct fit_record *) array;
}
break;
case FITFILE_MSGTYPE_LAP:
{
printf("LAP\n");
print_record_data(array, lap_data,
SIZEOFARRAY(lap_data));
//struct fit_lap *lap = (struct fit_lap *) array;
}
break;
case FITFILE_MSGTYPE_SESSION:
{
printf("SESSION\n");
print_record_data(array, session_data,
SIZEOFARRAY(session_data));
//struct fit_session *session = (struct fit_session *) array;
}
break;
case FITFILE_MSGTYPE_ACTIVITY:
{
printf("ACTIVITY\n");
print_record_data(array, activity_data,
SIZEOFARRAY(activity_data));
//struct fit_activity *activity = (struct fit_activity *) array;
}
break;
default:
fprintf(stdout, "Unknown record type %d\n", record_hdr & RECORD_TYPE_MASK);
}
#endif
//printf("\n");
}
/* Perform CRC check */
#if 0
uint16_t crc;
if ((nelms = fread(&crc, sizeof(crc), 1, fp)) != 1) {
}
printf("crc = 0x%04x\n", crc);
#endif
fclose(fp);
print_xml_footer();
return 0;
}
