public void Say(string sentense, SupportedLanguage language)
{
EnsureSynthesisModule();
if (language == SupportedLanguage.NotSpecified)
{
language = _synthesisProfiles.Keys.First();
}
if (!_synthesisProfiles.ContainsKey(language))
{
throw new LanguageNotSupportedException(language);
}
_synthesisModule.SetProfile(_synthesisProfiles[language]);
_synthesisModule.BuildSentence(1, sentense);
int nbuffers = _synthesisModule.QueryBufferNum(1);
for (int i = 0; i < nbuffers; i++)
{
PXCMAudio audio = _synthesisModule.QueryBuffer(1, i);
PXCMAudio.AudioData audioData;
audio.AcquireAccess(PXCMAudio.Access.ACCESS_READ, PXCMAudio.AudioFormat.AUDIO_FORMAT_PCM, out audioData);
RealSenseAudioPlayer.Play(audioData, _synthesisProfiles[language].outputs);
audio.ReleaseAccess(audioData);
}
_synthesisModule.ReleaseSentence(1);
}
/**
* @brief The function retrieves the synthesized speech as an Unity AudioClip object.
* @param[in] name The audio clip name
* @param[in] sid The sentence identifier
* @return the AudioClip instance, or null if there is any error.
*/
public AudioClip QueryAudioClip(String name, Int32 sid)
{
int nsamples = QuerySampleNum(sid);
if (nsamples == 0)
{
return(null);
}
ProfileInfo pinfo;
QueryProfile(out pinfo);
AudioClip clip = AudioClip.Create(name, nsamples * pinfo.outputs.nchannels,
pinfo.outputs.nchannels, pinfo.outputs.sampleRate, false, false);
int nbuffers = QueryBufferNum(sid);
for (int i = 0, offset = 0; i < nbuffers; i++)
{
PXCMAudio audio = QueryBuffer(sid, i);
PXCMAudio.AudioData data;
pxcmStatus sts = audio.AcquireAccess(PXCMAudio.Access.ACCESS_READ, PXCMAudio.AudioFormat.AUDIO_FORMAT_IEEE_FLOAT, out data);
if (sts < pxcmStatus.PXCM_STATUS_NO_ERROR)
{
break;
}
float[] samples = data.ToFloatArray();
clip.SetData(data.ToFloatArray(), offset);
offset += samples.Length;
audio.ReleaseAccess(data);
}
return(clip);
}
// Conversion extracted from the sample voice_synthesis.cs (RSSDK\framework\CSharp\voice_synthesis.cs)
// To understand a little bit more about the WAV file format, acess the following links:
// - http://www-mmsp.ece.mcgill.ca/documents/AudioFormats/WAVE/WAVE.html
// - http://www.sonicspot.com/guide/wavefiles.html
public static void Play(PXCMAudio.AudioData audioData, PXCMAudio.AudioInfo audioInfo) {
using (var memoryStream = new MemoryStream()) {
using (var bw = new BinaryWriter(memoryStream)) {
bw.Write(0x46464952); // chunkIdRiff:'FFIR'
bw.Write(0); // chunkDataSizeRiff
bw.Write(0x45564157); // riffType:'EVAW'
bw.Write(0x20746d66); // chunkIdFmt:' tmf'
bw.Write(0x12); // chunkDataSizeFmt
bw.Write((short)1); // compressionCode
bw.Write((short)audioInfo.nchannels); // numberOfChannels
bw.Write(audioInfo.sampleRate); // sampleRate
bw.Write(audioInfo.sampleRate * 2 * audioInfo.nchannels); // averageBytesPerSecond
bw.Write((short)(audioInfo.nchannels * 2)); // blockAlign
bw.Write((short)16); // significantBitsPerSample
bw.Write((short)0); // extraFormatSize
bw.Write(0x61746164); // chunkIdData:'atad'
bw.Write(0); // chunkIdSizeData
bw.Write(audioData.ToByteArray());
long pos = bw.Seek(0, SeekOrigin.Current);
bw.Seek(0x2a, SeekOrigin.Begin); // chunkDataSizeData
bw.Write((int)(pos - 46));
bw.Seek(0x04, SeekOrigin.Begin); // chunkDataSizeRiff
bw.Write((int)(pos - 8));
bw.Seek(0, SeekOrigin.Begin);
using (var soundPlayer = new SoundPlayer(memoryStream)) {
soundPlayer.PlaySync();
}
}
}
}
public int abc(Byte[] databuff, int index, PXCMAudio.AudioInfo audioinfo)
{
PXCMAudio.AudioInfo ainfo = new PXCMAudio.AudioInfo()
{
bufferSize = 8820, // max number of bytes
format = PXCMAudio.AudioFormat.AUDIO_FORMAT_PCM, // audio sample format
sampleRate = 44100, // sampling rate in Hz
nchannels = 2, // number of channels
};
PXCMAudio audio = session.CreateAudio(ainfo);
if (audio == null)
{
Debug.Log("RSSDK: CreateAudio error !");
return(0);
}
audioinfo = audio.QueryInfo();
PXCMAudio.AudioData data;
int num_samples = 0;
audio.AcquireAccess(PXCMAudio.Access.ACCESS_READ, out data);
data.ToByteArray().CopyTo(databuff, (long)index);
num_samples = (int)(data.dataSize);
audio.ReleaseAccess(data);
audio.Dispose();
return(num_samples);
}
public bool RenderAudio(PXCMAudio audio)
{
PXCMAudio.AudioData adata;
pxcmStatus sts = audio.AcquireAccess(PXCMAudio.Access.ACCESS_READ, PXCMAudio.AudioFormat.AUDIO_FORMAT_PCM, out adata);
if (sts < pxcmStatus.PXCM_STATUS_NO_ERROR) return false;
bw.Write(adata.ToByteArray());
audio.ReleaseAccess(adata);
return true;
}
public static string Speak(string sentence, int curr_volume, int curr_pitch, int curr_speech_rate)
{
string module = "";
int language = 0;
PXCMSession session = PXCMSession.CreateInstance();
if (session == null)
{
return("Failed to create an SDK session");
}
PXCMSession.ImplDesc desc = new PXCMSession.ImplDesc();
desc.friendlyName = module;
desc.cuids[0] = PXCMSpeechSynthesis.CUID;
PXCMSpeechSynthesis vsynth;
pxcmStatus sts = session.CreateImpl <PXCMSpeechSynthesis>(desc, out vsynth);
if (sts < pxcmStatus.PXCM_STATUS_NO_ERROR)
{
session.Dispose();
return("Failed to create the synthesis module");
}
PXCMSpeechSynthesis.ProfileInfo pinfo;
vsynth.QueryProfile(language, out pinfo);
pinfo.volume = curr_volume;
pinfo.rate = curr_speech_rate;
pinfo.pitch = curr_pitch;
sts = vsynth.SetProfile(pinfo);
if (sts < pxcmStatus.PXCM_STATUS_NO_ERROR)
{
vsynth.Dispose();
session.Dispose();
return("Failed to initialize the synthesis module");
}
sts = vsynth.BuildSentence(1, sentence);
if (sts >= pxcmStatus.PXCM_STATUS_NO_ERROR)
{
VoiceOut vo = new VoiceOut(pinfo.outputs);
for (int i = 0;; i++)
{
PXCMAudio sample = vsynth.QueryBuffer(1, i);
if (sample == null)
{
break;
}
vo.RenderAudio(sample);
}
vo.Close();
}
vsynth.Dispose();
session.Dispose();
return(null);
}
public bool RenderAudio(PXCMAudio audio)
{
PXCMAudio.AudioData adata;
pxcmStatus sts = audio.AcquireAccess(PXCMAudio.Access.ACCESS_READ, PXCMAudio.AudioFormat.AUDIO_FORMAT_PCM, out adata);
if (sts < pxcmStatus.PXCM_STATUS_NO_ERROR)
{
return(false);
}
bw.Write(adata.ToByteArray());
audio.ReleaseAccess(adata);
return(true);
}
public VoiceOut(PXCMAudio.AudioInfo ainfo)
{
fs = new MemoryStream();
bw = new BinaryWriter(fs);
bw.Write((int)0x46464952); // chunkIdRiff:'FFIR'
bw.Write((int)0); // chunkDataSizeRiff
bw.Write((int)0x45564157); // riffType:'EVAW'
bw.Write((int)0x20746d66); // chunkIdFmt:' tmf'
bw.Write((int)0x12); // chunkDataSizeFmt
bw.Write((short)1); // compressionCode
bw.Write((short)ainfo.nchannels); // numberOfChannels
bw.Write((int)ainfo.sampleRate); // sampleRate
bw.Write((int)(ainfo.sampleRate * 2 * ainfo.nchannels)); // averageBytesPerSecond
bw.Write((short)(ainfo.nchannels * 2)); // blockAlign
bw.Write((short)16); // significantBitsPerSample
bw.Write((short)0); // extraFormatSize
bw.Write((int)0x61746164); // chunkIdData:'atad'
bw.Write((int)0); // chunkIdSizeData
}
private void ButtonSpeechSynthesis_Click(object sender, RoutedEventArgs e)
{
var sts = synthesis.BuildSentence(1, TextSentence.Text);
if (sts < pxcmStatus.PXCM_STATUS_NO_ERROR)
{
return;
}
// 音声合成した結果を出力する
VoiceOut vo = new VoiceOut(profile.outputs);
int bufferNum = synthesis.QueryBufferNum(1);
for (int i = 0; i < bufferNum; ++i)
{
PXCMAudio sample = synthesis.QueryBuffer(1, i);
vo.RenderAudio(sample);
}
vo.Close();
}
public static String ToString(this PXCMAudio.AudioFormat format)
{
return(PXCMAudio.AudioFormatToString(format));
}
public static Int32 ToSize(this PXCMAudio.AudioFormat format)
{
return(PXCMAudio.AudioFormatToSize(format));
}
// Use this for initialization
void Start()
{
_pxcmSenseManager = PXCMSenseManager.CreateInstance();
if (_pxcmSenseManager == null)
{
Debug.LogError("SenseManager Initialization Failed");
}
else
{
int nbuffers;
int nsamples;
AudioSource aud = GetComponent <AudioSource>();
String name = "test";
Int32 sid = 1;
_pxcmSenseManager.session.CreateImpl <PXCMSpeechSynthesis>(out tts);
PXCMSpeechSynthesis.ProfileInfo pinfo;
tts.QueryProfile(0, out pinfo);
pinfo.language = PXCMSpeechSynthesis.LanguageType.LANGUAGE_US_ENGLISH;
tts.SetProfile(pinfo);
tts.BuildSentence(1, "The year is 2098. Interstellar space travel was made possible in 2045. But space travel is dangerous. Human life support systems for interdimensional transport are costly and high risk. The majority of trade ships are unmanned and piloted remotely using hyper dimensional virtual reality. Use the voice command initialize to begin, or click the play button.");
nsamples = tts.QuerySampleNum(sid);
if (nsamples != 0)
{
tts.QueryProfile(out pinfo);
clip = AudioClip.Create(
name,
nsamples * pinfo.outputs.nchannels,
pinfo.outputs.nchannels,
pinfo.outputs.sampleRate,
false
);
nbuffers = tts.QueryBufferNum(sid);
for (int i = 0, offset = 0; i < nbuffers; i++)
{
PXCMAudio audio = tts.QueryBuffer(sid, i);
PXCMAudio.AudioData data;
pxcmStatus sts = audio.AcquireAccess(
PXCMAudio.Access.ACCESS_READ,
PXCMAudio.AudioFormat.AUDIO_FORMAT_IEEE_FLOAT,
out data
);
if (sts < pxcmStatus.PXCM_STATUS_NO_ERROR)
{
break;
}
float[] samples = data.ToFloatArray();
clip.SetData(data.ToFloatArray(), offset);
offset += samples.Length;
audio.ReleaseAccess(data);
}
aud.clip = clip;
aud.Play();
}
}
tts.Dispose();
}
private void recording()
{
//Default values
string output_file_name = timestamp + ".wav";
// Get a memory stream for the audio data, wrapped with a big try catch for simplicity.
using (MemoryStream writer = new MemoryStream())
{
pxcmStatus status = PXCMSession.CreateInstance(out this.session);
if (status < pxcmStatus.PXCM_STATUS_NO_ERROR)
{
Console.Error.WriteLine("Failed to create the PXCMSession. status = " + status);
return;
}
PXCMCapture.AudioStream.DataDesc request = new PXCMCapture.AudioStream.DataDesc();
request.info.nchannels = 1;
request.info.sampleRate = 44100;
uint subchunk2_data_size = 0;
// Use the capture utility
using (this.session)
using (UtilMCapture capture = new UtilMCapture(this.session))
{
// Locate a stream that meets our request criteria
status = capture.LocateStreams(ref request);
if (status < PXCM_STATUS_NO_ERROR)
{
Console.Error.WriteLine("Unable to locate audio stream. status = " + status);
return;
}
// Set the volume level
status = capture.device.SetProperty(PXCMCapture.Device.Property.PROPERTY_AUDIO_MIX_LEVEL, 0.2f);
if (status < pxcmStatus.PXCM_STATUS_NO_ERROR)
{
Console.Error.WriteLine("Unable to set the volume level. status = " + status);
return;
}
Console.WriteLine("Begin audio recording");
isRecording = true;
// Get the n frames of audio data.
while (isRecording)
{
PXCMScheduler.SyncPoint sp = null;
PXCMAudio audio = null;
// We will asynchronously read the audio stream, which
// will create a synchronization point and a reference
// to an audio object.
status = capture.ReadStreamAsync(out audio, out sp);
if (status < PXCM_STATUS_NO_ERROR)
{
Console.Error.WriteLine("Unable to ReadStreamAsync. status = " + status);
return;
}
using (sp)
using (audio)
{
// For each audio frame
// 1) Synchronize so that you can access to the data
// 2) acquire access
// 3) write data while you have access,
// 4) release access to the data
status = sp.Synchronize();
if (status < PXCM_STATUS_NO_ERROR)
{
Console.Error.WriteLine("Unable to Synchronize. status = " + status);
return;
}
PXCMAudio.AudioData adata;
status = audio.AcquireAccess(PXCMAudio.Access.ACCESS_READ, PXCMAudio.AudioFormat.AUDIO_FORMAT_PCM, out adata);
if (status < PXCM_STATUS_NO_ERROR)
{
Console.Error.WriteLine("Unable to AcquireAccess. status = " + status);
return;
}
byte[] data = adata.ToByteArray();
int len = data.Length;
writer.Write(data, 0, len);
// keep a running total of how much audio data has been captured
subchunk2_data_size += (uint)(adata.dataSize * BYTES_PER_SAMPLE);
audio.ReleaseAccess(ref adata);
}
}
Console.WriteLine("End audio recording");
}
// The header needs to know how much data there is. Now that we are done recording audio
// we know that information and can write out the header and the audio data to a file.
using (BinaryWriter bw = new BinaryWriter(File.Open(output_file_name, FileMode.Create, FileAccess.Write)))
{
bw.Seek(0, SeekOrigin.Begin);
WriteAudioHeader(bw, subchunk2_data_size, (short)request.info.nchannels, request.info.sampleRate);
bw.Write(writer.ToArray());
}
}
}
