diff --git a/ptulsconv/__main__.py b/ptulsconv/__main__.py
index e40db41..656f207 100644
--- a/ptulsconv/__main__.py
+++ b/ptulsconv/__main__.py
@@ -5,9 +5,6 @@ import sys
 parser = OptionParser()
 parser.add_option('-t','--timecode', dest='convert_times', default=False, action='store_true',
                   help="Include timecode converted to seconds in output.")
-parser.add_option('-z','--offset', dest='apply_start_offset', default=False, action='store_true',
-                  help='Apply session start offset to converted start and finish timecodes on '
-                       'clips and markers. Implies -t.')
 parser.usage = "ptulsconv [-tz] TEXT_EXPORT.txt"
 
 if __name__ == "__main__":
@@ -18,6 +15,4 @@ if __name__ == "__main__":
         exit(-1)
 
     convert(input_file=args[1],
-            convert_times=(options.convert_times or options.apply_start_offset),
-            apply_session_start=options.apply_start_offset,
-            output=sys.stdout)
+            convert_times=options.convert_times, output=sys.stdout)
diff --git a/ptulsconv/commands.py b/ptulsconv/commands.py
index dc1082a..45e5c03 100644
--- a/ptulsconv/commands.py
+++ b/ptulsconv/commands.py
@@ -2,7 +2,7 @@ import ptulsconv
 import json
 import sys
 
-def convert(input_file, convert_times, apply_session_start, output=sys.stdout):
+def convert(input_file, convert_times, output=sys.stdout):
     parsed = dict()
     with open(input_file, 'r') as file:
         ast = ptulsconv.protools_text_export_grammar.parse(file.read())
@@ -11,7 +11,6 @@ def convert(input_file, convert_times, apply_session_start, output=sys.stdout):
 
     if convert_times:
         xform = ptulsconv.transformations.TimecodeInterpreter()
-        xform.apply_session_start = apply_session_start
         parsed = xform.transform(parsed)
 
     json.dump(parsed, output)
diff --git a/ptulsconv/transformations.py b/ptulsconv/transformations.py
index be9d4d0..6391d9c 100644
--- a/ptulsconv/transformations.py
+++ b/ptulsconv/transformations.py
@@ -1,4 +1,5 @@
-from timecode import Timecode, TimecodeError
+from . import broadcast_timecode
+import math
 
 class Transformation:
     def transform(self, input_dict) -> dict:
@@ -13,54 +14,44 @@ class TimecodeInterpreter(Transformation):
     def transform(self, input_dict: dict) -> dict:
         retval = super().transform(input_dict)
         rate = input_dict['header']['timecode_format']
-        start_tc = self.convert_time(input_dict['header']['start_timecode'],
-                                                               rate, offset=None)
+        start_tc = self.convert_time(input_dict['header']['start_timecode'], rate,
+                                     drop_frame=input_dict['header']['timecode_drop_frame'])
 
         retval['header']['start_timecode_decoded'] = start_tc
-        convert_start_tc = None
-        if self.apply_session_start is True:
-            convert_start_tc = Timecode(framerate=input_dict['header']['timecode_format'],
-                                        start_timecode=input_dict['header']['start_timecode'])
-
         retval['tracks'] = self.convert_tracks(input_dict['tracks'], timecode_rate=rate,
-                                               session_start=convert_start_tc)
+                                               drop_frame=retval['header']['timecode_drop_frame'])
 
 
         for marker in retval['markers']:
             marker['location_decoded'] = self.convert_time(marker['location'], rate,
-                                                           convert_start_tc)
+                                                           drop_frame=retval['header']['timecode_drop_frame'])
+
         return retval
 
-    def convert_tracks(self, tracks, timecode_rate, session_start):
+    def convert_tracks(self, tracks, timecode_rate, drop_frame):
         for track in tracks:
             new_clips = []
             for clip in track['clips']:
-                new_clips.append( self.convert_clip( clip ,
-                                                     timecode_rate= timecode_rate,
-                                                     session_start=session_start ))
+                new_clips.append( self.convert_clip(clip, drop_frame=drop_frame, timecode_rate= timecode_rate) )
 
             track['clips'] = new_clips
+
         return tracks
 
-    def convert_clip(self, clip, timecode_rate, session_start):
+    def convert_clip(self, clip, timecode_rate, drop_frame):
         time_fields = ['start_time', 'end_time', 'duration', 'timestamp']
 
         for time_field in time_fields:
             if clip[time_field] is not None:
-                if time_field == 'duration':
-                    clip[time_field + "_decoded"] = self.convert_time(clip[time_field],
-                                                         framerate=timecode_rate, offset=None)
-                else:
-                    clip[time_field + "_decoded"] = self.convert_time(clip[time_field],
-                                                    framerate=timecode_rate, offset=session_start)
-
+                clip[time_field + "_decoded"] = self.convert_time(clip[time_field], drop_frame=drop_frame,
+                                                                  frame_rate=timecode_rate)
         return clip
 
-    def convert_time(self, time_string, framerate, offset= None):
-        tc = Timecode(framerate=framerate, start_timecode=time_string)
-        if offset is not None:
-            tc = tc - offset
+    def convert_time(self, time_string, frame_rate, drop_frame=False):
+        lfps = math.ceil(frame_rate)
 
-        return dict(frames=tc.frames, framrate= framerate, seconds= (float(tc.frames) / float(tc.framerate)))
+        frame_count = broadcast_timecode.smpte_to_frame_count(time_string, lfps, drop_frame_hint=drop_frame)
+
+        return dict(frame_count=frame_count, logical_fps=lfps, drop_frame=drop_frame)