def testNewDecodedPadNotFixed(self):
video_template = gst.PadTemplate(
'video_00', gst.PAD_SRC, gst.PAD_ALWAYS,
gst.Caps('video/x-raw-rgb, '
'framerate=[0/1, %d/1]' % ((2**31) - 1)))
audio_template = gst.PadTemplate(
'audio_00', gst.PAD_SRC, gst.PAD_ALWAYS,
gst.Caps('audio/x-raw-int, '
'rate=[1, %d]' % ((2**31) - 1)))
video = gst.Pad(video_template)
audio = gst.Pad(audio_template)
video_ghost = gst.GhostPad("video", video)
audio_ghost = gst.GhostPad("audio", audio)
self.failUnlessEqual(self.discoverer.current_streams, [])
self.discoverer._newDecodedPadCb(None, video_ghost, False)
self.failUnlessEqual(len(self.discoverer.current_streams), 0)
self.failUnlessEqual(self.discoverer.new_video_pad_cb, 1)
self.discoverer._newDecodedPadCb(None, audio_ghost, False)
self.failUnlessEqual(len(self.discoverer.current_streams), 0)
self.failUnlessEqual(self.discoverer.new_video_pad_cb, 1)
# fix the caps
video.set_caps(gst.Caps('video/x-raw-rgb, framerate=25/1'))
self.failUnlessEqual(len(self.discoverer.current_streams), 1)
self.failUnlessEqual(self.discoverer.new_video_pad_cb, 1)
audio.set_caps(gst.Caps('audio/x-raw-int, rate=44100'))
self.failUnlessEqual(len(self.discoverer.current_streams), 2)
self.failUnlessEqual(self.discoverer.new_video_pad_cb, 1)
def __init__(self):
gst.Element.__init__(self)
# create source pads
self.audiosrc = gst.Pad(self._audiosrc, "audio-out")
self.add_pad(self.audiosrc)
self.videosrc = gst.Pad(self._videosrc, "video-out")
self.add_pad(self.videosrc)
# create the sink pads and set the chain and event function
self.audiosink = gst.Pad(self._audiosink, "audio-in")
self.audiosink.set_chain_function(
lambda pad, buffer: self.chainfunc(pad, buffer, self.audiosrc))
self.audiosink.set_event_function(
lambda pad, buffer: self.eventfunc(pad, buffer, self.audiosrc))
self.add_pad(self.audiosink)
self.videosink = gst.Pad(self._videosink, "video-in")
self.videosink.set_chain_function(
lambda pad, buffer: self.chainfunc(pad, buffer, self.videosrc))
self.videosink.set_event_function(
lambda pad, buffer: self.eventfunc(pad, buffer, self.videosrc))
self.add_pad(self.videosink)
# all this variables need to be protected with a lock!!!
self._lock = threading.Lock()
self._totalTime = 0L
self._syncTimestamp = 0L
self._syncOffset = 0L
self._resetReceived = True
self._sendNewSegment = True
def testPads(self):
timeline = Timeline()
stream1 = VideoStream(gst.Caps('video/x-raw-rgb'), 'src0')
stream2 = AudioStream(gst.Caps('audio/x-raw-int'), 'src1')
track1 = Track(stream1)
track2 = Track(stream2)
timeline.addTrack(track1)
timeline.addTrack(track2)
factory = TimelineSourceFactory(timeline)
bin = factory.makeBin()
self.failUnlessEqual(len(list(bin.src_pads())), 0)
pad1 = gst.Pad('src0', gst.PAD_SRC)
pad1.set_caps(gst.Caps('asd'))
pad1.set_active(True)
track1.composition.add_pad(pad1)
pad2 = gst.Pad('src0', gst.PAD_SRC)
pad2.set_caps(gst.Caps('asd'))
pad2.set_active(True)
track2.composition.add_pad(pad2)
self.failUnlessEqual(len(list(bin.src_pads())), 2)
track1.composition.remove_pad(pad1)
self.failUnlessEqual(len(list(bin.src_pads())), 1)
track2.composition.remove_pad(pad2)
self.failUnlessEqual(len(list(bin.src_pads())), 0)
factory.clean()
def __init__(self):
gst.Element.__init__(self)
self.sinkpad = gst.Pad(self.sinktemplate, "sink")
self.sinkpad.set_chain_function(self.chain)
self.add_pad(self.sinkpad)
self.srcpad = gst.Pad(self.srctemplate, "src")
self.add_pad(self.srcpad)
def __init__(self):
gst.Element.__init__(self)
self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
self.srcpad = gst.Pad(self._srcpadtemplate, "src")
self.add_pad(self.sinkpad)
self.add_pad(self.srcpad)
self.sinkpad.set_chain_function(self.chainfunc)
self.sinkpad.set_event_function(self.eventfunc)
def __init__(self, *args, **kwargs):
# init parent
gst.Element.__init__(self, *args, **kwargs)
self.backward_seek = False
self.forward_seek = False
self.stepnanoseconds = 1
self.step = 0
self.update = False
self.rate = 1.0
self.format = gst.FORMAT_TIME
self.start = 0
self.stop = -1
self.position = 0
self.seg_position = 0
self.qlock = threading.Lock()
self.cond_add = threading.Condition(self.qlock)
self.cond_del = threading.Condition(self.qlock)
self.seeklock = threading.Lock()
self.gui_wait = threading.Lock()
self.stored_buf = None
self.stored_event = None
self.running = False
self.item_waiting = False
self.push_newsegment = False
self.event_result = True
self.restrict = False
self.buf_result = gst.FLOW_OK
# create pads
self.keyseeksrcpad = gst.Pad(self._keyseeksrctemplate)
self.keyseeksinkpad = gst.Pad(self._keyseeksinktemplate)
self.secondsrcpad = gst.Pad(self._secondsrctemplate)
self.secondsinkpad = gst.Pad(self._secondsinktemplate)
# data handling functions
self.keyseeksinkpad.set_chain_function(self._chain)
self.keyseeksinkpad.set_event_function(self._handle_sink_event)
self.keyseeksinkpad.set_getcaps_function(self._getcaps)
self.keyseeksinkpad.set_setcaps_function(self._setcaps)
self.keyseeksinkpad.set_activatepush_function(self._sink_activate_push)
self.keyseeksinkpad.set_query_function(self._handle_query)
self.keyseeksrcpad.set_event_function(self._handle_src_event)
self.keyseeksrcpad.set_activatepush_function(self._src_activate_push)
self.keyseeksrcpad.set_getcaps_function(self._getcaps)
self.keyseeksrcpad.set_link_function(self._link_src)
self.keyseeksrcpad.set_query_function(self._handle_query)
self.secondsinkpad.set_getcaps_function(self._getcaps)
self.secondsinkpad.set_setcaps_function(self._setcaps)
self.secondsinkpad.set_event_function(self._handle_audio_event)
self.secondsinkpad.set_chain_function(self._audio_chain)
self.secondsinkpad.set_query_function(self._handle_query)
self.secondsrcpad.set_getcaps_function(self._getcaps)
self.secondsrcpad.set_event_function(self._handle_audio_event)
self.secondsrcpad.set_query_function(self._handle_query)
self.add_pad(self.keyseeksrcpad)
self.add_pad(self.keyseeksinkpad)
self.add_pad(self.secondsrcpad)
self.add_pad(self.secondsinkpad)
def testGetThumbnailFilenameFromPad(self):
pad = gst.Pad('src0', gst.PAD_SRC)
pad1 = gst.Pad('src1', gst.PAD_SRC)
self.discoverer.current_uri = "meh"
filename1 = self.discoverer._getThumbnailFilenameFromPad(pad)
filename2 = self.discoverer._getThumbnailFilenameFromPad(pad)
self.discoverer.current_uri = "boo"
filename3 = self.discoverer._getThumbnailFilenameFromPad(pad1)
self.failUnlessEqual(filename1, filename2)
self.failIfEqual(filename2, filename3)
def __init__(self):
gst.Element.__init__(self)
# add the source/sink pads
self.srcpad = gst.Pad(self._srctemplate)
self.sinkpad = gst.Pad(self._sinktemplate)
self.sinkpad.set_chain_function(self._chain)
self.sinkpad.set_event_function(self._sinkevent)
self.sinkpad.set_setcaps_function(self._setcaps)
self.add_pad(self.sinkpad)
self.add_pad(self.srcpad)
self.segment = gst.Segment()
self.segment.init(gst.FORMAT_UNDEFINED)
def __init__(self, sink_templ):
gst.Element.__init__(self)
self.bytestream = True
# Sinkpad should have the same template and caps as the wrapped decoder
self.sinkpad = gst.Pad(sink_templ, 'sink')
self.add_pad(self.sinkpad)
self.sinkpad.set_chain_function(self._chain)
self.sinkpad.set_setcaps_function(self._setcaps)
self.sinkpad.set_getcaps_function(self._getcaps)
# Srcpad is only internal -> any caps
self.srcpad = gst.Pad(self._src_padtemplate, 'src')
self.add_pad(self.srcpad)
def __init__(self, delay=0):
gst.Element.__init__(self)
self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
self.sinkpad.set_chain_function(self.chainfunc)
self.add_pad(self.sinkpad)
self.srcpad = gst.Pad(self._srcpadtemplate, "src")
self.add_pad(self.srcpad)
self._delay = long(delay * gst.MSECOND)
print self._delay
def __init__(self):
gst.Element.__init__(self)
self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
self.sinkpad.set_chain_function(self.chainfunc)
self.add_pad(self.sinkpad)
self.srcpad = gst.Pad(self._srcpadtemplate, "src")
self.add_pad(self.srcpad)
self._last_ts = 0L
self._count = 0
self.interval = DEFAULT_INTERVAL
def __init__(self):
gst.Element.__init__(self)
self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
self.sinkpad.use_fixed_caps()
self.srcpad = gst.Pad(self._srcpadtemplate, "src")
self.srcpad.use_fixed_caps()
self.sinkpad.set_chain_function(self.chainfunc)
self.sinkpad.set_event_function(self.eventfunc)
self.add_pad(self.sinkpad)
self.srcpad.set_event_function(self.srceventfunc)
self.add_pad(self.srcpad)
self.adapter = gst.Adapter()
def __init__(self, *args, **kwargs):
gst.Element.__init__(self, *args, **kwargs)
self.srcpad = gst.Pad(self._srctemplate)
self.srcpad.set_event_function(self._src_event)
self.sinkpad = gst.Pad(self._sinktemplate)
self.sinkpad.set_chain_function(self._sink_chain)
self.sinkpad.set_event_function(self._sink_event)
self.sinkpad.set_setcaps_function(self._sink_setcaps)
self.add_pad(self.srcpad)
self.add_pad(self.sinkpad)
self._reset()
def __init__(self, destination=None, request=None):
gst.Element.__init__(self)
self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
self.srcpad = gst.Pad(self._srcpadtemplate, "src")
self.add_pad(self.sinkpad)
self.add_pad(self.srcpad)
self.sinkpad.set_chain_function(self.chainfunc)
self.buffer = ''
self.buffer_size = 0
self.proxy = False
self.got_new_segment = False
self.closed = False
def testNewDecodedPadFixed(self):
video = gst.Pad('video_00', gst.PAD_SRC)
video.set_caps(gst.Caps('video/x-raw-rgb'))
audio = gst.Pad('audio_00', gst.PAD_SRC)
audio.set_caps(gst.Caps('audio/x-raw-int'))
self.failUnlessEqual(self.discoverer.current_streams, [])
self.discoverer._newDecodedPadCb(None, video, False)
self.failUnlessEqual(len(self.discoverer.current_streams), 1)
self.failUnlessEqual(self.discoverer.new_video_pad_cb, 1)
self.discoverer._newDecodedPadCb(None, audio, False)
self.failUnlessEqual(len(self.discoverer.current_streams), 2)
self.failUnlessEqual(self.discoverer.new_video_pad_cb, 1)
def __init__(self, *args, **kw):
super(OpticalFlowFinder, self).__init__(*args, **kw)
self.srcpad = gst.Pad(self.src_template)
self.add_pad(self.srcpad)
self.sinkpad = gst.Pad(self.sink_template)
self.sinkpad.set_chain_function(self._chain)
self.add_pad(self.sinkpad)
self._previous_img = None
self._previous_blob = None
self._finder = None
def __init__(self):
gst.Element.__init__(self)
self.flow_sink_pad = gst.Pad(self.flow_sink_template)
self.flow_sink_pad.set_chain_function(self._chain)
self.flow_sink_pad.set_event_function(self._flow_event)
self.add_pad(self.flow_sink_pad)
self.main_sink_pad = gst.Pad(self.main_sink_template)
self.main_sink_pad.set_chain_function(self._chain)
self.add_pad(self.main_sink_pad)
# FIXME: shouldn't we just use gstreamer queues outside of the elemnt?
self._pending_flow = deque()
self._pending_main = deque()
def __init__(self, *args, **kwargs):
#initialise parent class
gst.Element.__init__(self, *args, **kwargs)
#source pad, outgoing data
self.srcpad = gst.Pad(self._srctemplate)
#sink pad, incoming data
self.sinkpad = gst.Pad(self._sinktemplate)
self.sinkpad.set_setcaps_function(self._sink_setcaps)
self.sinkpad.set_chain_function(self._sink_chain)
#make pads available
self.add_pad(self.srcpad)
self.add_pad(self.sinkpad)
def __init__(self):
"""Sets up src and sink pads plus behaviour."""
super(BasePlaylistElement, self).__init__()
self._data = io.BytesIO()
self._done = False
self.sinkpad = gst.Pad(self.sinkpad_template)
self.sinkpad.set_chain_function(self._chain)
self.sinkpad.set_event_function(self._event)
self.add_pad(self.sinkpad)
if self.ghost_srcpad:
self.srcpad = gst.ghost_pad_new_notarget('src', gst.PAD_SRC)
else:
self.srcpad = gst.Pad(self.srcpad_template)
self.add_pad(self.srcpad)
def __init__(self, *args, **kw):
super(OpticalFlowDrawer, self).__init__(*args, **kw)
self.srcpad = gst.Pad(self.src_template)
self.add_pad(self.srcpad)
self._drawer = ArrowDrawer(width=self.line_thickness)
def __init__(self):
gst.Element.__init__(self)
self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
self.sinkpad.set_chain_function(self.chainfunc)
self.sinkpad.set_event_function(self.eventfunc)
self.sinkpad.set_getcaps_function(gst.Pad.proxy_getcaps)
self.sinkpad.set_setcaps_function(gst.Pad.proxy_setcaps)
self.add_pad(self.sinkpad)
self.srcpad = gst.Pad(self._srcpadtemplate, "src")
self.srcpad.set_event_function(self.srceventfunc)
self.srcpad.set_query_function(self.srcqueryfunc)
self.srcpad.set_getcaps_function(gst.Pad.proxy_getcaps)
self.srcpad.set_setcaps_function(gst.Pad.proxy_setcaps)
self.add_pad(self.srcpad)
def __init__(self, *args, **kwargs):
self.caps = gst.caps_from_string(
'audio/x-raw-int, rate=7600, endianness=1234, channels=1, width=16, depth=16, signed=true'
)
gst.BaseSrc.__init__(self)
gst.info("Creating Kaicong src pad")
self.src_pad = gst.Pad(self._src_template)
self.src_pad.use_fixed_caps()
def __init__(self, *args, **kw):
super(OpticalFlowCorrector, self).__init__(*args, **kw)
self.srcpad = gst.Pad(self.src_template)
self.add_pad(self.srcpad)
self.sinkpad = gst.Pad(self.sink_template)
self.sinkpad.set_chain_function(self._chain)
self.add_pad(self.sinkpad)
self._reference_img = None
self._reference_blob = None
self._last_output_img = None
self._reference_transform = numpy.asarray(
[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]], dtype=numpy.float128)
self._finder = None
def testDefaultBinGhostPads(self):
bin = gst.Bin()
pad = gst.Pad('meh', gst.PAD_SRC)
pad.set_caps(gst.Caps('audio/x-raw-float'))
self.factory._binNewDecodedPadCb(None, pad, None, bin)
self.failIfEqual(bin.get_pad('meh'), None)
self.factory._binRemovedDecodedPadCb(None, pad, bin)
self.failUnlessEqual(bin.get_pad('meh'), None)
def __init__(self, unlink, tolerance=1):
#initialise parent class
gst.Element.__init__(self)
self.datawatcher = DataWatcher(unlink, tolerance)
self.playing = False
#source pad, outgoing data
self.srcpad = gst.Pad(self._srctemplate)
#sink pad, incoming data
self.sinkpad = gst.Pad(self._sinktemplate)
self.sinkpad.set_setcaps_function(self._sink_setcaps)
self.sinkpad.set_chain_function(self._sink_chain)
#make pads available
self.add_pad(self.srcpad)
self.add_pad(self.sinkpad)
def __init__(self):
gst.Element.__init__(self)
self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
self.sinkpad.set_chain_function(self.chainfunc)
self.add_pad(self.sinkpad)
self.sinkpad.add_event_probe(self._tag_event_cb)
self.srcpad = gst.Pad(self._srcpadtemplate, "src")
self.add_pad(self.srcpad)
self._frameSize = self._DEFAULT_FRAMESIZE
self._numFrames = self._DEFAULT_NUMFRAMES
self._recountMetaint()
self.connect('broadcast-title', self._broadcast_title_handler)
self._reset()
def __init__(self):
gst.Element.__init__(self)
self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
self.add_pad(self.sinkpad)
self.sinkpad.set_chain_function(self.chainfunc)
self.sinkpad.set_event_function(self.eventfunc)
self.img_cb = lambda buffer: None
def __init__(self, *args, **kwargs):
self.frequencies = Math.get_frq(2049, 44100)
self.transmission = None
gst.Element.__init__(self, *args, **kwargs)
if not self.transmission:
self.transmission = numpy.ones(2049)
self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
self.sinkpad.use_fixed_caps()
self.srcpad = gst.Pad(self._srcpadtemplate, "src")
self.srcpad.use_fixed_caps()
self.sinkpad.set_chain_function(self.chainfunc)
self.sinkpad.set_event_function(self.eventfunc)
self.add_pad(self.sinkpad)
self.srcpad.set_event_function(self.srceventfunc)
self.add_pad(self.srcpad)
def __init__(self):
gst.Element.__init__(self)
gst.info('creating pads')
self.srcpad = gst.Pad(self._srcpadtemplate, "src")
self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
gst.info('adding pads to self')
self.add_pad(self.srcpad)
self.add_pad(self.sinkpad)
gst.info('setting chain/event functions')
#self.srcpad.set_chain_function(self.src_chainfunc)
#self.srcpad.set_event_function(self.src_eventfunc)
self.sinkpad.set_chain_function(self.sink_chainfunc)
self.sinkpad.set_event_function(self.sink_eventfunc)
self.time_cb = None
self.interval = 60
self._calc_next()
def __init__(self):
gst.Element.__init__(self)
gst.info('creating sinkpad')
self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
gst.info('adding sinkpad to self')
self.add_pad(self.sinkpad)
gst.info('setting chain/event functions')
self.sinkpad.set_chain_function(self.chainfunc)
self.sinkpad.set_event_function(self.eventfunc)
