Beispiel #1
0
 def _destroy_pdraw(self):
     ret = True
     if self.pdraw_demuxer:
         if not self.pdraw:
             self.logger.error(
                 "Cannot destroy pdraw demuxer: a NULL pdraw session")
             return False
         self.logger.info("destroying pdraw demuxer...")
         res = od.pdraw_demuxer_destroy(self.pdraw, self.pdraw_demuxer)
         if res != 0:
             self.logger.error(f"cannot destroy pdraw demuxer {res}")
             ret = False
         else:
             self.logger.info("pdraw demuxer destroyed")
         self.pdraw_demuxer = od.POINTER_T(od.struct_pdraw_demuxer)()
     if self.pdraw:
         self.logger.info("destroying pdraw...")
         res = od.pdraw_destroy(self.pdraw)
         if res != 0:
             self.logger.error(f"cannot destroy pdraw {res}")
             ret = False
         else:
             self.logger.info("pdraw destroyed")
         self.pdraw = od.POINTER_T(od.struct_pdraw)()
     return ret
Beispiel #2
0
    def listen(self):
        if self._listening:
            self.logger.info("Already listening")
            return True

        res = od.arsdk_publisher_net_new(
            self._backend._backend_net,
            self._thread_loop.pomp_loop,
            ctypes.c_char_p(),
            ctypes.byref(self._publisher_net),
        )
        if res < 0:
            self.logger.error(f"arsdk_publisher_net_new: {res}")
            return False

        res = od.arsdk_backend_net_start_listen(self._backend._backend_net,
                                                ctypes.byref(self._listen_cbs),
                                                self._dcport)
        if res < 0:
            od.arsdk_publisher_net_destroy(self._publisher_net)
            self._publisher_net = od.POINTER_T(od.struct_arsdk_publisher_net)()
            self.logger.error(f"arsdk_backend_net_start_listen: {res}")
            return False

        # start net publisher
        res = od.arsdk_publisher_net_start(
            self._publisher_net, ctypes.byref(self._publisher_net_cfg))
        if res < 0:
            od.arsdk_backend_net_stop_listen(self._backend._backend_net)
            od.arsdk_publisher_net_destroy(self._publisher_net)
            self._publisher_net = od.POINTER_T(od.struct_arsdk_publisher_net)()
            self.logger.error(f"arsdk_publisher_net_start: {res}")
            return False
        self._listening = True
        return True
Beispiel #3
0
    def info(self):
        """
        Returns a dictionary of video frame info
        """
        if self._frame_info is not None:
            return self._frame_info
        frame = self._get_video_frame()
        if not frame:
            return self._frame_info
        ancillary_data = od.POINTER_T(od.struct_mbuf_ancillary_data)()
        self._mbuf.get_ancillary_data(frame,
                                      od.PDRAW_ANCILLARY_DATA_KEY_VIDEOFRAME,
                                      ctypes.byref(ancillary_data))
        pdraw_video_frame_size = ctypes.c_size_t()
        pdraw_video_frame = ctypes.cast(
            od.mbuf_ancillary_data_get_buffer(
                ancillary_data, ctypes.byref(pdraw_video_frame_size)),
            od.POINTER_T(od.struct_pdraw_video_frame),
        )
        assert pdraw_video_frame_size.value == ctypes.sizeof(
            od.struct_pdraw_video_frame)

        # FIXME: workaround bug in pdraw ancillary data API
        frame_type = self._stream["frame_type"]
        pdraw_video_frame_copy = ctypes.pointer(
            self._pdraw_video_frame_storage)
        pdraw_video_frame_copy.contents = pdraw_video_frame.contents
        pdraw_video_frame = pdraw_video_frame_copy
        pdraw_video_frame.contents.format = frame_type
        if frame_type == od.VDEF_FRAME_TYPE_CODED:
            res = self._mbuf_vt[frame_type].get_frame_info(
                self._get_video_frame(),
                pdraw_video_frame.contents.pdraw_video_frame_0.coded,
            )
        else:
            res = self._mbuf_vt[frame_type].get_frame_info(
                self._get_video_frame(),
                pdraw_video_frame.contents.pdraw_video_frame_0.raw,
            )
        if res < 0:
            self.logger.error(
                f"mbuf_raw/coded_video_frame_get_frame_info returned error {res}"
            )
            return self._frame_info

        # convert the binary metadata into json
        self._frame_info = {}
        jsonbuf = ctypes.create_string_buffer(4096)
        res = od.pdraw_video_frame_to_json_str(pdraw_video_frame,
                                               self._vmeta_frame, jsonbuf,
                                               ctypes.sizeof(jsonbuf))
        if res < 0:
            self.logger.error(
                f"pdraw_frame_metadata_to_json returned error {res}")
        else:
            self._frame_info = json.loads(str(jsonbuf.value, encoding="utf-8"))
        return self._frame_info
