def stream_server_start(self, *args, **kargs): if self.is_streaming(): return logging.info('StreamServer start: {}'.format(kargs)) self._stream_server = StreamServer( kargs, lambda data: self.handler('server', data)) self._stream_server.start()
def __init__(self, target, adapter, size=None): self.client = BluetoothAsyncSocket() self.adapter = adapter self.client.bind((self.adapter.bt_address, 0)) self.target = target self.target_t = (target, 1) self.size = size if size else 'QQVGA' self.streamserver = StreamServer('0.0.0.0', CameraConnection.port) self.streamserver.create_server_socket() CameraConnection.port += 1
def run(self): server.init_storage(path=args['--path']) if args['--debug']: # gevent's monkey patch messes pudb up from streamserver import StreamServer # keep it single threaded args['--workers'] = 0 else: from gevent.server import StreamServer server.num_workers = int(args['--workers']) server.run() s = StreamServer(('0.0.0.0', int(args['--port'])), entry) s.serve_forever()
def stream_server_start(self, *args, **kargs): if self.is_streaming(): return logging.info('StreamServer start: {}'.format(kargs)) self._stream_server = StreamServer(kargs, lambda data: self.handler('server', data)) self._stream_server.start()
def __init__(self, target, adapter, size=None): self.client = BluetoothAsyncSocket() self.adapter = adapter self.client.bind( (self.adapter.bt_address, 0) ) self.target = target self.target_t = (target, 1) self.size = size if size else 'QQVGA' self.streamserver = StreamServer('0.0.0.0', CameraConnection.port) self.streamserver.create_server_socket() CameraConnection.port+=1
class Core(Thread): def __init__(self, args, extra_args): Thread.__init__(self) self._args = args self._extra_args = extra_args self._threads = [] self._event_handler = CoreEventHandler() if CrossPlatform.get().is_linux(): signal.signal(signal.SIGCHLD, self.signal_handler) signal.signal(signal.SIGTERM, self.signal_handler) def is_streaming(self): if hasattr(self, '_stream_server') and self._stream_server is not None: return True return False def stream_server_start(self, *args, **kargs): if self.is_streaming(): return logging.info('StreamServer start: {}'.format(kargs)) self._stream_server = StreamServer(kargs, lambda data: self.handler('server', data)) self._stream_server.start() def stream_server_stop(self): if hasattr(self, '_stream_server') and self._stream_server is not None: self._stream_server.stop() self._stream_server = None def playme(self, remote_ip, remote_port, service): def myip(remote_ip): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect((remote_ip, 0)) return s.getsockname()[0] def xbmc(): stream_url = self._stream_server.url.format(ip=myip(remote_ip)) url = 'http://{}:{}/xbmcCmds/xbmcHttp?command=PlayFile({})'.format( remote_ip, remote_port, stream_url) req = urllib2.Request(url) logging.info('url = {}'.format(url)) response = urllib2.urlopen(req, None, 5) result = response.read() logging.info('result: {}'.format(result)) def desktop_mirror(): stream_url = self._stream_server.url.format(ip=myip(remote_ip)) data_as_json = json.dumps({ 'method': 'Player.Open', 'id': 1, 'jsonrpc': '2.0', 'params': {'item': {'file': stream_url}}} ) url = 'http://{}:{}/jsonrpc'.format(remote_ip, remote_port) logging.info('url = {}'.format(url)) logging.info(' json = {}'.format(data_as_json)) req = urllib2.Request(url, data_as_json, {'Content-Type': 'application/json'}) response = urllib2.urlopen(req, None, 5) result = response.read() logging.info('result: {}'.format(result)) result = json.loads(result) #switch back to json with pretty format logging.debug(json.dumps(result, indent=4)) #logging.info('Got streaming url: {}'. # format(self._stream_server.url)) #if service == '_desktop-mirror._tcp': # desktop_mirror() #else: # xbmc() desktop_mirror() @property def targets(self): if not hasattr(self, '_avahi_browse'): return dict() return self._avahi_browse.targets @property def hosts(self): if not hasattr(self, '_avahi_browse'): return dict() return self._avahi_browse.hosts def run(self): self._avahi_browse = AvahiService(lambda data: self.handler('avahi', data)) self._stream_recever = StreamReceiver(lambda data: self.handler('srx', data)) self._threads.append(self._avahi_browse) self._threads.append(self._stream_recever) for thread in self._threads: thread.start() for thread in self._threads: thread.join() def stop(self): for thread in self._threads: logging.debug('Stopping thread - {}'.format(thread.name)) thread.stop() self.stream_server_stop() def launch_selection_area_process(self): SelectionArea(lambda data: self.handler('selection', data)).start() def register_listener(self, ui_window): self._event_handler.register_listener(ui_window) def on_event_relay(self, event_name, data): self._event_handler.on_event_relay(event_name, data) def on_event_stream_ready(self, event_name, data): self._event_handler.on_event_stream_ready(event_name, data) def handler(self, obj_id, data): self._event_handler.handler(obj_id, data) def signal_handler(self, signum, frame): logging.info('signal: ' + str(signum)) if signal.SIGTERM == signum: self.send_form_destroy() try: if CrossPlatform.get().is_linux(): if signal.SIGCHLD == signum: os.waitpid(-1, os.WNOHANG) except OSError: pass
class CameraConnection(): port = 10000 # class variable client = None # instance variables target = None adapter = None state = None index = 0 waiting_for_stop = False server_socket = None size = None def __init__(self, target, adapter, size=None): self.client = BluetoothAsyncSocket() self.adapter = adapter self.client.bind((self.adapter.bt_address, 0)) self.target = target self.target_t = (target, 1) self.size = size if size else 'QQVGA' self.streamserver = StreamServer('0.0.0.0', CameraConnection.port) self.streamserver.create_server_socket() CameraConnection.port += 1 def connected(self): logger.info("got connected") self.state = FSM.WELCOME self.client.setReadReady(self.data_available) if len(self.client.read_buffer) > 0: self.do_welcome() def connection_failed(self, condition): self.client.setCallback(None) self.client.setErrCallback(None) self.client.setReadReady(None) self.adapter.disconnected(self.target) def disconnect(self): self.client.setCallback(None) self.client.setErrCallback(None) self.client.setReadReady(None) self.adapter.disconnected(self.target) self.client.close() def connect(self): self.state = FSM.CONNECTING logger.info("connecting to %s from %s" % (self.target_t, self.adapter.bt_address)) if self.adapter.manager.zm_backend: self.pipe = '/tmp/camera_%s.pipe' % (self.target) if not os.path.exists(self.pipe): os.mkfifo(self.pipe) return self.client.connect_ex(self.target_t, self.connected, self.connection_failed) def do_welcome(self): if 'ACK0000' not in self.client.read_buffer: return logger.info("got welcome") self.client.read_buffer = "" self.state = FSM.SETUP protocol.set_command_mode(self.client) protocol.set_capture_mode(self.client, size=self.size) self.state = FSM.IDLE gobject.timeout_add(200, self.take_picture) def take_picture(self): logger.info("taking picture") self.state = FSM.STREAM protocol.send_command(self.client, "SET_PREVIEW_MODE") #gobject.timeout_add(300,self.ask_size) return False def ask_size(self): if self.state != FSM.ASK_SIZE: return logger.info("asking size") self.state = FSM.GET_SIZE protocol.send_command(self.client, 'GET_CAPTURE_SIZE') def get_size(self): if not CAPTURE_SIZE.match(self.client.read_buffer): return size = CAPTURE_SIZE.match(self.client.read_buffer).groupdict()['size'] self.size = size logger.info("got size %s" % size) self.state = FSM.STREAM protocol.send_command(self.client, 'START_CAPTURE_SEND') def extract_picture(self, start, end): logger.info("got picture") self.streamserver.send_to_all(self.client.read_buffer[start:end + 2], mimetype='image/jpeg') if self.adapter.manager.zm_backend: logger.info("writing %i bytes" % (end - start)) asyncpipe.write(self.pipe, self.client.read_buffer[start:end + 2]) if self.adapter.manager.op_backend: self.adapter.manager.tellListener( signals.HANDLE_PICTURE, dongle=self.adapter.bt_address, target=self.target, picture=self.client.read_buffer[start:end + 2]) self.index += 1 self.client.read_buffer = self.client.read_buffer[end + 2:] def wait_for_prompt(self): logger.info("wait for prompt") if time.time() - self.last > 2: logger.info("2 seconds without data, disconnect") self.disconnect() return False return True def do_stream(self): start, end = protocol.find_jpeg(self.client.read_buffer) if start > -1 and end > -1: self.extract_picture(start, end) if self.index == -100: protocol.send_command(self.client, 'SET_COMMAND_MODE') self.state = FSM.IDLE self.last = time.time() gobject.timeout_add(100, self.wait_for_prompt) def data_available(self, amount): if self.state == FSM.WELCOME: self.do_welcome() elif self.state == FSM.SETUP: self.do_setup() elif self.state == FSM.IDLE: logger.info("ignoring I'm in idle") self.last = time.time() self.client.read_buffer = "" elif self.state == FSM.ASK_SIZE: self.ask_size() elif self.state == FSM.GET_SIZE: self.get_size() elif self.state == FSM.STREAM: self.do_stream() else: logger.debug("not valid state %s" % self.state)
elif data == 'onpause': global lastStop droid.log("GUI has gone onPause") lastStop = time.time() elif data == 'onresume': global lastStop lastStop = None elif data.startswith('record_start'): record_start(data.split('$')[1]) elif data == 'record_stop': record_stop() else: droid.log("Not known event %s" % data) server = StreamServer('', 10000, droid) server.create_server_socket() init = True droid.toggleBluetoothState(True) camera = Camera(droid, size="QQVGA", callback=callback, err_callback=error) connect() droid.startActivity('de.mjpegsample.MjpegSample') while running: server.wait_connection() try: if len(droid.bluetoothActiveConnections().result) > 0: if droid.bluetoothReadReady():
elif data == "onpause": global lastStop droid.log("GUI has gone onPause") lastStop = time.time() elif data == "onresume": global lastStop lastStop = None elif data.startswith("record_start"): record_start(data.split("$")[1]) elif data == "record_stop": record_stop() else: droid.log("Not known event %s" % data) server = StreamServer("", 10000, droid) server.create_server_socket() init = True droid.toggleBluetoothState(True) camera = Camera(droid, size="QQVGA", callback=callback, err_callback=error) connect() droid.startActivity("de.mjpegsample.MjpegSample") while running: server.wait_connection() try: if len(droid.bluetoothActiveConnections().result) > 0: if droid.bluetoothReadReady():
class CameraConnection(): port = 10000 # class variable client = None # instance variables target = None adapter = None state = None index = 0 waiting_for_stop = False server_socket = None size = None def __init__(self, target, adapter, size=None): self.client = BluetoothAsyncSocket() self.adapter = adapter self.client.bind( (self.adapter.bt_address, 0) ) self.target = target self.target_t = (target, 1) self.size = size if size else 'QQVGA' self.streamserver = StreamServer('0.0.0.0', CameraConnection.port) self.streamserver.create_server_socket() CameraConnection.port+=1 def connected(self): logger.info("got connected") self.state = FSM.WELCOME self.client.setReadReady(self.data_available) if len(self.client.read_buffer) > 0: self.do_welcome() def connection_failed(self, condition): self.client.setCallback(None) self.client.setErrCallback(None) self.client.setReadReady(None) self.adapter.disconnected(self.target) def disconnect(self): self.client.setCallback(None) self.client.setErrCallback(None) self.client.setReadReady(None) self.adapter.disconnected(self.target) self.client.close() def connect(self): self.state = FSM.CONNECTING logger.info("connecting to %s from %s" % (self.target_t, self.adapter.bt_address)) if self.adapter.manager.zm_backend: self.pipe = '/tmp/camera_%s.pipe' % (self.target) if not os.path.exists(self.pipe): os.mkfifo(self.pipe) return self.client.connect_ex( self.target_t, self.connected, self.connection_failed) def do_welcome(self): if 'ACK0000' not in self.client.read_buffer: return logger.info("got welcome") self.client.read_buffer = "" self.state = FSM.SETUP protocol.set_command_mode(self.client) protocol.set_capture_mode(self.client, size=self.size) self.state = FSM.IDLE gobject.timeout_add(200,self.take_picture) def take_picture(self): logger.info("taking picture") self.state = FSM.STREAM protocol.send_command(self.client, "SET_PREVIEW_MODE") #gobject.timeout_add(300,self.ask_size) return False def ask_size(self): if self.state != FSM.ASK_SIZE: return logger.info("asking size") self.state = FSM.GET_SIZE protocol.send_command(self.client, 'GET_CAPTURE_SIZE') def get_size(self): if not CAPTURE_SIZE.match(self.client.read_buffer): return size = CAPTURE_SIZE.match(self.client.read_buffer).groupdict()['size'] self.size = size logger.info("got size %s" % size) self.state = FSM.STREAM protocol.send_command(self.client, 'START_CAPTURE_SEND') def extract_picture(self, start, end): logger.info("got picture") self.streamserver.send_to_all( self.client.read_buffer[start:end+2], mimetype='image/jpeg' ) if self.adapter.manager.zm_backend: logger.info("writing %i bytes" % (end-start)) asyncpipe.write(self.pipe, self.client.read_buffer[start:end+2]) if self.adapter.manager.op_backend: self.adapter.manager.tellListener( signals.HANDLE_PICTURE, dongle = self.adapter.bt_address, target = self.target, picture = self.client.read_buffer[start:end+2] ) self.index+=1 self.client.read_buffer = self.client.read_buffer[end+2:] def wait_for_prompt(self): logger.info("wait for prompt") if time.time() - self.last > 2: logger.info("2 seconds without data, disconnect") self.disconnect() return False return True def do_stream(self): start, end = protocol.find_jpeg(self.client.read_buffer) if start > -1 and end > -1: self.extract_picture(start, end) if self.index == -100: protocol.send_command(self.client, 'SET_COMMAND_MODE') self.state = FSM.IDLE self.last = time.time() gobject.timeout_add(100, self.wait_for_prompt) def data_available(self, amount): if self.state == FSM.WELCOME: self.do_welcome() elif self.state == FSM.SETUP: self.do_setup() elif self.state == FSM.IDLE: logger.info("ignoring I'm in idle") self.last = time.time() self.client.read_buffer = "" elif self.state == FSM.ASK_SIZE: self.ask_size() elif self.state == FSM.GET_SIZE: self.get_size() elif self.state == FSM.STREAM: self.do_stream() else: logger.debug("not valid state %s" % self.state)
def get_iterators_for_model(model_type, training_trace_set_paths, validation_trace_set_paths, conf, batch_size=512, hamming=False, subtype='custom', request_id=None): # Stream samples from other machine? if conf.online: stream_server = StreamServer(conf) batch_size = 32 else: stream_server = None batch_size = conf.batch_size training_iterator = None validation_iterator = None if model_type == 'aicorrnet' or model_type == 'aiascad': # TODO unify with one iterator training_iterator = AICorrSignalIterator(training_trace_set_paths, conf, batch_size=batch_size, request_id=request_id, stream_server=stream_server) validation_iterator = AICorrSignalIterator(validation_trace_set_paths, conf, batch_size=batch_size, request_id=request_id, stream_server=stream_server) elif model_type == 'aishacpu': training_iterator = AISHACPUSignalIterator(training_trace_set_paths, conf, batch_size=batch_size, request_id=request_id, stream_server=stream_server, hamming=hamming, subtype=subtype) validation_iterator = AISHACPUSignalIterator( validation_trace_set_paths, conf, batch_size=batch_size, request_id=request_id, stream_server=stream_server, hamming=hamming, subtype=subtype) elif model_type == 'aishacc': training_iterator = AISHACPUSignalIterator(training_trace_set_paths, conf, batch_size=batch_size, request_id=request_id, stream_server=stream_server, hamming=hamming, subtype='custom') validation_iterator = AISHACPUSignalIterator( validation_trace_set_paths, conf, batch_size=batch_size, request_id=request_id, stream_server=stream_server, hamming=hamming, subtype='custom') elif model_type == 'autoenc': training_iterator = AutoEncoderSignalIterator( training_trace_set_paths, conf, batch_size=batch_size, request_id=request_id, stream_server=stream_server) validation_iterator = AutoEncoderSignalIterator( validation_trace_set_paths, conf, batch_size=batch_size, request_id=request_id, stream_server=stream_server) #elif model_type == 'aiascad': # TODO Remove me # train_set, attack_set, metadata_set = load_ascad(join(conf.datasets_path, "ASCAD/ASCAD_data/ASCAD_databases/ASCAD.h5"), load_metadata=True) # metadata_train, metadata_attack = metadata_set # training_iterator = ASCADSignalIterator(train_set, meta=metadata_train) # validation_iterator = ASCADSignalIterator(attack_set, meta=metadata_attack) else: logger.error("Unknown training procedure %s specified." % model_type) exit(1) return training_iterator, validation_iterator
import modelMangler as m from model import * from lxml import etree TITLE = L('Spotify') ICON = 'icon-default.png' ART = "concert.jpeg" ABOUT = "about1_1.png" VERSION = "0.1.2" data = DataService() playback = PlaybackService() playback.start() streamserver = StreamServer(playback) cache = dict() #################################################################################################### def Start(): HTTP.CacheTime = None ObjectContainer.art = R(ART) Dict['LocalAddress']=Network.Address Dict['PublicAddress']=Network.PublicAddress Initialize() Thread.Create(refreshLibraryIndex) def Initialize(): Log.Debug("Initialize()")
# -*- coding: utf-8 -*- # Copyright (C) 2008 Simon Pantzare # See COPYING for details. import cherrypy from streamserver import StreamServer import os.path from code import interact # Let us first set up the streaming server and add some media to it. stream = StreamServer() media = [("m1.mp3", "Sample_MP3_1"), ("m2.mp3", "Sample_MP3_2"), ("va1.mpg", "Sample_MPEG"), ("vidonly1.mpg", "Sample_MPEG_video_only_1"), ("vidonly2.mpg", "Sample_MPEG_video_only_2")] for mp3 in range(0, 2): stream.addMP3(*media[mp3]) stream.addMPEG(*media[2]) for mpg in range(3, len(media)): stream.addMPEGVideo(*media[mpg]) # We could use a templating language but I think the extra dependencies is not # worth it in this case. html = """ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html lang="en"> <head><meta http-equiv="content-type" content="text/html; charset=utf-8"> <title>Streaming Server Demo</title> <script src="http://prototypejs.org/assets/2008/1/25/prototype-1.6.0.2.js"
class Core(Thread): def __init__(self, args, extra_args): Thread.__init__(self) self._args = args self._extra_args = extra_args self._threads = [] self._event_handler = CoreEventHandler() if CrossPlatform.get().is_linux(): signal.signal(signal.SIGCHLD, self.signal_handler) signal.signal(signal.SIGTERM, self.signal_handler) def is_streaming(self): if hasattr(self, '_stream_server') and self._stream_server is not None: return True return False def stream_server_start(self, *args, **kargs): if self.is_streaming(): return logging.info('StreamServer start: {}'.format(kargs)) self._stream_server = StreamServer( kargs, lambda data: self.handler('server', data)) self._stream_server.start() def stream_server_stop(self): if hasattr(self, '_stream_server') and self._stream_server is not None: self._stream_server.stop() self._stream_server = None def playme(self, remote_ip, remote_port, service): def myip(remote_ip): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect((remote_ip, 0)) return s.getsockname()[0] def xbmc(): stream_url = self._stream_server.url.format(ip=myip(remote_ip)) url = 'http://{}:{}/xbmcCmds/xbmcHttp?command=PlayFile({})'.format( remote_ip, remote_port, stream_url) req = urllib2.Request(url) logging.info('url = {}'.format(url)) response = urllib2.urlopen(req, None, 5) result = response.read() logging.info('result: {}'.format(result)) def desktop_mirror(): stream_url = self._stream_server.url.format(ip=myip(remote_ip)) data_as_json = json.dumps({ 'method': 'Player.Open', 'id': 1, 'jsonrpc': '2.0', 'params': { 'item': { 'file': stream_url } } }) url = 'http://{}:{}/jsonrpc'.format(remote_ip, remote_port) logging.info('url = {}'.format(url)) logging.info(' json = {}'.format(data_as_json)) req = urllib2.Request(url, data_as_json, {'Content-Type': 'application/json'}) response = urllib2.urlopen(req, None, 5) result = response.read() logging.info('result: {}'.format(result)) result = json.loads(result) #switch back to json with pretty format logging.debug(json.dumps(result, indent=4)) #logging.info('Got streaming url: {}'. # format(self._stream_server.url)) #if service == '_desktop-mirror._tcp': # desktop_mirror() #else: # xbmc() desktop_mirror() @property def targets(self): if not hasattr(self, '_avahi_browse'): return dict() return self._avahi_browse.targets @property def hosts(self): if not hasattr(self, '_avahi_browse'): return dict() return self._avahi_browse.hosts def run(self): self._avahi_browse = AvahiService( lambda data: self.handler('avahi', data)) self._stream_recever = StreamReceiver( lambda data: self.handler('srx', data)) self._threads.append(self._avahi_browse) self._threads.append(self._stream_recever) for thread in self._threads: thread.start() for thread in self._threads: thread.join() def stop(self): for thread in self._threads: logging.debug('Stopping thread - {}'.format(thread.name)) thread.stop() self.stream_server_stop() def launch_selection_area_process(self): SelectionArea(lambda data: self.handler('selection', data)).start() def register_listener(self, ui_window): self._event_handler.register_listener(ui_window) def on_event_relay(self, event_name, data): self._event_handler.on_event_relay(event_name, data) def on_event_stream_ready(self, event_name, data): self._event_handler.on_event_stream_ready(event_name, data) def handler(self, obj_id, data): self._event_handler.handler(obj_id, data) def signal_handler(self, signum, frame): logging.info('signal: ' + str(signum)) if signal.SIGTERM == signum: self.send_form_destroy() try: if CrossPlatform.get().is_linux(): if signal.SIGCHLD == signum: os.waitpid(-1, os.WNOHANG) except OSError: pass
# -*- coding: utf-8 -*- # Copyright (C) 2008 Simon Pantzare # See COPYING for details. import cherrypy from streamserver import StreamServer import os.path from code import interact # Let us first set up the streaming server and add some media to it. stream = StreamServer() media = [("m1.mp3", "Sample_MP3_1"), ("m2.mp3", "Sample_MP3_2"), ("va1.mpg", "Sample_MPEG"), ("vidonly1.mpg", "Sample_MPEG_video_only_1"), ("vidonly2.mpg", "Sample_MPEG_video_only_2")] for mp3 in range(0, 2): stream.addMP3(*media[mp3]) stream.addMPEG(*media[2]) for mpg in range(3, len(media)): stream.addMPEGVideo(*media[mpg]) # We could use a templating language but I think the extra dependencies is not # worth it in this case. html = """ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html lang="en"> <head><meta http-equiv="content-type" content="text/html; charset=utf-8"> <title>Streaming Server Demo</title>