def __onLoop(self, loop: bool) -> None:
if self.__player_id is None:
logger.warning("Player action without active player.")
return
self.call_async(
self.project_client.update_player_state(
self.__player_id,
audioproc.PlayerState(loop_enabled=loop)))
def __onToggle(self) -> None:
if self.__player_id is None:
logger.warning("Player action without active player.")
return
self.call_async(
self.project_client.update_player_state(
self.__player_id,
audioproc.PlayerState(playing=not self.__playing)))
async def setup(self) -> None:
self.__player_id, self.__player_realm = await self.project_client.create_player(
audioproc_address=self.audioproc_client.address)
self.__player_status_listener = self.audioproc_client.player_state_changed.add(
self.__player_realm, self.__player_state.updateFromProto)
self.__track_list.setPlayerID(self.__player_id)
self.__player_state.setPlayerID(self.__player_id)
await self.project_client.update_player_state(
self.__player_id,
audioproc.PlayerState(
current_time=self.__player_state.currentTimeProto(),
loop_enabled=self.__player_state.loopEnabled(),
loop_start_time=self.__player_state.loopStartTimeProto(),
loop_end_time=self.__player_state.loopEndTimeProto()))
self.__player_node_id = uuid.uuid4().hex
await self.audioproc_client.add_node(
'root',
id=self.__player_node_id,
child_realm=self.__player_realm,
description=node_db.Builtins.ChildRealmDescription)
await self.audioproc_client.connect_ports(
'root',
self.__player_node_id, 'out:left',
'sink', 'in:left',
node_db.PortDescription.AUDIO)
await self.audioproc_client.connect_ports(
'root',
self.__player_node_id, 'out:right',
'sink', 'in:right',
node_db.PortDescription.AUDIO)
self.__vumeter_node_id = uuid.uuid4().hex
await self.audioproc_client.add_node(
'root',
id=self.__vumeter_node_id,
description=self.project.get_node_description('builtin://vumeter'))
await self.audioproc_client.connect_ports(
'root',
self.__player_node_id, 'out:left',
self.__vumeter_node_id, 'in:left',
node_db.PortDescription.AUDIO)
await self.audioproc_client.connect_ports(
'root',
self.__player_node_id, 'out:right',
self.__vumeter_node_id, 'in:right',
node_db.PortDescription.AUDIO)
self.__vumeter_listener = self.audioproc_client.node_messages.add(
self.__vumeter_node_id, self.__vumeterMessage)
def mouseReleaseEvent(self, evt: QtGui.QMouseEvent) -> None:
if self.__move_time and evt.button() == Qt.LeftButton:
self.__move_time = False
x = evt.pos().x() + self.xOffset()
current_time = min(self.xToTime(x), self.projectEndTime())
if self.shouldSnap(evt):
current_time = self.snapTime(current_time)
self.call_async(
self.project_client.update_player_state(
self.__player_id,
audioproc.PlayerState(
playing=self.__old_player_state,
current_time=current_time.to_proto())))
self.__player_state.setTimeMode(player_state_lib.TimeMode.Follow)
evt.accept()
return
super().mouseReleaseEvent(evt)
def mousePressEvent(self, evt: QtGui.QMouseEvent) -> None:
if (self.__player_id is not None and evt.button() == Qt.LeftButton
and evt.modifiers() in (Qt.NoModifier, Qt.ShiftModifier)):
self.__move_time = True
self.__old_player_state = self.__player_state.playing()
x = evt.pos().x() + self.xOffset()
current_time = self.xToTime(x)
if self.shouldSnap(evt):
current_time = self.snapTime(current_time)
self.call_async(
self.project_client.update_player_state(
self.__player_id, audioproc.PlayerState(playing=False)))
self.__player_state.setTimeMode(player_state_lib.TimeMode.Manual)
self.__player_state.setCurrentTime(current_time)
evt.accept()
return
super().mousePressEvent(evt)
def setCurrentTime(
self, current_time: audioproc.MusicalTime, from_engine: bool = False) -> None:
if current_time == self.__current_time:
return
self.__current_time = current_time
if (self.__last_current_time_update is None
or time_lib.time() - self.__last_current_time_update > 5):
self.__set_session_value('current_time', current_time)
self.__last_current_time_update = time_lib.time()
if not from_engine:
self.call_async(
self.project_client.update_player_state(
self.__player_id,
audioproc.PlayerState(current_time=current_time.to_proto())))
self.currentTimeChanged.emit(current_time)
async def test_playback_demo(self):
p = player.Player( # type: ignore[call-arg]
project=self.project,
callback_address=self.callback_server.address,
event_loop=self.loop,
audioproc_client=self.audioproc_client_main,
realm='root')
try:
logger.info("Setup player...")
await p.setup()
logger.info("Player setup complete.")
logger.info("Wait until audioproc is ready...")
# self.assertEqual(
# await self.callback_server.wait_for('pipeline_state'), 'starting')
# self.assertEqual(
# await self.callback_server.wait_for('pipeline_state'), 'running')
with self.track_frame_stats('playback_demo'):
logger.info("Start playback...")
await p.update_state(audioproc.PlayerState(playing=True))
await self.callback_server.wait_for_player_state(
'playing', True)
logger.info("Waiting for end...")
await self.callback_server.wait_for_player_state(
'playing', False)
logger.info("Playback finished.")
except:
logger.exception("")
raise
finally:
await p.cleanup()
def onSetLoopEnd(self, loop_end_time: audioproc.MusicalTime) -> None:
self.call_async(
self.project_client.update_player_state(
self.__player_id,
audioproc.PlayerState(loop_end_time=loop_end_time.to_proto())))
async def run(self) -> None:
try:
await self.__setup_callback_stub()
await self.__callback.call(
'STATE', render_pb2.RenderStateRequest(state='setup'))
await self.__setup_data_pump()
await self.__setup_encoder_process()
await self.__setup_datastream_pipe()
await self.__setup_player()
await self.__callback.call(
'STATE', render_pb2.RenderStateRequest(state='render'))
response = render_pb2.RenderProgressResponse()
await self.__callback.call(
'PROGRESS',
render_pb2.RenderProgressRequest(numerator=0, denominator=1),
response)
if response.abort:
self.__fail("Aborted.")
await self.__player.update_state(
audioproc.PlayerState(
playing=True,
loop_enabled=False,
current_time=audioproc.MusicalTime(0).to_proto()))
await self.__player_started.wait()
await self.__setup_progress_pump()
await self.__wait_for_some(
asyncio.wait([
self.__datastream_protocol.wait(),
self.__progress_pump_task,
self.__encoder.wait()
],
loop=self.__event_loop), self.__failed.wait())
if self.__failed.is_set():
raise RendererFailed()
self.__data_queue.put_nowait(None)
await asyncio.wait([self.__data_pump_task], loop=self.__event_loop)
await self.__callback.call(
'PROGRESS',
render_pb2.RenderProgressRequest(numerator=1, denominator=1),
render_pb2.RenderProgressResponse())
await self.__callback.call(
'STATE', render_pb2.RenderStateRequest(state='cleanup'))
await self.__player.cleanup()
self.__player = None
await self.__callback.call(
'STATE', render_pb2.RenderStateRequest(state='complete'))
except RendererFailed:
await self.__callback.call(
'STATE', render_pb2.RenderStateRequest(state='failed'))
finally:
await self.__cleanup()
