def makeChain(self):
"""Create the filterchains
"""
self.fork = core.ForkFrameFilterN("fork_" + str(self.slot))
self.fork_yuv = core.ForkFrameFilterN("fork_yuv_" + str(self.slot))
self.framefifo_ctx = core.FrameFifoContext()
self.framefifo_ctx.n_basic = self.n_basic
self.framefifo_ctx.n_setup = self.n_setup
self.framefifo_ctx.n_signal = self.n_signal
self.framefifo_ctx.flush_when_full = True
self.avthread = core.AVThread(
"avthread_" + self.idst,
self.fork_yuv, # writes to self.fork_yuv
self.framefifo_ctx)
self.avthread.setAffinity(self.affinity)
self.info = core.InfoFrameFilter("debug")
# initial connections : recorded stream
self.connect_to_stream(
"rec_decode_" + str(self.slot),
self.avthread.getBlockingFrameFilter()) # self.fork to AVThread
# self.connect_to_stream("rec_decode_"+str(self.slot), self.info) # debug
# # self.valkkafs.setOutput(_id, slot, framefilter)
self.ctx = self.valkkafsmanager.setOutput(
self.id_rec, self.slot, self.fork) # recorded stream to self.fork
def __init__(self, **kwargs):
# auxiliary string for debugging output
self.pre = self.__class__.__name__ + " : "
# checks kwargs agains parameter_defs, attach ok'd parameters to this
# object as attributes
parameterInitCheck(LiveThread.parameter_defs, kwargs, self)
# some "api-level 1" objects here = swig-wrapped cpp objects
#
# This parameter set is defined at the cpp header file "framefifo.h"
self.framefifo_ctx = core.FrameFifoContext()
self.framefifo_ctx.n_basic = self.n_basic
self.framefifo_ctx.n_setup = self.n_setup
self.framefifo_ctx.n_signal = self.n_signal
self.framefifo_ctx.flush_when_full = self.flush_when_full
# swig wrapped cpp LiveThread
self.core = core.LiveThread(self.name, self.framefifo_ctx)
self.core.setAffinity(self.affinity)
if (self.rtsp_server > -1):
self.core.setRTSPServer(self.rtsp_server)
self.input_filter = self.core.getFrameFilter()
self.active = True
self.core.startCall()
def makeChain(self):
"""Create the filterchains
"""
self.fork = core.ForkFrameFilterN("fork_" + str(self.slot))
self.fork_yuv = core.ForkFrameFilterN("fork_yuv_" + str(self.slot))
self.framefifo_ctx = core.FrameFifoContext()
self.framefifo_ctx.n_basic = self.n_basic
self.framefifo_ctx.n_setup = self.n_setup
self.framefifo_ctx.n_signal = self.n_signal
self.framefifo_ctx.flush_when_full = True
self.avthread = core.AVThread(
"avthread_" + self.idst,
self.fork_yuv, # writes to self.fork_yuv
self.framefifo_ctx)
self.avthread.setAffinity(self.affinity)
# initial connections : live stream
self.createLiveContext() # LiveThread writes to self.fork
self.connect_to_stream(
"live_decode_" + str(self.slot),
self.avthread.getFrameFilter()) # self.fork to AVThread
self.connect_to_stream("recorder_" + str(self.slot),
self.valkkafsmanager.getFrameFilter()
) # self.fork to ValkkaFSWriterThread
self.valkkafsmanager.setInput(self.id_rec, self.slot)
def make_decode_branch(self):
self.fork_filter_decode = core.ForkFrameFilterN("fork_filter_decode_" +
str(self.slot))
self.framefifo_ctx = core.FrameFifoContext()
self.framefifo_ctx.n_basic = self.n_basic
self.framefifo_ctx.n_setup = self.n_setup
self.framefifo_ctx.n_signal = self.n_signal
self.framefifo_ctx.flush_when_full = self.flush_when_full
self.avthread = core.AVThread("avthread_" + str(self.slot),
self.fork_filter_decode,
self.framefifo_ctx)
if self.affinity > -1: # affinity overwrites number of threads
self.avthread.setAffinity(self.affinity)
elif self.number_of_threads > 1:
self.avthread.setNumberOfThreads(
self.number_of_threads) # two by default
# get input FrameFilter from AVThread
self.av_in_filter = self.avthread.getFrameFilter()
# connect to main:
self.fork_filter_main.connect("decoding_" + str(self.slot),
self.av_in_filter)
def makeChain(self):
"""Create the filter chain
"""
# *** main_branch ***
self.fork_filter = core.ForkFrameFilterN("av_fork_at_slot_" + str(
self.slot)) # FrameFilter chains can be attached to ForkFrameFilterN after it's been instantiated
self.framefifo_ctx = core.FrameFifoContext()
self.framefifo_ctx.n_basic = self.n_basic
self.framefifo_ctx.n_setup = self.n_setup
self.framefifo_ctx.n_signal = self.n_signal
self.framefifo_ctx.flush_when_full = self.flush_when_full
self.avthread = core.AVThread(
"avthread_" + self.idst,
self.fork_filter,
self.framefifo_ctx)
if (self.verbose): print(self.pre,"binding AVThread to core", int(self.affinity))
self.avthread.setAffinity(self.affinity)
# get input FrameFilter from AVThread
self.av_in_filter = self.avthread.getFrameFilter()
# *** swscale_branch ***
self.sws_fork_filter = core.ForkFrameFilterN("sws_fork_at_slot_" + str(self.slot))
self.sws_filter = core.SwScaleFrameFilter("sws_filter", self.width, self.height, self.sws_fork_filter)
self.interval_filter = core.TimeIntervalFrameFilter("interval_filter", self.shmem_image_interval, self.sws_filter)
def makeChain(self):
"""Create the filter chain
"""
# branch 1
self.gl_in_filter = self.openglthread.getInput(
) # get input FrameFilter from OpenGLThread
self.framefifo_ctx = core.FrameFifoContext()
self.framefifo_ctx.n_basic = self.n_basic
self.framefifo_ctx.n_setup = self.n_setup
self.framefifo_ctx.n_signal = self.n_signal
self.framefifo_ctx.flush_when_full = self.flush_when_full
self.avthread = core.AVThread("avthread_" + self.idst,
self.gl_in_filter, self.framefifo_ctx)
self.avthread.setAffinity(self.affinity)
self.av_in_filter = self.avthread.getFrameFilter(
) # get input FrameFilter from AVThread
# branch 2
self.live_out_filter = self.outgoing_livethread.core.getFrameFilter(
) # writing here writes to outgoing_livethread
# fork
self.fork = core.ForkFrameFilter(
"fork", self.av_in_filter,
self.live_out_filter) # this one is used by incoming_livethread
def makeChain(self):
"""Create the filter chain
"""
self.gl_in_filter = self.openglthread.getInput(
) # get input FrameFilter from OpenGLThread
self.framefifo_ctx = core.FrameFifoContext()
self.framefifo_ctx.n_basic = self.n_basic
self.framefifo_ctx.n_setup = self.n_setup
self.framefifo_ctx.n_signal = self.n_signal
self.framefifo_ctx.flush_when_full = self.flush_when_full
self.avthread = core.AVThread(
"avthread_" + self.idst,
self.gl_in_filter,
self.framefifo_ctx)
if self.affinity > -1 and self.n_threads > 1:
print("WARNING: can't use affinity with multiple threads")
self.avthread.setAffinity(self.affinity)
if self.affinity > -1:
self.avthread.setNumberOfThreads(self.n_threads)
# get input FrameFilter from AVThread
self.av_in_filter = self.avthread.getFrameFilter()
def makeChain(self):
"""Create the filter chain
"""
if (self.shmem_name is None):
self.shmem_name = "shmemff" + self.idst
# print(self.pre,self.shmem_name)
# self.n_bytes =self.shmem_image_dimensions[0]*self.shmem_image_dimensions[1]*3
n_buf = self.shmem_ringbuffer_size
# branch 1
# get input FrameFilter from OpenGLThread
self.gl_in_filter = self.openglthread.getInput()
# branch 2
# print(self.pre,"using shmem name",self.shmem_name)
# print(self.shmem_name)
self.shmem_filter = core.RGBShmemFrameFilter(
self.shmem_name,
n_buf,
self.shmem_image_dimensions[0],
self.shmem_image_dimensions[1]) # shmem id, cells, width, height
# self.shmem_filter =core.InfoFrameFilter ("info"+self.idst)
# # debug
self.sws_filter = core.SwScaleFrameFilter(
"sws_filter" + self.idst,
self.shmem_image_dimensions[0],
self.shmem_image_dimensions[1],
self.shmem_filter)
self.interval_filter = core.TimeIntervalFrameFilter(
"interval_filter" + self.idst, self.shmem_image_interval, self.sws_filter)
# fork: writes to branches 1 and 2
# self.fork_filter =core.ForkFrameFilter
# ("fork_filter"+self.idst,self.gl_in_filter,self.sws_filter) # FIX
self.fork_filter = core.ForkFrameFilter(
"fork_filter" + self.idst,
self.gl_in_filter,
self.interval_filter)
# self.fork_filter =core.ForkFrameFilter ("fork_filter"+self.idst,self.gl_in_filter,None)
# self.fork_filter=self.gl_in_filter # debugging
# main branch
self.framefifo_ctx = core.FrameFifoContext()
self.framefifo_ctx.n_basic = self.n_basic
self.framefifo_ctx.n_setup = self.n_setup
self.framefifo_ctx.n_signal = self.n_signal
self.framefifo_ctx.flush_when_full = self.flush_when_full
self.avthread = core.AVThread(
"avthread_" + self.idst,
self.fork_filter,
self.framefifo_ctx) # AVThread writes to self.fork_filter
self.avthread.setAffinity(self.affinity)
# get input FrameFilter from AVThread
self.av_in_filter = self.avthread.getFrameFilter()
def makeChain(self):
"""Create the filter chain
"""
self.gl_in_filter =self.openglthread.getInput() # get input FrameFilter from OpenGLThread
self.framefifo_ctx=core.FrameFifoContext()
self.framefifo_ctx.n_basic =self.n_basic
self.framefifo_ctx.n_setup =self.n_setup
self.framefifo_ctx.n_signal =self.n_signal
self.framefifo_ctx.flush_when_full =self.flush_when_full
self.avthread =core.AVThread("avthread_"+self.idst, self.gl_in_filter, self.framefifo_ctx)
self.avthread.setAffinity(self.affinity)
self.av_in_filter =self.avthread.getFrameFilter() # get input FrameFilter from AVThread
def makeChain(self):
"""Create the filter chain
"""
self.fork_filter=core.ForkFrameFilterN("av_fork_at_slot_"+str(self.slot)) # FrameFilter chains can attached to ForkFrameFilterN after it's been instantiated
self.framefifo_ctx=core.FrameFifoContext()
self.framefifo_ctx.n_basic =self.n_basic
self.framefifo_ctx.n_setup =self.n_setup
self.framefifo_ctx.n_signal =self.n_signal
self.framefifo_ctx.flush_when_full =self.flush_when_full
self.avthread =core.AVThread("avthread_"+self.idst, self.fork_filter, self.framefifo_ctx)
self.avthread.setAffinity(self.affinity)
self.av_in_filter =self.avthread.getFrameFilter() # get input FrameFilter from AVThread
def make_decode_branch(self):
self.fork_filter_decode = core.ForkFrameFilterN("fork_filter_decode_" + str(self.slot))
self.framefifo_ctx = core.FrameFifoContext()
self.framefifo_ctx.n_basic = self.n_basic
self.framefifo_ctx.n_setup = self.n_setup
self.framefifo_ctx.n_signal = self.n_signal
self.framefifo_ctx.flush_when_full = self.flush_when_full
self.avthread = core.AVThread(
"avthread_" + str(self.slot),
self.fork_filter_decode,
self.framefifo_ctx)
self.avthread.setAffinity(self.affinity)
# get input FrameFilter from AVThread
self.av_in_filter = self.avthread.getFrameFilter()
# connect to main:
self.fork_filter_main.connect("decoding_" + str(self.slot), self.av_in_filter)
def makeChain(self):
"""Create the filter chain
"""
# branch 1
# get input FrameFilter from OpenGLThread
self.gl_in_filter = self.openglthread.getInput()
# branch 2
self.sws_filter = core.SwScaleFrameFilter("sws_filter" + self.idst,
self.image_dimensions[0],
self.image_dimensions[1],
self.threadsafe_filter)
# MovementFrameFilter::MovementFrameFilter(char const *,long,float,long,FrameFilter *)
self.movement_filter = core.MovementFrameFilter(
"movement_" + self.idst, self.movement_interval,
self.movement_treshold, self.movement_duration, self.sws_filter)
if self.movement_callback is not None:
self.movement_filter.setCallback(self.movement_callback)
# main branch
self.fork_filter = core.ForkFrameFilter("fork_filter" + self.idst,
self.gl_in_filter,
self.movement_filter)
self.framefifo_ctx = core.FrameFifoContext()
self.framefifo_ctx.n_basic = self.n_basic
self.framefifo_ctx.n_setup = self.n_setup
self.framefifo_ctx.n_signal = self.n_signal
self.framefifo_ctx.flush_when_full = self.flush_when_full
self.avthread = core.AVThread(
"avthread_" + self.idst, self.fork_filter,
self.framefifo_ctx) # AVThread writes to self.fork_filter
self.avthread.setAffinity(self.affinity)
# get input FrameFilter from AVThread
self.av_in_filter = self.avthread.getFrameFilter()
"""
TODO: FileCacheThread should send initialization frame
- FileCacheThread .. per slot, two substream SetupFrame(s) .. or what?
- Video jerks a bit .. is this because the play edge is too close to the block edge and it runs empty before new frames arrive?
"""
setValkkaLogLevel(loglevel_debug)
def cb(mstime):
print("mstime callback", mstime)
# create OpenGLThread (for drawing video) and AVThread (for decoding)
glthread = OpenGLThread(name="gl_thread")
ctx = core.FrameFifoContext()
avthread = core.AVThread(
"avthread",
glthread.getInput(),
ctx)
av_in_filter = avthread.getFrameFilter()
avthread.startCall()
avthread.decodingOnCall()
# create an X-window
window_id = glthread.createWindow()
# map frames with slot 1 to that window
glthread.newRenderGroup(window_id)
context_id = glthread.newRenderContext(1, window_id, 0)
def makeChain(self):
"""
Create the filter chain
"""
setValkkaLogLevel(loglevel_silent)
# if (self.shmem_name is None):
# self.shmem_name = "shmemff" + self.idst
print(self.pre, self.shmem_name)
# self.n_bytes = self.shmem_image_dimensions[0] * self.shmem_image_dimensions[1]*3
n_buf = self.shmem_ringbuffer_size
# Branch 1 : Displaying Stream to the dashboard
# get input FrameFilter from OpenGLThread
self.gl_in_filter = self.openglthread.getInput()
# Decoding for displaying
self.avthread1_1 = core.AVThread(
"avthread_" + self.idst,
# self.fork_filter, # AVthread writes to self.fork_filter
self.gl_in_filter,
# self.framefifo_ctx
)
self.avthread1_1.setAffinity(self.affinity)
# get input framefilter from avthread
self.av_in_filter1_1 = self.avthread1_1.getFrameFilter()
# Branch 2 : Saving frames to shared memory for openCV/Tensorflow process
# these two lines for debugging bullshit so feel free to comment/uncomment them ya man
print(self.pre, "using shmem name ", self.shmem_name)
print(self.shmem_name)
try:
self.shmem_filter = core.RGBShmemFrameFilter(
self.shmem_name,
n_buf,
self.shmem_image_dimensions[0],
self.shmem_image_dimensions[1]
)
if self.shmem_filter:
print("Shared mem created ")
except Exception as e:
print(" There is a problem in allocating memory to RGBShmemFrameFilter : \n" + e)
# self.shmem_filter = core.InfoFrameFilter("info"+ selft.idst) ## debugging
self.sws_filter = core.SwScaleFrameFilter(
"sws_filter" + self.idst,
self.shmem_image_dimensions[0],
self.shmem_image_dimensions[1],
self.shmem_filter
)
if self.sws_filter:
print("Sws_filter created !")
self.interval_filter = core.TimeIntervalFrameFilter(
"interval_filter" + self.idst, self.shmem_image_interval, self.sws_filter
)
if self.interval_filter:
print("interval_filter created ")
self.avthread2_1 = core.AVThread(
"avthread_" + self.idst,
# self.fork_filter, # AVthread writes to self.fork_filter
self.interval_filter,
# self.framefifo_ctx
)
self.avthread2_1.setAffinity(self.affinity)
# get input framefilter from avthread
self.av_in_filter2_1 = self.avthread2_1.getFrameFilter()
# Branch 3 : Converting Stream to MP4 | Upload to Azure blob storage if activated
# For the moment this branch recieve h264 stream and convert it to fragmp4 chunks
n_buf_fragmp4 = self.frag_shmem_buffers
nb_cells = 1024 * 1024 * 3
# print(type(nb_cells))
# print(nb_cells)
try:
self.fshmem_filter = core.FragMP4ShmemFrameFilter(
self.frag_shmem_name,
n_buf_fragmp4,
nb_cells
)
except Exception as e:
print("Failed to create fragmp4 shared memory server : \n", e)
if (self.fshmem_filter):
print("fshmem filter created")
self.mux_filter = core.FragMP4MuxFrameFilter(
"fragmp4muxer",
self.fshmem_filter
)
if (self.mux_filter):
print("mux filter created")
# self.mux_filter.activate()
# Fork : Writes to branches 1, 2 and 3
self.fork_filter = core.ForkFrameFilter3(
"fork_filter" + self.idst,
self.av_in_filter1_1,
self.av_in_filter2_1,
self.mux_filter
)
# Main branch
self.framefifo_ctx = core.FrameFifoContext()
self.framefifo_ctx.n_basic = self.n_basic
self.framefifo_ctx.n_setup = self.n_setup
self.framefifo_ctx.n_signal = self.n_signal
self.framefifo_ctx.flush_when_full = self.flush_when_full
