def _on_vader_stop(self, vader, pos):
scarlett.log.debug(Fore.YELLOW + "Inside _on_vader_stop")
"""Send stop position as a message on the bus."""
import gst
struct = gst.Structure("stop")
pos = pos / 1000000000 # ns to s
struct.set_value("stop", pos)
def asr_result(self, asr, text, uttid):
"""Forward result signals on the bus to the main thread."""
struct = gst.Structure('result')
struct.set_value('hyp', text)
struct.set_value('uttid', uttid)
asr.post_message(gst.message_new_application(asr, struct))
def setup(self, conference, pipeline, participant, type):
relays = []
for r in self._stream.relays:
relay = gst.Structure("relay")
relay.set_value("username", r.username)
relay.set_value("password", r.password)
relay.set_value("ip", r.ip)
relay.set_value("port", r.port, "uint")
relays.append(relay)
if type in (MediaSessionType.SIP, MediaSessionType.TUNNELED_SIP):
if type is MediaSessionType.TUNNELED_SIP:
compatibility_mode = 3
else:
compatibility_mode = 2
params = {
"stun-ip": "64.14.48.28",
"stun-port": 3478,
"compatibility-mode": compatibility_mode,
"controlling-mode": self._stream.created_locally,
"relay-info": relays
}
else:
params = {}
media_type = media_types[self._stream.name]
self.fssession = conference.new_session(media_type)
self.fssession.set_codec_preferences(build_codecs(self._stream.name))
self.fsstream = self.fssession.new_stream(participant,
self._stream.direction,
"nice", params)
self.fsstream.connect("src-pad-added", self.on_src_pad_added, pipeline)
source = make_source(self._stream.name)
pipeline.add(source)
source.get_pad("src").link(self.fssession.get_property("sink-pad"))
pipeline.set_state(gst.STATE_PLAYING)
def __run_cmd__(self, listener, text, uttid):
"""We're inside __run_cmd__"""
scarlett.log.debug(Fore.YELLOW + "Inside __run_cmd__")
struct = gst.Structure('result')
struct.set_value('hyp', text)
struct.set_value('uttid', uttid)
listener.post_message(gst.message_new_application(listener, struct))
def vader_stop(self, vader, ts):
"""
Forward VADER stop signals on the bus to the main thread.
"""
struct = gst.Structure('vader_stop')
# Ignore the timestamp for now because gst-python is buggy
vader.post_message(gst.message_new_application(vader, struct))
def asr_result(self, asr, text, uttid):
print "asr result ----------------"
struct = gst.Structure("result")
struct.set_value("hyp", text)
struct.set_value("uttid", uttid)
self.debugMsg("asr result: " + text, 0)
asr.post_message(gst.message_new_application(asr, struct))
def handoff(self, element, buffer):
self.frame_count += 1
if (self.frame_count %
(self.framerate * self.__RESOLUTION_CHANGE_INTERVAL) == 0):
try:
tmp = self.tested_resolutions[self.index].split(",")
except IndexError:
# no more format changes
return True
target_res = tmp[0]
target_bitrate = int(tmp[1])
target_fps = int(tmp[2])
target_format = tmp[3]
self.index += 1
enc = self.pipeline.get_by_name("encoder")
enc.props.bitrate = target_bitrate
caps = self.pipeline.get_by_name("capsf")
print "Previous caps: " + str(caps.get_property("caps"))
width, height = [int(x) for x in target_res.split("x")]
s = gst.Structure("video/x-raw-yuv")
s["format"] = gst.Fourcc(target_format)
s["width"] = width
s["height"] = height
s["framerate"] = gst.Fraction(target_fps, 1)
caps.set_property("caps", gst.Caps(s))
print "Switched to: " + str(caps.get_property("caps"))
return True
def _on_vader_start(self, vader, pos):
scarlett.log.debug(Fore.YELLOW + "Inside _on_vader_start")
"""Send start position as a message on the bus."""
import gst
struct = gst.Structure("start")
pos = pos / 1000000000 # ns to s
struct.set_value("start", pos)
vader.post_message(gst.message_new_application(vader, struct))
def start_recording(self):
structure = gst.Structure("shifter-start-recording")
event = gst.event_new_custom(gst.EVENT_CUSTOM_UPSTREAM, structure)
res = self.pipeline.send_event(event)
if res:
print "start recording"
else:
gst.error("start recording failed")
def process_handoff(self, fakesink, buffer_, pad):
# When this function is called the first buffer has reached the end of
# the pipeline, and we can continue with the next track. Since we're
# in another thread, we send a message back to the main thread using
# the bus.
structure = gst.Structure('handoff')
message = gst.message_new_application(fakesink, structure)
bus = self.pipe.get_bus()
bus.post(message)
def blocked(x, is_blocked):
if not x in self.pads_awaiting_block:
return
self.pads_awaiting_block.remove(x)
if not self.pads_awaiting_block:
s = gst.Structure('pads-blocked')
m = gst.message_new_application(pipeline, s)
# marshal to the main thread
pipeline.post_message(m)
def _pad_added(element, pad, pipeline):
sink = gst.element_factory_make('fakesink')
sink.set_property('sync', False)
pipeline.add(sink)
sink.sync_state_with_parent()
pad.link(sink.get_pad('sink'))
if pad.get_caps().is_subset(_RAW_AUDIO):
struct = gst.Structure('have-audio')
element.get_bus().post(gst.message_new_application(element, struct))
def asr_partial_result(self, asr, text, uttid):
"""
Forward partial result signals on the bus to the main thread.
"""
#print text
#send the hypothesis on the socket connection
#self.conn.send(text)
struct = gst.Structure('partial_result')
struct.set_value('hyp', text)
struct.set_value('uttid', uttid)
asr.post_message(gst.message_new_application(asr, struct))
def create_pipeline(self):
p = gst.Pipeline()
width, height = self.framesize.split("x")
width, height = int(width), int(height)
if self.location:
src = gst.element_factory_make("filesrc")
src.props.location = self.location
if self.format == "I420":
bpp = 1.5
elif self.format == "UYVY":
bpp = 2
src.props.blocksize = int(width * height * bpp)
else:
src = gst.element_factory_make("videotestsrc")
src.props.num_buffers = self.num_buffers
bitrate = self.bitrate
enc = gst.element_factory_make(self.element)
if self.mode is not None:
enc.props.mode = self.mode
if bitrate:
enc.props.bitrate = bitrate
sink = gst.element_factory_make("fakesink")
s = gst.Structure("video/x-raw-yuv")
s["format"] = gst.Fourcc(self.format)
s["width"] = width
s["height"] = height
s["framerate"] = gst.Fraction(self.framerate, 1)
tee = gst.element_factory_make("tee")
queue = gst.element_factory_make("multiqueue")
ssim = gst.element_factory_make("xssim")
dec = gst.element_factory_make("avvdec")
p.add(tee, queue, ssim, dec)
capf = gst.element_factory_make("capsfilter")
capf.props.caps = gst.Caps(s)
p.add(src, capf, enc, sink)
gst.element_link_many(src, capf, tee)
gst.element_link_many(tee, enc, dec, queue, ssim)
ssim.connect("got_results", self.got_results)
gst.element_link_many(tee, queue, ssim)
ssim.link(sink)
return p
def testBusElement(self):
bag = {'called': False}
def finish_analysis(reason):
bag['called'] = True
self.discoverer._finishAnalysis = finish_analysis
self.failUnlessEqual(self.discoverer.error, None)
src = gst.Pad('src', gst.PAD_SRC)
# we ignore non-redirect messages
structure = gst.Structure('meh')
message = gst.message_new_element(src, structure)
self.discoverer._busMessageElementCb(None, message)
self.failUnlessEqual(self.discoverer.error, None)
self.failUnlessEqual(bag['called'], False)
# error out on redirects
structure = gst.Structure('redirect')
message = gst.message_new_element(src, structure)
self.discoverer._busMessageElementCb(None, message)
self.failIfEqual(self.discoverer.error, None)
self.failUnlessEqual(bag['called'], True)
def asr_result(self, asr, text, uttid):
"""
Forward result signals on the bus to the main thread.
"""
print text
#send the hypothesis on the socket connection
self.conn.send(text)
struct = gst.Structure('result')
struct.set_value('hyp', text)
struct.set_value('uttid', uttid)
#self.dag = pocketsphinx.Lattice(boxed=asr.get_property('lattice'))
asr.post_message(gst.message_new_application(asr, struct))
def handle(self, uris):
struct = gst.Structure('urilist-played')
event = gst.event_new_custom(gst.EVENT_CUSTOM_UPSTREAM, struct)
self.sinkpad.push_event(event)
# TODO: hookup about to finish and errors to rest of URIs so we
# round robin, only giving up once all have been tried.
# TODO: uris could be empty.
self.add(self.uridecodebin)
self.uridecodebin.set_state(gst.STATE_READY)
self.uridecodebin.set_property('uri', uris[0])
self.uridecodebin.sync_state_with_parent()
return True # Make sure we consume the EOS that triggered us.
def _send_event(self, timestamp):
clock = self.get_clock()
if clock is not None:
running_time = clock.get_time() - self.get_base_time()
else:
running_time = 0
s = gst.Structure("GstForceKeyUnit")
s.set_value('timestamp', timestamp, 'uint64')
s.set_value('stream-time', timestamp, 'uint64')
s.set_value('running-time', running_time, 'uint64')
s.set_value('all-headers', True)
s.set_value('count', self._count)
return self.srcpad.push_event(
gst.event_new_custom(gst.EVENT_CUSTOM_DOWNSTREAM, s))
def create_pipeline(self):
p = gst.Pipeline()
width, height = self.framesize.split("x")
width, height = int(width), int(height)
if self.location:
src = gst.element_factory_make("filesrc")
src.props.location = self.location
if self.format == "I420":
bpp = 1.5
elif self.format == "UYVY":
bpp = 2
src.props.blocksize = int(width * height * bpp)
else:
src = gst.element_factory_make("videotestsrc")
src.props.num_buffers = self.num_buffers
self.bitrates = self.bitrateseq.split(',')
bitrate = self.bitrate
enc = gst.element_factory_make(self.element, "encoder")
enc.props.bitrate = bitrate
enc.props.max_bitrate = self.max_bitrate
if self.mode is not None:
enc.props.mode = self.mode
if self.intra_refresh is not None:
enc.props.intra_refresh = self.intra_refresh
s = gst.Structure("video/x-raw-yuv")
s["format"] = gst.Fourcc(self.format)
s["width"] = width
s["height"] = height
s["framerate"] = gst.Fraction(self.framerate, 1)
capf_raw = gst.element_factory_make("capsfilter")
capf_raw.props.caps = gst.Caps(s)
ident = gst.element_factory_make("identity")
videorate = gst.element_factory_make("videorate")
sink = gst.element_factory_make("fakesink")
p.add(src, capf_raw, videorate, enc, ident, sink)
gst.element_link_many(src, capf_raw, videorate, enc, ident, sink)
ident.connect("handoff", self.handoff)
ident.set_property("signal-handoffs", True)
return p
def setup(self, conference, pipeline, participant, type):
relays = []
for r in self._stream.relays:
relay = gst.Structure("relay")
relay.set_value("username", r.username)
relay.set_value("password", r.password)
relay.set_value("ip", r.ip)
relay.set_value("port", r.port, "uint")
relays.append(relay)
if type in (MediaSessionType.SIP, MediaSessionType.TUNNELED_SIP):
if type is MediaSessionType.TUNNELED_SIP:
compatibility_mode = 3
else:
compatibility_mode = 2
params = {
"stun-ip": "64.14.48.28",
"stun-port": 3478,
"compatibility-mode": compatibility_mode,
"controlling-mode": self._stream.created_locally,
"relay-info": relays
}
else:
params = {}
media_type = media_types[self._stream.name]
self.fssession = conference.new_session(media_type)
self.fssession.set_codec_preferences(build_codecs(self._stream.name))
self.fsstream = self.fssession.new_stream(participant,
self._stream.direction,
"nice", params)
self.fsstream.connect("src-pad-added", self.on_src_pad_added, pipeline)
source = make_source(self._stream.name)
pipeline.add(source)
def on_src_message(bus, msg):
if msg.structure is None:
return
if msg.structure.get_name() == "prepare-xwindow-id":
msg.src.set_xwindow_id(self.surface_self)
print "XID222222"
#bus = pipeline.get_bus()
#bus.add_signal_watch()
#bus.enable_sync_message_emission()
#bus.connect("sync-message::element", on_src_message)
source.get_pad("src").link(self.fssession.get_property("sink-pad"))
pipeline.set_state(gst.STATE_PLAYING)
def __init__(self,
filename,
outTemplate,
width=None,
height=None,
framerate=None):
self.framerate = None
self.width = None
self.height = None
self.outfileTemplate = outTemplate
# TODO: What's a reasonable windowSize to use?
windowSize = 20
self.window = SlidingWindow(windowSize)
self.samples = 0
self.data = ([], [], [])
self.pipeline = pipeline = gst.Pipeline()
self.bus = pipeline.get_bus()
filesrc = gst.element_factory_make("filesrc")
decodebin = gst.element_factory_make("decodebin")
self.ffmpegcolorspace = gst.element_factory_make("ffmpegcolorspace")
videorate = gst.element_factory_make("videorate")
videoscale = gst.element_factory_make("videoscale")
self.theoraenc = gst.element_factory_make("theoraenc")
fakesink = gst.element_factory_make("fakesink")
filesrc.set_property("location", filename)
pipeline.add(filesrc, decodebin, self.ffmpegcolorspace, videorate,
videoscale, self.theoraenc, fakesink)
filesrc.link(decodebin)
gst.element_link_many(self.ffmpegcolorspace, videorate, videoscale)
structure = gst.Structure("video/x-raw-yuv")
if height:
structure['height'] = height
if width:
structure['width'] = width
if framerate:
structure['framerate'] = framerate
caps = gst.Caps(structure)
videoscale.link(self.theoraenc, caps)
self.theoraenc.link(fakesink)
decodebin.connect("new-decoded-pad", self._pad_added_cb)
def create_pipeline(self):
p = gst.Pipeline()
width, height = self.framesize.split("x")
width, height = int(width), int(height)
src = gst.element_factory_make("videotestsrc")
src.props.num_buffers = self.num_buffers
bitrate = self.bitrate
scaler = gst.element_factory_make("videoscale")
enc = gst.element_factory_make(self.element, "encoder")
if self.mode is not None:
enc.props.mode = self.mode
if self.intra_refresh is not None:
enc.props.intra_refresh = self.intra_refresh
enc.props.bitrate = bitrate
ident = gst.element_factory_make("identity")
sink = gst.element_factory_make("fakesink")
s = gst.Structure("video/x-raw-yuv")
s["format"] = gst.Fourcc(self.format)
s["width"] = width
s["height"] = height
s["framerate"] = gst.Fraction(self.framerate, 1)
caps = gst.element_factory_make("capsfilter", "capsf")
caps.props.caps = gst.Caps(s)
p.add(src, scaler, caps, enc, ident, sink)
gst.element_link_many(src, scaler, caps, enc, ident, sink)
ident.connect("handoff", self.handoff)
ident.set_property("signal-handoffs", True)
return p
def testReceivingTagEvent(self):
d = self._initComp()
d.addCallback(lambda _: comptest.delayed_d(0.1, _))
def assertTitleSet(title):
self.assertEqual(title, \
self.comp.muxer.get_property('iradio-title'))
# check if we respond currectly for title events
d.addCallback(lambda _: self._sendTitleEvent('some title'))
d.addCallback(lambda _: comptest.delayed_d(0.8, 'some title'))
d.addCallback(assertTitleSet)
d.addCallback(lambda _: self._sendTitleEvent('some other title'))
d.addCallback(lambda _: comptest.delayed_d(0.8, 'some other title'))
d.addCallback(assertTitleSet)
# now check if the events setting response headers work
mapping = {
'icy-name': 'organization',
'icy-genre': 'genre',
'icy-url': 'location'
}
struc = gst.Structure(name='taglist')
for key in mapping:
struc.set_value(mapping[key], mapping[key])
d.addCallback(lambda _: self._sendEvent(struc))
def assertValuesInResponseHeadersSet(_):
for key in mapping:
self.assertTrue(key in self.comp.icyHeaders, key)
self.assertEqual(mapping[key], self.comp.icyHeaders[key])
d.addCallback(lambda _: comptest.delayed_d(0.5, _))
d.addCallback(assertValuesInResponseHeadersSet)
d.addCallback(lambda _: self.tp.stop_flow())
return d
def create_pipeline(self):
p = gst.Pipeline()
width, height = self.framesize.split("x")
width, height = int(width), int(height)
if self.location:
src = gst.element_factory_make("filesrc")
src.props.location = self.location
if self.format == "I420":
bpp = 1.5
elif self.format == "UYVY":
bpp = 2
src.props.blocksize = int(width * height * bpp)
else:
src = gst.element_factory_make("videotestsrc")
src.props.num_buffers = self.num_buffers
enc = gst.element_factory_make(self.element)
enc.props.bitrate = self.bitrate
sink = gst.element_factory_make("filesink")
sink.props.location = self.tmp_filename
s = gst.Structure("video/x-raw-yuv")
s["format"] = gst.Fourcc(self.format)
s["width"] = width
s["height"] = height
s["framerate"] = gst.Fraction(self.framerate, 1)
capf = gst.element_factory_make("capsfilter")
capf.props.caps = gst.Caps(s)
p.add(src, capf, enc, sink)
if not gst.element_link_many(src, capf, enc, sink):
print " pipeline creation error !!"
return p
def jump_key(self, direction):
event = gst.event_new_custom(gst.EVENT_CUSTOM_UPSTREAM,
gst.Structure(direction))
self.audiosink.send_event(event)
def flumotion_reset_event():
''' Helper method to create a 'flumotion-reset' event '''
return gst.event_new_custom(gst.EVENT_CUSTOM_DOWNSTREAM,
gst.Structure('flumotion-reset'))
def asr_partial_result(self, asr, text, uttid):
struct = gst.Structure("partial_result")
struct.set_value("hyp", text)
struct.set_value("uttid", uttid)
self.debugMsg("asr partial: " + text, 0)
asr.post_message(gst.message_new_application(asr, struct))
def on_sphinx_result(self, sphinx, text, uttid, score=None):
msg = gst.Structure('sphinx_result')
msg['text'] = text
self.bus.post(gst.message_new_application(sphinx, msg))
def _have_type(element, probability, caps, decodebin):
decodebin.set_property('sink-caps', caps)
struct = gst.Structure('have-type')
struct['caps'] = caps.get_structure(0)
element.get_bus().post(gst.message_new_application(element, struct))
def _sendTitleEvent(self, title):
struc = gst.Structure(name='taglist')
struc.set_value('title', title.encode("utf-8", "replace"))
self._sendEvent(struc)
