def __init__(self, port, width, height, IS_DEBUG):
port_str = str(port)
self.is_push_buffer_allowed = False
self.port = port
self.url = f"http://127.0.0.1:{port}/fitness"
self.pipe = None
self.IS_DEBUG = IS_DEBUG
self.server = GstRtspServer.RTSPServer().new()
self.server.set_service(port_str)
self.server.connect("client-connected", self.client_connected)
self.f = GstRtspServer.RTSPMediaFactory().new()
self.f.set_eos_shutdown(True)
if self.IS_DEBUG == 0:
self.f.set_launch(get_pipe(width, height))
else:
self.f.set_launch(get_pipe_test(width, height))
self.f.set_shared(True)
self.f.connect("media-constructed", self.on_media_constructed)
m = self.server.get_mount_points()
m.add_factory("/fitness", self.f)
self.server.attach(None)
logger.info(f"[RTSP] ready at {self.url}")
def make_server(launch: str, port: int = 8554, url: str = '/test'):
# GObject.type_register(Factory)
# loop = GLib.MainLoop()
rtsp = GstRtspServer.RTSPServer()
rtsp.set_service(str(port))
#g_object_set(server, "service", port, NULL);
mp = rtsp.get_mount_points()
factory = GstRtspServer.RTSPMediaFactory()
factory.set_launch(launch)
# str(GstBuilder(
# 'tcambin name=source',
# '\'video/x-raw,format=RGBx,width=1280,height=720,framerate=(fraction)60/1\''
# #'capsfilter name=filter',
# 'videoconvert',
# '\'video/x-raw,format=I420\'',
# 'videoconvert',
# 'x264enc qp-min=18 speed-preset=superfast ! h264parse ! rtph264pay name=pay0 pt=96 config-interval=1'
# )))
factory.set_shared(True)
# mf = factory.g_type_instance
mp.add_factory(url, factory)
mp = None
rtsp.attach(None)
media = factory.construct(url)
media.set_reusable(True)
return media.pipeline
def _add_media(self, file_path, directory_root):
file = directory_root / file_path[1:]
if not vstreamer_utils.is_video_file(file):
raise ValueError("'%s' is not a valid video file" % str(file))
demuxer = VideoServer._corresponding_demuxer(file)
pipeline = "filesrc location=\"%s\" ! %s name=dmux " \
"dmux.video_0 ! queue ! rtph264pay name=pay0 pt=96 " \
"dmux.audio_0 ! queue ! rtpmp4apay name=pay1" % (file, demuxer)
factory = GstRtspServer.RTSPMediaFactory()
factory.set_launch(pipeline)
factory.set_shared(True)
encoded = urllib.parse.quote(file_path)
self.server.get_mount_points().add_factory(encoded, factory)
vstreamer_utils.log_info("Added '%s' to video server mount points" % str(file_path))
def __call__(self):
self.server = GstRtspServer.RTSPServer()
self.server.set_service(self.port)
self.server.set_address(self.ip)
self.factory = GstRtspServer.RTSPMediaFactory()
self.factory.set_launch("( {} )".format(self.pipeline))
self.factory.set_shared(True)
self.factory.props.latency = 50
self.server.get_mount_points().add_factory("/{}".format(self.mount), self.factory)
self.server_id = self.server.attach(None)
if self.server_id == 0:
logging.debug("Return value: {}".format(self.server_id))
logging.debug("SNAFU. Exiting...")
sys.exit(-1)
logging.info("stream ready at rtsp://{}:{}/{}".format(self.server.get_address(),
self.server.get_service(),
self.mount))
def __init__(self, port, width, height, fps, device_path):
port_str = str(port)
pipe = get_pipeline(width, height, fps)
self.pipe = None
self.server = GstRtspServer.RTSPServer().new()
self.server.set_service(port_str)
self.server.connect("client-connected", self.client_connected)
self.f = GstRtspServer.RTSPMediaFactory().new()
self.f.set_eos_shutdown(True)
self.f.set_launch(pipe)
self.f.set_shared(True)
self.f.connect("media-constructed", self.on_media_constructed)
self.device_path = device_path
m = self.server.get_mount_points()
m.add_factory(DEFAULT_URI, self.f)
self.server.attach(None)
def runServer(self):
self.logger.info("Server wird gestartet")
self.__ml = GLib.MainLoop()
self.__srv = GstRtspServer.RTSPServer()
self.__srv.connect("client-connected", self.client_connected_call)
mounts = self.__srv.get_mount_points()
self.__fac = GstRtspServer.RTSPMediaFactory()
self.__srv.set_address("0.0.0.0")
self.__fac.set_shared(True)
# Bitrate * Sekunden // 8
self.__fac.set_buffer_size((17000000 * 1 // 8)) # was // 8 )/2)
self.__fac.set_latency(250)
self.__fac.set_launch(
'( filesrc location=/tmp/motion-gst-pipe do-timestamp=true ! video/x-h264, framerate={}/1 ! h264parse ! rtph264pay name=pay0 pt=96 )'
.format(self._fps))
mounts.add_factory("/h264", self.__fac)
self.__srv.attach(None)
self.__ml.run()
self.logger.info("Server beendet")
def __init__(self,ip="0.0.0.0",port="8554",factory="/test",
gst_str=" videotestsrc ! x264enc ! rtph264pay name=pay0 pt=96 "):
self.server = GstRtspServer.RTSPServer.new()
self.address = ip
self.port = port
self.launch_description = gst_str
self.server.set_address(self.address)
self.server.set_service(self.port)
self.server.connect("client-connected", self.client_connected)
self.factory = GstRtspServer.RTSPMediaFactory().new()
self.factory.set_launch(self.launch_description)
#self.factory.set_latency(0)
self.factory.set_shared(True)
#self.factory.set_transport_mode(GstRtspServer.RTSPTransportMode.PLAY)
self.mount_points = self.server.get_mount_points()
self.mount_points.add_factory(factory, self.factory)
self.server.attach(None)
print('Stream ready')
def addMedia(self, videos, bitrate, framerate, path):
'''
Add videos to the server.
:param list videos: List of available videos.
:param int bitrate: The bitrate (in kbps).
:param int framerate: The framerate (in fps).
:param string path: Path to the video directory.
'''
for i, video in enumerate(videos):
for codec, items in supported_codecs.iteritems():
launch = 'filesrc location=%s/%s ! decodebin ! videorate ! video/x-raw,framerate=%s/1 ! %s bitrate=%s ! %s name=pay0' % (
path, video, framerate, items['encoder'],
items['bitrate_from_kbps'](bitrate), items['rtppay'])
pool = GstRtspServer.RTSPAddressPool()
pool.add_range("224.3.0.0", "224.3.0.10", 5000, 5010, 10)
factory = GstRtspServer.RTSPMediaFactory()
factory.set_address_pool(pool)
factory.set_launch(launch)
factory.set_shared(True)
factory.set_eos_shutdown(True)
name = '/video%s.' % (i) + codec
self.server.get_mount_points().add_factory(name, factory)
def main(args):
config_path = args.config_path
parser = ConfigObj(config_path)
file_location = parser['file_location']
rstp_host = parser['host']
rstp_port = parser['port']
factory_name = parser['factory_name']
Gst.init(None)
mainloop = GObject.MainLoop()
server = GstRtspServer.RTSPServer.new()
server.set_address(rstp_host)
server.set_service(rstp_port)
mounts = server.get_mount_points()
factory = GstRtspServer.RTSPMediaFactory()
factory.set_launch(
'filesrc location =%s ! qtdemux ! h264parse config-interval=-1 ! rtph264pay pt=96 config-interval=-1 name=pay0'
% (file_location))
factory.set_shared(True)
factory.set_buffer_size(4294967295)
#factory.set_protocols(GstRtsp.RTSPLowerTrans(1))
#factory.set_transport_mode(GstRtspServer.RTSPTransportMode.PLAY)
mounts.add_factory(factory_name, factory)
server.attach(None)
print("Stream ready at rtsp://%s:%s%s" %
(rstp_host, rstp_port, factory_name))
mainloop.run()
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
import gi
gi.require_version('Gst', '1.0')
from gi.repository import GObject, Gst, GstVideo, GstRtspServer
Gst.init(None)
mainloop = GObject.MainLoop()
server = GstRtspServer.RTSPServer()
mounts = server.get_mount_points()
factory = GstRtspServer.RTSPMediaFactory()
factory.set_launch(
'( videotestsrc is-live=1 ! x264enc speed-preset=ultrafast tune=zerolatency ! rtph264pay name=pay0 pt=96 )'
)
mounts.add_factory("/test", factory)
server.attach(None)
print "stream ready at rtsp://127.0.0.1:8554/test"
mainloop.run()
