def stop_recording_video(self):
if not self._has_camera:
return
# We stop the pipeline while we are adjusting the pipeline to stop
# recording because if we do it on-the-fly, the following video live
# feed to the screen becomes several seconds delayed. Weird!
# FIXME: retest on F11
# FIXME: could this be the result of audio shortening problems?
self._eos_cb = self._video_eos
self._pipeline.get_by_name('camsrc').send_event(gst.event_new_eos())
self._audiobin.get_by_name('absrc').send_event(gst.event_new_eos())
def stop(self): if self.running == "true": self.running = "false" print "Send EnOffStream(EOS) to source element" try: if self.source.send_event(gst.event_new_eos()): print "EOS event sucessfully send" else: print "EOS event NOT send, try to send it to pipeline" self.pipeline.send_event(gst.event_new_eos()) except NameError: print "Error: Pipeline: source not specified"
def chain(self, pad, buf):
ret = self.srcpad.push(buf)
if ret == gst.FLOW_OK:
self.info("pushed, doing EOS")
self.srcpad.push_event(gst.event_new_eos())
return ret
def record (self, start):
if start == 1:
print ("Start screencast record")
self.element.set_state (gst.STATE_PLAYING)
else:
print ("stop screencast record")
self.element.send_event (gst.event_new_eos ())
def on_message (self, bus, message):
if message.type == gst.MESSAGE_EOS:
self.player.seek_simple (gst.FORMAT_TIME, gst.SEEK_FLAG_FLUSH, self.startpos)
self.player.set_state (gst.STATE_READY)
self.updatelabelduration.emit ("00:00.000 / %s" % self.dur_str)
self.updatesliderseek.emit (self.seekmin)
elif message.type == gst.MESSAGE_ERROR:
self.player.seek_simple (gst.FORMAT_TIME, gst.SEEK_FLAG_FLUSH, self.startpos)
self.player.set_state (gst.STATE_READY)
self.updatelabelduration.emit ("00:00.000 / %s" % self.dur_str)
self.updatesliderseek.emit (self.seekmin)
err, debug = message.parse_error()
print 'Error: %s' % err, debug
elif message.type == gst.MESSAGE_STATE_CHANGED:
if not message.src == self.player:
return
old, new, pending = message.parse_state_changed()
if self.loop and old == gst.STATE_READY and new == gst.STATE_PAUSED:
self.seek (self.startpos, self.stoppos)
self.state = new
if new == gst.STATE_PLAYING:
self.updatethreadtimer.setInterval (30)
self.setbuttonpause.emit()
else:
self.updatethreadtimer.setInterval (200)
self.setbuttonplay.emit()
elif message.type == gst.MESSAGE_SEGMENT_DONE:
src = self.player.get_property ("source")
pad = src.get_pad ('src')
pad.push_event (gst.event_new_eos())
def swap_element(klass, swap_bin, previous_element, next_element,
old_element, new_element):
previous_pad = previous_element.get_static_pad("src")
#FIXME: Use the async method to work for paused state
previous_pad.set_blocked(True)
previous_element.unlink(old_element)
#make sure data is flushed out of element2:
old_pad = old_element.get_static_pad("src")
handler_id = old_pad.add_event_probe(event_received)
old_element.send_event(gst.event_new_eos())
old_pad.remove_event_probe(handler_id)
previous_element.unlink(old_element)
old_element.unlink(next_element)
old_element.set_state(gst.STATE_NULL)
swap_bin.remove(old_element)
swap_bin.add(new_element)
new_element.link(next_element)
previous_element.link(new_element)
new_element.set_state(gst.STATE_PLAYING)
previous_pad.set_blocked(False)
swap_bin.set_state(gst.STATE_PLAYING)
return
def button_press_event(self, widget, event):
if event.button == 1:
if self.playing == False:
self.win.fullscreen()
self.playing = True
starting = time.time()
self.start = []
self.start.append(starting)
self.player.set_state(gst.STATE_PLAYING)
self.file_times = open(self.timesfilename, 'w')
elif self.playing == True:
if self.current_page + 1 < self.n_pages:
self.starting_time = self.start[0]
right_now = time.time()
time_interval = str(int((right_now - self.starting_time)*1000))
self.file_times.write(time_interval + "\n")
self.current_page += 1
self.page_selector = self.document.get_page(self.current_page)
self.area.set_size_request(int(self.width),int(self.height))
self.area.queue_draw()
elif self.current_page + 1 == self.n_pages:
self.starting_time = self.start[0]
right_now = time.time()
time_interval = str(int((right_now - self.starting_time)*1000))
self.file_times.write(time_interval + "\n")
self.file_times.close()
self.win.unfullscreen()
#~ self.win.resize(1,1)
time.sleep(0.5) # add half a second to avoid problems with iRaccoonShow
self.player.send_event(gst.event_new_eos())
self.current_page =+ 1
def _error_func(self):
# No need to reinitialize more than once
if self._pipe.get_state(timeout=50*gst.MSECOND)[1] == gst.STATE_NULL:
return
self.stop()
self._pipe.set_state(gst.STATE_NULL)
self._pipe.set_property('audio-sink', None)
# The mainbin is still connected to the old element, need to
# disconnect it and flush it.
self._mainbin.unparent()
# Only flush the element if necessary
if self._mainbin.get_state(timeout=50*gst.MSECOND)[1] != gst.STATE_NULL:
# flush it
sinkpad = self._mainbin.get_static_pad('sink')
self._err_probe_id = sinkpad.add_event_probe(self._error_func_flush)
sinkpad.send_event(gst.event_new_eos())
else:
self._reinitialize()
def chain(self, pad, buf):
ret = self.srcpad.push(buf)
if ret == gst.FLOW_OK:
self.info("pushed, doing EOS")
self.srcpad.push_event(gst.event_new_eos())
return ret
def _error_func(self):
# No need to reinitialize more than once
if self._pipe.get_state(timeout=50 * gst.MSECOND)[1] == gst.STATE_NULL:
return
self.stop()
self._pipe.set_state(gst.STATE_NULL)
self._pipe.set_property('audio-sink', None)
# The mainbin is still connected to the old element, need to
# disconnect it and flush it.
self._mainbin.unparent()
# Only flush the element if necessary
if self._mainbin.get_state(timeout=50 *
gst.MSECOND)[1] != gst.STATE_NULL:
# flush it
sinkpad = self._mainbin.get_static_pad('sink')
self._err_probe_id = sinkpad.add_event_probe(
self._error_func_flush)
sinkpad.send_event(gst.event_new_eos())
else:
self._reinitialize()
def stop(self):
self.valve.set_property("drop", True)
self.sink.send_event(gst.event_new_eos())
self.sink.set_state(gst.STATE_NULL)
self.wavenc.unlink(self.filesink)
self.sink.remove(self.filesink)
self.recording = False
def swap_element(klass, swap_bin, previous_element, next_element,
old_element, new_element):
previous_pad = previous_element.get_static_pad("src")
#FIXME: Use the async method to work for paused state
previous_pad.set_blocked(True)
previous_element.unlink(old_element)
#make sure data is flushed out of element2:
old_pad = old_element.get_static_pad("src")
handler_id = old_pad.add_event_probe(event_received)
old_element.send_event(gst.event_new_eos())
old_pad.remove_event_probe(handler_id)
previous_element.unlink(old_element)
old_element.unlink(next_element)
old_element.set_state(gst.STATE_NULL)
swap_bin.remove(old_element)
swap_bin.add(new_element)
new_element.link(next_element)
previous_element.link(new_element)
new_element.set_state(gst.STATE_PLAYING)
previous_pad.set_blocked(False)
swap_bin.set_state(gst.STATE_PLAYING)
return
def _our_task(self, something):
if self._buffer == None:
self.warning("We were started without a buffer, exiting")
self.srcpad.pause_task()
return
#this is where we repeatedly output our buffer
self.debug("self:%r, something:%r" % (self, something))
self.debug("needsegment: %r" % self._needsegment)
if self._needsegment:
self.debug("Need to output a new segment")
segment = gst.event_new_new_segment(False, self._segment.rate,
self._segment.format,
self._segment.start,
self._segment.stop,
self._segment.start)
self.srcpad.push_event(segment)
# calculate offset
# offset is int(segment.start / outputrate)
self._offset = int(self._segment.start * self._outputrate.num /
self._outputrate.denom / gst.SECOND)
self._needsegment = False
self.debug("Newsegment event pushed")
# new position
position = self._offset * gst.SECOND * self._outputrate.denom / self._outputrate.num
if self._segment.stop != -1 and position > self._segment.stop:
self.debug(
"end of configured segment (position:%s / segment_stop:%s)" %
(gst.TIME_ARGS(position), gst.TIME_ARGS(self._segment.stop)))
# end of stream/segment handling
if self._segment.flags & gst.SEEK_FLAG_SEGMENT:
# emit a gst.MESSAGE_SEGMENT_DONE
self.post_message(
gst.message_new_segment_done(self, gst.FORMAT_TIME,
self._segment.stop))
else:
self.srcpad.push_event(gst.event_new_eos())
self.last_return = gst.FLOW_WRONG_STATE
self.srcpad.pause_task()
# we need to update the caps here !
obuf = self._buffer.make_metadata_writable()
ok, nstart, nstop = self._segment.clip(gst.FORMAT_TIME, position,
position + self._bufferduration)
if ok:
obuf.timestamp = nstart
obuf.duration = nstop - nstart
obuf.caps = self._srccaps
self.debug("Pushing out buffer %s" % gst.TIME_ARGS(obuf.timestamp))
self.last_return = self.srcpad.push(obuf)
self._offset += 1
if self.last_return != gst.FLOW_OK:
self.debug("Pausing ourself, last_return : %s" %
gst.flow_get_name(self.last_return))
self.srcpad.pause_task()
def stop(self):
"""
Stop this queue entry from processing.
"""
if hasattr(self, "transcoder") and self.transcoder.pipe:
self.transcoder.pipe.send_event(gst.event_new_eos())
self.transcoder.start()
self.force_stopped = True
def stop(self):
"""
Stop this queue entry from processing.
"""
if hasattr(self, "transcoder") and self.transcoder.pipe:
self.transcoder.pipe.send_event(gst.event_new_eos())
self.transcoder.start()
self.force_stopped = True
def on_message(bus, message, eos_cb, err_cb):
t = message.type
if t == gst.MESSAGE_EOS:
print "EOS"
eos_cb()
elif t == gst.MESSAGE_ERROR:
err, debug = message.parse_error()
print "error=", err
print "debug=", debug
pipeline.send_event(gst.event_new_eos())
def on_message(bus, message, eos_cb, err_cb):
t = message.type
if t == gst.MESSAGE_EOS:
print "EOS"
eos_cb()
elif t == gst.MESSAGE_ERROR:
err, debug = message.parse_error()
print "error=", err
print "debug=", debug
pipeline.send_event(gst.event_new_eos())
def _our_task(self, something):
if self._buffer == None:
self.warning("We were started without a buffer, exiting")
self.srcpad.pause_task()
return
#this is where we repeatedly output our buffer
self.debug("self:%r, something:%r" % (self, something))
self.debug("needsegment: %r" % self._needsegment)
if self._needsegment:
self.debug("Need to output a new segment")
segment = gst.event_new_new_segment(False,
self._segment.rate,
self._segment.format,
self._segment.start,
self._segment.stop,
self._segment.start)
self.srcpad.push_event(segment)
# calculate offset
# offset is int(segment.start / outputrate)
self._offset = int(self._segment.start * self._outputrate.num / self._outputrate.denom / gst.SECOND)
self._needsegment = False
self.debug("Newsegment event pushed")
# new position
position = self._offset * gst.SECOND * self._outputrate.denom / self._outputrate.num
if self._segment.stop != -1 and position > self._segment.stop:
self.debug("end of configured segment (position:%s / segment_stop:%s)" % (gst.TIME_ARGS(position),
gst.TIME_ARGS(self._segment.stop)))
# end of stream/segment handling
if self._segment.flags & gst.SEEK_FLAG_SEGMENT:
# emit a gst.MESSAGE_SEGMENT_DONE
self.post_message(gst.message_new_segment_done(self, gst.FORMAT_TIME, self._segment.stop))
else:
self.srcpad.push_event(gst.event_new_eos())
self.last_return = gst.FLOW_WRONG_STATE
self.srcpad.pause_task()
# we need to update the caps here !
obuf = self._buffer.make_metadata_writable()
ok, nstart, nstop = self._segment.clip(gst.FORMAT_TIME,
position, position + self._bufferduration)
if ok:
obuf.timestamp = nstart
obuf.duration = nstop - nstart
obuf.caps = self._srccaps
self.debug("Pushing out buffer %s" % gst.TIME_ARGS(obuf.timestamp))
self.last_return = self.srcpad.push(obuf)
self._offset += 1
if self.last_return != gst.FLOW_OK:
self.debug("Pausing ourself, last_return : %s" % gst.flow_get_name(self.last_return))
self.srcpad.pause_task()
def _monitor_for_stop(self, track, stop_offset):
if track == self.current and self.get_position() >= stop_offset * gst.SECOND and self.is_playing():
# send eos to pipe
self._pipe.send_event(gst.event_new_eos())
self._stop_id = None
return False
return True
def _clear_old_sink(self, old_audio_sink):
# push EOS into the element, which will be fired once all the
# data has left the sink
sinkpad = old_audio_sink.get_static_pad('sink')
self._pad_event_probe_id = sinkpad.add_event_probe(self._event_probe_cb, old_audio_sink)
sinkpad.send_event(gst.event_new_eos())
return False
def shutdown():
# This should work:
#pipeline.send_event(gst.event_new_eos())
# But because the gstreamer EOS stuff seems to be FUBAR,
# force the EOS to all pads
# TODO: THIS DOESN'T SEEM TO ALWAYS PROVIDE A CLEAN
# SHUTDOWN
for element in pipeline.recurse():
for pad in element.pads():
if pad.get_property("direction") != gst.PAD_SINK:
continue
pad.send_event(gst.event_new_eos())
def clean_shutdown(p):
camsrc = p.get_by_name("camsrc")
xsrc = p.get_by_name("xsrc")
asrc = p.get_by_name("asrc")
eos = gst.event_new_eos()
camsrc.send_event(eos)
xsrc.send_event(eos)
asrc.send_event(eos)
bus = p.get_bus()
bus.poll(gst.MESSAGE_EOS | gst.MESSAGE_ERROR, -1)
def _clear_old_sink(self, old_audio_sink):
# push EOS into the element, which will be fired once all the
# data has left the sink
sinkpad = old_audio_sink.get_static_pad('sink')
self._pad_event_probe_id = sinkpad.add_event_probe(
self._event_probe_cb, old_audio_sink)
sinkpad.send_event(gst.event_new_eos())
return False
def eventfunc(self, pad, event):
if event.type == gst.EVENT_FLUSH_START or\
event.type == gst.EVENT_FLUSH_STOP:
return False
elif event.type == gst.EVENT_EOS:
if pad == self.video_sinkpad:
self.video_srcpad.push_event(gst.event_new_eos())
else:
self.audio_srcpad.push_event(gst.event_new_eos())
return False
elif event.type != gst.EVENT_NEWSEGMENT:
return True
# New Segment
update, r, t, start, stop, position = event.parse_new_segment()
if not self._file_start:
# This is the first new segment, we use it to get the start time of
# the file.
self._file_start = start
return False
# if it's not a segment update, it's because it's a new segment comming
# after the seek
if not update:
# A new segment is starting now after the seek has been
# done, so update the values of the current segment to clip the
# incomming buffers with the values of the next segment
self._cur_segment[pad] = self._next_segment
self.info("Start of new segment on %s pad %r" %
(pad.get_name(), self._cur_segment[pad]))
if pad == self.video_sinkpad:
self._video_waiting_new_segment = False
else:
self._audio_waiting_new_segment = False
return False
def __on_bus_message(self, bus, message):
if message.type == gst.MESSAGE_ERROR:
error, debug = message.parse_error()
self.stop() # this seems neccessary here
self.emit("error", (error, debug))
elif message.type == gst.MESSAGE_NEW_CLOCK:
# we connect the timeout handler here
# to be sure that further queries succeed
interval = int((self.__stop_position - self.__start_position) / \
(2 * gst.SECOND) + 50)
self.__timeout_id = gobject.timeout_add(interval,
self.__on_timeout)
elif message.type == gst.MESSAGE_STATE_CHANGED:
old_state, new_state, pending = message.parse_state_changed()
if (old_state == gst.STATE_READY and
new_state == gst.STATE_PAUSED and
message.src == self.__playbin):
self.__seek(self.__start_pos, self.__stop_pos, True)
elif message.type == gst.MESSAGE_SEGMENT_DONE:
if self.__loop:
self.__seek(self.__start_pos, self.__stop_pos, False)
else:
src = self.__playbin.get_property("source")
pad = src.get_pad('src')
pad.push_event(gst.event_new_eos())
# this is the good old way:
#
# pads = src.src_pads()
# while True:
# try:
# pad = pads.next()
# pad.push_event(gst.event_new_eos())
# except:
# break
elif message.type == gst.MESSAGE_EOS:
self.stop()
return True
def __on_bus_message(self, bus, message):
if message.type == gst.MESSAGE_ERROR:
error, debug = message.parse_error()
self.stop() # this seems neccessary here
self.emit("error", (error, debug))
elif message.type == gst.MESSAGE_NEW_CLOCK:
# we connect the timeout handler here
# to be sure that further queries succeed
interval = int((self.__stop_position - self.__start_position) / \
(2 * gst.SECOND) + 50)
self.__timeout_id = gobject.timeout_add(interval,
self.__on_timeout)
elif message.type == gst.MESSAGE_STATE_CHANGED:
old_state, new_state, pending = message.parse_state_changed()
if (old_state == gst.STATE_READY and new_state == gst.STATE_PAUSED
and message.src == self.__playbin):
self.__seek(self.__start_pos, self.__stop_pos, True)
elif message.type == gst.MESSAGE_SEGMENT_DONE:
if self.__loop:
self.__seek(self.__start_pos, self.__stop_pos, False)
else:
src = self.__playbin.get_property("source")
pad = src.get_pad('src')
pad.push_event(gst.event_new_eos())
# this is the good old way:
#
# pads = src.src_pads()
# while True:
# try:
# pad = pads.next()
# pad.push_event(gst.event_new_eos())
# except:
# break
elif message.type == gst.MESSAGE_EOS:
self.stop()
return True
def on_message(self, bus, message):
if message.type == gst.MESSAGE_EOS:
self.player.seek_simple(gst.FORMAT_TIME, gst.SEEK_FLAG_FLUSH,
self.startpos)
self.player.set_state(gst.STATE_READY)
self.updatelabelduration.emit("00:00.000 / %s" % self.dur_str)
self.updatesliderseek.emit(self.seekmin)
elif message.type == gst.MESSAGE_ERROR:
self.player.seek_simple(gst.FORMAT_TIME, gst.SEEK_FLAG_FLUSH,
self.startpos)
self.player.set_state(gst.STATE_READY)
self.updatelabelduration.emit("00:00.000 / %s" % self.dur_str)
self.updatesliderseek.emit(self.seekmin)
err, debug = message.parse_error()
print 'Error: %s' % err, debug
elif message.type == gst.MESSAGE_STATE_CHANGED:
if not message.src == self.player:
return
old, new, pending = message.parse_state_changed()
if self.loop and old == gst.STATE_READY and new == gst.STATE_PAUSED:
self.seek(self.startpos, self.stoppos)
self.state = new
if new == gst.STATE_PLAYING:
self.updatethreadtimer.setInterval(30)
self.setbuttonpause.emit()
else:
self.updatethreadtimer.setInterval(200)
self.setbuttonplay.emit()
elif message.type == gst.MESSAGE_SEGMENT_DONE:
src = self.player.get_property("source")
pad = src.get_pad('src')
pad.push_event(gst.event_new_eos())
def _on_eater_blocked(self, pad, blocked):
self._on_pad_blocked(pad, blocked)
if blocked:
peer = pad.get_peer()
peer.send_event(gst.event_new_eos())
def stop_listening( self ):
"""Stop listening"""
if self._pipeline:
self._pipeline.set_state(gst.STATE_NULL)
self._pipeline.send_event( gst.event_new_eos() )
self._pipeline = None
def _on_eater_blocked(self, pad, blocked):
self._on_pad_blocked(pad, blocked)
if blocked:
peer = pad.get_peer()
peer.send_event(gst.event_new_eos())
def teardown(self):
if self.pipeline:
self.pipeline.send_event(gst.event_new_eos())
self.pipeline.set_state(gst.STATE_NULL)
def teardown(self):
if self._pipeline:
# self._pipeline.remove(self._sourceBin)
# self._pipeline.remove(self._sinkBin)
self._pipeline.send_event(gst.event_new_eos())
self._pipeline.set_state(gst.STATE_NULL)
def stop_loop(self):
self.pipeline.send_event(gst.event_new_eos())
self.pipeline.set_state(gst.STATE_NULL)
self.loop.quit()
def terminate(self):
self.terminating = True
self.el_feed.send_event(gst.event_new_eos())
def dec_handoff_out(self, element, buffer):
self.output_buffers += 1
if self.output_buffers < self.num_buffers:
return
self.pipeline.send_event(gst.event_new_eos())
def dec_handoff_out(self, element, buffer): self.output_buffers += 1 if self.output_buffers < self.num_buffers: return self.pipeline.send_event(gst.event_new_eos())
def teardown(self):
if self._pipeline:
# self._pipeline.remove(self._sourceBin)
# self._pipeline.remove(self._sinkBin)
self._pipeline.send_event(gst.event_new_eos())
self._pipeline.set_state(gst.STATE_NULL)
def send_eos(self, *args):
logger.info("Sending EOS")
event = gst.event_new_eos()
gst.Element.send_event(self.pipeline, event)
def teardown(self):
if self.pipeline:
self.pipeline.send_event(gst.event_new_eos())
self.pipeline.set_state(gst.STATE_NULL)
def stop(self):
self.src.send_event(gst.event_new_eos())
def stop(self):
self.source.send_event(gst.event_new_eos())
def doControlledShutdown(self):
logInfo("doing regular controlled shutdown")
#self.pipeline.send_event(gst.event_new_eos())
for pad in self.muxer.sink_pads():
threads.deferToThread(pad.send_event, gst.event_new_eos())
def stop_listening(self):
"""Stop listening"""
if self._pipeline:
self._pipeline.set_state(gst.STATE_NULL)
self._pipeline.send_event(gst.event_new_eos())
self._pipeline = None
def EOS(self):
self.pipeline.send_event(gst.event_new_eos())
def teardown(self):
if self._videoSrc:
self._videoSrc.send_event(gst.event_new_eos())
self._videoSrc.set_state(gst.STATE_NULL)
self._videoSrc = None
def teardown(self):
if self._videoSrc:
self._videoSrc.send_event(gst.event_new_eos())
self._videoSrc.set_state(gst.STATE_NULL)
self._videoSrc = None