Beispiel #4
0
 def _pop_stream_buffer(self, id_):
     buf = od.POINTER_T(od.struct_vbuf_buffer)()
     ret = od.vbuf_queue_pop(self.streams[id_]['video_queue'], 0,
                             ctypes.byref(buf))
     if ret < 0:
         if ret != -errno.EAGAIN:
             self.logging.error('vbuf_queue_pop returned error %d' % ret)
         buf = od.POINTER_T(od.struct_vbuf_buffer)()
     elif not buf:
         self.logging.error('vbuf_queue_pop returned NULL')
     return buf
Beispiel #5
0
    def _do_create(self):
        # default userdata callback argument
        self.userdata = ctypes.c_void_p()

        # Create the arsdk_ctrl
        arsdk_ctrl = od.POINTER_T(od.struct_arsdk_ctrl)()
        res = od.arsdk_ctrl_new(self._thread_loop.pomp_loop,
                                ctypes.byref(arsdk_ctrl))
        backend_net = od.POINTER_T(od.struct_arsdkctrl_backend_net)()

        arsdk_ctrl_device_cbs = od.struct_arsdk_ctrl_device_cbs.bind({
            "added":
            self._device_added_cb,
            "removed":
            self._device_removed_cb
        })
        # Send a command to add callbacks to the arsdk_ctrl
        res = od.arsdk_ctrl_set_device_cbs(arsdk_ctrl, arsdk_ctrl_device_cbs)

        if res != 0:
            raise RuntimeError("arsdk_ctrl_set_device_cbs: {}".format(res))

        self.logger.info("device callbacks have been added to arsdk_ctrl")

        # Create the net backend
        cfg = od.struct_arsdkctrl_backend_net_cfg(
            ctypes.create_string_buffer(b"net_config"))
        cfg.stream_supported = 1

        res = od.arsdkctrl_backend_net_new(arsdk_ctrl, ctypes.pointer(cfg),
                                           ctypes.byref(backend_net))

        if res != 0:
            raise RuntimeError("arsdkctrl_backend_net_new: {}".format(res))

        self.logger.debug("New net backend has been created")

        backend_net_socket_callback = od.arsdkctrl_backend_net_socket_cb_t(
            lambda *args: self._socket_cb(*args))

        res_set_socket = od.arsdkctrl_backend_net_set_socket_cb(
            backend_net, backend_net_socket_callback, self.userdata)
        if res_set_socket != 0:
            raise RuntimeError(
                "arsdkctrl_backend_net_set_socket_cb: {}".format(res))

        self.logger.debug("Set backend socket callback OK")

        return (
            arsdk_ctrl,
            arsdk_ctrl_device_cbs,
            backend_net,
            backend_net_socket_callback,
        )
Beispiel #6
0
 def _destroy(self):
     res = od.vbuf_pool_destroy(self.yuv_packed_buffer_pool)
     if res != 0:
         self.logging.logE("Cannot destroy yuv packed buffer pool")
     self.yuv_packed_buffer_pool = od.POINTER_T(od.struct_vbuf_pool)()
     if self.pdraw:
         res = od.pdraw_destroy(self.pdraw)
         if res != 0:
             self.logging.logE("Cannot destroy pdraw object")
     self.pdraw = od.POINTER_T(od.struct_pdraw)()
     self.logging.logI("pdraw destroyed")
     return True
Beispiel #7
0
 def _pop_stream_buffer(self, id_):
     frame_type = self.streams[id_]['frame_type']
     mbuf_video_frame = od.POINTER_T(
         self.video_sink_vt[frame_type].mbuf_video_frame_type)()
     res = self.video_sink_vt[frame_type].queue_pop(
         self.streams[id_]['video_queue'], ctypes.byref(mbuf_video_frame))
     if res < 0:
         if res not in (-errno.EAGAIN, -errno.ENOENT):
             self.logger.error(
                 f"mbuf_coded_video_frame_queue_pop returned error {res}")
         mbuf_video_frame = od.POINTER_T(
             self.video_sink_vt[frame_type].mbuf_video_frame_type)()
     elif not mbuf_video_frame:
         self.logger.error('mbuf_coded_video_frame_queue_pop returned NULL')
     return mbuf_video_frame
