tdms 0.1.0

data/lib/tdms/datatypes.rb

@@ -0,0 +1,173 @@
+module Tdms
+
+  module DataType
+
+    class Base
+      attr_accessor :value
+
+      def initialize(value=nil)
+        @value = value
+      end
+    end
+
+    class Int8 < Base
+      Id = 0x01
+      LengthInBytes = 1
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_i8)
+      end
+    end
+
+    class Int16 < Base
+      Id = 0x02
+      LengthInBytes = 2
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_i16)
+      end
+    end
+
+    class Int32 < Base
+      Id = 0x03
+      LengthInBytes = 4
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_i32)
+      end
+    end
+
+    class Int64 < Base
+      Id = 0x04
+      LengthInBytes = 8
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_i64)
+      end
+    end
+
+    class Uint8 < Base
+      Id = 0x05
+      LengthInBytes = 1
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_u8)
+      end
+    end
+
+    class Uint16 < Base
+      Id = 0x06
+      LengthInBytes = 2
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_u16)
+      end
+    end
+
+    class Uint32 < Base
+      Id = 0x07
+      LengthInBytes = 4
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_u32)
+      end
+    end
+
+    class Uint64 < Base
+      Id = 0x08
+      LengthInBytes = 8
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_u64)
+      end
+    end
+
+    class Single < Base
+      Id = 0x09
+      LengthInBytes = 4
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_single)
+      end
+    end
+
+    class Double < Base
+      Id = 0x0A
+      LengthInBytes = 8
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_double)
+      end
+    end
+
+    class SingleWithUnit < Base
+      Id = 0x19
+      LengthInBytes = 4
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_single)
+      end
+    end
+
+    class DoubleWithUnit < Base
+      Id = 0x1A
+      LengthInBytes = 8
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_double)
+      end
+    end
+
+    class Utf8String < Base
+      Id = 0x20
+      LengthInBytes = nil
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_utf8_string)
+      end
+    end
+
+    class Boolean < Base
+      Id = 0x21
+      LengthInBytes = 1
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_bool)
+      end
+    end
+
+    class Timestamp < Base
+      Id = 0x44
+      LengthInBytes = 16
+
+      def self.read_from_stream(tdms_file)
+        new(tdms_file.read_timestamp)
+      end
+    end
+
+    DataTypesById = {
+      Int8::Id           => Int8,
+      Int16::Id          => Int16,
+      Int32::Id          => Int32,
+      Int64::Id          => Int64,
+      Uint8::Id          => Uint8,
+      Uint16::Id         => Uint16,
+      Uint32::Id         => Uint32,
+      Uint64::Id         => Uint64,
+      Single::Id         => Single,
+      SingleWithUnit::Id => SingleWithUnit,
+      Double::Id         => Double,
+      DoubleWithUnit::Id => DoubleWithUnit,
+      Utf8String::Id     => Utf8String,
+      Boolean::Id        => Boolean,
+      Timestamp::Id      => Timestamp
+    }
+
+    def find_by_id(id_byte)
+      DataTypesById[id_byte] || raise(ArgumentError, "Don't know type %d" % id_byte)
+    end
+    module_function :find_by_id
+
+  end
+
+end

data/lib/tdms/document.rb

@@ -0,0 +1,114 @@
+module Tdms
+
+  class Document
+    attr_reader :segments, :channels, :file
+
+    def initialize(file)
+      @file = file
+      parse_segments
+      build_aggregates
+    end
+
+    private
+
+    def parse_segments
+      @segments = []
+
+      until file.eof?
+        segment = Tdms::Segment.new
+        segment.prev_segment = @segments[-1]
+        @segments << segment
+
+        lead_in = @file.read(0x1C)
+        metadata_pos = @file.pos
+
+        unpacked = lead_in.unpack("a4VVQQ")
+        tdms_tag     = unpacked[0]                # char[4]
+        toc_flags    = unpacked[1]                # u32
+        tdms_version = unpacked[2]                # u32
+        next_seg_pos = unpacked[3] + metadata_pos # u64
+        raw_data_pos = unpacked[4] + metadata_pos # u64
+
+        new_changed_objs = @file.read_u32
+
+        raw_data_pos_obj = raw_data_pos
+
+        1.upto(new_changed_objs) do |obj_index|
+          path = Tdms::Path.new(:path => @file.read_utf8_string)
+          index_block_len = @file.read_u32
+
+          if index_block_len == 0xFFFFFFFF
+            # no index block
+
+          elsif index_block_len == 0x000000
+            # index block is same as this channel in the last segment
+            prev_chan = segment.prev_segment.objects.find {|o| o.path == path }
+
+            chan = Tdms::Channel.new
+            chan.file = @file
+            chan.raw_data_pos = raw_data_pos_obj
+            chan.path         = prev_chan.path
+            chan.data_type_id = prev_chan.data_type_id
+            chan.dimension    = prev_chan.dimension
+            chan.num_values   = prev_chan.num_values
+
+            segment.objects << chan
+          else
+            # XXX why does the number of properties seem to be
+            # included in the raw data index block size?
+            # -4 is a hack
+            index_block = @file.read(index_block_len - 4)
+            decoded = index_block.unpack("VVQ")
+
+            chan = Tdms::Channel.new
+            chan.file = @file
+            chan.raw_data_pos = raw_data_pos_obj
+            chan.path         = path
+            chan.data_type_id = decoded[0] # first 4 bytes u32
+            chan.dimension    = decoded[1] # next 4 bytes u32
+            chan.num_values   = decoded[2] # next 8 bytes u64
+
+            data_type = Tdms::DataType.find_by_id(chan.data_type_id)
+            fixed_length = data_type::LengthInBytes
+
+            raw_data_pos_obj += if fixed_length
+              chan.num_values * fixed_length
+            else
+              # if the values are variable length (strings only) then
+              # the index block contains 8 additional bytes at the
+              # end with the total length of the raw data in u64
+              index_block[-8,8].unpack("Q")[0]
+            end
+
+            segment.objects << chan
+          end
+
+          # TODO store properties
+          num_props = @file.read_u32
+          1.upto(num_props) do |n|
+            prop = @file.read_property
+          end
+        end
+
+        @file.seek next_seg_pos
+      end
+
+    end
+
+    def build_aggregates
+      @channels = []
+
+      channels_by_path = {}
+      segments.each do |segment|
+        segment.objects.select { |o| o.path.channel? }.each do |ch|
+          (channels_by_path[ch.path.to_s] ||= []) << ch
+        end
+      end
+
+      channels_by_path.each do |path, channels|
+        @channels << AggregateChannel.new(channels)
+      end
+    end
+  end
+
+end

