def __init__(self):
"""x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
super(AOAudioPlaybackAdaptor, self).__init__()
try:
self.dev = ao.AudioDevice("oss")
except ao.aoError:
self.dev = ao.AudioDevice("alsa")
def main():
# Open the audio device.
dev = ao.AudioDevice('pulse', rate=44100)
# Create a wrapper object.
wrap = mywrapper()
# Open an MP3 file and read in all the data.
# For you, this data will come in over the network from the server.
f = open(sys.argv[1], 'r')
data = f.read()
f.close()
# Hand off the data to the wrapper object and use it to create a new MAD
# library decoder. For your client, you will be appending chunks of data
# to the end of wrap.data in your receiver thread while the player thread
# is removing and playing data from the front of it.
wrap.data = data
wrap.mf = mad.MadFile(wrap)
# Play the file.
while True:
buf = wrap.mf.read()
if buf is None: # eof
break
dev.play(buffer(buf), len(buf))
def play(self, fp):
import mad, ao
backend = self.backend
if backend is None:
import sys
backend = {
'darwin': 'macosx',
'win32': 'wmm',
'linux2': 'alsa'
}.get(sys.platform)
if backend is None:
raise Exception("Can't guess a usable libao baceknd."
"If you know a backend that may work on your system then"
"you can specify it using the backend options parameter.")
mf = mad.MadFile(fp)
dev = ao.AudioDevice(backend)
while True:
buf = mf.read()
if buf is None:
break
dev.play(buf, len(buf))
def listen(self,
start = 0,
length = 0,
dsp = "/dev/dsp"):
device = ao.AudioDevice("oss",
bits = 16,
rate = self.framerate,
channels = self.channels)
wave_object = self._get_wave()
startframe = int(start * self.framerate)
if length == 0:
length = self.number_of_frames - startframe
else:
length = int(length * self.framerate)
wave_object.setpos(startframe)
print "start, length:", start, length
print startframe, length
frames = wave_object.readframes(length)
try:
device.play(frames)
except KeyboardInterrupt:
pass
del device
def getSignature(filename, playWhileReading=None):
(path, ext) = os.path.splitext(filename)
if ext.lower() == '.ogg':
ff = ogg.vorbis.VorbisFile(filename)
elif ext.lower() == '.mp3':
ff = MadWrapper(filename)
elif ext.lower() == '.wav':
ff = WavWrapper(filename)
else:
raise SystemError, "Unsupported audio file."
if playWhileReading:
device = 'esd'
id = ao.driver_id(device)
aodev = ao.AudioDevice(id)
info = ff.info()
trm = musicbrainz.trm()
trm.SetPCMDataInfo(info.rate, info.channels, 16)
while 1:
(buff, bytes, bit) = ff.read()
if bytes == 0:
break
if trm.GenerateSignature(buff):
break
if playWhileReading:
aodev.play(buff, bytes)
sig = trm.FinalizeSignature()
return sig
def main():
if len(sys.argv) < 3:
print('Usage: %s <server name/ip> <server port>' % sys.argv[0])
sys.exit(1)
wrap = mywrapper()
cond_filled = threading.Condition()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((sys.argv[1], int(sys.argv[2])))
recv_thread = threading.Thread(target=recv_thread_func,
args=(wrap, cond_filled, sock))
recv_thread.daemon = True
recv_thread.start()
dev = ao.AudioDevice('pulse')
play_thread = threading.Thread(target=play_thread_func,
args=(wrap, cond_filled, dev))
play_thread.daemon = True
play_thread.start()
PROTOCOL_bytes = bytes('MRTSP', encoding='utf-8')
while True:
line = input('>> ')
one_arg = False
if ' ' in line:
cmd, args = line.split(' ', 1)
else:
cmd = line
one_arg = True
if cmd in ['l', 'list']:
print('The user asked for list.')
LIST_bytes = bytes(METHODS[0], encoding='utf-8')
send_data = struct.pack('5s4sI', PROTOCOL_bytes, LIST_bytes, 0)
sock.send(send_data)
if cmd in ['p', 'play']:
if one_arg == False: # input does have sid
print('The user asked to play:', args)
sid = int(args)
PLAY_bytes = bytes(METHODS[1], encoding='utf-8')
send_data = struct.pack('5s4sI', PROTOCOL_bytes, PLAY_bytes,
sid)
sock.send(send_data)
if cmd in ['s', 'stop']:
print('The user asked for stop.')
STOP_bytes = bytes(METHODS[2], encoding='utf-8')
send_data = struct.pack('5s4sI', PROTOCOL_bytes, STOP_bytes, 0)
sock.send(send_data)
if cmd in ['quit', 'q', 'exit']:
if wrap.method == 'PLAY':
# NOTE: don't worry, the server will not keep sending after
# the song ended! check server.py:203
print('Please stop your song before leaving!')
continue
sys.exit(0)
sock.close()
def play(self):
"""
Main function that plays a 7digital url
"""
if self.url == '':
return
if self.is_playing:
return
self.is_playing = True
self.do_stop = False
self.printinfo('start playing url:',self.url)
#urldata = urllib.urlretrieve(self.url)
urlstream = urllib2.urlopen(self.url)
mf = mad.MadFile(urlstream)
# if bits=32, too fast
self.dev = ao.AudioDevice('alsa', bits=16, rate=mf.samplerate(),channels=2)
buf = mf.read()
t1 = time.time()
while buf != None and not self.do_stop:
# len(buf) is 4608
self.dev.play(buf, len(buf))
buf = mf.read()
self.do_stop = False
self.is_playing = False
tlag = time.time() - t1
self.printinfo('done playing url after',str(int(tlag)),'seconds')
def __init__(self, id=None):
import ao
if id is None:
id = ao.driver_id('alsa') # oss
self.dev = ao.AudioDevice(
id, channels=1
) # rate, AudioDevice(aodevice, bits=16,rate=44100, byte_format=4,channels=1)
def main():
if len(sys.argv) < 3:
print 'Usage: %s <server name/ip> <server port>' % sys.argv[0]
sys.exit(1)
# Create a pseudo-file wrapper, condition variable, and socket. These will
# be passed to the thread we're about to create.
wrap = mywrapper()
# Create a condition variable to synchronize the receiver and player threads.
# In python, this implicitly creates a mutex lock too.
# See: https://docs.python.org/2/library/threading.html#condition-objects
cond_filled = threading.Condition()
# Create a TCP socket and try connecting to the server.
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((sys.argv[1], int(sys.argv[2])))
# Create a thread whose job is to receive messages from the server.
recv_thread = threading.Thread(
target=recv_thread_func,
args=(wrap, cond_filled, sock)
)
recv_thread.daemon = True
recv_thread.start()
# Create a thread whose job is to play audio file data.
dev = ao.AudioDevice('pulse')
play_thread = threading.Thread(
target=play_thread_func,
args=(wrap, cond_filled, dev)
)
play_thread.daemon = True
play_thread.start()
# Enter our never-ending user I/O loop. Because we imported the readline
# module above, raw_input gives us nice shell-like behavior (up-arrow to
# go backwards, etc.).
while True:
line = raw_input('>> ')
if ' ' in line:
cmd, args = line.split(' ', 1)
else:
cmd = line
# TODO: Send messages to the server when the user types things.
if cmd in ['l', 'list']:
print 'The user asked for list.'
if cmd in ['p', 'play']:
print 'The user asked to play:', args
if cmd in ['s', 'stop']:
print 'The user asked for stop.'
if cmd in ['quit', 'q', 'exit']:
sys.exit(0)
def play(self, do_speak=True):
files = self.get_files()
if do_speak:
self.speak(self.seek_time, self.file_index)
why_stopped = 'finished'
while self.file_index < len(files) and why_stopped == 'finished':
if self.isRadio:
f = self.get_radio_file()
else:
f = self.get_audio_file(files)
mf = mad.MadFile(f)
if self.seek_time > 5000: #seeking is broken a bit, we have to flush the buffer by reading
mf.seek_time(self.seek_time - 5000)
for i in range(100):
mf.read()
dev = ao.AudioDevice('alsa', rate=mf.samplerate())
iSave = 0
why_stopped = ''
logger.info("Starting to play")
self.msg_queue.put(PlayerMsg('started', self.isRadio))
while True:
buf = mf.read()
if (buf is None) or self.pipe.poll():
if buf is None:
why_stopped = 'finished'
break
dev.play(buf, len(buf))
#we cannot save in this process, we would get buffer underrun
if not self.isRadio:
iSave += 1
if iSave == 100:
self.seek_time = mf.current_time()
self.msg_queue.put(
SavePosMsg((self.seek_time, self.file_index,
self.folder_name)))
iSave = 0
if not self.isRadio:
self.seek_time = mf.current_time()
if why_stopped == 'finished':
self.seek_time = 0
self.file_index += 1
#now the whole system may be already quitting and message queue will not be inspected, so we must save position ourselves
if not self.isRadio:
conn = sqlite3.connect('player.db')
conn.execute(
'update lastpos set position = ?, fileindex = ? where foldername = ?',
(self.seek_time, self.file_index % len(files),
self.folder_name))
conn.commit()
#if we finished the last track, we shall mark it as complete (this is purely statistical, is not used by the program)
if (self.seek_time == 0) and (self.file_index == len(files)):
conn.execute(
'update lastpos set completed = completed + 1 where foldername = ?',
(self.folder_name, ))
conn.commit()
def play(u):
mf = mad.MadFile(u)
if mf.layer() == mad.LAYER_I:
print "MPEG Layer I"
elif mf.layer() == mad.LAYER_II:
print "MPEG Layer II"
elif mf.layer() == mad.LAYER_III:
print "MPEG Layer III"
else:
print "unexpected layer value"
if mf.mode() == mad.MODE_SINGLE_CHANNEL:
print "single channel"
elif mf.mode() == mad.MODE_DUAL_CHANNEL:
print "dual channel"
elif mf.mode() == mad.MODE_JOINT_STEREO:
print "joint (MS/intensity) stereo"
elif mf.mode() == mad.MODE_STEREO:
print "normal L/R stereo"
else:
print "unexpected mode value"
if mf.emphasis() == mad.EMPHASIS_NONE:
print "no emphasis"
elif mf.emphasis() == mad.EMPHASIS_50_15_US:
print "50/15us emphasis"
elif mf.emphasis() == mad.EMPHASIS_CCITT_J_17:
print "CCITT J.17 emphasis"
else:
print "unexpected emphasis value"
print "bitrate %lu bps" % mf.bitrate()
print "samplerate %d Hz" % mf.samplerate()
sys.stdout.flush()
#millis = mf.total_time()
#secs = millis / 1000
#print "total time %d ms (%dm%2ds)" % (millis, secs / 60, secs % 60)
dev = ao.AudioDevice(0, rate=mf.samplerate())
while 1:
buffy = mf.read()
if buffy is None:
break
dev.play(buffy, len(buffy))
def play(f): # f: Filename
if not path.exists(f):
ui.throw('文件不存在：' + f)
return
mf = mad.MadFile(f)
dev = ao.AudioDevice('alsa', rate=mf.samplerate())
ui.setInfo(f, mf.total_time())
ui.g.lrcFile = lrc.changeExt(f)
if not lrc.loadLrc(ui.g.lrcFile): # No LRC file
ui.g.lrcFile = ''
g.skip = False
while not g.skip:
if not g.paused:
buf = mf.read()
if buf is None:
break
dev.play(buf, len(buf))
ui.setTime(mf.current_time())
else:
time.sleep(0.1)
ui.draw()
def madradio(url):
scheme, netloc, path, params, query, fragment = urlparse(url)
try:
host, port = netloc.split(':')
except ValueError:
host, port = netloc, 80
if not path:
path = '/'
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, int(port)))
sock.send('GET %s HTTP/1.0\r\n\r\n' % path)
reply = sock.recv(1500)
# print repr(reply)
file = sock.makefile()
mf = mad.MadFile(file)
print(('bitrate %lu bps' % mf.bitrate()))
print(('samplerate %d Hz' % mf.samplerate()))
dev = ao.AudioDevice(0, rate=mf.samplerate())
while True:
buffy = mf.read()
if buffy is None:
break
dev.play(buffy, len(buffy))
def main():
# Open the audio device.
dev = ao.AudioDevice('pulse')
# Create a wrapper object.
wrap = mywrapper()
# Open an MP3 file and read in all the data.
# For you, this data will come in over the network from the server.
f = open(sys.argv[1], 'r')
while True:
# data = f.read(5000)
# data = "MEOW|100|>^,^<|" + data + "|>^,^<|>^,^<"
# data_len = len(data)
# print("LEN: {}".format(data_len))
# data = struct.pack("5300s", data)
# data = struct.unpack("5300s", data)[0]
# tokens = data.split("|")
# tokens = tokens[3: len(tokens) - 2]
# data = "|".join(tokens)
# Hand off the data to the wrapper object and use it to create a new MAD
# library decoder. For your client, you will be appending chunks of data
# to the end of wrap.data in your receiver thread while the player thread
# is removing and playing data from the front of it.
# wrap.data += data
wrap.mf = mad.MadFile(wrap)
# Play the file.
while True:
buf = wrap.mf.read()
if buf is None: # eof
print("BUF IS NONE")
break
dev.play(buffer(buf), len(buf))
# -*- coding: utf-8 -*-
# kate: space-indent on; indent-width 4; replace-tabs on;
from __future__ import division
import sys
import ffmpeg
import ao
pcm = ao.AudioDevice("pulse")
rdr = ffmpeg.Decoder(sys.argv[-1])
from numpy import array, log10, sqrt
import struct
from scipy import fft
import audioop
from OpenGL import GL, GLUT
class OglRenderer( object ):
def __init__( self, source, duration, width=250, height=100 ):
self.source = source
self.duration = duration
self.width = width
self.height = height
self.points = []
GLUT.glutInit( sys.argv )
def update(self):
if self.stream is None:
self.p = pyaudio.PyAudio()
if len(self.audioSrc) > 5:
self.mf = mad.MadFile(self.audioSrc)
self.sampleRate = self.mf.samplerate()
self.stream = self.p.open(format = pyaudio.paInt32, channels = 2, rate = self.sampleRate, output = True)
self.dev = ao.AudioDevice('pulse', rate = self.sampleRate)
threading.Thread(target=self.getmp3stream).start()
else:
for x in range(self.p.get_device_count()):
if self.p.get_device_info_by_index(x)['name'] == audioSrc:
break;
if x < self.p.get_device_count()-1:
self.stream = self.p.open(format = pyaudio.paInt16, channels = 1, rate = self.sampleRate, input = True, frames_per_buffer = self.bufferSize*2, input_device_index = x)
else:
raise Exception("Could not find pulse audio device")
threading.Thread(target=self.getstream).start()
if len(self.chunks) > 0:
d = np.fromstring(self.chunks.pop(0), dtype=np.short)
ffty = np.fft.fft(d)
ffty = abs(ffty[0:len(ffty)*0.5])*0.0001
ffty1 = ffty[:len(ffty)*0.5]
ffty2 = ffty[len(ffty)*0.5::]+2
ffty2 = ffty2[::-1]
ffty = ffty1+ffty2
ffty = np.log(ffty)-2
#fftx,ffty = self.downSample(self.fftx,ffty,5)
ffty = self.smoothMemory(ffty,3)
if len(ffty) > 0: self.data = ffty[1:int(len(ffty)*self.split)] * self.factor
if len(self.data) > 0:
#print str(len(ffty))+' samples, '+str((min(ffty)+1)*0.5)+' -> '+str((max(ffty)+1)*0.5)
count = 0.0
glBegin(GL_TRIANGLES)
glColor4f(1.0, 1.0, 1.0, 0.6)
for i in self.data:
val = np.array([(count/len(self.data), (count+1)/len(self.data)), (0.0, i)]) * self.winSize
glVertex3f(val[0][0], val[1][0], 0.0)
glVertex3f(val[0][1], val[1][0], 0.0)
glVertex3f(val[0][1], val[1][1], 0.0)
glVertex3f(val[0][1], val[1][1], 0.0)
glVertex3f(val[0][0], val[1][1], 0.0)
glVertex3f(val[0][0], val[1][0], 0.0)
count += 1.0
glEnd()
click = self.mouse.checkClick()
select = self.mouse.checkSelect()
for s in self.selections:
s.update(self.data)
if self.mouse.checkClick() == 0: self.MOUSE = True # Check for a new click
if self.MOUSE == True:
selection = self.mouse.getSelection() # Get current selection if mouse has registered a click
if self.mouse.MOUSE == False: # If the mouse has been released
self.MOUSE = False # Set local variable
self.selections.append(selection) # Add selection to array if the mouse has been released
ss = self.selections # Make a copy of the selections
if self.MOUSE == True: ss.prepend(selection) # Prepend the current selection to the temp selections list
for s in ss:
if self.mouse.MOUSE == True:
average = 0.2
else:
average = np.average(self.data[int(s[0][0]*len(self.data)):int(s[1][0]*len(self.data))])
average = (average - s[0][1]) / (s[1][1] - s[0][1])
if average > 1.0: average = 1.0
if average < 0.0: average = 0.0
s = s * np.array([self.mouse.winSize, self.mouse.winSize]) + [(1,1),(0,0)]
glBegin(GL_TRIANGLES)
glColor4f(1.0,1.0,1.0,average)
glVertex3f(s[0][0], s[0][1], 0.0)
glVertex3f(s[1][0], s[0][1], 0.0)
glVertex3f(s[1][0], s[1][1], 0.0)
glVertex3f(s[1][0], s[1][1], 0.0)
glVertex3f(s[0][0], s[1][1], 0.0)
glVertex3f(s[0][0], s[0][1], 0.0)
glEnd()
glBegin(GL_LINES)
glColor4f(1.0,1.0,1.0,1.0)
glVertex3f(s[0][0], s[0][1], 0.0)
glVertex3f(s[1][0], s[0][1], 0.0)
glVertex3f(s[1][0], s[0][1], 0.0)
glVertex3f(s[1][0], s[1][1], 0.0)
glVertex3f(s[1][0], s[1][1], 0.0)
glVertex3f(s[0][0], s[1][1], 0.0)
glVertex3f(s[0][0], s[1][1], 0.0)
glVertex3f(s[0][0], s[0][1], 0.0)
glEnd()
def main():
if len(sys.argv) < 3:
print 'Usage: %s <server name/ip> <server port>' % sys.argv[0]
sys.exit(1)
wrap = mywrapper()
cond_filled = threading.Condition()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((sys.argv[1], int(sys.argv[2])))
recv_thread = threading.Thread(
target=recv_thread_func,
args=(wrap, cond_filled, sock)
)
recv_thread.daemon = True
recv_thread.start()
dev = ao.AudioDevice('pulse')
play_thread = threading.Thread(
target=play_thread_func,
args=(wrap, cond_filled, dev)
)
play_thread.daemon = True
play_thread.start()
while True:
line = raw_input('>> ')
if ' ' in line:
cmd, args = line.split(' ', 1)
else:
cmd = line
message = ""
if cmd in ['l', 'list']:
message = "REQUEST\nclient-ip: {}\n request-type: list\n\n\r\n".format(sock.getsockname()[0])
if cmd in ['p', 'play']:
message = "REQUEST\nclient-ip: {}\nrequest-type: play\nsong-number: {}\n\n\r\n".format(sock.getsockname()[0], args)
print 'The user asked to play:', args
wrap.state = 1
if cmd in ['s', 'stop']:
message = "REQUEST\nclient-ip: {}\n request-type: stop\n\n\r\n".format(sock.getsockname()[0])
print 'The user asked for stop.'
wrap.data = ""
wrap.mf = None
wrap.state = 0
if cmd in ['quit', 'q', 'exit']:
sock.close()
sys.exit(0)
sock.send(message)
sock.close()
def __init__(self, filename):
id = ao.driver_id('alsa')
self.vf = ogg.vorbis.VorbisFile(filename)
self.device = ao.AudioDevice(id)
#!/usr/bin/env python
'''short.py - a really brief demonstration of using the ao and hip modules'''
import hip
import ao
import sys
filename = sys.argv[1]
device = 'esd'
SIZE = 4806
hf = hip.hip(filename)
id = ao.driver_id(device)
ao = ao.AudioDevice(id)
while 1:
(buff, bytes, bit) = hf.read(SIZE)
if bytes == 0: break
ao.play(buff, bytes)
def __init__(self, id=None):
super(AOPlayerComponent, self).__init__()
#if id is None:
# id = 'oss'
#print "FOO1"
self.dev = ao.AudioDevice("oss")
#!/usr/bin/python
# Very simple FLAC player using the FLAC FileDecoder and libao
import flac.decoder as decoder
import flac.metadata as metadata
import ao
import sys
# setup libao audio device
#ao = ao.AudioDevice('esd')
#ao = ao.AudioDevice('alsa09')
#ao = ao.AudioDevice('wav', filename='out.wav')
ao = ao.AudioDevice('oss')
# write our callbacks (in Python!!)
def metadata_callback(dec, block):
if block.type == metadata.VORBIS_COMMENT:
# use flac.metadata to access vorbis comments!
vc = metadata.VorbisComment(block)
print vc.vendor_string
for k in vc.comments:
print '%s=%s' % (k, vc.comments[k])
def error_callback(dec, status):
pass
def write_callback(dec, buff, size):
"""The player_madao module provides the Player class.
This implementation of Player uses python wrappers for libmad and libao,
which provide interfaces to audio files and audio devices.
"""
import thread
import time
import ao
import mad
AODEV = ao.AudioDevice(0)
class Player(object):
"""The Player class provides an audio stream for a file."""
_filename = None
_madfile = None
_is_playing = False # may need a lock since stop and play_internal both write
_callback = None
def __init__(self, filename):
"""Construct a Player.
:param filename
"""
self._filename = filename
self.reset()
def length(self):
"""Get the length of the audio stream in milliseconds."""
return self._madfile.total_time()
def main():
'''
main function
'''
if len(sys.argv) < 3:
print('Usage: {} <server name/ip> <server port>'.format(sys.argv[0]))
sys.exit(1)
# Create a pseudo-file wrapper.
wrap = mywrapper()
global BOOL_PLAY #pylint: disable=global-statement
# Create a condition variable to synchronize the receiver and
# player threads. This implicitly creates a mutex lock too.
cond_filled = threading.Condition()
# Create a TCP socket and try connecting to the server.
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((sys.argv[1], int(sys.argv[2])))
# Create a thread whose job is to receive messages from the server,
# using the socket, condition variable, and psuedo-file wrapper.
recv_thread = threading.Thread(target=recv_thread_func,
args=(wrap, cond_filled, sock))
recv_thread.daemon = True
recv_thread.start()
# set up audio device
dev = ao.AudioDevice('pulse')
# set up play thread
play_thread = threading.Thread(target=play_thread_func,
args=(wrap, cond_filled, dev))
# start play thread
play_thread.daemon = True
play_thread.start()
# Enter our never-ending user I/O loop.
# Because we imported the readline module above, raw_input gives us
# nice shell-like behavior (up-arrow to go backwards, etc.).
while True:
line = raw_input('>> ') #pylint: disable=undefined-variable
if ' ' in line:
cmd, args = line.split(' ', 1)
else:
cmd = line
if cmd in ['l', 'list']:
print('The user asked for a list of all songs available.')
# send request to server to list all available songs
send_request('list', sock)
elif cmd in ['p', 'play']:
if ' ' not in line:
print("Please type in a song ID to play")
continue
print('The user asked to play:', args)
BOOL_PLAY = False
# if already playing, stop and clear buffer
send_request('stop', sock)
stop(wrap, cond_filled)
sleep(2)
BOOL_PLAY = True
# send request to server to play
send_request('play', sock, line)
elif cmd in ['s', 'stop']:
print('The user asked to stop.')
BOOL_PLAY = False
# send request to server to stop sending packets
send_request('stop', sock)
# clear wrapper
stop(wrap, cond_filled)
elif cmd in ['quit', 'q', 'exit']:
print('The user asked to exit.')
sys.exit(0)
else:
print('Incorrect usage; please try again.')
def main():
if len(sys.argv) < 3:
print 'Usage: %s <server name/ip> <server port>' % sys.argv[0]
sys.exit(1)
# Create a pseudo-file wrapper, condition variable, and socket. These will
# be passed to the thread we're about to create.
wrap = mywrapper()
global curr_song
global curr_play
# Create a condition variable to synchronize the receiver and player threads.
# In python, this implicitly creates a mutex lock too.
# See: https://docs.python.org/2/library/threading.html#condition-objects
cond_filled = threading.Condition()
# Create a TCP socket and try connecting to the server.
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((sys.argv[1], int(sys.argv[2])))
# Create a thread whose job is to receive messages from the server.
recv_thread = threading.Thread(target=recv_thread_func,
args=(wrap, cond_filled, sock))
recv_thread.daemon = True
recv_thread.start()
# Create a thread whose job is to play audio file data.
dev = ao.AudioDevice('pulse')
play_thread = threading.Thread(target=play_thread_func,
args=(wrap, cond_filled, dev))
play_thread.daemon = True
play_thread.start()
# Enter our never-ending user I/O loop. Because we imported the readline
# module above, raw_input gives us nice shell-like behavior (up-arrow to
# go backwards, etc.).
while True:
line = raw_input('>> ')
if ' ' in line:
cmd, args = line.split(' ', 1)
else:
cmd, args = line, None
if cmd in ['l', 'list']:
print 'The user asked for list.'
p = Packet(msg_type='list')
send_packet(p, sock, 'list')
elif cmd in ['p', 'play']:
if args == None or unicode(args).isnumeric() == False:
print 'Please enter a song ID number to play'
continue
print 'The user asked to play:', args
# stop playing the current song before playing a new song
curr_song = None
curr_play = False
p = Packet(msg_type='stop')
send_packet(p, sock, 'stop')
stop_play(wrap, cond_filled)
sleep(1)
# now send play packet
curr_song = args
curr_play = True
p = Packet(msg_type='play', song_id=args)
send_packet(p, sock, 'play')
elif cmd in ['s', 'stop']:
print 'The user asked to stop.'
curr_song = None
curr_play = False
p = Packet(msg_type='stop')
send_packet(p, sock, 'stop')
stop_play(wrap, cond_filled)
elif cmd in ['quit', 'q', 'exit']:
print 'The user asked to quit.'
p = Packet(msg_type='quit')
send_packet(p, sock, 'quit')
sys.exit(0)
else:
print 'Please input a valid command'
def play_array(a, sr):
data = a.tostring()
dev = ao.AudioDevice(0, bits=16, channels=1, rate=sr)
print dev.driver_info(), sr
dev.play(data)
def main():
if len(sys.argv) < 4:
print 'Usage: %s <download directory> <server name/ip> <server port>' % sys.argv[
0]
sys.exit(1)
#get the download path from client to store downloaded songs
download_dir = str(sys.argv[1])
# Create a pseudo-file wrapper, condition variable, and socket. These will
# be passed to the thread we're about to create.
wrap = mywrapper()
wrap.mf = mad.MadFile(wrap)
# Create a condition variable to synchronize the receiver and player threads.
# In python, this implicitly creates a mutex lock too.
# See: https://docs.python.org/2/library/threading.html#condition-objects
cond_filled = threading.Condition()
# Create a TCP socket and try connecting to the server.
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((sys.argv[2], int(sys.argv[3])))
# Create a thread whose job is to receive messages from the server.
recv_thread = threading.Thread(target=recv_thread_func,
args=(wrap, cond_filled, sock,
download_dir))
recv_thread.daemon = True
recv_thread.start()
# Create a thread whose job is to play audio file data.
dev = ao.AudioDevice('pulse')
play_thread = threading.Thread(target=play_thread_func,
args=(wrap, cond_filled, dev))
play_thread.daemon = True
play_thread.start()
# Enter our never-ending user I/O loop. Because we imported the readline
# module above, raw_input gives us nice shell-like behavior (up-arrow to
# go backwards, etc.).
while True:
line = raw_input('>> ')
if ' ' in line:
cmd, args = line.split(' ', 1)
else:
cmd = line
# TODO: Send messages to the server when the user types things.
if cmd in ['l', 'list']:
print 'The user asked for list.'
sendRequest(sock, cmd)
elif cmd in ['p', 'play']:
if ' ' not in line:
print "Enter song id or song name!"
continue
print 'The user asked to play:', args
#wrap.mp = None
#if the music is already downloaded locally
'''
if args in downloaded:
f = open(download_dir+"/"+downloaded[args], 'r')
data = f.read()
f.close()
# Hand off the data to the wrapper object and use it to create a new MAD
# library decoder. For your client, you will be appending chunks of data
# to the end of wrap.data in your receiver thread while the player thread
# is removing and playing data from the front of it.
wrap.data = data
'''
if playing[0]:
playing[0] = False
cond_filled.acquire()
wrap.data = ''
wrap.mf = mad.MadFile(wrap)
cond_filled.notify()
cond_filled.release()
sendRequest(sock, "stop")
sendRequest(sock, cmd + " " + args)
elif cmd in ['s', 'stop']:
if not playing[0]:
print "No song is playing!"
continue
playing[0] = False
print 'The user asked for stop.'
cond_filled.acquire()
wrap.data = ''
wrap.mf = mad.MadFile(wrap)
cond_filled.notify()
cond_filled.release()
sendRequest(sock, cmd)
elif cmd in ['quit', 'q', 'exit']:
sendRequest(sock, cmd)
sock.close()
sys.exit(0)
else:
print "Try again, wrong command"
def playAudio(self, audio_data, tp='mplayer_mp3'):
if tp == 'mplayer_mp3':
cmd = 'mplayer -novideo -nolirc -cache 1024 -really-quiet -softvol -volume 100 -'
cmd = shlex.split(cmd)
#-# debug('EXEC_CMD< %s ...', cmd)
proc = subprocess.Popen(cmd, stdin=subprocess.PIPE)
try:
outs, errs = proc.communicate(audio_data, timeout=30)
proc.kill() # TODO useless ?
outs, errs = proc.communicate()
proc.terminate()
except subprocess.TimeoutExpired:
warn('kill timeout proc %s', proc)
proc.kill()
outs, errs = proc.communicate()
elif tp == 'play':
#-# cmd = 'play -t mp3 - -q gain -b -l 10'
cmd = 'play -t mp3 - -q'
cmd = shlex.split(cmd)
#-# debug('EXEC_CMD< %s ...', cmd)
proc = None
try:
proc = subprocess.Popen(cmd, stdin=subprocess.PIPE)
outs, errs = proc.communicate(audio_data, timeout=30)
except subprocess.TimeoutExpired:
if proc:
warn('kill timeout proc %s', proc)
proc.kill()
outs, errs = proc.communicate()
elif tp == 'mplayer':
cmd = 'mplayer -demuxer rawaudio -rawaudio channels=1:rate=16000:bitrate=16 -novideo -really-quiet -noconsolecontrols -nolirc -'
cmd = shlex.split(cmd)
debug('EXEC_CMD< %s ...', cmd)
proc = subprocess.Popen(cmd, stdin=subprocess.PIPE)
try:
outs, errs = proc.communicate(audio_data, timeout=30)
except subprocess.TimeoutExpired:
warn('kill timeout proc %s', proc)
proc.kill()
outs, errs = proc.communicate()
elif tp == 'ao':
import ao
ao.AudioDevice('raw', bits=16, rate=16000,
channels=1).play(audio_data)
elif tp == 'pcm':
import alsaaudio
pcm = alsaaudio.PCM(card='Intel')
pcm.setchannels(2)
pcm.setrate(16000)
pcm.setformat(alsaaudio.PCM_FORMAT_S16_LE)
# play pcm file from tts
pcm.write(audio_data)
del pcm
if tp == 'pyaudio':
with noalsaerr():
p = pyaudio.PyAudio()
#-# stream = p.open(format=p.get_format_from_width(2), channels=2, rate=16000, output=True)
stream = p.open(format=pyaudio.paInt16,
channels=1,
rate=16000,
output=True)
stream.write(audio_data)
sleep(0.5) # wait steam play done
stream.stop_stream()
stream.close()
p.terminate()
#!/usr/bin/python
import mad
import ao
import sys
mf = mad.MadFile(sys.argv[1])
dev = ao.AudioDevice('alsa', rate=mf.samplerate())
while 1:
buf = mf.read()
if buf is None:
break
dev.play(buf, len(buf))
def __init__(self, aodevice, rate, options):
self.ao = ao.AudioDevice(aodevice,
rate=rate,
byte_format=4,
options=options)
--- cypack/player.py.bak 2011-02-12 21:11:21.000000000 +0100
+++ cypack/player.py 2011-02-12 21:12:19.000000000 +0100
@@ -370,7 +370,7 @@
import mad, ao
self.mf = mad.MadFile(self.path)
self.total = self.mf.total_time()/1000
- dev = ao.AudioDevice('alsa', rate=self.mf.samplerate())
+ dev = ao.AudioDevice('oss', rate=self.mf.samplerate())
global player
while 1:
# manually halted, set mode to stop - to make sure poll won't
