def _select_demuxer_media(self, pdraw, media, count, userdata):
# by default select the default media (media_id=0)
selected_media_id = 0
selected_media_idx = 0
for idx in range(count):
self.logger.info(
"_select_demuxer_media: "
"idx={} media_id={} name={} default={}".format(
idx, media[idx].media_id,
od.string_cast(media[idx].name),
str(bool(media[idx].is_default)))
)
if (self.media_name is not None and
self.media_name == od.string_cast(media[idx].name)):
selected_media_id = media[idx].media_id
selected_media_idx = idx
if (
self.media_name is not None and
od.string_cast(media[selected_media_idx].name) != self.media_name
):
self.logger.warning(
"media_name {} is unavailable. "
"Selecting the default media instead".format(self.media_name)
)
return selected_media_id
def _select_media(self, pdraw, demuxer, medias, count, userdata):
# by default select the default media (media_id=0)
selected_media_id = 0
selected_media_idx = 0
default_media_id = 0
default_media_idx = 0
for idx in range(count):
self.logger.info(f"_select_media: "
f"idx={idx} media_id={medias[idx].media_id} "
f"name={od.string_cast(medias[idx].name)} "
f"default={str(bool(medias[idx].is_default))}")
if bool(medias[idx].is_default):
default_media_id = medias[idx].media_id
default_media_idx = idx
if (self.media_name is not None
and self.media_name == od.string_cast(medias[idx].name)):
selected_media_id = medias[idx].media_id
selected_media_idx = idx
if (self.media_name is not None and od.string_cast(
medias[selected_media_idx].name) != self.media_name):
default_media_name = od.string_cast(medias[default_media_idx].name)
self.logger.warning(
f"media_name {self.media_name} is unavailable. "
f"Selecting the default media instead: {default_media_name}")
self.session_metadata = od.struct_vmeta_session.as_dict(
medias[default_media_idx].session_meta)
else:
self.session_metadata = od.struct_vmeta_session.as_dict(
medias[selected_media_idx].session_meta)
if selected_media_id:
return 1 << selected_media_id
elif default_media_id:
return 1 << default_media_id
else:
return 0
def _canceled_cb(self, _arsdk_peer, arsdk_peer_info, reason, _user_data):
reason = od.string_cast(od.arsdk_conn_cancel_reason_str(reason))
peer_name = od.string_cast(arsdk_peer_info.contents.ctrl_name)
self.logger.info(f"Connection to peer: {peer_name} has been canceled "
f"for reason: {reason}")
if self._connect_future is not None:
self._connect_future.set_result(False)
self._thread_loop.run_later(self._on_device_removed)
def _canceled_cb(self, _arsdk_device, arsdk_device_info, reason, _user_data):
"""
Notify connection cancellation. Either because 'disconnect' was
called before 'connected' callback or remote aborted/rejected the
request.
"""
device_name = od.string_cast(arsdk_device_info.contents.name)
reason = od.string_cast(
od.arsdk_conn_cancel_reason_str(reason))
self.logger.info(
f"Connection to device: {device_name} has been canceled for reason: {reason}")
if self._connect_future is not None and not self._connect_future.done():
self._connect_future.set_result(False)
self._thread_loop.run_later(self._on_device_removed)
def from_arsdk_peer(cls, arsdk_peer):
peer_info = od.POINTER_T(od.struct_arsdk_peer_info)()
res = od.arsdk_peer_get_info(arsdk_peer, ctypes.byref(peer_info))
if res < 0 or not peer_info:
raise RuntimeError(f"Failed to get peer info: {res}")
peer_info = peer_info.contents
return cls(
ctrl_name=od.string_cast(peer_info.ctrl_name),
ctrl_type=od.string_cast(peer_info.ctrl_type),
ctrl_addr=od.string_cast(peer_info.ctrl_addr),
device_id=od.string_cast(peer_info.device_id),
proto_v=int(peer_info.proto_v),
json=od.string_cast(peer_info.json),
arsdk_peer=arsdk_peer,
)
def from_arsdk_device(cls, backend, device):
device_info = ctypes.POINTER(od.struct_arsdk_device_info)()
res = od.arsdk_device_get_info(device, ctypes.pointer(device_info))
if res != 0:
raise RuntimeError(f"Failed to get device info: {res}")
return DeviceInfo(
serial=od.string_cast(device_info.contents.id) or "",
name=od.string_cast(device_info.contents.name) or "",
device_type=int(device_info.contents.type),
ip_addr=od.string_cast(device_info.contents.addr) or "",
port=int(device_info.contents.port),
proto_v=int(getattr(device_info.contents, "proto_v", 1)),
state=DeviceState(device_info.contents.state),
json=od.string_cast(device_info.contents.json) or "",
arsdk_device=device,
backend=backend,
)
def _disconnected_cb(self, _arsdk_peer, arsdk_peer_info, _user_data):
peer_name = od.string_cast(arsdk_peer_info.contents.ctrl_name)
self.logger.info(f"Disconnected from peer: {peer_name}")
self.connected = False
if self._disconnect_future is not None:
self._disconnect_future.set_result(True)
self._thread_loop.run_later(self._on_device_removed)
def _connected_cb(self, _arsdk_device, arsdk_device_info, _user_data):
"""
Notify connection completion.
"""
device_name = od.string_cast(arsdk_device_info.contents.name)
self.set_device_name(device_name)
self.logger.info(f"Connected to device: {device_name}")
json_info = od.string_cast(arsdk_device_info.contents.json)
try:
json_info = json.loads(json_info)
self.logger.info(pprint.pformat(json_info))
except ValueError:
self.logger.error(f'json contents cannot be parsed: {json_info}')
self.connected = True
if self._connect_future is not None and not self._connect_future.done():
self._connect_future.set_result(True)
def _disconnected_cb(self, _arsdk_device, arsdk_device_info, _user_data):
"""
Notify disconnection.
"""
device_name = od.string_cast(arsdk_device_info.contents.name)
self.logger.info(f"Disconnected from device: {device_name}")
self.connected = False
if self._disconnect_future is not None and not self._disconnect_future.done():
self._disconnect_future.set_result(True)
self._thread_loop.run_later(self._on_device_removed)
def _connected_cb(self, arsdk_peer, arsdk_peer_info, _user_data):
peer_name = od.string_cast(arsdk_peer_info.contents.ctrl_name)
self.logger.info(f"Connected to peer: {peer_name}")
self._cmd_itf = self._create_command_interface(arsdk_peer)
if self._cmd_itf is None:
msg = f"Unable to create command interface: {peer_name}"
self.logger.error(msg)
self._thread_loop.run_later(self._disconnection_impl)
self.connected = True
if self._connect_future is not None:
self._connect_future.set_result(True)
def _connecting_cb(self, _arsdk_device, arsdk_device_info, _user_data):
"""
Notify connection initiation.
"""
device_name = od.string_cast(arsdk_device_info.contents.name)
self.logger.info(f"Connecting to device: {device_name}")
