Add a test case and fix for transcribing markers over a single audio AAF file (#1259)

Author: jchen9

contrib/opentimelineio_contrib/adapters/advanced_authoring_format.py

@@ -1246,22 +1246,53 @@ def _attach_markers(collection):
                 current_track.markers.remove(marker)
 
                 # determine new item to attach the marker to
-                target_item = target_track.child_at_time(marker.marked_range.start_time)
-                if target_item is None or not hasattr(target_item, 'markers'):
+                try:
+                    target_item = target_track.child_at_time(
+                        marker.marked_range.start_time
+                    )
+
+                    if target_item is None or not hasattr(target_item, 'markers'):
+                        # Item found cannot have markers, for example Transition.
+                        # See also `marker-over-transition.aaf` in test data.
+                        #
+                        # Leave markers on the track for now.
+                        _transcribe_log(
+                            'Skip target_item `{}` cannot have markers'.format(
+                                target_item,
+                            ),
+                        )
+                        target_item = target_track
+
+                    # transform marked range into new item range
+                    marked_start_local = current_track.transformed_time(
+                        marker.marked_range.start_time, target_item
+                    )
+
+                    marker.marked_range = otio.opentime.TimeRange(
+                        start_time=marked_start_local,
+                        duration=marker.marked_range.duration
+                    )
+
+                except otio.exceptions.CannotComputeAvailableRangeError as e:
+                    # For audio media AAF file (marker-over-audio.aaf),
+                    # this exception would be triggered in:
+                    # `target_item = target_track.child_at_time()` with error
+                    # message:
+                    # "No available_range set on media reference on clip".
+                    #
+                    # Leave markers on the track for now.
+                    _transcribe_log(
+                        'Cannot compute availableRange from {} to {}: {}'.format(
+                            marker,
+                            target_track,
+                            e,
+                        ),
+                    )
                     target_item = target_track
 
                 # attach marker to target item
                 target_item.markers.append(marker)
 
-                # transform marked range into new item range
-                marked_start_local = current_track.transformed_time(
-                    marker.marked_range.start_time, target_item
-                )
-
-                marker.marked_range = otio.opentime.TimeRange(
-                    start_time=marked_start_local, duration=marker.marked_range.duration
-                )
-
                 _transcribe_log(
                     "Marker: '{}' (time: {}), attached to item: '{}'".format(
                         marker.name,

contrib/opentimelineio_contrib/adapters/tests/sample_data/marker-over-audio.aaf

@@ -220,6 +220,11 @@
     "marker-over-transition.aaf",
 )
 
+MARKER_OVER_AUDIO_PATH = os.path.join(
+    SAMPLE_DATA_DIR,
+    "marker-over-audio.aaf"
+)
+
 
 def safe_str(maybe_str):
     """To help with testing between python 2 and 3, this function attempts to
@@ -1125,6 +1130,63 @@ def test_aaf_marker_over_transition(self):
 
         self.assertIsNotNone(timeline)
 
+    def test_aaf_marker_over_audio_file(self):
+        """
+        Make sure we can transcibe markers over an audio AAF file.
+        """
+
+        timeline = None
+
+        try:
+            timeline = otio.adapters.read_from_file(
+                MARKER_OVER_AUDIO_PATH
+            )
+
+        except Exception as e:
+            print('[ERROR] Transcribing test sample data `{}` caused an exception: {}'.format(  # noqa
+                os.path.basename(MARKER_OVER_AUDIO_PATH),
+                e)
+            )
+
+        self.assertIsNotNone(timeline)
+
+        # Verify markers
+        # We expect 1 track with 3 markers on it from the test data.
+        self.assertTrue(1 == len(timeline.tracks))
+
+        track = timeline.tracks[0]
+        self.assertEqual(3, len(track.markers))
+
+        fps = 24.0
+        expected_markers = [
+            {
+                'color': 'RED',
+                'label': 'm1',
+                'start_time': otio.opentime.from_frames(50.0, fps)
+            },
+            {
+                'color': 'GREEN',
+                'label': 'm2',
+                'start_time': otio.opentime.from_frames(103.0, fps)
+            },
+            {
+                'color': 'BLUE',
+                'label': 'm3',
+                'start_time': otio.opentime.from_frames(166.0, fps)
+            }
+        ]
+
+        for index, marker in enumerate(track.markers):
+            expected_marker = expected_markers[index]
+
+            color = marker.color
+            label = marker.metadata.get('AAF', {}).get('CommentMarkerUSer')
+            start_time = marker.marked_range.start_time
+
+            self.assertEqual(color, expected_marker.get('color'))
+            self.assertEqual(label, expected_marker.get('label'))
+            self.assertEqual(start_time, expected_marker.get('start_time'))
+
     def _verify_user_comments(self, aaf_metadata, expected_md):
 
         self.assertTrue(aaf_metadata is not None)