public byte[] GetClipData()
{
float[] samples = new float[clip.samples];
SpeexDecoder decoder = new SpeexDecoder(BandMode.Wide);
clip.GetData(samples, 0);
short[] outData = new short[samples.Length];
for (int i = 0; i < samples.Length; i++)
{
outData[i] = (short)(samples[i] * rescaleFactor);
}
SpeexEncoder encoder = new SpeexEncoder(BandMode.Wide);
byte[] encodedData = new byte[samples.Length * 2];
encoder.Encode(outData, 0, outData.Length, encodedData, 0, encodedData.Length);
testText = "length:" + encodedData.Length;
return(encodedData);
}
protected override void OnSamples(long sampleTimeInHundredNanoseconds, long sampleDurationInHundredNanoseconds, byte[] sampleData)
{
if (sampleDurationInHundredNanoseconds < 400000)
{
return;
}
// convert to short
short[] data = new short[320];
int sampleIndex = 0;
for (int index = 0; sampleIndex < data.Length; index += 2, sampleIndex++)
{
data[sampleIndex] = BitConverter.ToInt16(sampleData, index);
}
var encodedData = new byte[data.Length];
var encodedBytes = encoder.Encode(data, 0, sampleIndex, encodedData, 0, data.Length);
if (encodedBytes != 0)
{
var upstreamFrame = new byte[encodedBytes];
Array.Copy(encodedData, upstreamFrame, encodedBytes);
//Debug.WriteLine("Publishing: " + encodedBytesSample + " bytes");));)
sender.Begin_Publish(upstreamFrame, null, null);
}
}
public override RTPPacket[] Encode(short[] sData)
{
if (sData.Length != Encoder.FrameSize)
{
throw new Exception("Must provide input data equal to 1 frame size"); // for now, later it can be multiples
}
int nRet = 0;
//try
//{
watch.Start();
nRet = Encoder.Encode(sData, 0, sData.Length, bEncodeBuffer, 0, bEncodeBuffer.Length);
watch.Stop();
m_nPacketsEncoded++;
//}
//catch (ArgumentNullException)
//{ }
//catch (ArgumentOutOfRangeException)
//{
//}
byte[] bRet = new byte[nRet];
Array.Copy(bEncodeBuffer, 0, bRet, 0, nRet);
RTPPacket packet = new RTPPacket();
packet.PayloadData = bRet;
return(new RTPPacket[] { packet });
}
private void SoundIn_DataAvailable(object sender, WaveInEventArgs e)
{
if (CurrentCalls.Count <= 0)
{
return;
}
short[] data = new short[e.BytesRecorded / 2];
Buffer.BlockCopy(e.Buffer, 0, data, 0, e.BytesRecorded);
var encodedData = new byte[e.BytesRecorded];
var encodedBytes = encoder.Encode(data, 0, data.Length, encodedData, 0, encodedData.Length);
if (encodedBytes != 0)
{
var upstreamFrame = new byte[encodedBytes];
Array.Copy(encodedData, upstreamFrame, encodedBytes);
//SoundOutProvider.Write(upstreamFrame, 0, upstreamFrame.Length);
NewCall[] tmpcalls = CurrentCalls.Values.ToArray();
foreach (NewCall call in tmpcalls)
{
call.SendData(upstreamFrame);
}
}
//byte[] Loud = ChangeVolume(e.Buffer, true, 50); // 50% Increase
}
// Token: 0x06004C3F RID: 19519 RVA: 0x00197D4C File Offset: 0x0019614C
private byte[] SpeexEncode(short[] input, global::BandMode mode)
{
SpeexEncoder speexEncoder = null;
int num = 320;
if (mode != global::BandMode.Narrow)
{
if (mode != global::BandMode.Wide)
{
if (mode == global::BandMode.UltraWide)
{
speexEncoder = this.m_ultrawide_enc;
num = 1280;
}
}
else
{
speexEncoder = this.m_wide_enc;
num = 640;
}
}
else
{
speexEncoder = this.m_narrow_enc;
num = 320;
}
byte[] @byte = USpeakPoolUtils.GetByte(num + 4);
int value = speexEncoder.Encode(input, 0, input.Length, @byte, 4, @byte.Length);
byte[] bytes = BitConverter.GetBytes(value);
Array.Copy(bytes, @byte, 4);
return(@byte);
}
void ReadSample()
{
// Extract data
recordAudio.clip.GetData(sampleBuffer, sampleIndex);
// Grab a new sample buffer
float[] targetSampleBuffer = new float[targetSamplingSize];
// Resample our real sample into the buffer
Resample(sampleBuffer, targetSampleBuffer);
// Forward index
sampleIndex += recordSampleSize;
short[] data = ToShortArray(targetSampleBuffer);
byte[] buf = new byte[recordSampleSize * 4];
int len = speexEncoder.Encode(data, 0, data.Length, buf, 0, buf.Length);
if (len != 0)
{
encodeBufList.AddRange(buf.Take(len).ToArray());
}
totalSampleSize += (recordSampleSize * 4);
}
public static byte[] SpeexCompress(float[] input, out int length)
{
short[] shortBuffer = new short[input.Length];
byte[] encoded = new byte[input.Length];
input.ToShortArray(shortBuffer);
length = speexEnc.Encode(shortBuffer, 0, input.Length, encoded, 0, encoded.Length);
return(encoded);
}
private static byte[] SpeexCompress(float[] input, out int length)
{
short[] array = VoiceChatShortPool.Instance.Get();
byte[] array2 = VoiceChatBytePool.Instance.Get();
input.ToShortArray(array);
length = speexEnc.Encode(array, 0, input.Length, array2, 0, array2.Length);
VoiceChatShortPool.Instance.Return(array);
return(array2);
}
public void EncodeData(AudioFrameData frameData)
{
short[] shortData = new short[frameData.AudioData.Length];
Util.ConvertToShortArray(frameData.AudioData, shortData);
Byte[] encodedBytes = new Byte[shortData.Length * 2];
int numEncodedBytes = encoder.Encode(shortData, 0, encoder.FrameSize, encodedBytes, 0, encodedBytes.Length);
int difference = encodedBytes.Length - numEncodedBytes;
Debug.Log("Wasted bytes: " + difference);
byte[] trimmedBytes = new byte[numEncodedBytes];
Buffer.BlockCopy(encodedBytes, 0, trimmedBytes, 0, numEncodedBytes);
OnAudioFrameEncoded(trimmedBytes, numEncodedBytes);
}
private void WaveIn_DataAvailable(object sender, WaveInEventArgs e)
{
short[] data = new short[e.BytesRecorded / 2];
Buffer.BlockCopy(e.Buffer, 0, data, 0, e.BytesRecorded);
var encodedData = new byte[e.BytesRecorded];
var encodedBytes = encoder.Encode(data, 0, data.Length, encodedData, 0, encodedData.Length);
if (encodedBytes != 0)
{
}
var sendData = new byte[encodedBytes];
Buffer.BlockCopy(encodedData, 0, sendData, 0, encodedBytes);
Send(sendData);
Console.WriteLine($"{e.BytesRecorded} => {encodedBytes} {DateTime.Now}");
}
public byte[] Encode(byte[] data, int offset, int length)
{
FeedSamplesIntoEncoderInputBuffer(data, offset, length);
int samplesToEncode = _encoderInputBuffer.ShortBufferCount;
if (samplesToEncode % _encoder.FrameSize != 0)
{
samplesToEncode -= samplesToEncode % _encoder.FrameSize;
}
byte[] outputBufferTemp = new byte[length]; // contains more than enough space
int bytesWritten = _encoder.Encode(_encoderInputBuffer.ShortBuffer, 0, samplesToEncode, outputBufferTemp, 0, length);
byte[] encoded = new byte[bytesWritten];
System.Array.Copy(outputBufferTemp, 0, encoded, 0, bytesWritten);
ShiftLeftoverSamplesDown(samplesToEncode);
return(encoded);
}
private void waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
// convert to short
short[] data = new short[e.BytesRecorded / 2];
Buffer.BlockCopy(e.Buffer, 0, data, 0, e.BytesRecorded);
var encodedData = new byte[e.BytesRecorded];
var encodedBytes = encoder.Encode(data, 0, data.Length, encodedData, 0, encodedData.Length);
if (encodedBytes != 0)
{
var upstreamFrame = new byte[encodedBytes];
Array.Copy(encodedData, upstreamFrame, encodedBytes);
//Debug.WriteLine("Publishing: " + encodedBytesSample + " bytes");));)
this.sender.Publish(upstreamFrame);
}
}
public byte[] Encode(byte[] data, int offset, int length)
{
FeedSamplesIntoEncoderInputBuffer(data, offset, length);
int samplesToEncode = encoderInputBuffer.ShortBufferCount;
if (samplesToEncode % encoder.FrameSize != 0)
{
samplesToEncode -= samplesToEncode % encoder.FrameSize;
}
var outputBufferTemp = new byte[length]; // contains more than enough space
int bytesWritten = encoder.Encode(encoderInputBuffer.ShortBuffer, 0, samplesToEncode, outputBufferTemp, 0, length);
var encoded = new byte[bytesWritten];
Array.Copy(outputBufferTemp, 0, encoded, 0, bytesWritten);
ShiftLeftoverSamplesDown(samplesToEncode);
Debug.WriteLine(String.Format("NSpeex: In {0} bytes, encoded {1} bytes [enc frame size = {2}]", length, bytesWritten, encoder.FrameSize));
return(encoded);
}
private byte[] encodedBytes(AudioFrameData audioFramedata, out int length)
{
byte[] recordedBytes = Util.ToByteArrayBlockCopy(audioFramedata.AudioData);
int numOfShortsToSend = (recordedBytes.Length / 2) - (recordedBytes.Length / 2) % encoder.FrameSize;
short[] data = new short[numOfShortsToSend];
Buffer.BlockCopy(recordedBytes, 0, data, 0, numOfShortsToSend * 2);
byte[] encodedData = new byte[numOfShortsToSend * 2];
// note: the number of samples per frame must be a multiple of encoder.FrameSize
Debug.Log("recordedBytes: " + recordedBytes.Length +
" data: " + data.Length +
" encodedData: " + encodedData.Length +
" numOfBytesToSend: " + numOfShortsToSend * 2 +
" framesize: " + encoder.FrameSize);
length = encoder.Encode(data, 0, data.Length, encodedData, 0, encodedData.Length);
return(encodedData);
}
private unsafe byte[] Encode(byte[] data)
{
fixed(byte *bBuffer = data)
{
var sBuffer = (short *)bBuffer;
var samplesToEncode = data.Length / 2;
if (samplesToEncode % _encoder.FrameSize != 0)
{
samplesToEncode -= samplesToEncode % _encoder.FrameSize;
}
var outputBufferTemp = new byte[data.Length];
var bytesWritten = _encoder.Encode(sBuffer, 0, samplesToEncode, outputBufferTemp, 0, data.Length);
var encoded = new byte[bytesWritten];
Buffer.BlockCopy(outputBufferTemp, 0, encoded, 0, bytesWritten);
return(encoded);
}
}
void EncodeAudio(object _rawData)
{
//Extract data from incoming data
AudioData voiceData = (AudioData)_rawData;
int iAudioDataSize = voiceData.iAudioDataSize;
int iFrequency = voiceData.iFrequency;
short[] saAudioData = voiceData.saData;
// Encode frames
byte[] baEncodedData = new byte[iAudioDataSize];
int iTotalNumEncodedBytes = m_cEncoder.Encode(saAudioData, 0, saAudioData.Length, baEncodedData, 0, baEncodedData.Length);
s_AudioPacket.Write(iFrequency);
s_AudioPacket.Write(iAudioDataSize);
s_AudioPacket.Write(iTotalNumEncodedBytes);
s_AudioPacket.Write(baEncodedData, iTotalNumEncodedBytes);
}
private static byte[] EncodeSpeech(byte[] buf, int len)
{
BandMode mode = GetBandMode(mic.SampleRate);
SpeexEncoder encoder = new SpeexEncoder(mode);
// set encoding quality to lowest (which will generate the smallest size in the fastest time)
encoder.Quality = 1;
int inDataSize = len / 2;
// convert to short array
short[] data = new short[inDataSize];
int sampleIndex = 0;
for (int index = 0; index < len; index += 2, sampleIndex++)
{
data[sampleIndex] = BitConverter.ToInt16(buf, index);
}
// note: the number of samples per frame must be a multiple of encoder.FrameSize
inDataSize = inDataSize - inDataSize % encoder.FrameSize;
var encodedData = new byte[len];
int encodedBytes = encoder.Encode(data, 0, inDataSize, encodedData, 0, len);
if (encodedBytes != 0)
{
// each chunk is laid out as follows:
// | 4-byte total chunk size | 4-byte encoded buffer size | <encoded-bytes> |
byte[] inDataSizeBuf = BitConverter.GetBytes(inDataSize);
byte[] sizeBuf = BitConverter.GetBytes(encodedBytes + inDataSizeBuf.Length);
byte[] returnBuf = new byte[encodedBytes + sizeBuf.Length + inDataSizeBuf.Length];
sizeBuf.CopyTo(returnBuf, 0);
inDataSizeBuf.CopyTo(returnBuf, sizeBuf.Length);
Array.Copy(encodedData, 0, returnBuf, sizeBuf.Length + inDataSizeBuf.Length, encodedBytes);
return(returnBuf);
}
else
{
return(buf);
}
}
private byte[] Encode(byte[] data, int offset, int length)
{
FeedSamplesIntoEncoderInputBuffer(data, offset, length);
var samplesToEncode = _encoderInputBuffer.ShortBufferCount;
if (samplesToEncode % _encoder.FrameSize != 0)
{
samplesToEncode -= samplesToEncode % _encoder.FrameSize;
}
var outputBufferTemp = new byte[length]; // contains more than enough space
var bytesWritten = _encoder.Encode(_encoderInputBuffer.ShortBuffer, 0, samplesToEncode, outputBufferTemp, 0,
length);
var encoded = new byte[bytesWritten];
Array.Copy(outputBufferTemp, 0, encoded, 0, bytesWritten);
ShiftLeftoverSamplesDown(samplesToEncode);
//Debug.WriteLine(
//$"NSpeex: In {length} bytes, encoded {bytesWritten} bytes [enc frame size = {_encoder.FrameSize}]");
return(encoded);
}
private void WriteCore(float[] samples, int count)
{
if (shortBuffer == null || shortBuffer.Length < count * 10)
{
shortBuffer = new short[count * 10];
}
if (byteBuffer == null || byteBuffer.Length < count * 10)
{
byteBuffer = new byte[count * 10];
}
ArrayConverters.FloatToShort(samples, count, shortBuffer);
var bytesEncoded = speexEncoder.Encode(shortBuffer, 0, count, byteBuffer, 0, byteBuffer.Length);
if (encodeOgg)
{
oggWriter.WritePacket(byteBuffer, 0, bytesEncoded);
}
else
{
targetStream.Write(byteBuffer, 0, bytesEncoded);
}
}
/// <summary>
/// 将采集到的音频数据进行编码。
/// </summary>
public byte[] Encode(byte[] data)
{
if (data == null)
{
return(null);
}
if (data.Length % (FrameSize * 2) != 0)
{
throw new ArgumentException("Invalid Data Length.");
}
int nbBytes;
short[] input = new short[FrameSize];
byte[] buffer = new byte[200];
byte[] output = new byte[0];
for (int i = 0; i < data.Length / (FrameSize * 2); i++)
{
for (int j = 0; j < input.Length; j++)
{
input[j] = (short)(data[i * FrameSize * 2 + j * 2] + data[i * FrameSize * 2 + j * 2 + 1] * 0x100);
}
nbBytes = _encoder.Encode(input, 0, input.Length, buffer, 0, buffer.Length);
Array.Resize <byte>(ref output, output.Length + nbBytes + sizeof(int));
Array.Copy(buffer, 0, output, output.Length - nbBytes, nbBytes);
for (int j = 0; j < sizeof(int); j++)
{
output[output.Length - nbBytes - sizeof(int) + j] = (byte)(nbBytes % 0x100);
nbBytes /= 0x100;
}
}
return(output);
}
private static byte[] EncodeSpeech(byte[] buf, int len)
{
BandMode mode = GetBandMode(mic.SampleRate);
SpeexEncoder encoder = new SpeexEncoder(mode);
// set encoding quality to lowest (which will generate the smallest size in the fastest time)
encoder.Quality = 1;
int inDataSize = len / 2;
// convert to short array
short[] data = new short[inDataSize];
int sampleIndex = 0;
for (int index = 0; index < len; index += 2, sampleIndex++)
{
data[sampleIndex] = BitConverter.ToInt16(buf, index);
}
// note: the number of samples per frame must be a multiple of encoder.FrameSize
inDataSize = inDataSize - inDataSize % encoder.FrameSize;
var encodedData = new byte[len];
int encodedBytes = encoder.Encode(data, 0, inDataSize, encodedData, 0, len);
if (encodedBytes != 0)
{
// each chunk is laid out as follows:
// | 4-byte total chunk size | 4-byte encoded buffer size | <encoded-bytes> |
byte[] inDataSizeBuf = BitConverter.GetBytes(inDataSize);
byte[] sizeBuf = BitConverter.GetBytes(encodedBytes + inDataSizeBuf.Length);
byte[] returnBuf = new byte[encodedBytes + sizeBuf.Length + inDataSizeBuf.Length];
sizeBuf.CopyTo(returnBuf, 0);
inDataSizeBuf.CopyTo(returnBuf, sizeBuf.Length);
Array.Copy(encodedData, 0, returnBuf, sizeBuf.Length + inDataSizeBuf.Length, encodedBytes);
return returnBuf;
}
else
return buf;
}
public void FileInfoTest()
{
const string name = "male.wav";
const int HEAD_SIZE = 8;
const string CHUNK_DATA = "data";
FileInfo file = GetWavFile(name);
Console.WriteLine("file name:" + file.FullName);
FileStream fs = File.OpenRead(file.FullName);
byte[] tmp = new byte[2560];
fs.Read(tmp, 0, HEAD_SIZE + 4);
String ckID = LittleEndian.ReadString(tmp, 0, 4);
Console.WriteLine("ckID,0-3:" + ckID);
int cksize = LittleEndian.ReadInt(tmp, 4);
Console.WriteLine("cksize,4-7:" + cksize);
String WAVEID = LittleEndian.ReadString(tmp, 8, 4);
Console.WriteLine("WAVEID,8-11:" + WAVEID);
fs.Read(tmp, 0, HEAD_SIZE);
String chunk = LittleEndian.ReadString(tmp, 0, 4);
int size = LittleEndian.ReadInt(tmp, 4);
//
short format = 0;
short nChannels = 0;
int nSamplesPerSec = 0;
int nAvgBytesPerSec = 0;
short nBlockAlign = 0;
short wBitsPerSample = 0;
while (!chunk.Equals(CHUNK_DATA))
{
Console.WriteLine("chunk:" + chunk);
Console.WriteLine("size:" + size);
// read size bytes
fs.Read(tmp, 0, size);
format = LittleEndian.ReadShort(tmp, 0);
Console.WriteLine("format,0-1:" + format);
nChannels = LittleEndian.ReadShort(tmp, 2);
Console.WriteLine("nChannels,2-3:" + nChannels);
nSamplesPerSec = LittleEndian.ReadInt(tmp, 4);
Console.WriteLine("nSamplesPerSec,4-7:" + nSamplesPerSec);
nAvgBytesPerSec = LittleEndian.ReadInt(tmp, 8);
Console.WriteLine("nAvgBytesPerSec:" + nAvgBytesPerSec);
nBlockAlign = LittleEndian.ReadShort(tmp, 12);
Console.WriteLine("nBlockAlign:" + nBlockAlign);
wBitsPerSample = LittleEndian.ReadShort(tmp, 14);
Console.WriteLine("wBitsPerSample:" + wBitsPerSample);
fs.Read(tmp, 0, HEAD_SIZE);
chunk = LittleEndian.ReadString(tmp, 0, 4);
size = LittleEndian.ReadInt(tmp, 4);
Console.WriteLine("chunk:" + chunk);
Console.WriteLine("size:" + size);
}
BandMode mode;
if (nSamplesPerSec < 12000)
{
// Narrowband
mode = BandMode.Narrow;
}
else if (nSamplesPerSec < 24000)
{
// Wideband
mode = BandMode.Wide;
}
else
{
//Ultra-wideband
mode = BandMode.UltraWide;
}
SpeexEncoder speexEncoder = new SpeexEncoder(mode);
int quality = 2; // modify your self
int framesPerPackage = 4; // one frame one package
bool vbr = false;
// speexEncoder.getEncoder().setComplexity(5);
// speexEncoder.getEncoder().setBitRate();
// speexEncoder.getEncoder().setVbr();
// speexEncoder.getEncoder().setVbrQuality();
// speexEncoder.getEncoder().setVad();
// speexEncoder.getEncoder().setDtx();
OggSpeexWriter2 writer = new OggSpeexWriter2(mode, nSamplesPerSec, nChannels, framesPerPackage, vbr, nAvgBytesPerSec);
writer.Open("result.spx");
writer.WriteHeader("alking");
int pcmPacketSize = 2 * nChannels * speexEncoder.FrameSize;
int bytesCount = 0;
while (bytesCount < size)
{
int read = pcmPacketSize * framesPerPackage;
fs.Read(tmp, 0, read);
short[] data = new short[read / 2];
Buffer.BlockCopy(tmp, 0, data, 0, read);
int encSize = speexEncoder.Encode(data, 0, data.Length, tmp, 0, tmp.Length);
if (encSize > 0)
{
writer.WritePackage(tmp, 0, encSize);
}
bytesCount += read;
}
writer.Close();
fs.Close();
}
private byte[] EncodeSpeech(byte[] buf, int len)
{
SpeexEncoder encoder = new SpeexEncoder(BandMode.Wide);
//// convert to short array
//short[] data = new short[len / 2];
//int sampleIndex = 0;
//for (int index = 0; index < len; index += 2, sampleIndex++)
//{
// data[sampleIndex] = BitConverter.ToInt16(buf, index);
//}
//var encodedData = new byte[len];
//// note: the number of samples per frame must be a multiple of encoder.FrameSize
//int encodedBytes = encoder.Encode(data, 0, sampleIndex, encodedData, 0, len);
//if (encodedBytes != 0)
//{
// byte[] sizeBuf = BitConverter.GetBytes(encodedBytes);
// byte[] returnBuf = new byte[encodedBytes + sizeBuf.Length];
// sizeBuf.CopyTo(returnBuf, 0);
// Array.Copy(encodedData, 0, returnBuf, sizeBuf.Length, encodedBytes);
// return returnBuf;
//}
//else
// return buf;
int inDataSize = len / 2;
// convert to short array
short[] data = new short[inDataSize];
int sampleIndex = 0;
for (int index = 0; index < len; index += 2, sampleIndex++)
{
data[sampleIndex] = BitConverter.ToInt16(buf, index);
}
// note: the number of samples per frame must be a multiple of encoder.FrameSize
inDataSize = inDataSize - inDataSize % encoder.FrameSize;
var encodedData = new byte[len];
int encodedBytes = encoder.Encode(data, 0, inDataSize, encodedData, 0, len);
if (encodedBytes != 0)
{
// each chunk is laid out as follows:
// | 4-byte total chunk size | 4-byte encoded buffer size | <encoded-bytes> |
byte[] inDataSizeBuf = BitConverter.GetBytes(inDataSize);
byte[] sizeBuf = BitConverter.GetBytes(encodedBytes + inDataSizeBuf.Length);
byte[] returnBuf = new byte[encodedBytes + sizeBuf.Length + inDataSizeBuf.Length];
sizeBuf.CopyTo(returnBuf, 0);
inDataSizeBuf.CopyTo(returnBuf, sizeBuf.Length);
Array.Copy(encodedData, 0, returnBuf, sizeBuf.Length + inDataSizeBuf.Length, encodedBytes);
return returnBuf;
}
else
return buf;
}