Beispiel #8
0
    def _media_removed(self, pdraw, media_info, userdata):
        id_ = media_info.contents.id
        if id_ not in self.streams:
            self.logging.error(
                'Received removed event from unknown ID {}'.format(id_))
            return

        self.logging.info("_media_removed called id : {}".format(id_))

        # FIXME: Workaround media_removed called with destroyed media
        if not self.pdraw:
            self.logging.error(
                "_media_removed called with a destroyed pdraw id : {}".format(
                    id_))
            return
        with self.streams[id_]['video_sink_lock']:
            if self.streams[id_]['video_queue_event']:
                self.callbacks_thread_loop.remove_event_from_loop(
                    self.streams[id_]['video_queue_event'])
                self.streams[id_]['video_queue_event'] = None

            if not self.streams[id_]['video_sink']:
                self.logging.error(
                    'pdraw_video_sink for media_id {} has already been stopped'
                    .format(id_))
                return
            res = od.pdraw_stop_video_sink(pdraw,
                                           self.streams[id_]['video_sink'])
            if res < 0:
                self.logging.error('pdraw_stop_video_sink() returned %s' % res)
            self.streams[id_]['video_queue'] = None
            self.streams[id_]['video_sink'] = od.POINTER_T(
                od.struct_pdraw_video_sink)()
Beispiel #9
0
    def _get_pdraw_video_frame(self):
        if self._yuv_packed_video_frame:
            return self._yuv_packed_video_frame

        if self._pdraw_video_frame:
            return self._pdraw_video_frame

        res = od.vbuf_metadata_get(
            self._buf,
            self._stream['video_sink'],
            od.POINTER_T(ctypes.c_uint32)(),
            od.POINTER_T(ctypes.c_uint64)(),
            ctypes.byref(self._pdraw_video_frame))

        if res < 0:
            self.logging.logE(
                'vbuf_metadata_get returned error {}'.format(res))
            self._pdraw_video_frame = od.POINTER_T(ctypes.c_ubyte)()
            return self._pdraw_video_frame
        self._pdraw_video_frame = ctypes.cast(
            self._pdraw_video_frame, od.POINTER_T(od.struct_pdraw_video_frame))
        if self._stream['type'] == od.PDRAW_VIDEO_MEDIA_FORMAT_H264:
            return self._pdraw_video_frame

        if not self._yuv_packed_buffer:
            res = od.vbuf_pool_get(
                self._yuv_packed_buffer_pool,
                0,
                ctypes.byref(self._yuv_packed_buffer)
            )
            if res < 0:
                self.logging.logE(
                    'vbuf_pool_get returned error {}'.format(res))
                return self._yuv_packed_video_frame
        self._yuv_packed_video_frame = ctypes.pointer(
            self._yuv_packed_video_frame_storage)
        res = od.pdraw_pack_yuv_frame(
            self._pdraw_video_frame,
            self._yuv_packed_video_frame,
            self._yuv_packed_buffer)
        if res < 0:
            self._yuv_packed_video_frame = od.POINTER_T(
                od.struct_pdraw_video_frame)()
            self.logging.logE(
                'pdraw_pack_yuv_frame returned error {}'.format(res))
        return self._yuv_packed_video_frame
Beispiel #10
0
 def __init__(self, logging, buf, media_id, stream, yuv_packed_buffer_pool,
              session_metadata):
     self.logging = logging
     self._buf = buf
     self._media_id = media_id
     self._stream = stream
     self._yuv_packed_buffer_pool = yuv_packed_buffer_pool
     self._session_metadata = session_metadata
     self._pdraw_video_frame = od.POINTER_T(ctypes.c_ubyte)()
     self._frame_pointer = ctypes.POINTER(ctypes.c_ubyte)()
     self._frame_size = 0
     self._frame_array = None
     self._yuv_packed_buffer = od.POINTER_T(od.struct_vbuf_buffer)()
     self._yuv_packed_video_frame_storage = od.struct_pdraw_video_frame()
     self._yuv_packed_video_frame = od.POINTER_T(
         od.struct_pdraw_video_frame)()
     self._frame_info = None
     self._metadata_pointers = []
