def main():
rospy.init_node( 'beep_publisher' )
# parameters
loop_rate = rospy.get_param( '~loop_rate', 100 )
buffer_size = rospy.get_param( '~buffer_size', 4096 )
use_audio_common = rospy.get_param( '~use_audio_common', False )
topicname_data = '~audio'
topicname_info = '~info'
# import message modules
if use_audio_common:
from audio_common_msgs.msg import AudioData
from audio_stream_msgs.msg import AudioInfo
else:
from audio_stream_msgs.msg import AudioData, AudioInfo
# publishers
publisher_data = rospy.Publisher( topicname_data, AudioData, queue_size=1000 )
publisher_info = rospy.Publisher( topicname_info, AudioInfo, queue_size=10 )
# message
msg_data = AudioData()
msg_info = AudioInfo()
# gen a default buffer
msg_info.channels = 1
msg_info.sampling_rate = 16000
msg_info.width = 2
frequency_f0 = 440 # 基本周波数
frequency_beep = 1.0 # beepの周期
buffer_beep = generateBeep( 0.1*((2**8) ** 2), [ 440, 480, 500, 520, 400, 300, 600, 800 ], frequency_beep, msg_info.sampling_rate, 10.0, 0.5 ).astype(np.uint16).tobytes()
r = rospy.Rate( loop_rate )
index = 0
time_played = 0.0; # sec
time_start = time.time()
while not rospy.is_shutdown():
rospy.loginfo('publish')
if index > len(buffer_beep):
index = 0
msg_info.header.stamp = rospy.Time.now()
if ( len(buffer_beep) - index) < buffer_size:
msg_data.data = buffer_beep[index:]
time_played += 1.0 * ( len(buffer_beep) - index ) / ( msg_info.width * msg_info.sampling_rate )
else:
msg_data.data = buffer_beep[index:index+buffer_size]
time_played += 1.0 * buffer_size / ( msg_info.width * msg_info.sampling_rate )
time_passed = time.time() - time_start
while time_played - time_passed > 0:
time_passed = time.time() - time_start
if rospy.is_shutdown():
return
r.sleep()
publisher_data.publish( msg_data )
publisher_info.publish( msg_info )
index += buffer_size
def read_from_cache(text):
global locale
m = hashlib.md5()
m.update(text.data)
audio_filename = m.hexdigest()
if not os.path.exists("xiaoqiang_tts"):
os.mkdir("xiaoqiang_tts")
return None
# 兼容以前版本
if os.path.exists(os.path.join("xiaoqiang_tts", audio_filename)) and \
os.path.getsize(os.path.join("xiaoqiang_tts", audio_filename)) > 0 and locale == "zh-cn":
with open(os.path.join("xiaoqiang_tts", audio_filename),
"rb") as audio_file:
audio_data = AudioData()
audio_data.data = audio_file.read()
return audio_data
if not os.path.exists(os.path.join("xiaoqiang_tts", locale)):
os.mkdir(os.path.join("xiaoqiang_tts", locale))
return None
# 从对应locale路径读取
if os.path.exists(os.path.join("xiaoqiang_tts", locale, audio_filename)) and \
os.path.getsize(os.path.join("xiaoqiang_tts", locale, audio_filename)) > 0:
with open(os.path.join("xiaoqiang_tts", locale, audio_filename),
"rb") as audio_file:
audio_data = AudioData()
audio_data.data = audio_file.read()
return audio_data
return None
def audio_cb(self, data):
#: :type data: AudioBuffer
#ab = AudioBuffer()
# This contains (in the 'data' field): int16[] data
rospy.loginfo("Callback received!")
ad = AudioData()
# This is: uint8[] data
data_uint8 = numpy.array(data.data, dtype=numpy.uint8)
ad.data = data_uint8.tolist()
self.pub.publish(ad)
def sample_audio_test(self, in_data, frame_count, time_info, status):
#data_int = np.fromstring(in_data, dtype=np.int16)
#msg_audio = AudioData16()
#msg_audio.data = data_int
msg_audio = AudioData()
msg_audio.data = in_data
self.raw_pub.publish(msg_audio)
return None, pyaudio.paContinue
def read_from_cache(text):
if not os.path.exists("/tmp/xiaoqiang_tts"):
os.mkdir("/tmp/xiaoqiang_tts")
return None
if os.path.exists(os.path.join("/tmp/xiaoqiang_tts", text.data)):
with open(os.path.join("/tmp/xiaoqiang_tts", text.data),
"rb") as audio_file:
audio_data = AudioData()
audio_data.data = audio_file.read()
return audio_data
return None
def tts(self, words):
result = self.client.synthesis(words, 'zh', 1, {
'vol': 5,
})
if isinstance(result, dict):
rospy.logerr(result)
return None
audio_data = AudioData()
audio_data.data = result
return audio_data
def stream_audio(self):
reccmd = self.arecord_command
self.p = subprocess.Popen(reccmd, stdout=subprocess.PIPE)
while not rospy.is_shutdown():
self.last_data = self.p.stdout.read(self.block_size)
if self.last_data is not None:
ad = AudioData()
ad.data = tuple(np.fromstring(self.last_data, dtype=np.uint8))
self.pub.publish(ad)
self.close()
def run(self):
try:
data = self.stream.read(self.CHUNK)
except IOError as ex:
if ex[1] != pyaudio.paInputOverflowed:
raise
print("ERROR")
return
amplitude = np.fromstring(data, np.uint8)
print type(amplitude)
msg = AudioData()
msg.data = amplitude.tolist()
self.pub.publish(msg)
def read_from_cache(text):
m = hashlib.md5()
m.update(text.data)
audio_filename = m.hexdigest()
if not os.path.exists("xiaoqiang_tts"):
os.mkdir("xiaoqiang_tts")
return None
if os.path.exists(os.path.join("xiaoqiang_tts", audio_filename)) and \
os.path.getsize(os.path.join("xiaoqiang_tts", audio_filename)) > 0:
with open(os.path.join(
"xiaoqiang_tts", audio_filename), "rb") as audio_file:
audio_data = AudioData()
audio_data.data = audio_file.read()
return audio_data
return None
def topic_cb(self, msg):
# Retrieve 1 channel audio data
tmp = list(msg.data)
tmp = tmp[0::len(msg.channelMap)]
# Convert audio format: Int -> Buffer(Uint8)
dataBuff = ""
for i in range(0, len(tmp)):
if tmp[i] < 0:
tmp[i] = tmp[i] + 65536
dataBuff = dataBuff + chr(tmp[i] % 256)
dataBuff = dataBuff + chr((tmp[i] - (tmp[i] % 256)) / 256)
# Publish audio topic
audio_data = AudioData()
audio_data.data = dataBuff
self.audiodata_pub.publish(audio_data)
def main():
rospy.init_node('colored_noise_publisher')
# parameters
loop_rate = int(rospy.get_param('~loop_rate', 100))
buffer_size = int(rospy.get_param('~buffer_size', 4096))
use_audio_common = bool(rospy.get_param('~use_audio_common', False))
beta = float(rospy.get_param('~exponent', 1))
level = float(rospy.get_param('~level', 0.5))
# import message modules
if use_audio_common:
from audio_common_msgs.msg import AudioData
from audio_stream_msgs.msg import AudioInfo
else:
from audio_stream_msgs.msg import AudioData, AudioInfo
# publishers
publisher_data = rospy.Publisher('~audio', AudioData, queue_size=1000)
publisher_info = rospy.Publisher('~info', AudioInfo, queue_size=10)
# gen a default buffer
msg_info = AudioInfo()
msg_data = AudioData()
msg_info.channels = 1
msg_info.sampling_rate = 16000
msg_info.width = 2
A = level * ((2**8)**2)
buffer_wave = generateColoredNoise(beta, A, msg_info.sampling_rate,
30).astype(np.uint16).tobytes()
r = rospy.Rate(loop_rate)
index = 0
time_played = 0.0 # sec
time_start = time.time()
while not rospy.is_shutdown():
rospy.loginfo('publish')
# update msg_info header
msg_info.header.stamp = rospy.Time.now()
# fill msg_data.data
if (len(buffer_wave) - index) < buffer_size:
msg_data.data = buffer_wave[index:] + buffer_wave[:index +
buffer_size -
len(buffer_wave)]
time_played += 1.0 * (len(buffer_wave) - index) / (
msg_info.width * msg_info.sampling_rate)
index = index + buffer_size - len(buffer_wave)
else:
msg_data.data = buffer_wave[index:index + buffer_size]
time_played += 1.0 * buffer_size / (msg_info.width *
msg_info.sampling_rate)
index = index + buffer_size
time_passed = time.time() - time_start
while time_played > time_passed:
time_passed = time.time() - time_start
if rospy.is_shutdown():
return
r.sleep()
# publish them
publisher_data.publish(msg_data)
publisher_info.publish(msg_info)
rospy.Subscriber("~audio", AudioData, process_audio)
def audio_status_cb(audio_status):
global AUDIO_STATUS
AUDIO_STATUS = audio_status.data
rospy.Subscriber("~audio_status", Bool, audio_status_cb)
while not rospy.is_shutdown():
time.sleep(0.5)
rospy.loginfo("AUDIO_CACHE Duration: " +
str(audio_duration(AUDIO_CACHE)))
if is_end(AUDIO_CACHE) and audio_duration(AUDIO_CACHE) > 2:
# valid audio content
CURRENT_AUDIO.data = AUDIO_CACHE.data
AUDIO_CACHE.data = []
if not is_empty(CURRENT_AUDIO):
rospy.loginfo("New content found")
rospy.loginfo(
"Duration: " + str(audio_duration(CURRENT_AUDIO)))
audio_file_name = "/home/randoms/audio_" + \
str(int(time.time()))
# with open(audio_file_name, "w+") as audio_file:
# audio_file.write(wav_file(
# unify(CURRENT_AUDIO).data, 16000))
words = String()
words.data = client.asr(CURRENT_AUDIO)
if len(words.data) == 0:
continue
words_pub.publish(words)
def callback(self, data):
rospy.loginfo("Callback received!")
ad = AudioData()
data_uint8 = numpy.array(data.data, dtype=numpy.uint8)
ad.data = data_uint8.tolist()
self.pub.publish(ad)
pub = rospy.Publisher('replay_audio/audio', AudioData, queue_size = 10)
msg = AudioData()
parser = argparse.ArgumentParser()
parser.add_argument('path', type=str,
help='path to pickle file')
args = parser.parse_args()
FILE_NAME = args.path
with open(FILE_NAME, "rb") as handle:
data_dict = pickle.load(handle)
states = data_dict["state_list"]
actions = data_dict["action_list"]
images = data_dict["image_list"]
audio = data_dict["audio_list"]
print("len of states{} len of actions{} len of images{}".format(len(states), len(actions), len(images)))
import time
for image,sound in zip(images, audio):
image_list = []
print(len(sound))
for i in range(6):
image_list.append(gray_rgb(image[:,:,i]))
vis_tool._display(image_list)
# import pdb; pdb.set_trace()
msg.data = sound
pub.publish(msg)
time.sleep(0.09);
def main():
rospy.init_node( 'audio_stream_publisher' )
# parameters
loop_rate = rospy.get_param( '~loop_rate', 100 )
is_loop = rospy.get_param( '~is_loop', False )
filename = rospy.get_param( '~filename' )
buffer_size = rospy.get_param( '~buffer_size', 4096 )
max_precede = rospy.get_param( '~max_precede', 10.0 )
use_audio_common = rospy.get_param( '~use_audio_common', False )
topicname_data = '~audio'
topicname_info = '~info'
# import message modules
if use_audio_common:
from audio_common_msgs.msg import AudioData
from audio_stream_msgs.msg import AudioInfo
else:
from audio_stream_msgs.msg import AudioData, AudioInfo
# publishers
publisher_data = rospy.Publisher( topicname_data, AudioData, queue_size=1 )
publisher_info = rospy.Publisher( topicname_info, AudioInfo, queue_size=1 )
# message
msg_data = AudioData()
msg_info = AudioInfo()
# open wavefile
wavefile = wave.open( filename, 'r' )
wave_channels = wavefile.getnchannels()
wave_width = wavefile.getsampwidth()
wave_framerate = wavefile.getframerate()
wave_framenum = wavefile.getnframes()
wave_data = wavefile.readframes( wave_framenum )
infostr = (\
'== Wave file info ==\n' +\
'channels: {}\n' +\
'sample size [byte]: {}\n' +\
'sampling rate [hz]: {}\n' +\
'number of frames: {} ( {} secs )').format( wave_channels, wave_width, wave_framerate, wave_framenum, wave_framenum*1.0/wave_framerate )
rospy.loginfo( infostr )
if wave_channels != 1 or not ( wave_width == 1 or wave_width == 2):
rospy.logerr( 'Currently 8bit or 16bit monaural wave files are supported.' )
sys.exit(1)
if buffer_size % wave_width > 0:
rospy.logerr ( 'buffer_size must be multiple of wave_width' )
sys.exit(1)
msg_info.channels = wave_channels
msg_info.sampling_rate = wave_framerate
msg_info.width = wave_width
msg_info.header.stamp = rospy.Time.now()
publisher_info.publish( msg_info )
r = rospy.Rate( loop_rate )
if is_loop:
time_played = 0.0; # sec
time_start = time.time()
index = 0
while not rospy.is_shutdown():
# return to first if index is out of wave_data
if index > wave_framenum:
index = 0
# preparing msg data
msg_info.header.stamp = rospy.Time.now()
if ( wave_framenum - index ) < buffer_size:
msg_data.data = wave_data[index:]
time_played += 1.0 * ( wave_framenum - index ) / ( wave_width * wave_framerate )
else:
msg_data.data = wave_data[index:index+buffer_size]
time_played += 1.0 * buffer_size / ( wave_width * wave_framerate )
# sleep if played time is ahead of passed time
time_passed = time.time() - time_start
while time_played - time_passed > max_precede:
time_passed = time.time() - time_start
if rospy.is_shutdown():
return
r.sleep()
# publishing data
publisher_data.publish( msg_data )
publisher_info.publish( msg_info )
# debug print
rospy.logdebug( 'time played: {}, time passed {}'.format( time_played, time_passed ) )
# increase index
index += buffer_size
else:
time_played = 0.0; # sec
time_start = time.time()
index = 0
while not rospy.is_shutdown():
# return to first if index is out of wave_data
if index > wave_framenum:
break
# preparing msg data
msg_info.header.stamp = rospy.Time.now()
if ( wave_framenum - index ) < buffer_size:
msg_data.data = wave_data[index:]
time_played += 1.0 * ( wave_framenum - index ) / ( wave_width * wave_framerate )
else:
msg_data.data = wave_data[index:index+buffer_size]
time_played += 1.0 * buffer_size / ( wave_width * wave_framerate )
# sleep if played time is ahead of passed time
time_passed = time.time() - time_start
while time_played - time_passed > max_precede:
time_passed = time.time() - time_start
if rospy.is_shutdown():
return
r.sleep()
# publishing data
publisher_data.publish( msg_data )
publisher_info.publish( msg_info )
# debug print
rospy.logdebug( 'time played: {}, time passed {}'.format( time_played, time_passed ) )
# increase index
index += buffer_size
#!/usr/bin/env python
import roslib
roslib.load_manifest(
'usb2dynamixel_widomx'
) #this step is necessary in order to use the customized message
import roslib
roslib.load_manifest(
'widomX') #this step is necessary in order to use the customized message
import rospy
from audio_common_msgs.msg import AudioData
import pickle
import time
#store 10 secs audio data
if __name__ == '__main__':
rospy.init_node("mp3_replay", anonymous=True)
pub = rospy.Publisher('/audio/audio', AudioData, queue_size=10)
with open("audio_raw_mp3.pkl", 'rb') as handle:
data = pickle.load(handle)
array = data['audio_mp3']
for i in array:
msg = AudioData()
msg.data = i
pub.publish(msg)
print(len(i))
time.sleep(0.08)
