rubyfit 0.0.2

data/ext/rubyfit/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile("rubyfit/rubyfit")

data/ext/rubyfit/fit.c

@@ -0,0 +1,281 @@
+////////////////////////////////////////////////////////////////////////////////
+// The following .FIT software provided may be used with .FIT devices only and
+// remains the copyrighted property of Dynastream Innovations Inc.
+// The software is being provided on an "as-is" basis and as an accommodation,
+// and therefore all warranties, representations, or guarantees of any kind
+// (whether express, implied or statutory) including, without limitation,
+// warranties of merchantability, non-infringement, or fitness for a particular
+// purpose, are specifically disclaimed.
+//
+// Copyright 2008 Dynastream Innovations Inc.
+// All rights reserved. This software may not be reproduced by any means
+// without express written approval of Dynastream Innovations Inc.
+////////////////////////////////////////////////////////////////////////////////
+
+#include "string.h"
+#include "fit_product.h"
+
+
+///////////////////////////////////////////////////////////////////////
+// Public Constants
+///////////////////////////////////////////////////////////////////////
+
+const FIT_UINT8 fit_base_type_sizes[FIT_BASE_TYPES] =
+{
+   sizeof(FIT_ENUM),
+   sizeof(FIT_SINT8),
+   sizeof(FIT_UINT8),
+   sizeof(FIT_SINT16),
+   sizeof(FIT_UINT16),
+   sizeof(FIT_SINT32),
+   sizeof(FIT_UINT32),
+   sizeof(FIT_STRING),
+   sizeof(FIT_FLOAT32),
+   sizeof(FIT_FLOAT64),
+   sizeof(FIT_UINT8Z),
+   sizeof(FIT_UINT16Z),
+   sizeof(FIT_UINT32Z),
+   sizeof(FIT_BYTE),
+};
+
+const FIT_ENUM fit_enum_invalid = FIT_ENUM_INVALID;
+const FIT_SINT8 fit_sint8_invalid = FIT_SINT8_INVALID;
+const FIT_UINT8 fit_uint8_invalid = FIT_UINT8_INVALID;
+const FIT_SINT16 fit_sint16_invalid = FIT_SINT16_INVALID;
+const FIT_UINT16 fit_uint16_invalid = FIT_UINT16_INVALID;
+const FIT_SINT32 fit_sint32_invalid = FIT_SINT32_INVALID;
+const FIT_UINT32 fit_uint32_invalid = FIT_UINT32_INVALID;
+const FIT_STRING fit_string_invalid = FIT_STRING_INVALID;
+const FIT_FLOAT32 fit_float32_invalid = FIT_FLOAT32_INVALID;
+const FIT_FLOAT64 fit_float64_invalid = FIT_FLOAT64_INVALID;
+const FIT_UINT8Z fit_uint8z_invalid = FIT_UINT8Z_INVALID;
+const FIT_UINT16Z fit_uint16z_invalid = FIT_UINT16Z_INVALID;
+const FIT_UINT32Z fit_uint32z_invalid = FIT_UINT32Z_INVALID;
+const FIT_BYTE fit_byte_invalid = FIT_BYTE_INVALID;
+
+const FIT_UINT8 *fit_base_type_invalids[FIT_BASE_TYPES] =
+{
+   (FIT_UINT8 *)&fit_enum_invalid,
+   (FIT_UINT8 *)&fit_sint8_invalid,
+   (FIT_UINT8 *)&fit_uint8_invalid,
+   (FIT_UINT8 *)&fit_sint16_invalid,
+   (FIT_UINT8 *)&fit_uint16_invalid,
+   (FIT_UINT8 *)&fit_sint32_invalid,
+   (FIT_UINT8 *)&fit_uint32_invalid,
+   (FIT_UINT8 *)&fit_string_invalid,
+   (FIT_UINT8 *)&fit_float32_invalid,
+   (FIT_UINT8 *)&fit_float64_invalid,
+   (FIT_UINT8 *)&fit_uint8z_invalid,
+   (FIT_UINT8 *)&fit_uint16z_invalid,
+   (FIT_UINT8 *)&fit_uint32z_invalid,
+   (FIT_UINT8 *)&fit_byte_invalid,
+};
+
+
+///////////////////////////////////////////////////////////////////////
+// Public Functions
+///////////////////////////////////////////////////////////////////////
+
+FIT_UINT8 Fit_GetArch(void)
+{
+   const FIT_UINT16 arch = 0x0100;
+   return (*(FIT_UINT8 *)&arch);
+}
+
+const FIT_MESG_DEF *Fit_GetMesgDef(FIT_MESG_NUM global_mesg_num)
+{
+   FIT_UINT8 index;
+
+   for (index = 0; index < FIT_MESGS; index++)
+   {
+      if (fit_mesg_defs[index]->global_mesg_num == global_mesg_num)
+         return (FIT_MESG_DEF *) fit_mesg_defs[index];
+   }
+
+   return (FIT_MESG_DEF *) FIT_NULL;
+}
+
+FIT_UINT16 Fit_GetMesgDefSize(const FIT_MESG_DEF *mesg_def)
+{
+   if (mesg_def == FIT_NULL)
+      return 0;
+
+   return FIT_STRUCT_OFFSET(fields, FIT_MESG_DEF) + (FIT_UINT16)mesg_def->num_fields * FIT_FIELD_DEF_SIZE;
+}
+
+FIT_UINT8 Fit_GetMesgSize(FIT_MESG_NUM global_mesg_num)
+{
+   const FIT_MESG_DEF *mesg_def;
+   FIT_UINT8 field;
+   FIT_UINT8 size = 0;
+
+   mesg_def = Fit_GetMesgDef(global_mesg_num);
+
+   if (mesg_def == FIT_NULL)
+      return 0;
+
+   for (field = 0; field < mesg_def->num_fields; field++)
+   {
+      size += mesg_def->fields[FIT_MESG_DEF_FIELD_OFFSET(size, field)];
+   }
+
+   return size;
+}
+
+FIT_BOOL Fit_InitMesg(const FIT_MESG_DEF *mesg_def, void *mesg)
+{
+   FIT_UINT8 *mesg_buf = (FIT_UINT8 *) mesg;
+   FIT_UINT8 field;
+
+   if (mesg_def == FIT_NULL)
+      return FIT_FALSE;
+
+   for (field = 0; field < mesg_def->num_fields; field++)
+   {
+      FIT_UINT8 base_type_num = mesg_def->fields[FIT_MESG_DEF_FIELD_OFFSET(base_type, field)] & FIT_BASE_TYPE_NUM_MASK;
+      FIT_UINT8 base_type_size;
+      FIT_UINT8 field_size;
+
+      if (base_type_num >= FIT_BASE_TYPES)
+         return FIT_FALSE;
+
+      base_type_size = fit_base_type_sizes[base_type_num];
+
+      for (field_size = 0; field_size < mesg_def->fields[FIT_MESG_DEF_FIELD_OFFSET(size, field)]; field_size += base_type_size)
+      {
+         memcpy(mesg_buf, fit_base_type_invalids[base_type_num], base_type_size);
+         mesg_buf += base_type_size;
+      }
+   }
+
+   return FIT_TRUE;
+}
+
+FIT_UINT8 Fit_GetFieldOffset(const FIT_MESG_DEF *mesg_def, FIT_UINT8 field_def_num)
+{
+   FIT_UINT8 offset = 0;
+   FIT_UINT8 field;
+
+   if (mesg_def == FIT_NULL)
+      return FIT_UINT8_INVALID;
+
+   for (field = 0; field < mesg_def->num_fields; field++)
+   {
+      if (mesg_def->fields[FIT_MESG_DEF_FIELD_OFFSET(field_def_num, field)] == field_def_num)
+         return offset;
+
+      offset += mesg_def->fields[FIT_MESG_DEF_FIELD_OFFSET(size, field)];
+   }
+
+   return FIT_UINT8_INVALID;
+}
+
+FIT_UINT8 Fit_LookupMessage(FIT_UINT16 global_mesg_num, FIT_UINT16 message_index, FIT_UINT32 *offset, FIT_READ_BYTES_FUNC read_bytes_func)
+{
+   FIT_UINT16 global_mesg_nums[FIT_MAX_LOCAL_MESGS];
+   FIT_UINT8 sizes[FIT_MAX_LOCAL_MESGS];
+   FIT_UINT16 current_message_index = FIT_UINT16_INVALID;
+   #if defined(FIT_MESSAGE_INDEX)
+      FIT_UINT16 message_index_offset = FIT_UINT16_INVALID;
+   #endif
+   FIT_UINT8 i;
+
+   *offset = 0;
+
+   for (i = 0; i < FIT_MAX_LOCAL_MESGS; i++)
+      global_mesg_nums[i] = FIT_UINT16_INVALID;
+
+   while (1)
+   {
+      FIT_UINT8 header;
+      FIT_UINT8 local_mesg_num;
+
+      if (read_bytes_func(&header, *offset, sizeof(header)) != sizeof(header))
+         return FIT_UINT8_INVALID;
+         
+      *offset += sizeof(header);
+
+      if ((header & (FIT_HDR_TIME_REC_BIT | FIT_HDR_TYPE_DEF_BIT)) == FIT_HDR_TYPE_DEF_BIT)
+      {
+         FIT_MESG_DEF mesg_def_header;
+         FIT_FIELD_DEF field_def;
+         #if defined(FIT_MESSAGE_INDEX)
+            FIT_UINT16 current_message_index_offset = FIT_UINT16_INVALID;  // Initialize to invalid.  If not found, it will remain invalid.
+         #endif
+         FIT_UINT8 current_size;
+         FIT_UINT8 current_field_def;
+
+         local_mesg_num = header & FIT_HDR_TYPE_MASK;
+
+         if (read_bytes_func(&mesg_def_header, *offset, FIT_MESG_DEF_HEADER_SIZE) != FIT_MESG_DEF_HEADER_SIZE)
+            return FIT_UINT8_INVALID;
+
+         *offset += FIT_MESG_DEF_HEADER_SIZE;
+         global_mesg_nums[local_mesg_num] = mesg_def_header.global_mesg_num;
+         current_size = 0;
+
+         for (current_field_def = 0; current_field_def < mesg_def_header.num_fields; current_field_def++)
+         {
+            if (read_bytes_func(&field_def, *offset, FIT_FIELD_DEF_SIZE) != FIT_FIELD_DEF_SIZE)
+               return FIT_UINT8_INVALID;
+
+            #if defined(FIT_MESSAGE_INDEX)
+               if (field_def.field_def_num == FIT_MESSAGE_INDEX_FIELD_NUM)
+                  current_message_index_offset = current_size;
+            #endif
+
+            current_size += field_def.size;
+            *offset += FIT_FIELD_DEF_SIZE;
+         }
+
+         sizes[local_mesg_num] = current_size;
+
+         #if defined(FIT_MESSAGE_INDEX)
+            if (global_mesg_nums[local_mesg_num] == global_mesg_num)
+               message_index_offset = current_message_index_offset;
+         #endif
+      }
+      else
+      {
+         if (header & FIT_HDR_TIME_REC_BIT)
+            local_mesg_num = (header & FIT_HDR_TIME_TYPE_MASK) >> FIT_HDR_TIME_TYPE_SHIFT;
+         else
+            local_mesg_num = header & FIT_HDR_TYPE_MASK;
+
+         if (global_mesg_nums[local_mesg_num] == global_mesg_num)
+         {
+            // If the requested message index is invalid, we've found a match.
+            if (message_index == FIT_UINT16_INVALID)
+               return local_mesg_num;
+
+            #if defined(FIT_MESSAGE_INDEX)
+               if (message_index_offset != FIT_UINT16_INVALID)
+               {
+                  // Read the message index.
+                  if (read_bytes_func(&current_message_index, *offset + message_index_offset, sizeof(current_message_index)) != sizeof(current_message_index))
+                     return FIT_UINT8_INVALID;
+               }
+               else
+            #endif
+            {
+               current_message_index++;
+            }
+            
+            #if defined(FIT_MESSAGE_INDEX)
+               if ((message_index & FIT_MESSAGE_INDEX_MASK) == (current_message_index & FIT_MESSAGE_INDEX_MASK))
+            #else
+               if (message_index == current_message_index)
+            #endif
+            {
+               return local_mesg_num;
+            }
+         }
+         else if (global_mesg_nums[local_mesg_num] == FIT_UINT16_INVALID)
+         {
+            return FIT_UINT8_INVALID;
+         }
+
+         *offset += sizes[local_mesg_num];
+      }
+   }
+}