data/lib/tdms/path.rb

@@ -0,0 +1,58 @@
+module Tdms
+
+  class Path
+    attr_reader :group, :channel
+
+    def initialize(options={})
+      load(options[:path]) if options[:path]
+      @group   = options[:group]   if options[:group]
+      @channel = options[:channel] if options[:channel]
+    end
+
+    def load(path)
+      segments = path.split("/").map do |seg|
+        seg.sub(/^'/,'').sub(/'$/,'').sub("''", "'")
+      end
+
+      _, @group, @channel = *segments
+    end
+
+    def ==(other)
+      if other.is_a?(String)
+        self.to_s == other
+      elsif other.is_a?(Path)
+        self.dump == other.dump
+      else
+        super
+      end
+    end
+
+    def dump
+      raise ArgumentError if channel && group.nil?
+
+      parts = [""]
+      parts << ("'" + group.sub("'","''")   + "'") if group
+      parts << ("'" + channel.sub("'","''") + "'") if channel
+
+      dumped = parts.join("/")
+      dumped.empty? ? "/" : dumped
+    end
+
+    def to_s
+      dump
+    end
+
+    def root?
+      (! channel?) && (! group?)
+    end
+
+    def group?
+      (! @group.nil?) && (@channel.nil?)
+    end
+
+    def channel?
+      (! @channel.nil?)
+    end
+  end
+
+end

data/lib/tdms/property.rb

@@ -0,0 +1,17 @@
+module Tdms
+
+  class Property
+    attr_accessor :name
+    attr_accessor :data # tdms::data_type
+
+    def initialize(name=nil, data=nil)
+      @name = name
+      @data = data
+    end
+
+    def value
+      data.value
+    end
+
+  end
+end

data/lib/tdms/segment.rb

@@ -0,0 +1,12 @@
+module Tdms
+
+  class Segment
+    attr_accessor :prev_segment
+    attr_reader :objects
+
+    def initialize
+      @objects = []
+    end
+  end
+
+end

data/lib/tdms/streaming.rb

@@ -0,0 +1,82 @@
+require 'date'
+
+module Tdms
+
+  module Streaming
+    def read_property
+      name    = read_utf8_string
+      type_id = read_u32
+
+      data = Tdms::DataType.find_by_id(type_id).read_from_stream(self)
+      Tdms::Property.new(name, data)
+    end
+
+    def read_bool
+      read(1) == "\001"
+    end
+
+    def read_u8
+      read(1).unpack("C")[0]
+    end
+
+    def read_u16
+      read(2).unpack("v")[0]
+    end
+
+    def read_u32
+      read(4).unpack("V")[0]
+    end
+
+    def read_u64
+      lo_hi = read(8).unpack("VV")
+      lo_hi[0] + (lo_hi[1] << 32)
+    end
+
+    def read_i8
+      read(2).unpack("c")[0]
+    end
+
+    def read_i16
+      read(2).unpack("s")[0] # TODO little endian not native
+    end
+
+    def read_i32
+      read(4).unpack("l")[0] # TODO little endian not native
+    end
+
+    def read_i64
+      read(8).unpack("q")[0] # TODO little endian not native
+    end
+
+    def read_single
+      read(4).unpack("e")[0]
+    end
+
+    def read_double
+      read(8).unpack("E")[0]
+    end
+
+    def read_utf8_string
+      length = read_u32
+      read length
+    end
+
+    def read_timestamp
+      positive_fractions_of_second = read_u64 # ignored
+      seconds_since_labview_epoch  = read(8).unpack("q")[0] # TODO little endian not native
+
+      labview_epoch = ::DateTime.new(1904, 1, 1)
+      labview_epoch + Rational(seconds_since_labview_epoch, 86400)
+    end
+  end
+
+  class File < ::File
+    include Streaming
+
+    def self.parse(filename)
+      f = self.open(filename, "rb")
+      Document.new(f)
+    end
+  end
+
+end