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'
