boris-behav-obs 9.6.6__tar.gz → 9.7.1__tar.gz

{boris_behav_obs-9.6.6 → boris_behav_obs-9.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boris-behav-obs
-Version: 9.6.6
+Version: 9.7.1
 Summary: BORIS - Behavioral Observation Research Interactive Software
 Author-email: Olivier Friard <olivier.friard@unito.it>
 License-Expression: GPL-3.0-only
@@ -52,13 +52,15 @@ It provides also some analysis tools like time budget and some plotting function
 <!-- The BO-RIS paper has more than [![BORIS citations counter](https://penelope.unito.it/friard/boris_scopus_citations.png) citations](https://www.boris.unito.it/citations) in peer-reviewed scientific publications. -->
 
 
-The BORIS paper has more than 2337 citations in peer-reviewed scientific publications.
+The BORIS paper has more than 2407 citations in peer-reviewed scientific publications.
 
 
 
 
 See the official [BORIS web site](https://www.boris.unito.it).
 
+<a href="https://www.boris.unito.it" target="_blank"><img alt="Website" src="https://img.shields.io/website?url=https%3A%2F%2Fwww.boris.unito.it"></a>
+<a href="https://www.boris.unito.it/user_guide/" target="_blank"><img alt="User guide" src="https://img.shields.io/badge/Documentation-orange"></a>
 [![Python web site](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org)
 ![Python versions](https://img.shields.io/pypi/pyversions/boris-behav-obs)
 ![BORIS license](https://img.shields.io/pypi/l/boris-behav-obs)
@@ -136,7 +138,3 @@ GNU General Public License for more details.
 Distributed with a [GPL v.3 license](LICENSE.TXT).
 
 Copyright (C) 2012-2025 Olivier Friard
-
-
-
-

{boris_behav_obs-9.6.6 → boris_behav_obs-9.7.1}/README.md

@@ -14,13 +14,15 @@ It provides also some analysis tools like time budget and some plotting function
 <!-- The BO-RIS paper has more than [![BORIS citations counter](https://penelope.unito.it/friard/boris_scopus_citations.png) citations](https://www.boris.unito.it/citations) in peer-reviewed scientific publications. -->
 
 
-The BORIS paper has more than 2337 citations in peer-reviewed scientific publications.
+The BORIS paper has more than 2407 citations in peer-reviewed scientific publications.
 
 
 
 
 See the official [BORIS web site](https://www.boris.unito.it).
 
+<a href="https://www.boris.unito.it" target="_blank"><img alt="Website" src="https://img.shields.io/website?url=https%3A%2F%2Fwww.boris.unito.it"></a>
+<a href="https://www.boris.unito.it/user_guide/" target="_blank"><img alt="User guide" src="https://img.shields.io/badge/Documentation-orange"></a>
 [![Python web site](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org)
 ![Python versions](https://img.shields.io/pypi/pyversions/boris-behav-obs)
 ![BORIS license](https://img.shields.io/pypi/l/boris-behav-obs)
@@ -98,7 +100,3 @@ GNU General Public License for more details.
 Distributed with a [GPL v.3 license](LICENSE.TXT).
 
 Copyright (C) 2012-2025 Olivier Friard
-
-
-
-

{boris_behav_obs-9.6.6 → boris_behav_obs-9.7.1}/boris/cmd_arguments.py

@@ -35,6 +35,8 @@ def parse_arguments():
     parser.add_option("-n", "--nosplashscreen", action="store_true", default=False, help="No splash screen")
     parser.add_option("-p", "--project", action="store", default="", dest="project", help="Project file")
     parser.add_option("-o", "--observation", action="store", default="", dest="observation", help="Observation id")
+    parser.add_option("-i", "--ipc", action="store_true", default="", dest="ipc", help="MPV IPC mode")
+
     parser.add_option(
         "-f",
         "--no-first-launch-dialog",

{boris_behav_obs-9.6.6 → boris_behav_obs-9.7.1}/boris/config.py

@@ -22,8 +22,7 @@ This file is part of BORIS.
 
 programName: str = "BORIS"
 
-
-MACOS_CODE = "darwin"
+# socket for MPV IPC mode
 MPV_SOCKET = "/tmp/mpvsocket"
 
 

{boris_behav_obs-9.6.6 → boris_behav_obs-9.7.1}/boris/connections.py

@@ -120,6 +120,7 @@ def connections(self):
     self.actionSelect_observations.triggered.connect(lambda: event_operations.select_events_between_activated(self))
 
     self.actionEdit_selected_events.triggered.connect(lambda: event_operations.edit_selected_events(self))
+    self.action_add_comment.triggered.connect(lambda: event_operations.add_comment(self))
     self.actionEdit_event_time.triggered.connect(lambda: event_operations.edit_time_selected_events(self))
 
     self.actionCopy_events.triggered.connect(lambda: event_operations.copy_selected_events(self))
@@ -343,6 +344,8 @@ def connections(self):
 
     self.tv_events.addAction(self.actionAdd_event)
     self.tv_events.addAction(self.actionEdit_selected_events)
+    self.tv_events.addAction(self.action_add_comment)
+
     self.tv_events.addAction(self.actionEdit_event_time)
 
     self.tv_events.addAction(self.actionCopy_events)

{boris_behav_obs-9.6.6 → boris_behav_obs-9.7.1}/boris/core.py

@@ -150,7 +150,7 @@ if util.versiontuple(platform.python_version()) < util.versiontuple(MIN_PYTHON_V
     logging.critical(msg)
     sys.exit()
 
-if sys.platform == "darwin":  # for MacOS
+if sys.platform.startswith("darwin"):  # for MacOS
     os.environ["LC_ALL"] = "en_US.UTF-8"
 
 
@@ -236,8 +236,8 @@ class MainWindow(QMainWindow, Ui_MainWindow):
     processes: list = []  # list of QProcess processes
     overlays: dict = {}  # dict for storing video overlays
 
-    undo_queue = deque() # queue for undoing event operations
-    undo_description = deque() # queue for description of event operations
+    undo_queue = deque()  # queue for undoing event operations
+    undo_description = deque()  # queue for description of event operations
 
     current_player: int = 0  # id of the selected (left click) video player
 
@@ -400,7 +400,7 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
         # if BORIS is running on Mac lock all dockwidget features
         # because Qdockwidgets may have a strange behavior
-        if sys.platform == "darwin":
+        if sys.platform.startswith("darwin"):
             self.action_block_dockwidgets.setChecked(True)
             self.block_dockwidgets()
 
@@ -1428,55 +1428,60 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         if not self.dw_player[player].player.playlist_count:
             return
 
-        # one media
-        if self.dw_player[player].player.playlist_count == 1:
-            if new_time < self.dw_player[player].player.duration:
-                new_time_float = round(float(new_time), 3)
-
-                self.dw_player[player].player.seek(new_time_float, "absolute+exact")
+        try:
+            # one media
+            if self.dw_player[player].player.playlist_count == 1:
+                if new_time < self.dw_player[player].player.duration:
+                    new_time_float = round(float(new_time), 3)
 
-                if player == 0 and not self.user_move_slider:
-                    self.video_slider.setValue(
-                        round(self.dw_player[0].player.time_pos / self.dw_player[0].player.duration * (cfg.SLIDER_MAXIMUM - 1))
-                    )
-                return 0
-            else:
-                return 1
+                    self.dw_player[player].player.seek(new_time_float, "absolute+exact")
+                    self.mpv_timer_out()
 
-        # many media
-        else:
-            if new_time < self.dw_player[player].cumul_media_durations_sec[-1]:
-                for idx, d in enumerate(self.dw_player[player].cumul_media_durations_sec[:-1]):
-                    if d <= new_time < self.dw_player[player].cumul_media_durations_sec[idx + 1]:
-                        self.dw_player[player].player.playlist_pos = idx
-                        time.sleep(0.5)
-
-                        self.dw_player[player].player.seek(
-                            round(
-                                float(new_time)
-                                - sum(self.dw_player[player].media_durations[0 : self.dw_player[player].player.playlist_pos]) / 1000,
-                                3,
-                            ),
-                            "absolute+exact",
+                    if player == 0 and not self.user_move_slider:
+                        self.video_slider.setValue(
+                            round(self.dw_player[0].player.time_pos / self.dw_player[0].player.duration * (cfg.SLIDER_MAXIMUM - 1))
                         )
+                    return 0
+                else:
+                    return 1
+
+            # many media
+            else:
+                if new_time < self.dw_player[player].cumul_media_durations_sec[-1]:
+                    for idx, d in enumerate(self.dw_player[player].cumul_media_durations_sec[:-1]):
+                        if d <= new_time < self.dw_player[player].cumul_media_durations_sec[idx + 1]:
+                            self.dw_player[player].player.playlist_pos = idx
+                            time.sleep(0.5)
+
+                            self.dw_player[player].player.seek(
+                                round(
+                                    float(new_time)
+                                    - sum(self.dw_player[player].media_durations[0 : self.dw_player[player].player.playlist_pos]) / 1000,
+                                    3,
+                                ),
+                                "absolute+exact",
+                            )
 
-                        break
+                            break
 
-                if player == 0 and not self.user_move_slider:
-                    self.video_slider.setValue(
-                        round(self.dw_player[0].player.time_pos / self.dw_player[0].player.duration * (cfg.SLIDER_MAXIMUM - 1))
+                    if player == 0 and not self.user_move_slider:
+                        self.video_slider.setValue(
+                            round(self.dw_player[0].player.time_pos / self.dw_player[0].player.duration * (cfg.SLIDER_MAXIMUM - 1))
+                        )
+                    return 0
+                else:
+                    QMessageBox.warning(
+                        self,
+                        cfg.programName,
+                        (
+                            "The indicated position is greater than the total media duration "
+                            f"({util.seconds2time(self.dw_player[player].cumul_media_durations_sec[-1])})"
+                        ),
                     )
-                return 0
-            else:
-                QMessageBox.warning(
-                    self,
-                    cfg.programName,
-                    (
-                        "The indicated position is greater than the total media duration "
-                        f"({util.seconds2time(self.dw_player[player].cumul_media_durations_sec[-1])})"
-                    ),
-                )
-                return 1
+                    return 1
+        except Exception as e:
+            print(f"error in seek mediaplayer function: {e}")
+            return 0
 
     def jump_to(self) -> None:
         """
@@ -3685,6 +3690,7 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         if self.playerType == cfg.MEDIA:
             for dw in self.dw_player:
                 dw.player.frame_step()
+
                 if self.geometric_measurements_mode:
                     self.extract_frame(dw)
 
@@ -3692,6 +3698,8 @@ class MainWindow(QMainWindow, Ui_MainWindow):
                 for idx in self.plot_data:
                     self.timer_plot_data_out(self.plot_data[idx])
 
+            self.mpv_timer_out()
+
         if self.geometric_measurements_mode:
             geometric_measurement.redraw_measurements(self)
 
@@ -3709,6 +3717,7 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         if self.playerType == cfg.MEDIA:
             for dw in self.dw_player:
                 dw.player.frame_back_step()
+
                 if self.geometric_measurements_mode:
                     self.extract_frame(dw)
 
@@ -3716,6 +3725,8 @@ class MainWindow(QMainWindow, Ui_MainWindow):
                 for idx in self.plot_data:
                     self.timer_plot_data_out(self.plot_data[idx])
 
+            self.mpv_timer_out()
+
         if self.geometric_measurements_mode:
             geometric_measurement.redraw_measurements(self)
 
@@ -3728,77 +3739,78 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         QMessageBox.warning(self, cfg.programName, "Function not yet implemented")
         return
 
-        if not self.observationId:
-            self.no_observation()
-            return
-
-        if self.twEvents.selectedItems():
-            row_s = self.twEvents.selectedItems()[0].row()
-            row_e = self.twEvents.selectedItems()[-1].row()
-            eventtime_s = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][row_s][0]
-            eventtime_e = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][row_e][0]
-
-            durations = []  # in seconds
-
-            # TODO: check for 2nd player
-            for mediaFile in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE][cfg.PLAYER1]:
-                durations.append(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO]["length"][mediaFile])
-
-            mediaFileIdx_s = [idx1 for idx1, x in enumerate(durations) if eventtime_s >= sum(durations[0:idx1])][-1]
-            media_path_s = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE][cfg.PLAYER1][mediaFileIdx_s]
-
-            mediaFileIdx_e = [idx1 for idx1, x in enumerate(durations) if eventtime_e >= sum(durations[0:idx1])][-1]
-            media_path_e = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE][cfg.PLAYER1][mediaFileIdx_e]
-
-            # calculate time for current media file in case of many queued media files
-
-            eventtime_onmedia_s = round(eventtime_s - util.float2decimal(sum(durations[0:mediaFileIdx_s])), 3)
-            eventtime_onmedia_e = round(eventtime_e - util.float2decimal(sum(durations[0:mediaFileIdx_e])), 3)
-
-            if media_path_s != media_path_e:
-                return
-
-            media_path = media_path_s
-
-            # example of external command defined in environment:
-            # export BORISEXTERNAL="myprog -i {MEDIA_PATH} -s {START_S} -e {END_S} {DURATION_MS} --other"
+        # if not self.observationId:
+        #    self.no_observation()
+        #    return
 
-            if "BORISEXTERNAL" in os.environ:
-                external_command_template = os.environ["BORISEXTERNAL"]
-            else:
-                return
-
-            external_command = external_command_template.format(
-                OBS_ID=self.observationId,
-                MEDIA_PATH=f'"{media_path}"',
-                MEDIA_BASENAME=f'"{os.path.basename(media_path)}"',
-                START_S=eventtime_onmedia_s,
-                END_S=eventtime_onmedia_e,
-                START_MS=eventtime_onmedia_s * 1000,
-                END_MS=eventtime_onmedia_e * 1000,
-                DURATION_S=eventtime_onmedia_e - eventtime_onmedia_s,
-                DURATION_MS=(eventtime_onmedia_e - eventtime_onmedia_s) * 1000,
-            )
-
-            print(external_command)
-            """
-            p = subprocess.Popen(external_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
-            """
-            """
-            if eventtimeS == eventtimeE:
-                q = []
-            else:
-                durationsec = eventtimeE-eventtimeS
-                q = ["--durationmsec",str(int(durationsec*1000))]
-            args = [ex, "-f",os.path.abspath(fn),"--seekmsec",str(int(eventtimeS*1000)),*q,*("--size 1 --track 1 --redetect 100")
-            .split(" ")]
-            if os.path.split(fn)[1].split("_")[0] in set(["A1","A2","A3","A4","A5","A6","A7","A8","A9","A10"]):
-                args.append("--flip")
-                args.append("2")
-            print (os.path.split(fn)[1].split("_")[0])
-            print ("running",ex,"with",args,"in",os.path.split(ex)[0])
-            #pid = subprocess.Popen(args,executable=ex,cwd=os.path.split(ex)[0])
-            """
+    #
+    # if self.twEvents.selectedItems():
+    #    row_s = self.twEvents.selectedItems()[0].row()
+    #    row_e = self.twEvents.selectedItems()[-1].row()
+    #    eventtime_s = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][row_s][0]
+    #    eventtime_e = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][row_e][0]
+    #
+    #    durations = []  # in seconds
+    #
+    #    # TODO: check for 2nd player
+    #    for mediaFile in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE][cfg.PLAYER1]:
+    #        durations.append(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO]["length"][mediaFile])
+    #
+    #    mediaFileIdx_s = [idx1 for idx1, x in enumerate(durations) if eventtime_s >= sum(durations[0:idx1])][-1]
+    #    media_path_s = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE][cfg.PLAYER1][mediaFileIdx_s]
+    #
+    #    mediaFileIdx_e = [idx1 for idx1, x in enumerate(durations) if eventtime_e >= sum(durations[0:idx1])][-1]
+    #    media_path_e = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE][cfg.PLAYER1][mediaFileIdx_e]
+    #
+    #    # calculate time for current media file in case of many queued media files
+    #
+    #    eventtime_onmedia_s = round(eventtime_s - util.float2decimal(sum(durations[0:mediaFileIdx_s])), 3)
+    #    eventtime_onmedia_e = round(eventtime_e - util.float2decimal(sum(durations[0:mediaFileIdx_e])), 3)
+    #
+    #    if media_path_s != media_path_e:
+    #        return
+    #
+    #    media_path = media_path_s
+    #
+    #    # example of external command defined in environment:
+    #    # export BORISEXTERNAL="myprog -i {MEDIA_PATH} -s {START_S} -e {END_S} {DURATION_MS} --other"
+    #
+    #    if "BORISEXTERNAL" in os.environ:
+    #        external_command_template = os.environ["BORISEXTERNAL"]
+    #    else:
+    #        return
+    #
+    #    external_command = external_command_template.format(
+    #        OBS_ID=self.observationId,
+    #        MEDIA_PATH=f'"{media_path}"',
+    #        MEDIA_BASENAME=f'"{os.path.basename(media_path)}"',
+    #        START_S=eventtime_onmedia_s,
+    #        END_S=eventtime_onmedia_e,
+    #        START_MS=eventtime_onmedia_s * 1000,
+    #        END_MS=eventtime_onmedia_e * 1000,
+    #        DURATION_S=eventtime_onmedia_e - eventtime_onmedia_s,
+    #        DURATION_MS=(eventtime_onmedia_e - eventtime_onmedia_s) * 1000,
+    #    )
+    #
+    #    print(external_command)
+    #    """
+    #    p = subprocess.Popen(external_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
+    #    """
+    #    """
+    #    if eventtimeS == eventtimeE:
+    #        q = []
+    #    else:
+    #        durationsec = eventtimeE-eventtimeS
+    #        q = ["--durationmsec",str(int(durationsec*1000))]
+    #    args = [ex, "-f",os.path.abspath(fn),"--seekmsec",str(int(eventtimeS*1000)),*q,*("--size 1 --track 1 --redetect 100")
+    #    .split(" ")]
+    #    if os.path.split(fn)[1].split("_")[0] in set(["A1","A2","A3","A4","A5","A6","A7","A8","A9","A10"]):
+    #        args.append("--flip")
+    #        args.append("2")
+    #    print (os.path.split(fn)[1].split("_")[0])
+    #    print ("running",ex,"with",args,"in",os.path.split(ex)[0])
+    #    #pid = subprocess.Popen(args,executable=ex,cwd=os.path.split(ex)[0])
+    #    """
 
     def no_media(self):
         QMessageBox.warning(self, cfg.programName, "There is no media available")
@@ -3859,10 +3871,8 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         returns frame index for player player_idx
         """
 
-        if not sys.platform.startswith(cfg.MACOS_CODE):
-            estimated_frame_number = self.dw_player[player_idx].player.estimated_frame_number
-        else:
-            estimated_frame_number = observation_operations.send_command({"command": ["get_property", "estimated_frame_number"]})
+        estimated_frame_number = self.dw_player[player_idx].player.estimated_frame_number
+
         if estimated_frame_number is not None:
             return estimated_frame_number
         else:
@@ -3938,7 +3948,8 @@ class MainWindow(QMainWindow, Ui_MainWindow):
             if self.dw_player[0].player.duration is None:
                 return
             video_position = slider_position * self.dw_player[0].player.duration
-            self.dw_player[0].player.command("seek", str(video_position), "absolute")
+            # self.dw_player[0].player.command("seek", str(video_position), "absolute")
+            self.dw_player[0].player.seek(video_position, "absolute")
 
             self.plot_timer_out()
 
@@ -4131,7 +4142,7 @@ class MainWindow(QMainWindow, Ui_MainWindow):
                 self.dw_player[n_player].player.playlist_pos = self.dw_player[n_player].player.playlist_count - 1
                 self.seek_mediaplayer(self.dw_player[n_player].media_durations[-1], player=n_player)
 
-    def mpv_timer_out(self, value: Union[float, None], scroll_slider=True):
+    def mpv_timer_out(self, value: Union[float, None] = None, scroll_slider=True):
         """
         print the media current position and total length for MPV player
         scroll video slider to video position
@@ -4141,13 +4152,17 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         if not self.observationId:
             return
 
+        print("mpv timer out")
+
         cumulative_time_pos = self.getLaps()
+        print(f"{cumulative_time_pos=}")
         # get frame index
         frame_idx = self.get_frame_index()
+        print(f"{frame_idx=}")
         # frame_idx = 0
 
-        if value is None:
-            current_media_time_pos = 0
+        if value is None:  # ipc mpv
+            current_media_time_pos = self.dw_player[0].player.time_pos
         else:
             current_media_time_pos = value
 
@@ -4185,22 +4200,19 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
         ct0 = cumulative_time_pos
 
-        if not sys.platform.startswith(cfg.MACOS_CODE):
-            if self.dw_player[0].player.time_pos is not None:
-                for n_player in range(1, len(self.dw_player)):
-                    ct = self.getLaps(n_player=n_player)
+        if self.dw_player[0].player.time_pos is not None:
+            for n_player in range(1, len(self.dw_player)):
+                ct = self.getLaps(n_player=n_player)
 
-                    # sync players 2..8 if time diff >= 1 s
-                    if (
-                        abs(ct0 - (ct + dec(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO][cfg.OFFSET][str(n_player + 1)])))
-                        >= 1
-                    ):
-                        self.sync_time(n_player, ct0)  # self.seek_mediaplayer(ct0, n_player)
+                # sync players 2..8 if time diff >= 1 s
+                if abs(ct0 - (ct + dec(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO][cfg.OFFSET][str(n_player + 1)]))) >= 1:
+                    self.sync_time(n_player, ct0)  # self.seek_mediaplayer(ct0, n_player)
 
         currentTimeOffset = dec(cumulative_time_pos + self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TIME_OFFSET])
 
         all_media_duration = sum(self.dw_player[0].media_durations) / 1000
         current_media_duration = self.dw_player[0].player.duration  # mediaplayer_length
+
         self.mediaTotalLength = current_media_duration
 
         # current state(s)
@@ -4225,6 +4237,9 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         self.show_current_states_in_subjects_table()
 
         # current media name
+        print(f"{self.dw_player[0].player.playlist_pos=}")
+        print(f"{self.dw_player[0].player.playlist=}")
+
         if self.dw_player[0].player.playlist_pos is not None:
             current_media_name = Path(self.dw_player[0].player.playlist[self.dw_player[0].player.playlist_pos]["filename"]).name
             current_playlist_index = self.dw_player[0].player.playlist_pos
@@ -4300,6 +4315,8 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
             self.actionPlay.setIcon(QIcon(f":/play_{gui_utilities.theme_mode()}"))
 
+        print(f"{msg=}")
+
         if msg:
             self.lb_current_media_time.setText(msg)
 
@@ -4316,14 +4333,6 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
         logging.info("Media end reached")
 
-        """
-        print(f"{self.dw_player[0].player.time_pos=}")
-        print(f"{self.dw_player[0].player.pause=}")
-        print(f"{self.dw_player[0].player.core_idle=}")
-        print(f"{self.dw_player[0].player.eof_reached=}")
-        print(f"{self.dw_player[0].player.playlist_pos=}")
-        """
-
         if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.CLOSE_BEHAVIORS_BETWEEN_VIDEOS]:
             if self.dw_player[0].player.eof_reached and self.dw_player[0].player.core_idle:
                 if self.dw_player[0].player.playlist_pos == len(self.dw_player[0].player.playlist) - 1:
@@ -4593,14 +4602,9 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
             if self.playerType == cfg.MEDIA:
                 # cumulative time
-                if not sys.platform.startswith(cfg.MACOS_CODE):
-                    mem_laps = sum(self.dw_player[n_player].media_durations[0 : self.dw_player[n_player].player.playlist_pos]) + (
-                        0 if self.dw_player[n_player].player.time_pos is None else self.dw_player[n_player].player.time_pos * 1000
-                    )
-                else:
-                    time_pos = observation_operations.send_command({"command": ["get_property", "time-pos"]})
-                    # TODO: fix!
-                    return dec(time_pos)
+                mem_laps = sum(self.dw_player[n_player].media_durations[0 : self.dw_player[n_player].player.playlist_pos]) + (
+                    0 if self.dw_player[n_player].player.time_pos is None else self.dw_player[n_player].player.time_pos * 1000
+                )
 
                 return dec(str(round(mem_laps / 1000, 3)))
 
@@ -5388,6 +5392,18 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         """
         logging.debug("function: closeEvent")
 
+        # close MPV in IPC mode
+        if self.MPV_IPC_MODE:
+            try:
+                for idx, p in enumerate(self.dw_player):
+                    p.player.process.terminate()
+                    try:
+                        p.player.process.wait(timeout=3)  # wait up to 3s
+                    except subprocess.TimeoutExpired:
+                        p.player.process.kill()  # force if still alive
+            except Exception as e:
+                logging.warning(f"Error stopping MPV process #{idx}: {e}")
+
         # check if re-encoding
         if self.processes:
             if (
@@ -5441,6 +5457,8 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         check if first player ended
         """
 
+        print("play_video")
+
         if self.geometric_measurements_mode:
             return
 
@@ -5462,6 +5480,9 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
         self.statusbar.showMessage("", 0)
 
+        if self.ipc_mpv_timer is not None:
+            self.ipc_mpv_timer.start()
+
         self.plot_timer.start()
 
         # start all timer for plotting data
@@ -5493,6 +5514,10 @@ class MainWindow(QMainWindow, Ui_MainWindow):
                     for data_timer in self.ext_data_timer_list:
                         data_timer.stop()
 
+                    if self.ipc_mpv_timer is not None:
+                        self.ipc_mpv_timer.stop()
+                        self.mpv_timer_out()
+
                     player.player.pause = True
 
         self.lb_player_status.setText(msg)
@@ -5542,13 +5567,6 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
             self.update_visualizations()
 
-            # subtitles
-            """
-            st_track_number = 0 if self.config_param[DISPLAY_SUBTITLES] else -1
-            for player in self.dw_player:
-                player.mediaplayer.video_set_spu(st_track_number)
-            """
-
     def jumpForward_activated(self):
         """
         forward from current position
@@ -5666,12 +5684,18 @@ def main():
     ret, msg = util.check_ffmpeg_path()
     if not ret:
         if sys.platform.startswith("win"):
-
             import ctypes
+
             MessageBoxTimeoutW = ctypes.windll.user32.MessageBoxTimeoutW
-            MessageBoxTimeoutW.argtypes = [ctypes.c_void_p, ctypes.c_wchar_p, ctypes.c_wchar_p,
-                                ctypes.c_uint, ctypes.c_uint, ctypes.c_uint]
-            ctypes.windll.user32.MessageBoxTimeoutW(None, "The FFmpeg framework is not available.\nIt will be downloaded from the BORIS GitHub repository.", "FFmpeg", 0, 0, 10000) # time out
+            MessageBoxTimeoutW.argtypes = [ctypes.c_void_p, ctypes.c_wchar_p, ctypes.c_wchar_p, ctypes.c_uint, ctypes.c_uint, ctypes.c_uint]
+            ctypes.windll.user32.MessageBoxTimeoutW(
+                None,
+                "The FFmpeg framework is not available.\nIt will be downloaded from the BORIS GitHub repository.",
+                "FFmpeg",
+                0,
+                0,
+                10000,
+            )  # time out
 
             # if (not options.nosplashscreen):
             #     QMessageBox.warning(
@@ -5684,7 +5708,7 @@ def main():
             logging.info("FFmpeg is not available. It will be downloaded from the BORIS GitHub repository")
 
             # download ffmpeg and ffprobe from https://github.com/boris-behav-obs/boris-behav-obs.github.io/releases/download/files/
-            url:str = "https://github.com/boris-behav-obs/boris-behav-obs.github.io/releases/download/files/"
+            url: str = "https://github.com/boris-behav-obs/boris-behav-obs.github.io/releases/download/files/"
 
             # search where to download ffmpeg
             ffmpeg_dir = Path(__file__).parent / "misc"
@@ -5799,6 +5823,22 @@ def main():
                 results.ptText.appendHtml(f"Some issues were found in the project<br><br>{msg}")
                 results.show()
 
+    # check mpv IPC mode
+    window.MPV_IPC_MODE = False
+    if options.ipc or sys.platform.startswith("darwin"):
+        window.MPV_IPC_MODE = True
+        # check if mpv is available
+        if not shutil.which("mpv"):
+            logging.critical("The mpv command is not available on the path")
+            QMessageBox.critical(
+                None,
+                cfg.programName,
+                ("The mpv command is not available on the path"),
+                QMessageBox.Ok | QMessageBox.Default,
+                QMessageBox.NoButton,
+            )
+            sys.exit()
+
     window.show()
     window.raise_()  # for overlapping widget (?)