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')
