Remove the rate argument to to_timecode.

Author: ssteinbach

contrib/opentimelineio_contrib/adapters/ale.py

@@ -290,19 +290,19 @@ def val_for_column(column, clip):
             if not clip.source_range:
                 return ""
             return otio.opentime.to_timecode(
-                clip.source_range.start_time, fps
+                clip.source_range.start_time.rescaled_to(fps)
             )
         elif column == "Duration":
             if not clip.source_range:
                 return ""
             return otio.opentime.to_timecode(
-                clip.source_range.duration, fps
+                clip.source_range.duration.rescaled_to(fps)
             )
         elif column == "End":
             if not clip.source_range:
                 return ""
             return otio.opentime.to_timecode(
-                clip.source_range.end_time_exclusive(), fps
+                clip.source_range.end_time_exclusive().rescaled_to(fps)
             )
         else:
             return clip.metadata.get("ALE", {}).get(column)

contrib/opentimelineio_contrib/adapters/ffmpeg_burnins.py

@@ -274,8 +274,9 @@ def add_timecode(self, align, options=None):
         :param dict options: recommended to use TimeCodeOptions
         """
         options = options or TimeCodeOptions()
-        timecode = _frames_to_timecode(options['frame_offset'],
-                                       self.frame_rate)
+        timecode = _frames_to_timecode(
+            options['frame_offset'].rescaled_to(self.frame_rate)
+        )
         options = options.copy()
         if not options.get('fps'):
             options['fps'] = self.frame_rate

src/opentime/rationalTime.cpp

@@ -187,23 +187,19 @@ RationalTime::from_time_string(std::string const& time_string, double rate, Erro
 
 std::string
 RationalTime::to_timecode(
-        double rate,
         IsDropFrameRate drop_frame,
         ErrorStatus* error_status
 ) const {
 
     *error_status = ErrorStatus();
 
-    double value_in_target_rate = _value;
-    if (rate != _rate) {
-        value_in_target_rate = this->value_rescaled_to(rate);
-    }
-    
-    if (value_in_target_rate < 0) {
+    if (_value < 0) {
         *error_status = ErrorStatus(ErrorStatus::NEGATIVE_VALUE);
         return std::string();
     }
 
+    double rate = _rate;
+    
     if (!is_valid_timecode_rate(rate)) {
         *error_status = ErrorStatus(ErrorStatus::INVALID_TIMECODE_RATE);
         return std::string();
@@ -257,7 +253,7 @@ RationalTime::to_timecode(
             (std::round(rate) * 60) - dropframes);
 
     // If the number of frames is more than 24 hours, roll over clock
-    double value = std::fmod(value_in_target_rate, frames_per_24_hours);
+    double value = std::fmod(_value, frames_per_24_hours);
 
     if (rate_is_dropframe) {
         int ten_minute_chunks = static_cast<int>(std::floor(value/frames_per_10_minutes));

src/opentime/rationalTime.h

@@ -88,13 +88,12 @@ class RationalTime {
     }
 
     std::string to_timecode(
-            double rate,
             IsDropFrameRate drop_frame,
             ErrorStatus *error_status
     ) const;
 
     std::string to_timecode(ErrorStatus *error_status) const {
-        return to_timecode(_rate, IsDropFrameRate::InferFromRate, error_status);
+        return to_timecode(IsDropFrameRate::InferFromRate, error_status);
     }
 
     std::string to_time_string() const;

src/opentimelineview/track_widgets.py

@@ -153,25 +153,21 @@ def _set_labels_timecode(self):
         self.source_in_label.setText(
             '{timeline}\n{source}'.format(
                 timeline=otio.opentime.to_timecode(
-                    self.timeline_range.start_time,
-                    self.timeline_range.start_time.rate
+                    self.timeline_range.start_time
                 ),
                 source=otio.opentime.to_timecode(
-                    self.item.trimmed_range.start_time,
-                    self.item.trimmed_range.start_time.rate
+                    self.item.trimmed_range.start_time
                 )
             )
         )
 
         self.source_out_label.setText(
             '{timeline}\n{source}'.format(
                 timeline=otio.opentime.to_timecode(
-                    self.timeline_range.end_time_exclusive(),
-                    self.timeline_range.end_time_exclusive().rate
+                    self.timeline_range.end_time_exclusive()
                 ),
                 source=otio.opentime.to_timecode(
-                    self.item.trimmed_range.end_time_exclusive(),
-                    self.item.trimmed_range.end_time_exclusive().rate
+                    self.item.trimmed_range.end_time_exclusive()
                 )
             )
         )

src/py-opentimelineio/opentime-bindings/opentime_rationalTime.cpp

@@ -84,23 +84,14 @@ void opentime_rationalTime_bindings(py::module m) {
         .def("to_frames", (int (RationalTime::*)() const) &RationalTime::to_frames)
         .def("to_frames", (int (RationalTime::*)(double) const) &RationalTime::to_frames, "rate"_a)
         .def("to_seconds", &RationalTime::to_seconds)
-        .def("to_timecode", [](RationalTime rt, double rate, py::object drop_frame) { 
+        .def("to_timecode", [](RationalTime rt, py::object drop_frame) { 
                 return rt.to_timecode(
-                        rate, 
                         df_enum_converter(drop_frame),
                         ErrorStatusConverter()
                 ); 
-        }, "rate"_a, "drop_frame"_a)
-        .def("to_timecode", [](RationalTime rt, double rate) { 
-                return rt.to_timecode(
-                        rate, 
-                        IsDropFrameRate::InferFromRate,
-                        ErrorStatusConverter()
-                ); 
-        }, "rate"_a)
+        }, "drop_frame"_a)
         .def("to_timecode", [](RationalTime rt) {
                 return rt.to_timecode(
-                        rt.rate(),
                         IsDropFrameRate::InferFromRate,
                         ErrorStatusConverter()); 
                 })

src/py-opentimelineio/opentimelineio/adapters/cmx_3600.py

@@ -556,8 +556,7 @@ def parse(self, line):
                         opentime.from_frames(
                             int(getattr(self, prop)),
                             self.edl_rate
-                        ),
-                        self.edl_rate
+                        )
                     )
                 )
 
@@ -1124,10 +1123,10 @@ def to_edl_format(self, edit_number):
             'edit': edit_number,
             'reel': self.reel,
             'kind': self._kind,
-            'src_in': opentime.to_timecode(self.source_in, self._rate),
-            'src_out': opentime.to_timecode(self.source_out, self._rate),
-            'rec_in': opentime.to_timecode(self.record_in, self._rate),
-            'rec_out': opentime.to_timecode(self.record_out, self._rate),
+            'src_in': opentime.to_timecode(self.source_in.rescaled_to(self._rate)),
+            'src_out': opentime.to_timecode(self.source_out.rescaled_to(self._rate)),
+            'rec_in': opentime.to_timecode(self.record_in.rescaled_to(self._rate)),
+            'rec_out': opentime.to_timecode(self.record_out.rescaled_to(self._rate)),
             'diss': int(
                 opentime.to_frames(self.dissolve_length, self._rate)
             ),
@@ -1182,8 +1181,7 @@ def _generate_comment_lines(
                 clip.name,
                 timing_effect.time_scalar * edl_rate,
                 opentime.to_timecode(
-                    clip.trimmed_range().start_time,
-                    edl_rate
+                    clip.trimmed_range().start_time.rescaled_to(edl_rate)
                 )
             )
         )
@@ -1241,8 +1239,7 @@ def _generate_comment_lines(
     # Output any markers on this clip
     for marker in clip.markers:
         timecode = opentime.to_timecode(
-            marker.marked_range.start_time,
-            edl_rate
+            marker.marked_range.start_time.rescaled_to(edl_rate)
         )
 
         color = marker.color

src/py-opentimelineio/opentimelineio/adapters/fcp_xml.py

@@ -1360,7 +1360,7 @@ def _build_timecode(time, fps, drop_frame=False, additional_metadata=None):
 
     # Get the time values
     tc_time = opentime.RationalTime(time.value_rescaled_to(fps), tc_fps)
-    tc_string = opentime.to_timecode(tc_time, tc_fps, drop_frame)
+    tc_string = opentime.to_timecode(tc_time.rescaled_to(tc_fps), drop_frame)
 
     _append_new_sub_element(tc_element, "string", text=tc_string)
 

src/py-opentimelineio/opentimelineio/console/otiostat.py

@@ -125,7 +125,7 @@ def _total_duration(input):
 def _total_duration_timecode(input):
     try:
         d = input.tracks.duration()
-        return otio.opentime.to_timecode(d, d.rate)
+        return otio.opentime.to_timecode(d)
     except AttributeError:
         return "n/a"
 

src/py-opentimelineio/opentimelineio/opentime.py

@@ -13,11 +13,11 @@
 duration_from_start_end_time = RationalTime.duration_from_start_end_time
 
 
-def to_timecode(rt, rate=None, drop_frame=None):
+def to_timecode(rt, drop_frame=None):
     return (
         rt.to_timecode()
-        if rate is None and drop_frame is None
-        else rt.to_timecode(rate, drop_frame)
+        if drop_frame is None
+        else rt.to_timecode(drop_frame)
     )