Beispiel #11
0
 def _on_close_resp_done(self, close_resp_future):
     if close_resp_future.cancelled():
         # FIXME: workaround pdraw closing timeout
         # This random issue is quiet hard to reproduce
         self.logging.error("Closing Pdraw timedout")
         if self.pdraw:
             self.pdraw_thread_loop.run_later(od.pdraw_destroy, self.pdraw)
         self.pdraw = od.POINTER_T(od.struct_pdraw)()
         self.state = PdrawState.Error
         self.logging.error("Pdraw has been closed")
Beispiel #12
0
    def __init__(self, logger, mbuf_video_frame, media_id, stream,
                 session_metadata):
        self.logger = logger
        self._mbuf_video_frame = mbuf_video_frame
        self._media_id = media_id
        self._stream = stream
        self._session_metadata = session_metadata
        self._mbuf = self._mbuf_vt[self._stream["frame_type"]]
        self._frame_pointer = ctypes.c_void_p()
        self._frame_size = ctypes.c_size_t()
        self._frame_array = None
        self._packed_buffer = od.POINTER_T(od.struct_mbuf_mem)()
        self._packed_video_frame = od.POINTER_T(self._mbuf.frame_type)()
        self._frame_info = None

        self._vmeta_frame = od.POINTER_T(od.struct_vmeta_frame)()
        self._metadata_pointers = []

        self._pdraw_video_frame_storage = od.struct_pdraw_video_frame()
Beispiel #13
0
 def __init__(self, backend, ip_addr, device_types=None):
     super().__init__(backend=backend)
     if device_types is None:
         device_types = DEVICE_TYPE_LIST
     self._device_types = device_types
     ctypes_device_type_list = (ctypes.c_int * len(device_types))(*device_types)
     self.discovery_cfg = od.struct_arsdk_discovery_cfg(
         ctypes.cast(ctypes_device_type_list, od.POINTER_T(od.arsdk_device_type)),
         len(ctypes_device_type_list),
     )
     self.ip_addr = ip_addr
Beispiel #14
0
    def _create_discovery(self):
        discovery = od.POINTER_T(od.struct_arsdk_discovery)()

        backendparent = od.arsdkctrl_backend_net_get_parent(self._backend._backend_net)

        res = od.arsdk_discovery_new(
            b"netraw", backendparent, self._backend._arsdk_ctrl, ctypes.byref(discovery)
        )
        if res != 0:
            raise RuntimeError(f"Unable to create raw discovery:{res}")
        return discovery
Beispiel #15
0
def StreamFactory():
    return {
        'id': None,
        'id_userdata': ctypes.c_void_p(),
        'type': od.PDRAW_VIDEO_MEDIA_FORMAT_UNKNOWN,
        'h264_header': None,
        'video_sink': od.POINTER_T(od.struct_pdraw_video_sink)(),
        'video_sink_lock': threading.RLock(),
        'video_queue': None,
        'video_queue_event': None,
    }
Beispiel #16
0
 def _destroy(self):
     if self.pdraw:
         self.logging.info("destroying pdraw...")
         res = od.pdraw_destroy(self.pdraw)
         if res != 0:
             self.logging.error("cannot destroy pdraw {}".format(res))
         else:
             self.logging.info("pdraw destroyed")
     if self.yuv_packed_buffer_pool:
         self.logging.info("destroying yuv buffer pool...")
         res = od.vbuf_pool_destroy(self.yuv_packed_buffer_pool)
         if res != 0:
             self.logging.error(
                 "cannot destroy yuv packed buffer pool: {}".format(res))
         else:
             self.logging.info("yuv buffer pool destroyed")
     self.yuv_packed_buffer_pool = od.POINTER_T(od.struct_vbuf_pool)()
     self.pdraw = od.POINTER_T(od.struct_pdraw)()
     if self.pdraw_thread_loop.stop():
         self.logging.info("pdraw thread loop stopped")
     return True
Beispiel #17
0
 def _pdraw_new(self):
     res = od.pdraw_new(
         self.pomp_loop, self.pdraw_cbs,
         ctypes.cast(ctypes.pointer(ctypes.py_object(self)),
                     ctypes.c_void_p), ctypes.byref(self.pdraw))
     if res != 0:
         self.logger.error(f"Error while creating pdraw interface: {res}")
         self.pdraw = od.POINTER_T(od.struct_pdraw)()
         return False
     else:
         self.logger.info("Pdraw interface has been created")
         return True