data/ext/rubyfit/fit.h

@@ -0,0 +1,253 @@
+////////////////////////////////////////////////////////////////////////////////
+// The following .FIT software provided may be used with .FIT devices only and
+// remains the copyrighted property of Dynastream Innovations Inc.
+// The software is being provided on an "as-is" basis and as an accommodation,
+// and therefore all warranties, representations, or guarantees of any kind
+// (whether express, implied or statutory) including, without limitation,
+// warranties of merchantability, non-infringement, or fitness for a particular
+// purpose, are specifically disclaimed.
+//
+// Copyright 2008 Dynastream Innovations Inc.
+// All rights reserved. This software may not be reproduced by any means
+// without express written approval of Dynastream Innovations Inc.
+////////////////////////////////////////////////////////////////////////////////
+
+
+#if !defined(FIT_H)
+#define FIT_H
+
+#include "fit_config.h"
+
+#if defined(__cplusplus)
+   extern "C" {
+#endif
+
+
+///////////////////////////////////////////////////////////////////////
+// Version
+///////////////////////////////////////////////////////////////////////
+
+#define FIT_PROTOCOL_VERSION_MAJOR           1 // Non-backwards compatible changes. Decode compatible with this version and earlier.
+#define FIT_PROTOCOL_VERSION_MINOR           0 // Backwards compatible changes.
+#define FIT_PROTOCOL_VERSION_MAJOR_SHIFT     4
+#define FIT_PROTOCOL_VERSION_MAJOR_MASK      ((FIT_UINT8) (0x0F << FIT_PROTOCOL_VERSION_MAJOR_SHIFT))
+#define FIT_PROTOCOL_VERSION_MINOR_MASK      ((FIT_UINT8) 0x0F)
+#define FIT_PROTOCOL_VERSION                 ((FIT_UINT8) (FIT_PROTOCOL_VERSION_MAJOR << FIT_PROTOCOL_VERSION_MAJOR_SHIFT) | FIT_PROTOCOL_VERSION_MINOR)      
+
+
+///////////////////////////////////////////////////////////////////////
+// Type Definitions
+///////////////////////////////////////////////////////////////////////
+
+#define FIT_ANTFS_FILE_DATA_TYPE    128
+
+#define FIT_BASE_TYPE_ENDIAN_FLAG   ((FIT_UINT8)0x80)
+#define FIT_BASE_TYPE_RESERVED      ((FIT_UINT8)0x60)
+#define FIT_BASE_TYPE_NUM_MASK      ((FIT_UINT8)0x1F)
+
+typedef unsigned char FIT_ENUM;
+#define FIT_ENUM_INVALID            ((FIT_ENUM)0xFF)
+#define FIT_BASE_TYPE_ENUM          ((FIT_UINT8)0x00)
+
+typedef signed char FIT_SINT8;
+#define FIT_SINT8_INVALID           ((FIT_SINT8)0x7F)
+#define FIT_BASE_TYPE_SINT8         ((FIT_UINT8)0x01)
+
+typedef unsigned char FIT_UINT8;
+#define FIT_UINT8_INVALID           ((FIT_UINT8)0xFF)
+#define FIT_BASE_TYPE_UINT8         ((FIT_UINT8)0x02)
+
+typedef signed short FIT_SINT16;
+#define FIT_SINT16_INVALID          ((FIT_SINT16)0x7FFF)
+#define FIT_BASE_TYPE_SINT16        ((FIT_UINT8)0x83)
+
+typedef unsigned short FIT_UINT16;
+#define FIT_UINT16_INVALID   ((FIT_UINT16)0xFFFF)
+#define FIT_BASE_TYPE_UINT16 ((FIT_UINT8)0x84)
+
+typedef signed long FIT_SINT32;
+#define FIT_SINT32_INVALID   ((FIT_SINT32)0x7FFFFFFF)
+#define FIT_BASE_TYPE_SINT32 ((FIT_UINT8)0x85)
+
+typedef unsigned long FIT_UINT32;
+#define FIT_UINT32_INVALID   ((FIT_UINT32)0xFFFFFFFF)
+#define FIT_BASE_TYPE_UINT32 ((FIT_UINT8)0x86)
+                                                                            
+typedef char FIT_STRING;
+#define FIT_STRING_INVALID   ((FIT_STRING)0x00)
+#define FIT_BASE_TYPE_STRING ((FIT_UINT8)0x07)
+
+typedef float FIT_FLOAT32;
+#define FIT_FLOAT32_INVALID   ((FIT_FLOAT32)0xFFFFFFFF)
+#define FIT_BASE_TYPE_FLOAT32 ((FIT_UINT8)0x88)
+
+typedef double FIT_FLOAT64;
+#define FIT_FLOAT64_INVALID   ((FIT_FLOAT64)0xFFFFFFFFFFFFFFFFull)
+#define FIT_BASE_TYPE_FLOAT64 ((FIT_UINT8)0x89)
+
+typedef unsigned char FIT_UINT8Z;
+#define FIT_UINT8Z_INVALID   ((FIT_UINT8Z)0x00)
+#define FIT_BASE_TYPE_UINT8Z ((FIT_UINT8)0x0A)
+
+typedef unsigned short FIT_UINT16Z;
+#define FIT_UINT16Z_INVALID   ((FIT_UINT16Z)0x0000)
+#define FIT_BASE_TYPE_UINT16Z ((FIT_UINT8)0x8B)
+
+typedef unsigned long FIT_UINT32Z;
+#define FIT_UINT32Z_INVALID   ((FIT_UINT32Z)0x00000000)
+#define FIT_BASE_TYPE_UINT32Z ((FIT_UINT8)0x8C)
+
+typedef unsigned char FIT_BYTE;
+#define FIT_BYTE_INVALID   ((FIT_BYTE)0xFF)
+#define FIT_BASE_TYPE_BYTE ((FIT_UINT8)0x0D)
+
+#define FIT_BASE_TYPES    14
+
+typedef FIT_ENUM FIT_BOOL;
+#define FIT_BOOL_INVALID      FIT_ENUM_INVALID
+#define FIT_BOOL_FALSE        ((FIT_BOOL)0)
+#define FIT_BOOL_TRUE         ((FIT_BOOL)1)
+#define FIT_FALSE             FIT_BOOL_FALSE
+#define FIT_TRUE              FIT_BOOL_TRUE
+#define FIT_NULL              ((void *) 0)
+
+typedef FIT_UINT32 (*FIT_READ_BYTES_FUNC)(void *, FIT_UINT32, FIT_UINT32);
+#define FIT_MESG_DEF_HEADER_SIZE  FIT_STRUCT_OFFSET(fields, FIT_MESG_DEF)
+
+
+///////////////////////////////////////////////////////////////////////
+// File Header
+///////////////////////////////////////////////////////////////////////
+
+typedef struct
+{
+   FIT_UINT8 header_size; // FIT_FILE_HDR_SIZE (size of this structure)
+   FIT_UINT8 protocol_version; // FIT_PROTOCOL_VERSION
+   FIT_UINT8 profile_version_minor; // FIT_PROFILE_VERSION_MINOR
+   FIT_UINT8 profile_version_major; // FIT_PROFILE_VERSION_MAJOR
+   FIT_UINT32 data_size; // Does not include file header or crc.  Little endian format.
+   FIT_UINT8 data_type[4]; // ".FIT"
+} FIT_FILE_HDR;
+
+#define FIT_FILE_HDR_SIZE         12
+
+///////////////////////////////////////////////////////////////////////
+// Record Definitions
+///////////////////////////////////////////////////////////////////////
+
+#define FIT_HDR_SIZE               1
+#define FIT_HDR_TIME_REC_BIT      ((FIT_UINT8) 0x80)
+#define FIT_HDR_TIME_TYPE_MASK    ((FIT_UINT8) 0x60)
+#define FIT_HDR_TIME_TYPE_SHIFT   5
+#define FIT_HDR_TIME_OFFSET_MASK  ((FIT_UINT8) 0x1F)
+#define FIT_HDR_TYPE_DEF_BIT      ((FIT_UINT8) 0x40)
+#define FIT_HDR_TYPE_MASK         ((FIT_UINT8) 0x0F)
+#define FIT_MAX_LOCAL_MESGS       (FIT_HDR_TYPE_MASK + 1)
+
+
+///////////////////////////////////////////////////////////////////////
+// Message Definitions
+///////////////////////////////////////////////////////////////////////
+
+typedef struct
+{
+   FIT_UINT8 field_def_num;
+   FIT_UINT8 size;
+   FIT_UINT8 base_type;
+} FIT_FIELD_DEF;
+
+#define FIT_FIELD_DEF_SIZE  3
+
+typedef struct
+{
+   FIT_UINT8 reserved_1;
+   FIT_UINT8 arch;
+   FIT_UINT16 global_mesg_num;
+   FIT_UINT8 num_fields;
+   FIT_UINT8 fields[1];
+} FIT_MESG_DEF;
+
+#define FIT_MAX_MESG_SIZE         ((FIT_UINT8)255)
+
+#define FIT_ARCH_ENDIAN_MASK      ((FIT_UINT8)0x01)
+#define FIT_ARCH_ENDIAN_LITTLE    ((FIT_UINT8)0)
+#define FIT_ARCH_ENDIAN_BIG       ((FIT_UINT8)1)
+
+
+///////////////////////////////////////////////////////////////////////
+// Field Definitions
+///////////////////////////////////////////////////////////////////////
+
+#define FIT_MAX_FIELD_SIZE             ((FIT_UINT8)255)
+#define FIT_FIELD_NUM_INVALID          ((FIT_UINT8)0xFF)
+#define FIT_MESSAGE_INDEX_FIELD_NUM    ((FIT_UINT8)254)
+#define FIT_TIMESTAMP_FIELD_NUM        ((FIT_UINT8)253)
+
+
+///////////////////////////////////////////////////////////////////////
+// Macros
+///////////////////////////////////////////////////////////////////////
+
+#define FIT_STRUCT_OFFSET(MEMBER, STRUCT_TYPE)                                 ( ((FIT_UINT8 *) &(((STRUCT_TYPE *) FIT_NULL)->MEMBER)) - ((FIT_UINT8 *) (FIT_NULL)) ) // Computes the byte offset of a member in a file.  Compiles to a constant.
+#define FIT_MESG_OFFSET(MESG_MEMBER, MESG_TYPE, MESG_INDEX, MESG_SIZE, FILE)   (FIT_STRUCT_OFFSET(MESG_MEMBER, FILE) + MESG_INDEX * (FIT_HDR_SIZE + MESG_SIZE) + FIT_HDR_SIZE) // Computes the byte offset of a message in a file structure.  Compiles to a constant.
+#define FIT_MESG_DEF_OFFSET(MESG_DEF_MEMBER, FILE)                             (FIT_STRUCT_OFFSET(MESG_DEF_MEMBER, FILE) + FIT_HDR_SIZE) // Computes the byte offset of a message definition in a file structure.  Compiles to a constant.
+#define FIT_MESG_DEF_FIELD_OFFSET(FIELD_MEMBER, FIELD_INDEX)                   (FIT_STRUCT_OFFSET(FIELD_MEMBER, FIT_FIELD_DEF) + FIT_FIELD_DEF_SIZE * FIELD_INDEX) // Computes the byte offset of a field definition member.  Compiles to a constant.
+
+
+///////////////////////////////////////////////////////////////////////
+// Public Constants
+///////////////////////////////////////////////////////////////////////
+
+const extern FIT_UINT8 fit_base_type_sizes[FIT_BASE_TYPES];
+const extern FIT_UINT8 *fit_base_type_invalids[FIT_BASE_TYPES];
+
+
+///////////////////////////////////////////////////////////////////////
+// Public Functions
+///////////////////////////////////////////////////////////////////////
+
+FIT_UINT8 Fit_GetArch(void);
+///////////////////////////////////////////////////////////////////////
+// Returns architecture type.
+// Includes runtime check for little or big endian.
+// See FIT_MESG_DEF->arch and FIT_ARCH_*.
+///////////////////////////////////////////////////////////////////////
+
+const FIT_MESG_DEF *Fit_GetMesgDef(FIT_UINT16 global_mesg_num);
+///////////////////////////////////////////////////////////////////////
+// Returns message definition corresponding to global message number.
+///////////////////////////////////////////////////////////////////////
+
+FIT_UINT16 Fit_GetMesgDefSize(const FIT_MESG_DEF *mesg_def);
+///////////////////////////////////////////////////////////////////////
+// Returns the size of message definition.
+///////////////////////////////////////////////////////////////////////
+
+FIT_UINT8 Fit_GetMesgSize(FIT_UINT16 global_mesg_num);
+///////////////////////////////////////////////////////////////////////
+// Returns the size of message corresponding to global message number.
+///////////////////////////////////////////////////////////////////////
+
+FIT_BOOL Fit_InitMesg(const FIT_MESG_DEF *mesg_def, void *mesg);
+///////////////////////////////////////////////////////////////////////
+// Initializes message with invalids.
+// Returns 1 if successful, otherwise 0.
+///////////////////////////////////////////////////////////////////////
+
+FIT_UINT8 Fit_GetFieldOffset(const FIT_MESG_DEF *mesg_def, FIT_UINT8 field_def_num);
+///////////////////////////////////////////////////////////////////////
+// Returns the byte offset of a field in a message.
+///////////////////////////////////////////////////////////////////////
+
+FIT_UINT8 Fit_LookupMessage(FIT_UINT16 global_mesg_num, FIT_UINT16 message_index, FIT_UINT32 *offset, FIT_READ_BYTES_FUNC read_bytes_func);
+///////////////////////////////////////////////////////////////////////
+// Finds the byte offset of a message with the given message index in a .FIT file
+// Requires a pointer to a function which can read a given number of bytes from a provided offset in a .FIT file.
+// Returns the local message number if successful, or FIT_UINT8 if unsuccessful.
+///////////////////////////////////////////////////////////////////////
+
+#if defined(__cplusplus)
+   }
+#endif
+
+#endif // !defined(FIT_H)

