def createLiveContext(self):
"""Creates a LiveConnectionContext and registers it to LiveThread
"""
self.ctx = core.LiveConnectionContext()
self.ctx.slot = self.slot
if (self.address.find("rtsp://") == 0):
self.ctx.connection_type = core.LiveConnectionType_rtsp
else:
self.ctx.connection_type = core.LiveConnectionType_sdp
self.ctx.address = self.address
self.ctx.framefilter = self.fork # writes to self.fork
self.ctx.msreconnect = self.msreconnect
# some extra parameters
"""
ctx.time_correction =TimeCorrectionType::none;
ctx.time_correction =TimeCorrectionType::dummy;
default time correction is smart
ctx.recv_buffer_size=1024*1024*2; // Operating system ringbuffer size for incoming socket
ctx.reordering_time =100000; // Live555 packet reordering treshold time (microsecs)
"""
if (self.time_correction is not None):
self.ctx.time_correction = self.time_correction
self.ctx.recv_buffer_size = self.recv_buffer_size
self.ctx.reordering_time = self.reordering_mstime * 1000 # from millisecs to microsecs
# send the information about the stream to LiveThread
self.livethread.registerStream(self.ctx)
self.livethread.playStream(self.ctx)
def createContext(self):
"""Creates a LiveConnectionContext and registers it to LiveThread
"""
# define stream source, how the stream is passed on, etc.
self.ctx=core.LiveConnectionContext()
self.ctx.slot=self.slot # slot number identifies the stream source
if (self.address.find("rtsp://")==0):
self.ctx.connection_type=core.LiveConnectionType_rtsp
else:
self.ctx.connection_type=core.LiveConnectionType_sdp # this is an rtsp connection
self.ctx.address=self.address
# stream address, i.e. "rtsp://.."
self.ctx.framefilter=self.av_in_filter
self.ctx.msreconnect=self.msreconnect
# some extra parameters
"""
// ctx.time_correction =TimeCorrectionType::none;
// ctx.time_correction =TimeCorrectionType::dummy;
// default time correction is smart
// ctx.recv_buffer_size=1024*1024*2; // Operating system ringbuffer size for incoming socket
// ctx.reordering_time =100000; // Live555 packet reordering treshold time (microsecs)
"""
if (self.time_correction!=None): self.ctx.time_correction =self.time_correction
self.ctx.recv_buffer_size =self.recv_buffer_size
self.ctx.reordering_time =self.reordering_mstime*1000 # from millisecs to microsecs
# send the information about the stream to LiveThread
self.livethread.registerStream(self.ctx)
self.livethread.playStream(self.ctx)
def createLiveContext(self):
"""Context for LiveThread
Creates & registers a context to LiveThread and connects it to the main filterchain
Parameters required:
::
self.slot
self.address
self.msreconnect
self.time_correction
self.recv_buffer_size
self.reordering_mstime
"""
self.ctx = core.LiveConnectionContext()
self.ctx.slot = self.slot
if (self.address.find("rtsp://") == 0):
self.ctx.connection_type = core.LiveConnectionType_rtsp # rtsp connection
else:
self.ctx.connection_type = core.LiveConnectionType_sdp # an sdp file
if (self.request_tcp):
self.ctx.request_tcp = self.request_tcp
self.ctx.address = self.address
# stream address, i.e. "rtsp://.."
self.ctx.msreconnect = self.msreconnect
self.ctx.recv_buffer_size = self.recv_buffer_size
self.ctx.reordering_time = self.reordering_mstime * 1000 # from millisecs to microsecs
self.ctx.time_correction = self.time_correction
if self.ctx.time_correction == core.TimeCorrectionType_smart:
print("createLiveContext: smart timestamps")
else:
print("createLiveContext: dummy timestamps")
# connect to the main filterchain
self.ctx.framefilter = self.fork_filter_main
# send the information about the stream to LiveThread
self.livethread.registerStream(self.ctx)
self.livethread.playStream(self.ctx)
def createContext(self):
"""
Creates a LiveConnectionContext and registers it to LiveThread
"""
# Define the stream source, how the stream is passed on, etc
self.ctx = core.LiveConnectionContext()
# slot number identifies the stream source
self.ctx.slot = self.slot
if (self.address.find("rtsp://")) == 0:
self.ctx.connection_type = core.LiveConnectionType_rtsp
else:
self.ctx.connection_type = core.LiveConnectionType_sdp
self.ctx.address = self.address
self.ctx.framefilter = self.fork_filter
self.ctx.msreconnect = self.msreconnect
# some extra parameters
"""
// ctx.time_correction =TimeCorrectionType::none;
// ctx.time_correction =TimeCorrectionType::dummy;
// default time correction is smart
// ctx.recv_buffer_size=1024*1024*2; // Operating system ringbuffer size for incoming socket
// ctx.reordering_time =100000; // Live555 packet reordering treshold time (microsecs)
"""
if (self.time_correction is not None):
self.ctx.time_correction = self.time_correction
# self.time_correction = core.TimeCorrectionType_smart # default
self.ctx.recv_buffer_size = self.recv_buffer_size
self.ctx.reordering_time = self.reordering_mstime * 1000
# send information about the stream to livethread
self.livethread.registerStream(self.ctx)
self.livethread.playStream(self.ctx)
self.mux_filter.activate()
def createContext(self):
"""Creates a LiveConnectionContext and registers it to LiveThread.
"""
# define stream source, how the stream is passed on, etc.
self.ctx = core.LiveConnectionContext()
self.ctx.slot = self.slot # slot number identifies the stream source
if (self.address.find("rtsp://") == 0):
self.ctx.connection_type = core.LiveConnectionType_rtsp
else:
self.ctx.connection_type = core.LiveConnectionType_sdp # this is an rtsp connection
self.ctx.address = self.address
# stream address, i.e. "rtsp://.."
self.ctx.framefilter = self.fork
self.ctx.msreconnect = self.msreconnect
# send the information about the stream to LiveThread
self.incoming_livethread.registerStream(self.ctx)
self.incoming_livethread.playStream(self.ctx)
def setLiveContext(self,address):
"""
The user is responsible for:
self.livethread.registerStream(self.ctx)
self.livethread.playStream(self.ctx)
self.livethread.stopStream(self.ctx)
self.livethread.deregisterStream(self.ctx)
"""
self.live_ctx=core.LiveConnectionContext()
self.live_ctx.slot=self.slot # slot number identifies the stream source
if (address.find("rtsp://")==0):
self.live_ctx.connection_type=core.LiveConnectionType_rtsp
else:
self.live_ctx.connection_type=core.LiveConnectionType_sdp # this is an rtsp connection
self.live_ctx.address=address
# stream address, i.e. "rtsp://.."
self.live_ctx.framefilter=self.av_in_filter
self.live_ctx.msreconnect=self.msreconnect # if no frames received in this time, attempt to reconnect
print(" Core loaded from ", core.__file__)
"""Test instantiation of some objects
"""
print()
print(" Testing Valkka classes")
live = core.LiveThread("live")
# inp =core.FrameFifo("fifo") # in the API no more
# ff =core.FifoFrameFilter("fifo",inp)
out = core.DummyFrameFilter("dummy")
av = core.AVThread("av", out)
gl = core.OpenGLThread("gl")
av_in = av.getFrameFilter()
gl_in = gl.getFrameFilter()
ctx = core.LiveConnectionContext()
ctx.slot = 1
ctx.connection_type = core.LiveConnectionType_rtsp
ctx.address = "rtsp://*****:*****@192.168.0.157"
ctx2 = core.LiveConnectionContext(core.LiveConnectionType_rtsp,
"rtsp://*****:*****@192.168.0.157", 1, out)
print(" Valkka classes ok")
print()
# this is modified automatically by setver.bash - don't touch!
VERSION_MAJOR = 0
VERSION_MINOR = 16
VERSION_PATCH = 0
print("Checking Valkka python examples")
print(" version:",
def __call__(self, livethread=None, openglthread=None):
"""
Register running live & openglthreads, construct filterchain, start threads
"""
assert (livethread is not None)
self.livethread = livethread
self.openglthread = openglthread
# Construct Filter graph from end to beginning
# Main branch
self.main_fork = core.ForkFrameFilterN("main_fork" + str(self.slot))
# connect livethread to main branch
self.live_ctx = core.LiveConnectionContext(
core.LiveConnectionType_rtsp, self.rtsp_address, self.slot,
self.main_fork) # stream rights to main_fork
# Some aditional parameters you can give to livethread streaming context
## 1 : for NATs and Streaming over the internet, use tcp streaming
self.live_ctx.request_tcp = True
## 2 : if you don't have enough buffering or timestamps are wrong, use this:
# self.live_ctx.time_correction = core.TimeCorrectionType_smart
## 3 : enable automatic reconnection every 10 seconds if camera is offline
self.live_ctx.mstimeout = 10000
self.livethread.registerStreamCall(self.live_ctx)
# Branch B : Mux Branch
self.fmp4_shmem = core.FragMP4ShmemFrameFilter(
self.fmp4_shmem_name, self.fmp4_shmem_buffers,
self.fmp4_shmem_cellsize)
print(">", self.fmp4_sync_event)
self.fmp4_shmem.useFd(self.fmp4_sync_event)
self.fmp4_muxer = core.FragMP4MuxFrameFilter("mp4_muxer",
self.fmp4_shmem)
# self.fmp4_muxer.activate()
# connect main branch to mux branch
self.main_fork.connect("fragmp4_terminal" + str(self.slot),
self.fmp4_muxer)
# muxer must be connected from the very beginning so that it receives setupframes, sent only in the beginning of streaming process
# Branch A : Decoding Branch
self.decode_fork = core.ForkFrameFilterN("decode_fork_" +
str(self.slot))
self.avthread = core.AVThread(
"avthread_" + str(self.slot),
self.decode_fork) # Here avthread feeds decode_fork
# connect main branch to avthread to decode_fork
self.avthread_in_filter = self.avthread.getFrameFilter()
self.main_fork.connect("decoder_" + str(self.slot),
self.avthread_in_filter)
# Branch A : Sub_Branch_A.1 : RGB shared memory
self.rgb_shmem_filter = core.RGBShmemFrameFilter(
self.rgb_shmem_name, self.rgb_shmem_buffers, self.width,
self.height)
self.rgb_shmem_filter.useFd(self.rgb_sync_event)
self.sws_filter = core.SwScaleFrameFilter("sws_filter", self.width,
self.height,
self.rgb_shmem_filter)
self.interval_filter = core.TimeIntervalFrameFilter(
"interval_filter", self.image_interval, self.sws_filter)
self.decode_fork.connect("rgb_shmem_terminal" + str(self.slot),
self.interval_filter)
# Branch A : Sub_Branch_A.2 : OpenGl branch Displaying
if self.openglthread is not None:
# connect decode frames in opengl
self.opengl_input_filter = self.openglthread.getFrameFilter()
self.decode_fork.connect("gl_terminal" + str(self.slot),
self.opengl_input_filter)
# Create X window
#
# win_id = self.openglthread.createWindow(show=False)
# frame = QtFrame(self.widget, win_id)
# self.lay.addWidget(frame.widget, 0, 0)
#
# token = self.openglthread.connect(slot=self.slot, window_id=win_id)
# if token == 0:
# print("mapping failled ! ")
# else:
# print("mapping done ! ")
self.window_id = self.openglthread.createWindow()
self.openglthread.newRenderGroupCall(self.window_id)
self.context_id = self.openglthread.newRenderContextCall(
self.slot, self.window_id, 0)
self.livethread.playStreamCall(self.live_ctx)
self.avthread.startCall()
self.avthread.decodingOnCall()