Beispiel #18
0
 def _on_close_resp_done(self, close_resp_future):
     if close_resp_future.cancelled():
         # FIXME: workaround pdraw closing timeout
         # This random issue is quiet hard to reproduce
         self.logging.logE("Closing Pdraw timedout")
         if self.pdraw:
             res = od.pdraw_destroy(self.pdraw)
             if res != 0:
                 self.logging.logE("Cannot destroy pdraw object")
         self.pdraw = od.POINTER_T(od.struct_pdraw)()
         self._state = State.Closed
         self.logging.logE("Pdraw has been closed")
Beispiel #19
0
    def init(self, *, pdraw, media_id=0):
        self._pdraw = pdraw
        self._media_id = media_id
        self._pdraw_renderer = od.POINTER_T(od.struct_pdraw_video_renderer)()
        self._render_zone = od.struct_pdraw_rect(0, 0, self.width, self.height)
        self._renderer_params = od.struct_pdraw_video_renderer_params.bind({
            "fill_mode":
            od.PDRAW_VIDEO_RENDERER_FILL_MODE_FIT_PAD_BLUR_EXTEND,
            "enable_transition_flags":
            od.PDRAW_VIDEO_RENDERER_TRANSITION_FLAG_ALL,
            "enable_hmd_distortion_correction":
            0,
            "video_scale_factor":
            1.0,
            "enable_overexposure_zebras":
            0,
            "overexposure_zebras_threshold":
            1.0,
            "enable_histograms":
            0,
            "video_texture_width":
            self.width,
            "video_texture_dar_width":
            self.width,
            "video_texture_dar_height":
            self.height,
        })
        self._media_infos = dict()

        self._renderer_cbs = od.struct_pdraw_video_renderer_cbs.bind({
            "media_added":
            self._media_added_cb,
            "media_removed":
            self._media_removed_cb,
            "render_ready":
            self._render_ready_cb,
            # explicitly set to NULL is important here
            # to disable external texture loading
            "load_texture":
            None,
            "render_overlay":
            None,
        })
        od.pdraw_video_renderer_new(
            self._pdraw.pdraw,
            self._media_id,
            self._render_zone,
            self._renderer_params,
            self._renderer_cbs,
            None,
            ctypes.byref(self._pdraw_renderer),
        )
Beispiel #20
0
 def _destroy_pdraw(self):
     ret = True
     if self.pdraw:
         self.logger.info("destroying pdraw...")
         res = od.pdraw_destroy(self.pdraw)
         if res != 0:
             self.logger.error("cannot destroy pdraw {}".format(res))
             ret = False
         else:
             self.logger.info("pdraw destroyed")
     if self.yuv_packed_buffer_pool:
         self.logger.info("destroying yuv buffer pool...")
         res = od.vbuf_pool_destroy(self.yuv_packed_buffer_pool)
         if res != 0:
             ret = False
             self.logger.error(
                 "cannot destroy yuv packed buffer pool: {}".format(res))
         else:
             self.logger.info("yuv buffer pool destroyed")
     self.yuv_packed_buffer_pool = od.POINTER_T(od.struct_vbuf_pool)()
     self.pdraw = od.POINTER_T(od.struct_pdraw)()
     return ret
Beispiel #21
0
def StreamFactory():
    return {
        'id': None,
        'id_userdata': ctypes.c_void_p(),
        'frame_type': od.VDEF_FRAME_TYPE_UNKNOWN,
        'h264_header': None,
        'track_id': None,
        'metadata_track_id': None,
        'video_sink': None,
        'video_sink_cbs': None,
        'video_sink_lock': threading.RLock(),
        'video_queue': None,
        'video_queue_event': od.POINTER_T(od.struct_pomp_evt)(),
    }
Beispiel #22
0
 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,
     )
Beispiel #23
0
 def __init__(self,
              name=None,
              dcport=44444,
              drone_type=0,
              proto_v_min=1,
              proto_v_max=3):
     self._logger_scope = "device"
     self._dcport = dcport
     self._peer = None
     self._publisher_net = od.POINTER_T(od.struct_arsdk_publisher_net)()
     self._listening = False
     super().__init__(name=name,
                      drone_type=drone_type,
                      proto_v_min=1,
                      proto_v_max=3)
Beispiel #24
0
 def _pdraw_new(self):
     res = od.pdraw_new(
         self.pomp_loop,
         self.cbs,
         ctypes.cast(ctypes.pointer(ctypes.py_object(self)), ctypes.c_void_p),
         ctypes.byref(self.pdraw)
     )
     if res != 0:
         msg = "Error while creating pdraw interface: {}".format(res)
         self.logging.logE(msg)
         self.pdraw = od.POINTER_T(od.struct_pdraw)()
         return False
     else:
         self.logging.logI("Pdraw interface has been created")
         return True