data/ext/rubyfit/fit_config.h

@@ -0,0 +1,36 @@
+////////////////////////////////////////////////////////////////////////////////
+// The following .FIT software provided may be used with .FIT devices only and
+// remains the copyrighted property of Dynastream Innovations Inc.
+// The software is being provided on an "as-is" basis and as an accommodation,
+// and therefore all warranties, representations, or guarantees of any kind
+// (whether express, implied or statutory) including, without limitation,
+// warranties of merchantability, non-infringement, or fitness for a particular
+// purpose, are specifically disclaimed.
+//
+// Copyright 2008 Dynastream Innovations Inc.
+// All rights reserved. This software may not be reproduced by any means
+// without express written approval of Dynastream Innovations Inc.
+////////////////////////////////////////////////////////////////////////////////
+
+
+#if !defined(FIT_CONFIG_H)
+#define FIT_CONFIG_H
+
+
+#if defined(__cplusplus)
+   extern "C" {
+#endif
+
+#define FIT_LOCAL_MESGS     16 // Adjust to suit RAM requirements.
+#define FIT_ARCH_ENDIAN     FIT_ARCH_ENDIAN_LITTLE   // Set to correct endian for build architecture.
+
+#define FIT_CONVERT_CHECK_CRC // Define to check file crc.
+#define FIT_CONVERT_TIME_RECORD // Define to support time records (compressed timestamp).
+//#define FIT_CONVERT_MULTI_THREAD // Define to support multiple conversion threads.
+//#define FIT_CONVERT_CHECK_FILE_HDR_DATA_TYPE // Define to check file header for .FIT data type.  Verifies file is .FIT format before starting decode.
+
+#if defined(__cplusplus)
+   }
+#endif
+
+#endif // !defined(FIT_CONFIG_H)