def __init__(self, media_stream_descriptor): try: # media descriptor holding input data format self.media_stream_descriptor = media_stream_descriptor # Get how data will be transferred if (self.media_stream_descriptor.WhichOneof( "data_transfer_properties") is None): self.content_transfer_type = TransferType.BYTES elif self.media_stream_descriptor.HasField( "shared_memory_buffer_transfer_properties"): self.content_transfer_type = TransferType.REFERENCE elif self.media_stream_descriptor.HasField( "shared_memory_segments_transfer_properties"): self.content_transfer_type = TransferType.HANDLE # Setup if shared mem used if self.content_transfer_type == TransferType.REFERENCE: # Create shared memory accessor specific to the client self.shared_memory_manager = SharedMemoryManager( name=self.media_stream_descriptor. shared_memory_buffer_transfer_properties.handle_name, size=self.media_stream_descriptor. shared_memory_buffer_transfer_properties.length_bytes, ) else: self.shared_memory_manager = None except: log_exception(get_logger("State")) raise
def __init__(self, rtsp_server): GstRtspServer.RTSPMediaFactory.__init__(self) self._logger = logging.get_logger('GStreamerRtspFactory', is_static=True) self._rtsp_server = rtsp_server if not self._rtsp_server: self._logger.error("GStreamerRtspFactory: Invalid RTSP Server") raise Exception("GStreamerRtspFactory: Invalid RTSP Server")
def __init__(self, pipeline, version, debug=False, parameters=None, input_queue_size=1): self._pipeline = pipeline self._version = version self._input_queue_size = input_queue_size self._logger = get_logger("MediaGraphExtension") self._debug = debug self._parameters = parameters
def __init__(self, identifier, config, model_manager, request, finished_callback, options): # TODO: refactor as abstract interface # pylint: disable=super-init-not-called self.config = config self.identifier = identifier self.pipeline = None self.template = config['template'] self.models = model_manager.models self.model_manager = model_manager self.request = request self.state = Pipeline.State.QUEUED self.frame_count = 0 self.start_time = None self.stop_time = None self.avg_fps = 0 self._gst_launch_string = None self.latency_times = dict() self.sum_pipeline_latency = 0 self.count_pipeline_latency = 0 self._real_base = None self._stream_base = None self._year_base = None self._month_base = None self._day_base = None self._dir_name = None self._bus_connection_id = None self._create_delete_lock = Lock() self._finished_callback = finished_callback self._bus_messages = False self.appsrc_element = None self._app_source = None self.appsink_element = None self._app_destinations = [] self._cached_element_keys = [] self._logger = logging.get_logger('GSTPipeline', is_static=True) self.rtsp_path = None if (not GStreamerPipeline._mainloop): GStreamerPipeline._mainloop_thread = Thread( target=GStreamerPipeline.gobject_mainloop) GStreamerPipeline._mainloop_thread.daemon = True GStreamerPipeline._mainloop_thread.start() if (options.enable_rtsp and not GStreamerPipeline._rtsp_server): GStreamerPipeline._rtsp_server = GStreamerRtspServer( options.rtsp_port) GStreamerPipeline._rtsp_server.start() self.rtsp_server = GStreamerPipeline._rtsp_server self._verify_and_set_rtsp_destination()
def __init__(self, model_dir, network_preference=None, ignore_init_errors=False): self.logger = logging.get_logger('ModelManager', is_static=True) self.model_dir = model_dir self.network_preference = network_preference self.models = defaultdict(dict) self.network_preference = {'CPU': ["FP32"], 'HDDL': ["FP16"], 'GPU': ["FP16"], 'VPU': ["FP16"], 'KMB': ["U8"]} success = self.load_models(self.model_dir, network_preference) if (not ignore_init_errors) and (not success): raise Exception("Error Initializing Models")
def __init__(self, port): self._logger = logging.get_logger('GSTRtspServer', is_static=True) Gst.init(None) self._stopped = False self._port = port self._server = GstRtspServer.RTSPServer() self._server.set_service(str(port)) self._context = None self._mainloop = None self._mount_points = self._server.get_mount_points() self._streams = {} self._thread = None self._factory = GStreamerRtspFactory(self) self._factory.set_shared(True)
def __init__(self, request, pipeline): AppDestination.__init__(self, request, pipeline) self._pipeline = pipeline self._rtsp_path = pipeline.rtsp_path self._rtsp_server = pipeline.rtsp_server self._identifier = pipeline.identifier self._number_frames = 0 self._app_src = None self._is_audio_pipeline = False self._fps = 30 self._logger = logging.get_logger('GStreamerRtspDestination', is_static=True) self._start_time = None self._need_data = False
def validate_config(config): template = config["template"] pipeline = Gst.parse_launch(template) appsink_elements = GStreamerPipeline._get_elements_by_type(pipeline, ["GstAppSink"]) metaconvert = pipeline.get_by_name("metaconvert") metapublish = pipeline.get_by_name("destination") appsrc_elements = GStreamerPipeline._get_elements_by_type(pipeline, ["GstAppSrc"]) logger = logging.get_logger('GSTPipeline', is_static=True) if (len(appsrc_elements) > 1): logger.warning("Multiple appsrc elements found") if len(appsink_elements) != 1: logger.warning("Missing or multiple appsink elements") if metaconvert is None: logger.warning("Missing metaconvert element") if metapublish is None: logger.warning("Missing metapublish element")
def __init__(self, model_manager, pipeline_dir, max_running_pipelines=-1, ignore_init_errors=False): self.max_running_pipelines = max_running_pipelines self.model_manager = model_manager self.running_pipelines = 0 self.pipeline_types = {} self.pipeline_instances = {} self.pipeline_state = {} self.pipeline_id = 0 self.pipelines = {} self.pipeline_queue = deque() self.pipeline_dir = pipeline_dir self.logger = logging.get_logger('PipelineManager', is_static=True) success = self._load_pipelines() if (not ignore_init_errors) and (not success): raise Exception("Error Initializing Pipelines")
def __init__(self, identifier, config, model_manager, request, finished_callback, _unused_options): # TODO: refactor as abstract interface # pylint: disable=super-init-not-called self.config = config self.models = model_manager.models self.model_manager = model_manager self.template = config['template'] self.identifier = identifier self._process = None self.start_time = None self.stop_time = None self._ffmpeg_launch_string = None self.request = request self.state = Pipeline.State.QUEUED self.fps = 0 self._finished_callback = finished_callback self._logger = logging.get_logger('FFmpegPipeline', is_static=True) self._fps_regex = re.compile( r"\s*frame=\s*(?P<frame_count>\d+)\s*fps=\s*(?P<fps>\d+\.?\d*).*" r"time=(?P<duration>\d+:\d+:\d+\.\d+).*speed=\s*(?P<speed>\d+\.\d+)x" ) self._recording_started_regex = re.compile( r"\[segment @ 0x.*?\] Opening '(.*?)' for writing") self._recording_prefix = None self._current_recording = None self._stream_base = None self._real_base = None self._temp_recording_dir = None self._recording_dir = None self._ffmpeg_args = None self._video_filters = None self._inputs = None self._outputs = None self._create_delete_lock = Lock() self._video_filter_index = Counter() self._video_filter_map = {} self._output_format_index = Counter() self._output_format_map = {} self.pipeline_type = "FFmpeg"
''' * Copyright (C) 2019-2020 Intel Corporation. * * SPDX-License-Identifier: BSD-3-Clause ''' from http import HTTPStatus import connexion from vaserving.common.utils import logging from vaserving.vaserving import VAServing logger = logging.get_logger('Default Controller', is_static=True) bad_request_response = 'Invalid pipeline, version or instance' def models_get(): # noqa: E501 """models_get Return supported models # noqa: E501 :rtype: List[ModelVersion] """ try: logger.debug("GET on /models") return VAServing.model_manager.get_loaded_models() except Exception as error: logger.error('pipelines_name_version_get %s', error) return ('Unexpected error', HTTPStatus.INTERNAL_SERVER_ERROR)
def __init__(self): self._logger = logging.get_logger("VAServing", is_static=True) self.options = None self.model_manager = None self.pipeline_manager = None self._stopped = True
#!/usr/bin/env python3 ''' * Copyright (C) 2019-2020 Intel Corporation. * * SPDX-License-Identifier: BSD-3-Clause ''' import sys import connexion from vaserving.common.utils import logging from vaserving.vaserving import VAServing logger = logging.get_logger('main', is_static=True) def main(options): try: app = connexion.App(__name__, port=options.port, specification_dir='rest_api/', server='tornado') app.add_api('video-analytics-serving.yaml', arguments={'title': 'Video Analytics Serving API'}) logger.info("Starting Tornado Server on port: %s", options.port) app.run(port=options.port, server='tornado') except (KeyboardInterrupt, SystemExit): logger.info("Keyboard Interrupt or System Exit") except Exception as error: logger.error("Error Starting Tornado Server: %s", error) VAServing.stop() logger.info("Exiting")
if isinstance(args, dict): args = ["--{}={}".format(key, value) for key, value in args.items() if value] return parser.parse_known_args(args) def append_default_server_args(va_serving_args, max_running_pipelines): va_serving_args.append("--max_running_pipelines") va_serving_args.append(str(max_running_pipelines)) return va_serving_args if __name__ == "__main__": args, va_serving_args = parse_args() logger = get_logger("Main") try: server_args = append_default_server_args( va_serving_args, args.max_running_pipelines ) try: VAServing.start(server_args) except Exception as error: logger.error(error) logger.error("Exception encountered during VAServing start") raise if ( (args.pipeline_name and not args.pipeline_version) or (not args.pipeline_name and args.pipeline_version)
gi.require_version('Gst', '1.0') # pylint: disable=wrong-import-position from gi.repository import Gst from gstgva import VideoFrame from vaserving.common.utils import logging # pylint: enable=wrong-import-position def print_message(message): print("", flush=True) print(message, flush=True) Gst.init(sys.argv) logger = logging.get_logger('videoAnalyticsBridge', is_static=True) class Bridge: # pylint: disable=too-few-public-methods, unused-argument def __init__(self, topic="objects_detected", edgexdevice="videoAnalytics-mqtt", edgexcommand="videoAnalyticsData", edgexresource="videoAnalyticsData", analyticsimage="edgex-vas:latest", containername="edgex-vas", source="rtsp://cam1"): logger.debug('Python Bridge.init() method invoked!') self._topic = 'edgex_bridge/' + topic self._edgex_device = edgexdevice self._edgex_command = edgexcommand
import os import copy from threading import Lock from threading import Thread import gi from gstgva.util import GVAJSONMeta from vaserving.pipeline import Pipeline from vaserving.common.utils import logging # pylint: disable=wrong-import-order, wrong-import-position from gi.repository import Gst gi.require_version('Gst', '1.0') # pylint: enable=wrong-import-order, wrong-import-position logger = logging.get_logger('GSTPipeline', is_static=True) class GStreamerPipeline(Pipeline): Gst.init(None) GVA_INFERENCE_ELEMENT_TYPES = [ "GstGvaDetect", "GstGvaClassify", "GstGvaInference" ] _inference_element_cache = {} _mainloop = None _mainloop_thread = None @staticmethod def gobject_mainloop(): gi.require_version('Gst', '1.0')