Beispiel #25
0
    def _unrecoverable_error(self, pdraw, demuxer, userdata):
        self.logger.error("_unrecoverable_error() -> pdraw teardown...")
        # remove every video sinks
        for id_ in self.streams:
            self._video_sink_flush_impl(id_)
            self._media_removed_impl(id_)

        # demuxer.close -> demuxer.destroy
        if self.pdraw and self.pdraw_demuxer:
            od.pdraw_demuxer_close(self.pdraw, self.pdraw_demuxer)
            # the demuxer will be destroyed in close_resp
            self.pdraw_demuxer = od.POINTER_T(od.struct_pdraw_demuxer)()
        self.logger.error("_unrecoverable_error() -> pdraw teardown done")

        # we should be good to go again with a Pdraw.play()
        self._state = PdrawState.Created
Beispiel #26
0
 def _open(self, filepath):
     mux = od.POINTER_T(od.struct_mp4_mux)()
     now = ctypes.c_uint64(int(time.time()))
     res = od.mp4_mux_open(
         od.char_pointer_cast(filepath), PDRAW_TIMESCALE, now, now, ctypes.byref(mux)
     )
     if res != 0:
         raise RuntimeError(f"mp4_mux_open returned {res}")
     res = od.mp4_mux_add_file_metadata(
         mux,
         od.char_pointer_cast("com.parrot.olympe.version"),
         od.char_pointer_cast(__version__),
     )
     if res != 0:
         self.logger.error(f"mp4_mux_add_file_metadata returned {res}")
     return mux
Beispiel #27
0
    def _create_discovery(self):
        """
        Start net discovery in order to detect devices
        """
        discovery = od.POINTER_T(od.struct_arsdk_discovery_net)()

        res = od.arsdk_discovery_net_new(
            self._backend._arsdk_ctrl,
            self._backend._backend_net,
            ctypes.pointer(self.discovery_cfg),
            od.char_pointer_cast(self.ip_addr),
            ctypes.byref(discovery),
        )
        if res != 0:
            self._logging.error("arsdk_discovery_net_new: {}".format(res))
            return None
        return discovery
Beispiel #28
0
    def _close_resp(self, pdraw, status, userdata):
        self._close_output_files()
        if status != 0:
            self.logging.error("_close_resp called {}".format(status))
            self._close_resp_future.set_result(False)
            self.state = PdrawState.Error
        else:
            self.logging.info("_close_resp called {}".format(status))
            self.state = PdrawState.Closed
            self._close_resp_future.set_result(True)

        if self.pdraw:
            res = od.pdraw_destroy(self.pdraw)
            if res != 0:
                self.logging.error("Cannot destroy pdraw object")
        self.pdraw = od.POINTER_T(od.struct_pdraw)()
        self._close_resp_future.set_result(True)
Beispiel #29
0
    def _create_command_interface(self, peer):
        """
        Create a command interface to send command to the device
        """

        cmd_itf = od.POINTER_T(od.struct_arsdk_cmd_itf)()

        res = od.arsdk_peer_create_cmd_itf(peer, self._cmd_itf_cbs,
                                           ctypes.pointer(cmd_itf))

        if res != 0:
            self.logger.error(f"Error while creating command interface: {res}")
            cmd_itf = None
        else:
            self.logger.info("Command interface has been created")

        return cmd_itf
Beispiel #30
0
 def _close_resp(self, pdraw, demuxer, status, userdata):
     self._close_output_files()
     if status != 0:
         self.logger.error(f"_close_resp called {status}")
         self._close_resp_future.set_result(False)
         self.state = PdrawState.Error
     else:
         self.logger.debug(f"_close_resp called {status}")
         self.state = PdrawState.Closed
         self._close_resp_future.set_result(True)
     if not self._open_resp_future.done():
         self._open_resp_future.set_result(False)
     if demuxer == self.pdraw_demuxer:
         self.pdraw_demuxer = od.POINTER_T(od.struct_pdraw_demuxer)()
     res = od.pdraw_demuxer_destroy(pdraw, demuxer)
     if res != 0:
         self.logger.error(f"pdraw_demuxer_destroy: {res}")
     else:
         self.logger.debug(f"pdraw_demuxer_destroy: {res}")