def PassThroughAudioSegment(tmpFilePath, edit, backplane_name):
"""\
Prefab.
For a particular edit decision; reads in the audio frames corresponding to
the video frames referred to in the reframing instructions in sequence.
Outputs the audio frames out of the "outbox" outbox.
Arguments:
- edlfile -- full filepathname of the EDL xml file
- tmpFilePath -- temp directory into which video frames have been saved
Inboxes:
- "inbox" -- NOT USED
- "control" -- Shutdown signalling
Outboxes:
- "outbox" -- raw audio data, chunked by frames
- "signal" -- Shutdown signalling
"""
print " Audio segment: ", edit
filenames = [
tmpFilePath + "%08d.wav" % i
for i in range(edit["start"], edit["end"] + 1)
]
return Graphline( \
FILENAMES = ForwardIteratingChooser(filenames),
FRAME_LOADER = Carousel( lambda filename :
Graphline(
READ = MaxSpeedFileReader(filename),
PARS = WAVParser(),
META = PublishTo(backplane_name),
linkages = {
("READ","outbox") : ("PARS","inbox"),
("PARS","outbox") : ("","outbox"),
("PARS","all_meta") : ("META","inbox"),
("","control") : ("READ","control"),
("READ","signal") : ("PARS","control"),
("PARS","signal") : ("META","control"),
("META","signal") : ("","signal"),
},
boxsizes = { ("PARS","inbox") : 2 },
),
make1stRequest=False ),
linkages = {
("FRAME_LOADER", "requestNext") : ("FILENAMES", "inbox"),
("FILENAMES", "outbox") : ("FRAME_LOADER", "next"),
("FRAME_LOADER", "outbox") : ("", "outbox"),
("FILENAMES", "signal") : ("FRAME_LOADER", "control"),
("FRAME_LOADER", "signal") : ("", "signal"),
},
)
def initComponents(self):
sub = SubscribeTo("JID")
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
pub = PublishTo("DISCO_FEAT")
self.link((self, 'features-announce'), (pub, 'inbox'))
self.addChildren(pub)
pub.activate()
sub = SubscribeTo("BOUND")
self.link((sub, 'outbox'), (self, 'initiate'))
self.addChildren(sub)
sub.activate()
return 1
def initComponents(self):
sub = SubscribeTo("JID")
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
pub = PublishTo("DISCO_FEAT")
self.link((self, 'features-announce'), (pub, 'inbox'))
self.addChildren(pub)
pub.activate()
sub = SubscribeTo("BOUND")
self.link((sub, 'outbox'), (self, 'initiate'))
self.addChildren(sub)
sub.activate()
return 1
def FilteringPubsubBackplane(backplaneID, **FilterTagWrapperOptions):
"""Sends tagged events to a backplane. Emits events not tagged by this pubsub."""
return FilterAndTagWrapper(
Pipeline(
PublishTo(backplaneID),
# well, should be to separate pipelines, this is lazier!
SubscribeTo(backplaneID),
),
**FilterTagWrapperOptions)
def EchoEveryone(**kwargs):
peer = str(kwargs.get("peer", "<>"))
peerport = str(kwargs.get("peerport", "<>"))
return Pipeline(
PureTransformer(lambda x: "%s:%s says %s" % (peer, peerport, x)),
PublishTo("CHAT_ONE"),
# ------------
SubscribeTo("CHAT_ONE"),
)
def ChatClient(*argc, **argd):
peer = argd["peer"]
peerport = argd["peerport"]
return Pipeline(
PureTransformer(lambda x: " %s:%s says %s" %
(str(peer), str(peerport), str(x))),
PublishTo("CHAT"), # Take data from client and publish to all clients
# ----------------------
SubscribeTo("CHAT"
), # Take data from other clients and send to our client
PureTransformer(lambda x: "Chat:" + str(x).strip() + "\n"),
)
def connectToLogger(component, logger_name):
"""
This method is used to connect a method with a log outbox to a logger.
"""
component.LoggerName = logger_name
publisher = PublishTo('LOG_' + logger_name)
graph = Graphline( COMPONENT = component,
PUBLISHER = publisher,
linkages = {
('COMPONENT', 'log') : ('PUBLISHER', 'inbox'),
('COMPONENT', 'signal') : ('PUBLISHER', 'control'),
})
graph.activate()
component.addChildren(publisher, graph)
REMWCCANVAS=ProperSurfaceDisplayer(displaysize=(190, 140 * 4 + 4),
position=(1024 - 191, 32 + 140 + 3),
bgcolour=(0, 0, 0),
webcam=2),
CAM_SPLITTER=TwoWaySplitter(),
CONSOLE=ConsoleEchoer(),
linkages={
('', 'inbox'): ('REMWCCANVAS', 'inbox'),
('LOCALWEBCAM', 'outbox'): ('CAM_SPLITTER', 'inbox'),
('CAM_SPLITTER', 'outbox2'): ('WCCANVAS', 'inbox'),
('CAM_SPLITTER', 'outbox'): ('', 'outbox'),
})
# primary whiteboard
Pipeline(SubscribeTo("WHITEBOARD"), TagAndFilterWrapper(mainsketcher),
PublishTo("WHITEBOARD")).activate()
# primary sound IO - tagged and filtered, so can't hear self
Pipeline(
SubscribeTo("AUDIO"),
TagAndFilterWrapperKeepingTag(
Pipeline(
RawAudioMixer(),
SoundOutput(),
######
SoundInput(),
), ),
PublishTo("AUDIO"),
).activate()
# primary webcam - capture > to jpeg > framing > backplane > TCPC > Deframing > etc
from Kamaelia.UI.Pygame.Display import PygameDisplay
from Kamaelia.UI.Pygame.VideoOverlay import VideoOverlay
from Kamaelia.Util.Backplane import Backplane, PublishTo, SubscribeTo
from Kamaelia.Util.RateFilter import MessageRateLimit
PygameDisplay.setDisplayService(
PygameDisplay(width=1024, height=500).activate())
Pipeline(
UnixProcess("ffmpeg -i " + infile +
" -f yuv4mpegpipe -y /dev/stdout"),
2,
YUV4MPEGToFrame(),
50,
MessageRateLimit(25, 25),
PublishTo("VIDEO"),
Backplane("VIDEO"),
StopSelector(waitForTrigger=True),
).activate()
Pipeline(
SubscribeTo("VIDEO"),
TagWithSequenceNumber(),
DetectShotChanges(threshold),
FormatOutput(),
ConsoleEchoer(),
).activate()
Pipeline(SubscribeTo("VIDEO"), VideoOverlay()).run()
linkages={
("CANVAS", "eventsOut"): ("PAINTER", "inbox"),
#("PAINTER", "outbox") : ("CANVAS", "inbox"),
("PAINTER", "outbox"): ("TWOWAY", "inbox"),
#("CLEAR", "outbox") : ("CANVAS", "inbox"),
("CALIBRATE", "outbox"): ("CANVAS", "inbox"),
#("CANVAS", "toApp") : ("CALIBRATE", "coords"),
("TWOWAY", "outbox"): ("CALIBRATE", "coords"),
("TWOWAY", "outbox2"): ("CANVAS", "inbox"),
("CALIBBUTTON", "outbox"): ("CALIBRATE", "inbox"),
("CALIBRATE", "finaldata"): ("FILEWRITER", "inbox"),
("FILEWRITER", "outbox"): ("CALIBRATE", "inbox"),
},
)
if __name__ == "__main__":
mainsketcher = \
Graphline( SKETCHER = makeBasicSketcher(width=1024,height=768),
linkages = { ('','inbox'):('SKETCHER','inbox'),
('SKETCHER','outbox'):('','outbox'),
}
)
# primary calibrator
Pipeline(SubscribeTo("CALIBRATOR"), TagAndFilterWrapper(mainsketcher),
PublishTo("CALIBRATOR")).activate()
print("Starting calibration...")
Backplane("CALIBRATOR").run()
("", "request") : ("PSI", "request"),
}
),
{"PSI_Tables":"request"}
).activate()
# ------------------------------------------------------------------------------
# now and next data on a backplane
Pipeline(
Subscribe("PSI_Tables", [EIT_PID]),
ParseEventInformationTable_Subset(True, False, False, False),
FilterOutNotCurrent(),
SimplifyEIT(),
NowNextProgrammeJunctionDetect(),
PublishTo("nowEvents"),
).activate()
Backplane("nowEvents").activate()
# ------------------------------------------------------------------------------
# A service to map textual channel names to service_id's
RegisterService( \
Graphline( TABLE_SOURCE = Subscribe("PSI_Tables", [SDT_PID]),
PARSING = ParseServiceDescriptionTable_ActualTS(),
LOOKUP = ChannelNameLookupService(),
linkages = {
("","inbox") : ("LOOKUP", "request"),
("TABLE_SOURCE", "outbox") : ("PARSING", "inbox"),
("PARSING", "outbox") : ("LOOKUP", "inbox"),
mode = None
source = None
sink = None
priorselected = None
selected = None
Backplane("VIS").activate()
Backplane("UI_Events").activate()
X = Pipeline(
SubscribeTo("VIS"),
chunks_to_lines(),
lines_to_tokenlists(),
AxonVisualiser(position=(0,0)),
ConsoleEchoer(forwarder=True),
PublishTo("UI_Events"),
).activate()
Graphline(
EXAMPLE = example,
ADDASSET = Button(caption="ADD ASSET", position=(800, 20), msg='add'),
LINKER = Button(caption="LINK", position=(800, 53), msg=("MAKELINKTO",) ),
EVENTS = SubscribeTo("UI_Events"),
MAGIC = Magic(),
ASSETS = AssetManager(),
CONTROL = PublishTo("VIS"),
linkages = {
("EVENTS","outbox") : ("MAGIC","nodeselect"),
("LINKER","outbox") : ("MAGIC","makelink"),
if self.dataReady("control"):
data = self.recv("control")
print "Control: %s" % data
self.send(producerFinished(self), "signal")
return
#if not self.anyReady():
# self.pause()
yield 1
backplane = Backplane("SAMPLE")
backplane.activate()
producer = Producer()
consumer = Consumer()
published = PublishTo("SAMPLE")
subscribe = SubscribeTo("SAMPLE")
pipe1 = Pipeline(
producer,
published,
)
pipe1.activate()
pipe2 = Pipeline(
subscribe,
consumer
)
consumer2 = Consumer()
consumer2.activate()
def setup(self):
# Backplanes are like a global entry points that
# can be accessible both for publishing and
# recieving data.
# In other words, a component interested
# in advertising to many other components that
# something happened may link one of its outbox
# to a PublishTo component's inbox.
# A component wishing to receive that piece of
# information will link one of its inbox
# to the SubscribeTo component's outbox.
# This helps greatly to make components more
# loosely connected but also allows for some data
# to be dispatched at once to many (such as when
# the server returns the per-session JID that
# is of interest for most other components).
Backplane("CONSOLE").activate()
Backplane("JID").activate()
# Used to inform components that the session is now active
Backplane("BOUND").activate()
# Used to inform components of the supported features
Backplane("DISCO_FEAT").activate()
sub = SubscribeTo("JID")
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
log = Logger(path=None, stdout=True, name='XmppLogger')
Backplane('LOG_' + self.log_location).activate()
Pipeline(SubscribeTo('LOG_' + self.log_location), log).activate()
log_writable = WsgiLogWritable(self.log_location)
log.activate()
log_writable.activate()
# We pipe everything typed into the console
# directly to the console backplane so that
# every components subscribed to the console
# backplane inbox will get the typed data and
# will decide it it's of concern or not.
Pipeline(ConsoleReader(), PublishTo('CONSOLE')).activate()
# Add two outboxes ro the ClientSteam to support specific extensions.
ClientStream.Outboxes["%s.query" % XMPP_IBR_NS] = "Registration"
ClientStream.Outboxes["%s.query" % XMPP_LAST_NS] = "Activity"
ClientStream.Outboxes["%s.query" % XMPP_DISCO_INFO_NS] = "Discovery"
self.client = ClientStream(self.jid, self.passwordLookup, use_tls=self.usetls)
WsgiConfig ={
'server_software' : "Example WSGI Web Server",
'server_admin' : "Jason Baker",
'wsgi_ver' : (1,0),
}
routing = [ ["/", SimpleWsgiFactory(log_writable, WsgiConfig, simple_app, '/simple')], ]
#routing = [ ['/', Echoer]]
self.graph = Graphline(client = self,
console = SubscribeTo('CONSOLE'),
logger = PublishTo('LOG_' + self.log_location),
tcp = TCPClient(self.server, self.port),
xmlparser = XMLIncrParser(),
xmpp = self.client,
streamerr = StreamError(),
saslerr = SaslError(),
discohandler = DiscoHandler(self.jid, self.domain),
activityhandler = ActivityHandler(),
rosterhandler = RosterHandler(self.jid),
registerhandler = RegistrationHandler(self.username, self.password),
msgdummyhandler = WebMessageHandler(),
presencehandler = PresenceHandler(),
presencedisp = PresenceDispatcher(),
rosterdisp = RosterDispatcher(),
msgdisp = MessageDispatcher(),
discodisp = DiscoveryDispatcher(),
activitydisp = ActivityDispatcher(),
registerdisp = RegisterDispatcher(),
pjid = PublishTo("JID"),
pbound = PublishTo("BOUND"),
proto_man = ProtocolManager(Protocol=HTTPProtocol(routing)),
linkages = {('xmpp', 'terminated'): ('client', 'inbox'),
('console', 'outbox'): ('client', 'control'),
('client', 'forward'): ('xmpp', 'forward'),
('client', 'outbox'): ('tcp', 'inbox'),
('client', 'signal'): ('tcp', 'control'),
("tcp", "outbox") : ("xmlparser", "inbox"),
("xmpp", "starttls") : ("tcp", "makessl"),
("tcp", "sslready") : ("xmpp", "tlssuccess"),
("xmlparser", "outbox") : ("xmpp" , "inbox"),
("xmpp", "outbox") : ("tcp" , "inbox"),
("xmpp", "reset"): ("xmlparser", "reset"),
("client", "log"): ("logger", "inbox"),
("xmpp", "log"): ("logger", "inbox"),
("xmpp", "jid"): ("pjid", "inbox"),
("xmpp", "bound"): ("pbound", "inbox"),
("xmpp", "features"): ("client", "streamfeat"),
("client", "doauth"): ("xmpp", "auth"),
# Registration
("xmpp", "%s.query" % XMPP_IBR_NS): ("registerdisp", "inbox"),
("registerdisp", "log"): ('logger', "inbox"),
("registerdisp", "xmpp.error"): ("registerhandler", "error"),
("registerdisp", "xmpp.result"): ("registerhandler", "inbox"),
("registerhandler", "outbox"): ("registerdisp", "forward"),
("client", "doregistration"): ("registerdisp", "forward"),
("registerdisp", "outbox"): ("xmpp", "forward"),
# Presence
("xmpp", "%s.presence" % XMPP_CLIENT_NS): ("presencedisp", "inbox"),
("presencedisp", "log"): ('logger', "inbox"),
("presencedisp", "xmpp.subscribe"): ("presencehandler", "subscribe"),
("presencedisp", "xmpp.unsubscribe"): ("presencehandler", "unsubscribe"),
("presencehandler", "outbox"): ("presencedisp", "forward"),
("presencehandler", "roster"): ("rosterdisp", "forward"),
("presencedisp", "outbox"): ("xmpp", "forward"),
# Roster
("xmpp", "%s.query" % XMPP_ROSTER_NS): ("rosterdisp", "inbox"),
("rosterdisp", "log"): ('logger', "inbox"),
('rosterdisp', 'xmpp.set'): ('rosterhandler', 'pushed'),
('rosterdisp', 'xmpp.result'): ('rosterhandler', 'inbox'),
('rosterhandler', 'result'): ('rosterdisp', 'forward'),
("rosterdisp", "outbox"): ("xmpp", "forward"),
# Discovery
("xmpp", "%s.query" % XMPP_DISCO_INFO_NS): ("discodisp", "features.inbox"),
("discodisp", "log"): ('logger', "inbox"),
("discohandler", "features-disco"): ('discodisp', "features.forward"),
("discodisp", "out.features.result"): ('discohandler', "features.result"),
("discodisp", "outbox"): ("xmpp", "forward"),
# Message
("xmpp", "%s.message" % XMPP_CLIENT_NS): ("msgdisp", "inbox"),
("msgdisp", "log"): ('logger', "inbox"),
("msgdisp", "xmpp.chat"): ('msgdummyhandler', 'inbox'),
("msgdummyhandler", "outbox"): ('msgdisp', 'forward'),
("msgdisp", "outbox"): ("xmpp", "forward"),
('msgdummyhandler', 'proto') : ('proto_man' , 'inbox'),
('proto_man', 'outbox') : ('msgdummyhandler', 'inbox'),
# Activity
("xmpp", "%s.query" % XMPP_LAST_NS): ("activitydisp", "inbox"),
("activitydisp", "log"): ('logger', "inbox"),
("activitydisp", "outbox"): ("xmpp", "forward"),
("activityhandler", 'activity-supported'): ('rosterhandler', 'ask-activity'),
("rosterhandler", 'activity'): ('activitydisp', 'forward'),
}
)
self.addChildren(self.graph)
self.graph.activate()
return 1
camera = Graphline( LOCALWEBCAM = VideoCaptureSource(),
WCCANVAS = ProperSurfaceDisplayer(displaysize = (190, 140), position = (1024-191,32+2), bgcolour=(0,0,0), webcam = 1),
REMWCCANVAS = ProperSurfaceDisplayer(displaysize = (190, 140*4+4), position = (1024-191,32+140+3), bgcolour=(0,0,0), webcam = 2),
CAM_SPLITTER = TwoWaySplitter(),
CONSOLE = ConsoleEchoer(),
linkages = { ('','inbox'):('REMWCCANVAS','inbox'),
('LOCALWEBCAM','outbox'):('CAM_SPLITTER','inbox'),
('CAM_SPLITTER','outbox2'):('WCCANVAS','inbox'),
('CAM_SPLITTER','outbox'):('','outbox'),
}
)
# primary whiteboard
Pipeline( SubscribeTo("WHITEBOARD"),
TagAndFilterWrapper(mainsketcher),
PublishTo("WHITEBOARD")
).activate()
# primary sound IO - tagged and filtered, so can't hear self
Pipeline( SubscribeTo("AUDIO"),
TagAndFilterWrapperKeepingTag(
Pipeline(
RawAudioMixer(),
SoundOutput(),
######
SoundInput(),
),
),
PublishTo("AUDIO"),
).activate()