def listener(self, sock, *args): '''Asynchronous connection listener. Starts a handler for each connection.''' self.conn, temp = sock.accept() loggy.log( "mpdserver connected from " + str(self.conn.getsockname())) GObject.io_add_watch(self.conn, GObject.IO_IN, self.handler) self.conn.send('OK MPD 0.16.0\n') return True
def do_set_property(self, property, value): loggy.log('player.do_set_property') if property.name == 'vol': self.vol = value self.player.set_property('volume', float(value)/100) else: raise AttributeError, 'unknown property %s' % property.name
def update_db(self): # self.recreate_media_table() self.sb.config.config["dbupdatetime"] = loggy.currenttime() self.totag = [] if not self.tagger: self.tagger = tagger.tagger() for folder in self.sb.config.config["libraryfolders"]: loggy.log("ELE " + folder) for path, dirs, files in os.walk(folder): for filename in [os.path.abspath(os.path.join(path, filename)) for filename in files]: row = self.get_uri_db_info("file://" + filename) if row: mtime = int(os.path.getmtime(filename)) # (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(filename) # print ' old {0}, new {1} mtimes'.format(row['mtime'], mtime) if mtime >= row["mtime"]: continue mime = mimetypes.guess_type(filename)[0] # TODO: get rid of mimetype if not mime: loggy.log("Update database - no mime type for " + filename) elif mime.startswith("audio"): loggy.log("Database recreate_db Adding Audio :" + filename) self.totag.append(filename) elif mime.startswith("video"): loggy.log("Database recreate_db Adding Video :" + filename) self.totag.append(filename) else: None # loggy.log("Database recreate_db Unknown mime type:" +mime+", ignoring:" +filename) self.totaltotag = len(self.totag) loggy.log("Database:" + str(self.totaltotag) + " files to scan") self.gettag()
def settag(self): loggy.log(str(len(self.totag)) + " of " + str(self.totaltotag) + " remaining") mime = mimetypes.guess_type(self.tagger.uri)[0] # take mime out into function? if not mime: loggy.warn("Mime type error in settag - no mime info") elif mime.startswith("audio"): type = "audio" elif mime.startswith("video"): type = "video" else: loggy.warn("Mime type error in settag - mime info incorrect") self.tagger.tags["uri"] = self.tagger.uri self.tagger.tags["mime"] = type # print self.tagger.uri[7:] # (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(self.tagger.uri[7:]) # filetemp = Gio.file_new_for_uri(self.tagger.uri) #file_new_for_uri # temp.query_info('*',flags=gio.FILE_QUERY_INFO_NONE, cancellable=None) # info = filetemp.query_info('standard::mtime') self.tagger.tags["mtime"] = int(os.path.getmtime(self.tagger.uri[7:])) if len(type) > 0: # try: row = [] for key in self.keys: if key in self.tagger.tags: row.append(self.tagger.tags[key]) else: row.append(None) print(str(row)) self.insert_media(row) self.gettag()
def on_message(self, bus, message): if message.type == gst.MESSAGE_EOS: #TODO: reorder for speed , or take signals out individually... self.get_next() elif message.type == gst.MESSAGE_ERROR: self.reset() err, debug = message.parse_error() loggy.warn( "Player GST_MESSAGE_ERROR: " + str(err) + str(debug)) self.get_next() elif message.type == gst.MESSAGE_STATE_CHANGED: #self.update_play_state() if message.src == self.player: if (self.getstate() != self.state): self.state = self.getstate() self.emit('play-state-change', self.state) print 'state change' elif message.type == gst.MESSAGE_STREAM_STATUS: self.update_position() elif message.type == gst.MESSAGE_NEW_CLOCK: None elif message.type == gst.MESSAGE_ASYNC_DONE: self.emit('async-done') for comm in self.on_update_tags: comm() loggy.log('Player Async Done') elif message.type == gst.MESSAGE_TAG: # thanks to http://www.jezra.net/blog/use_python_and_gstreamer_to_get_the_tags_of_an_audio_file taglist = message.parse_tag() for key in taglist.keys(): self.tags[key] = taglist[key] # if key == 'image': # img = open('temp', 'w') # img.write(taglist[key]) # img.close() # else: # True #loggy.log('Player GST tag:' + key + ' : ' + str(taglist[key]) ) #gst_tag_list_free()? elif message.type == gst.MESSAGE_DURATION: format = gst.Format(gst.FORMAT_TIME) self.dur = self.player.query_duration(format)[0] self.dursec = int(self.dur / gst.SECOND) elif message.type == gst.MESSAGE_QOS: None elif message.type == gst.MESSAGE_ELEMENT: if message.structure is None: return message_name = message.structure.get_name() if message_name == "prepare-xwindow-id": imagesink = message.src loggy.warn('Player prepare-xwindow-id got') imagesink.set_property("force-aspect-ratio", True) #gtk.gdk.threads_enter() if self.vidout.has_key('xid'): imagesink.set_xwindow_id(self.vidout['xid']) #imagesink.set_xwindow_id(self.VID.window.xid) #gtk.gdk.threads_leave() elif message_name == "have-xwindow-id": None else: loggy.log( "Player GST message unhandled:" + str(message.type)) else: loggy.warn('Player - unknown messge' + str(message.type))
def listener(self, sock, *args): '''Asynchronous connection listener. Starts a handler for each connection.''' conn, addr = sock.accept() loggy.log( "Connected from " + str(conn.getsockname())) gobject.io_add_watch(conn, gobject.IO_IN, self.handler) conn.send('OK MPD 0.16.0\n') return True
def settag(self): # if len(self.tagger.tags): # loggy.log( str(self.tagger.tags)) loggy.log(str(len(self.totag))+' of '+str(self.totaltotag)+' remaining') mime = mimetypes.guess_type(self.tagger.filename)[0] # take mime out into function? if not mime: loggy.warn('Mime type error in settag - no mime info') elif mime.startswith("audio"): type = 'audio' elif mime.startswith("video"): type = 'video' else: loggy.warn('Mime type error in settag - mime info incorrect') self.tagger.tags['uri'] = self.tagger.filename if len(type)>0: #try: row = [] for key in self.keys: if key in self.tagger.tags: row.append(self.tagger.tags[key]) else: row.append('') row.append(type) #(mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(self.tagger.filename) row = row + [1,2,3,4,5] print row self.insert_row('media', row) #self.insert_row(type, [self.tagger.filename, self.tagger.tags['artist'], self.tagger.tags['title']]) #except: #loggy.log('OOOOOOOOOOOOOOOOOOOOOOOOOOOO')#TODO: - deal with errors properly self.gettag()
def recreate_db(self): self.recreate_media_table() self.totag = [] self.sb.config.config["dbupdatetime"] = loggy.currenttime() if not self.tagger: self.tagger = tagger.tagger() for folder in self.sb.config.config["libraryfolders"]: loggy.log("ELE " + folder) for path, dirs, files in os.walk(folder): for filename in [os.path.abspath(os.path.join(path, filename)) for filename in files]: mime = mimetypes.guess_type(filename)[0] # TODO: get rid of mimetype if not mime: loggy.log("Update database - no mime type for " + filename) elif mime.startswith("audio"): loggy.log("Database recreate_db Adding Audio :" + filename) self.totag.append(filename) elif mime.startswith("video"): loggy.log("Database recreate_db Adding Video :" + filename) self.totag.append(filename) else: None # loggy.log("Database recreate_db Unknown mime type:" +mime+", ignoring:" +filename) self.totaltotag = len(self.totag) loggy.log("Database:" + str(self.totaltotag) + " files to scan") self.gettag()
def setpos(self, pos): if (pos<(self.dur) and pos>=0): self.player.seek_simple(gst.FORMAT_TIME, gst.SEEK_FLAG_FLUSH, pos) loggy.log('seeking to |' + str(secs) + '|') return True #TODO: check pipeline changes? else: loggy.log('player.seeksecs could not understand seek to ' + str(secs)) return False
def gettag(self): if len(self.totag)>0: self.tagger.load_file(self.totag.pop(), self.settag) else: self.conn.commit() loggy.log('finished getting tags...') gobject.MainLoop().quit() print self.get_uri_db_info("file:///home/sam/Music/POPCORN.MP3")
def setpos(self, pos): if (pos<(self.dur) and pos>=0): self.player.seek_simple(Gst.FORMAT_TIME, Gst.SEEK_FLAG_FLUSH, (pos*SECOND)) loggy.log('seeking to |' + str(pos) + '|') return True #TODO: convert setpos/getpos to seconds else: loggy.log('player.seeksecs could not understand seek to ' + str(pos)) return False
def old(net): fs = FigSet() filetypes = [ 'jpeg', 'jpeg', 'jpeg', 'jpeg', 'jpeg', 'jpeg', 'png', 'jpeg', 'jpeg', 'jpeg' ] for i in range(10): fs.viss.clear() fs.viss.append(FigData()) fs.viss[0].item_type = 'image' # Read the image to classify file = 'images/' + str(i + 1) + '.' + filetypes[i] log('working with file:$', file) if filetypes[i] == 'png': I = imread(file) I = make255(I) else: I = imread(file).astype(np.uint8) # Adjust size of the image if not JUST_TEST_SMALL_IMAGES: sz = net.layers[0]._batch_input_shape # [1:3] else: sz = (3, 3, 3) if RESIZE: I = arr(Image.fromarray(I).resize((sz[1], sz[2])).getdata()) if JUST_TEST_SMALL_IMAGES: I = np.resize(I, (3, 3, 3)) else: I = np.resize(I, (299, 299, 3)) else: I = I[0:sz[1], 0:sz[2], 0:sz[3]] # for ii in range(I.shape[1]): # I[0,ii] = I[0,ii].insert(0) # # Classify the image using GoogLeNet # for # make valus from 0 to 1 I = make1(I) if JUST_TEST_SMALL_IMAGES: label = 'test' else: label = net.predict(arr([I])) label = maxindex(label) label = irn2.ImageNetClasses[label] log('label:$', label) # # Show the image and the classification results fs.viss[0].x = I.tolist() title = str(i + 1) + ':' + label fs.viss[0].title = title savePlotAndTableData(fs, 'dnn-old', title.replace(':', '-'))
def setpos(self, posns): '''Sets current position of track in nanoseconds''' if (posns<(self.durns) and posns>=0): self.player.seek_simple(gst.FORMAT_TIME, gst.SEEK_FLAG_FLUSH, posns) loggy.log('seeking to |' + str(posns) + 'ns|') return True #TODO: check pipeline changes? else: loggy.log('player.seeksecs could not understand seek to ' + str(posns)) return False
def startserver(self, host, port): self.host = host self.port = port self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.bind((self.host, self.port)) #TODO: check port empty first self.sock.listen(1) loggy.log('MPD Server Interface Running on ' + host + ':' + str(port) ) gobject.io_add_watch(self.sock, gobject.IO_IN, self.listener)
def on_button2_clicked(self, button): selection = self.folderview.get_selection() model, treeiter = selection.get_selected() if treeiter != None: loggy.log ("Removing " + model[treeiter][0] + "from folderlist") self.sb.config.config['libraryfolders'].remove(model[treeiter][0]) self.folderstore.remove(treeiter) self.sb.config.save_config() #now redo list store True
def __init__(self, soundblizzard): self.config = soundblizzard.config self.config.load() self.dbpath = self.config.get('Main', 'dbfile') loggy.log("Database: Loading database from " + self.dbpath) self.conn = sqlite3.connect(self.dbpath) self.curs = self.conn.cursor() self.conn.row_factory = sqlite3.Row self.keys = ('uri', 'artist', 'title', 'album', 'date', 'genre', 'duration', 'rating') # + mimetype , atime, mtime, ctime, dtime self.addkeys = ('mimetype', 'atime', 'mtime', 'ctime', 'dtime', 'size') self.totkeys = self.keys + self.addkeys self.conn.commit()
def startserver(self, host, port): self.host = host self.port = port self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) try: self.sock.bind((self.host, self.port)) #TODO: check port empty first except: loggy.warn('mpdserver failed to start on host %s port %s' % (self.host, self.port)) return False self.sock.listen(1) loggy.log('mpdserver Interface Running on ' + host + ':' + str(port) ) GObject.io_add_watch(self.sock, GObject.IO_IN, self.listener)
def recreate_db(self): self.recreate_table("media", (self.keys + self.addkeys)) #TODO: delete database and restart from scratch #self.recreate_table("videos", self.keys) #self.insert_row('music', ['fart.avi', 'farter', 'fart song']) self.totag = [] self.tagger = tagger.tagger() self.tagger.init() for folder in self.config.get('Main', 'libraryfolders').split(" "): loggy.log('ELE '+folder) for path, dirs, files in os.walk(folder): for filename in [os.path.abspath(os.path.join(path, filename)) for filename in files ]: mime = mimetypes.guess_type(filename)[0] #TODO: get rid of mimetype if not mime: None elif mime.startswith("audio"): loggy.log("Database recreate_db Adding Audio :" + filename) self.totag.append(filename) elif mime.startswith("video"): loggy.log("Database recreate_db Adding Video :" + filename) self.totag.append(filename) else: None # loggy.log("Database recreate_db Unknown mime type:" +mime+", ignoring:" +filename) self.totaltotag = len(self.totag) loggy.log('Database:' + str(self.totaltotag) + ' files to scan') self.gettag()
def doOverwrite(path, forceArg): #Assume file exists if forceArg: return True acceptable = ["y", "n", ""] loggy.log("File " + path + " exists, would you like to overwrite? (Y/n)", "*") usrIn = raw_input() while not usrIn.lower() in acceptable: loggy.log("File " + path + " exists, would you like to overwrite? (Y/n)", "*") usrIn = raw_input() usrIn = usrIn.lower() if usrIn == "" or usrIn == "y": loggy.log("Overwriting " + path, "*") return True else: loggy.log("Overwrite blocked." + path, "*") return False
def __init__(self, sb): loggy.log('Gui loading...') #self.play_buttons = [] #self.progress_bars = [] #self.position_labels = [] self.volume_scales =[] #self.info_labels = [] self.album_arts = [] self.main_trees = [] self.slave_windows = [] self.main_tree_modes = {} self.WIDGETS = 3 self.widgets={'consume_toggles':[],'repeat_toggles':[],'single_toggles':[],'random_toggles':[],'play_buttons':[], 'progress_bars':[], 'position_labels':[], 'info_labels':[], 'fullscreen_widgets':[]} #self.sb = soundblizzard.soundblizzard # fakes for tab completion self.sb = sb self.sb.player.connect('async-done', self.on_async_done) self.master_tree_load() self.builder = Gtk.Builder() self.builder.add_from_file("glade/gui.glade") self.builder.connect_signals(self) #widgets = self.builder.get_objects() self.window = self.builder.get_object("window1") self.window.set_title("SoundBlizzard") self.window.connect('delete-event', Gtk.main_quit) #pixbuf = GdkPixbuf.Pixbuf.new_from_file('/home/sam/Code/Eclipse workspace/soundblizzard/logo.png') self.window.set_icon_from_file('logo.png') self.get_widgets('window') for window in self.widgets['window']: window.show() self.window.show() #self.window.fullscreen() #TODO: fullscreen #self.get_widgets('albumartdrawingarea') #for alb in self.widgets['albumartdrawingarea']: #self.album_arts.append(alb) #print alb.window #self.sb.player.videosink.set_xwindow_id(alb.window.xid) #print(alb.get_window_xid()) #self.sb.player.on_update_play_state.append(self.on_play_state_change) #self.sb.player.on_update_volume.append(self.on_volume_change) #self.sb.player.on_update_tags.append(self.on_update_tags) self.sb.player.connect('async-done', self.on_update_tags) self.sb.player.connect('volume-changed', self.on_volume_change) self.sb.player.connect('position-changed', self.on_position_change) self.sb.player.connect('play-state-changed', self.on_play_state_change)
def on_button1_clicked(self, button): Folderbox = Gtk.FileChooserDialog("Please select a folder containing media", self.sb.gtkgui.window, Gtk.FileChooserAction.SELECT_FOLDER, (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OK, Gtk.ResponseType.OK)) Folderbox.set_default_size(800,400) Folderbox.set_select_multiple(True) Folderbox.set_local_only(False) response = Folderbox.run() if response == Gtk.ResponseType.OK: loggy.log("Gui adding media folder: " + str(Folderbox.get_filenames())) self.sb.config.config['libraryfolders'] = self.sb.config.config['libraryfolders'] + Folderbox.get_filenames() self.sb.config.save_config() for folder in Folderbox.get_filenames(): self.folderstore.append([folder]) Folderbox.destroy() True
def outputNewText(replaceDict, inputF, outputF): text = "" try: infile = open(inputF, "r+") #List of words in the file text = infile.read() infile.close() except IOError: loggy.log("Couldn't open input file, exiting " + "-") sys.exit() #Split file by words: #untested newText = "" if len(replaceDict) != 0: for i in text.split(" "): newText += ( replace(i, replaceDict) + " " ) else: print "No words in data file!" #Now save the words again #Save if a file has been specified newText = newText[:-1] if outputF != None: saveFile = open(outputF, "w+") saveFile.write(newText) saveFile.close() else: print newText
def read_playlist_from_giofile(self, giofile): name = giofile.get_path() (success, contents, tag) = giofile.load_contents() contents = contents.decode().splitlines() #print(contents) if contents.pop(0).startswith('#EXTM3U'): #playlist found, wipe/create playlist with that name self.playlists[name] = [] for line in contents: if line.startswith('/'): self.playlists[name].append('file://'+line) elif (line.startswith('#')): None else: loggy.warn('Could not analyse line in playlist '+name+' :'+line) loggy.log('Found '+str(len(self.playlists[name]))+' items in m3u playlist '+name) self.playlist=self.playlists[name] self.sb.player.emit('new-playlist',name)
def __init__(self, soundblizzard): #load defaults first then config file then command line args self.config = { 'configfile' : os.path.expanduser('~/.config/soundblizzard/soundblizzard.conf'), 'libraryfolders' : [os.path.expanduser('~/Music')], #TODO: support multiple folders 'playlistfolder' : '~/.config/playlists', 'databasefile' : os.path.expanduser('~/.config/soundblizzard/soundblizzard.db'), 'mpdhost' : 'localhost', 'mpdport' : 6600, 'dbupdatetime' : loggy.currenttime() } if (not(os.path.isdir(os.path.dirname(self.config['configfile'])))): os.makedirs(os.path.dirname(self.config['configfile'])) or loggy.warn ('could not create config dir') # if (not (os.path.isfile('~/.config/soundblizzard/soundblizzard.conf'))) fd = None try: fd = open(self.config['configfile'], 'r')#tries to open config file except: loggy.warn('Could not open config file '+ self.config['configfile']) try: self.config.update(json.load(fd)) #adds config file to dictionary and overrides with config file except: loggy.warn('Could not read config file '+ self.config['configfile']) #Handle command line arguments #Splits command line args into dict, if key starts with -- then takes this as an argument and prints these # if key is help prints defaults #TODO: improve command line argument recognition a = sys.argv[1:] if len(a) % 2: a.append('') b = {a[i]: a[i+1] for i in range(0, len(a), 2)} c ={} for key in b: if key.startswith('--help'): loggy.warn ('Soundblizzard media player\nTo amend config settings please use --key \'value\' on the command line. \n Current values:') print json.dumps(self.config, sort_keys=True, indent=2) loggy.die('help delivered') elif key.startswith('--'): c[key[2:]] = b[key] self.config.update(c) loggy.log('Configuration:' +str(self.config))
def read_playlist_dir(self): self.plfolder = Gio.File.new_for_path(path=self.sb.config.config['playlistfolder']) query = self.plfolder.query_file_type(Gio.FileQueryInfoFlags.NONE, None) if (query != Gio.FileType.DIRECTORY): loggy.warn('Playlist folder is not a directory:' + self.sb.config.config['playlistfolder']) return childrenenumerator = self.plfolder.enumerate_children('standard::display-name,time::modified', Gio.FileQueryInfoFlags.NONE, None)#fills childrenenumerator with fileinfos of child files of directory with information on display name and modified (only). Follows symlinks. See https://developer.gnome.org/pygobject/2.18/gio-constants.html#gio-file-attribute-constants. Content type does not seem to be particularly useful in this context while True: fl = childrenenumerator.next_file() if fl: if fl.get_display_name().lower().endswith('.m3u'): #loggy.log('found playlist'+ fl.get_display_name()) self.read_playlist_from_giofile(self.plfolder.get_child_for_display_name(fl.get_display_name()), ) else: loggy.log('Done reading playlist folder') break self.plmonitor = self.plfolder.monitor_directory(Gio.FileMonitorFlags.NONE, None) if self.plmonitor == None: loggy.warn('unable to monitor playlist directory') self.plmonitor.connect('changed', self.playlist_monitor_changed)
def on_message(self, bus, message): #Gst.MESSAGE_TAG:thanks to http://www.jezra.net/blog/use_python_and_gstreamer_to_get_the_tags_of_an_audio_file #msgtype = (Gst.message_type_get_name(message.type)) #print('message') 'TODO implement as dict rather than if elif for speed if ((message.type == Gst.MessageType.STREAM_STATUS) or (message.type == Gst.MessageType.STATE_CHANGED) or (message.type == Gst.MessageType.STREAM_START)): True elif (message.type == Gst.MessageType.TAG): print('tag MESSAGE') print (self.player.query_duration(Gst.Format.TIME)) taglist = message.parse_tag() #other ways of accessing list are taglist.to_string() or taglist.foreach() or taglist.get_string('artist') for key in dbtags.keys(): self.tags[key] = taglist.get_value_index(key, 0) elif (message.type == Gst.MessageType.ASYNC_DONE): #Gst.MESSAGE_ASYNC_DONE: query = Gst.Query.new_duration(Gst.Format.TIME) print(self.playbin.query(query)) print (self.player.query_duration(Gst.Format.TIME)) #print (self.player.get_state(1)) self.tags['duration'] = int ((self.playbin.query_duration(Gst.Format.TIME)[1]) / Gst.SECOND) #print str(self.player.query_duration(Gst.Format.TIME)) self.tags['uri'] = self.uri #self.tags['date'] = self.tags['date'].year loggy.log('Tagger got ' + str(self.tags)) #self.player.set_state(Gst.State.NULL) #TODO: replace mime types with Gstreamer alternative from Gst.extend self.callback() elif (message.type == Gst.MessageType.DURATION_CHANGED): #Gst.MESSAGE_DURATION: ?does this ever happen self.tags['duration'] = int ((int(self.playbin.query_duration(Gst.Format.TIME)[1]) / Gst.SECOND)) loggy.warn('got duration huzzah!') #TODO not working at present elif (message.type == Gst.MessageType.ERROR): #Gst.MESSAGE_ERROR: err, debug = message.parse_error() loggy.warn( "Player GST_MESSAGE_ERROR: " + str(err) + str(debug)) #TODO: sort out unicode self.error = str(debug) if self.error: self.player.set_state(Gst.State.NULL) self.__init__() self.callback() else: loggy.warn( "Player GST message unhandled:" + str(message.type))
def on_message(self, bus, message): if message.type == gst.MESSAGE_EOS: #TODO: reorder for speed , or take signals out individually... self.emit('eos')#called when end of stream reached elif message.type == gst.MESSAGE_ERROR: self.reset() err, debug = message.parse_error() loggy.warn( "Player GST_MESSAGE_ERROR: " + str(err) + str(debug)) self.emit('eos') elif message.type == gst.MESSAGE_STATE_CHANGED: if message.src == self.player: self.updatestate() elif message.type == gst.MESSAGE_STREAM_STATUS: #loggy.log('ss') appears to be related to buffering status #self.update_position() None elif message.type == gst.MESSAGE_NEW_CLOCK: None elif message.type == gst.MESSAGE_ASYNC_DONE: self.emit('async-done') loggy.log('Player Async Done') elif message.type == gst.MESSAGE_TAG: # thanks to http://www.jezra.net/blog/use_python_and_gstreamer_to_get_the_tags_of_an_audio_file taglist = message.parse_tag() for key in taglist.keys(): self.tags[key] = taglist[key] #gst_tag_list_free()? elif message.type == gst.MESSAGE_DURATION: self.updatedur() elif message.type == gst.MESSAGE_QOS: loggy.log('QOS') elif message.type == gst.MESSAGE_ELEMENT: if message.structure is None: return message_name = message.structure.get_name() if message_name == "prepare-xwindow-id": imagesink = message.src loggy.warn('Player prepare-xwindow-id got') imagesink.set_property("force-aspect-ratio", True) #gtk.gdk.threads_enter() if self.vidout.has_key('xid'): imagesink.set_xwindow_id(self.vidout['xid']) #imagesink.set_xwindow_id(self.VID.window.xid) #gtk.gdk.threads_leave() elif message_name == "have-xwindow-id": loggy.log('have xwindow id') else: loggy.log( "Player GST message unhandled:" + str(message.type)) else: loggy.warn('Player - unknown messge' + str(message.type))
def on_message(self, bus, message): if message.type == Gst.MessageType.EOS: #TODO: reorder for speed , or take signals out individually... see http://bazaar.launchpad.net/~jderose/+junk/gst-examples/view/head:/video-player-1.0 self.emit('eos')#called when end of stream reached elif message.type == Gst.MessageType.ERROR: self.reset() err, debug = message.parse_error() loggy.warn( "Player GST_MESSAGE_ERROR: " + str(err) + str(debug)) self.emit('eos') elif message.type == Gst.MessageType.STATE_CHANGED: if message.src == self.player: self.updatestate() elif message.type == Gst.MessageType.STREAM_STATUS: #loggy.log('ss') appears to be related to buffering status #self.update_position() None elif message.type == Gst.MessageType.NEW_CLOCK: None elif message.type == Gst.MessageType.ASYNC_DONE: self.emit('async-done') loggy.log('Player Async Done') elif message.type == Gst.MessageType.TAG: # thanks to http://www.jezra.net/blog/use_python_and_gstreamer_to_get_the_tags_of_an_audio_file taglist = message.parse_tag() #gst_tag_list_free()? for key in dbtags.keys(): self.tags[key] = taglist.get_value_index(key, 0) elif message.type == Gst.MessageType.DURATION_CHANGED: self.updatedur()#could query message? elif message.type == Gst.MessageType.QOS: loggy.log('QOS') elif message.type == Gst.MessageType.ELEMENT: if message.structure is None: return message_name = message.get_structure().get_name() if message_name == "prepare-window-handle": loggy.warn('Player prepare-window-handle got') message.src.set_property("force-aspect-ratio", True) #gtk.gdk.threads_enter() if self.vidout.has_key('xid'): message.src.set_window_handle(self.vidout['xid']) #imagesink.set_xwindow_id(self.VID.window.xid) #gtk.gdk.threads_leave() elif message_name == "have-xwindow-id": loggy.log('have xwindow id') else: loggy.log( "Player GST message unhandled:" + str(message.type)) elif (message.type == Gst.MessageType.STREAM_START or message.type == Gst.MessageType.RESET_TIME): None else: loggy.warn('Player - unknown message' + str(message.type))
def on_message(self, bus, message): if message.type == gst.MESSAGE_EOS: self.reset() #TODO: get next song elif message.type == gst.MESSAGE_ERROR: self.reset() err, debug = message.parse_error() loggy.log( "Player GST_MESSAGE_ERROR: " + err + debug) elif message.type == gst.MESSAGE_STATE_CHANGED: self.update_play_state() elif message.type == gst.MESSAGE_STREAM_STATUS: self.update_play_state() # elif message.type == gst.MESSAGE_NEW_CLOCK: # None #TODO: # elif message.type == gst.MESSAGE_QOS: # None #TODO: elif message.type == gst.MESSAGE_ASYNC_DONE: None #TODO: elif message.type == gst.MESSAGE_TAG: # thanks to http://www.jezra.net/blog/use_python_and_gstreamer_to_get_the_tags_of_an_audio_file taglist = message.parse_tag() for key in taglist.keys(): self.tags[key] = taglist[key] if key == 'image': img = open('temp', 'w') img.write(taglist[key]) img.close() else: loggy.log('Player GST tag:' + key + ' : ' + str(taglist[key]) ) #gst_tag_list_free() elif message.type == gst.MESSAGE_DURATION: #loggy.log( 'GST duration' + str( duration[0] )) format = gst.Format(gst.FORMAT_TIME) self.dur = self.player.query_duration(format)[0] self.duration = datetime.timedelta(seconds=(self.dur / gst.SECOND)) loggy.log(str(self.duration)) # elif message.type == gst.MESSAGE_ELEMENT: # None #TODO: else: loggy.log( "Player GST message unhandled:" + str(message.type))
def main(): #Argparse parser = argparse.ArgumentParser(description='Switch out words to cement language understanding.') parser.add_argument('datafile', type=str, help='File containing swap information (end.lsw)') parser.add_argument('infile', type=str, help='path to file to read in as original language') parser.add_argument('-w --write', metavar="writeFile" , help='path to file to be written out') parser.add_argument('-f --force', action="store_true", help="Forces overwrites without prompts") #args is a dictionary of the results args = vars(parser.parse_args()) #Now parse values infile = args["infile"] data = args["datafile"] outputF = args["w __write"] forceArg = args["f __force"] #Check paths are ok, if not, exits if not okPath(infile): loggy.log("Infile did not exist. Exiting... ", "-") sys.exit() if not okPath(infile): loggy.log("Data file did not exist. Exiting... ", "-") sys.exit() #Checks output is valid and checks for overwrite if okPath(outputF): #If we are not to overwrite file then exit if not doOverwrite(outputF, forceArg): loggy.log("Not overwriting designated out file, exiting... ", "-") sys.exit() #If we are to overwrite file, delete it now else: os.remove(outputF) #Actually do the replacing replacements = getReplacements(data) outputNewText(replacements, infile, outputF)
def load_uri(self, uri): self.reset() loggy.log( "Player loading " + uri ) self.uri = uri self.player.set_property("uri", uri) self.player.set_state(gst.STATE_PLAYING)
File('WC/put').resolve(key).write(value) def __getitem__(self, item): File('WC/get-request').resolve(item).write('') response = File('WC/get-response').resolve(item) while not response.exists(): sleep(0.01) data = response.read() response.delete() return data WC = WC_Sync_API() if __name__ == '__main__': log('testing put 1') WC['test1'] = 'result1' log('tested put 1') log('testing put 2') WC['test2'] = 'result2' log('tested put 2') log('testing get 1') r1 = WC['test1'] log('tested get 1:$', r1) log('testing get 2') r2 = WC['test2'] log('tested get 2:$', r2) WC['lastsave'] = 'mac'