/// <summary>
/// OnJitterBufferDataAvailable
/// </summary>
/// <param name="packet"></param>
private void OnJitterBufferDataAvailable(Object sender, WinSound.RTPPacket rtp)
{
try
{
if (Player != null)
{
//Nach Linear umwandeln
Byte[] linearBytes = WinSound.Utils.MuLawToLinear(rtp.Data, BitsPerSample, Channels);
//Wenn kein Mute
if (IsMuteAll == false && IsMute == false)
{
//Abspielen
Player.PlayData(linearBytes, false);
}
//Wenn Buffer nicht zu gross
Queue <List <Byte> > q = StreamClient.DictionaryMixed[sender];
if (q.Count < 10)
{
//Daten Zu Mixer hinzufügen
StreamClient.DictionaryMixed[sender].Enqueue(new List <Byte>(linearBytes));
}
}
}
catch (Exception ex)
{
Console.WriteLine(String.Format("FormMain.cs | OnJitterBufferDataAvailable() | {0}", ex.Message));
}
}
/// <summary>
/// OnDataAvailable
/// </summary>
/// <param name="packet"></param>
private void OnDataAvailable(Object sender, WinSound.RTPPacket rtp)
{
//Nach Linear umwandeln
Byte[] linearBytes = WinSound.Utils.MuLawToLinear(rtp.Data, Config.BitsPerSample, Config.Channels);
//Abspielen
m_Player.PlayData(linearBytes, false);
}
private void OnJitterBufferServerDataAvailable(Object sender, WinSound.RTPPacket rtp)
{
try
{
if (IsServerRunning)
{
if (m_IsFormMain)
{
//RTP Packet in Bytes umwandeln
Byte[] rtpBytes = rtp.ToBytes();
//Für alle Clients
List <NF.ServerThread> list = new List <NF.ServerThread>(m_Server.Clients);
foreach (NF.ServerThread client in list)
{
//Wenn nicht Mute
if (client.IsMute == false)
{
try
{
//Absenden
client.Send(m_PrototolClient.ToBytes(rtpBytes));
}
catch (Exception)
{
}
}
}
}
}
}
catch (Exception)
{
}
}
private void OnProtocolClient_DataComplete(Object sender, Byte[] data)
{
try
{
//Wenn der Player gestartet wurde
if (m_PlayerClient != null)
{
if (m_PlayerClient.Opened)
{
//RTP Header auslesen
WinSound.RTPPacket rtp = new WinSound.RTPPacket(data);
//Wenn Header korrekt
if (rtp.Data != null)
{
//In JitterBuffer hinzufügen
if (m_JitterBufferClientPlaying != null)
{
m_JitterBufferClientPlaying.AddData(rtp);
}
}
}
}
else
{
//Konfigurationsdaten erhalten
OnClientConfigReceived(sender, data);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private void OnJitterBufferClientDataAvailablePlaying(Object sender, WinSound.RTPPacket rtp)
{
try
{
if (m_PlayerClient != null)
{
if (m_PlayerClient.Opened)
{
if (m_IsFormMain)
{
//Wenn nicht stumm
if (m_Config.MuteClientPlaying == false)
{
//Nach Linear umwandeln
Byte[] linearBytes = WinSound.Utils.MuLawToLinear(rtp.Data, m_Config.BitsPerSampleClient, m_Config.ChannelsClient);
//Abspielen
m_PlayerClient.PlayData(linearBytes, false);
}
}
}
}
}
catch (Exception)
{
System.Diagnostics.StackFrame sf = new System.Diagnostics.StackFrame(true);
}
}
/// <summary>
/// ToRTPData
/// </summary>
/// <param name="linearData"></param>
/// <param name="bitsPerSample"></param>
/// <param name="channels"></param>
/// <returns></returns>
private Byte[] ToRTPData(Byte[] data, int bitsPerSample, int channels)
{
//Neues RTP Packet erstellen
WinSound.RTPPacket rtp = ToRTPPacket(data, bitsPerSample, channels);
//RTPHeader in Bytes erstellen
Byte[] rtpBytes = rtp.ToBytes();
//Fertig
return(rtpBytes);
}
/// <summary>
/// OnJitterBufferDataAvailable
/// </summary>
/// <param name="packet"></param>
private void OnJitterBufferDataAvailable(Object sender, WinSound.RTPPacket rtp)
{
if (Player != null)
{
//Nach Linear umwandeln
Byte[] linearBytes = WinSound.Utils.MuLawToLinear(rtp.Data, BitsPerSample, Channels);
//Abspielen
Player.PlayData(linearBytes, false);
}
}
/// <summary>
/// OnProtocolDataComplete
/// </summary>
/// <param name="sender"></param>
/// <param name="data"></param>
private void OnProtocolDataComplete(Object sender, Byte[] bytes)
{
//Wenn initialisiert
if (IsInitialized)
{
if (ServerThread != null && Player != null)
{
try
{
//Wenn der Player gestartet wurde
if (Player.Opened)
{
//RTP Header auslesen
WinSound.RTPPacket rtp = new WinSound.RTPPacket(bytes);
////Wenn Anzeige
//if (IsDrawCurve)
//{
// TimeMeasurement();
// m_BytesToDraw = rtp.Data;
//}
//Wenn Header korrekt
if (rtp.Data != null)
{
//Wenn JitterBuffer verwendet werden soll
if (JitterBuffer != null && JitterBuffer.Maximum >= 2)
{
JitterBuffer.AddData(rtp);
}
else
{
//Nach Linear umwandeln
Byte[] linearBytes = WinSound.Utils.MuLawToLinear(rtp.Data, this.BitsPerSample, this.Channels);
//Abspielen
Player.PlayData(linearBytes, false);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
IsInitialized = false;
}
}
}
}
private void OnDataReceivedFromSoundcard_Client(Byte[] data)
{
try
{
lock (this)
{
if (IsClientConnected)
{
//Wenn gewünscht
if (m_Config.ClientNoSpeakAll == false)
{
//Sounddaten in kleinere Einzelteile zerlegen
int bytesPerInterval = WinSound.Utils.GetBytesPerInterval((uint)m_Config.SamplesPerSecondClient, m_Config.BitsPerSampleClient, m_Config.ChannelsClient);
int count = data.Length / bytesPerInterval;
int currentPos = 0;
for (int i = 0; i < count; i++)
{
//Teilstück in RTP Packet umwandeln
Byte[] partBytes = new Byte[bytesPerInterval];
Array.Copy(data, currentPos, partBytes, 0, bytesPerInterval);
currentPos += bytesPerInterval;
WinSound.RTPPacket rtp = ToRTPPacket(partBytes, m_Config.BitsPerSampleClient, m_Config.ChannelsClient);
//Wenn JitterBuffer
if (UseJitterBufferClientRecording)
{
//In Buffer legen
m_JitterBufferClientRecording.AddData(rtp);
}
else
{
//Alles in RTP Packet umwandeln
Byte[] rtpBytes = ToRTPData(data, m_Config.BitsPerSampleClient, m_Config.ChannelsClient);
//Absenden
m_Client.Send(m_PrototolClient.ToBytes(rtpBytes));
}
}
}
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
/// <summary>
/// OnDataReceivedFromSoundcard
/// </summary>
/// <param name="linearData"></param>
private void OnDataReceivedFromSoundcard(Byte[] data)
{
try
{
lock (this)
{
if (IsServerRunning)
{
//Wenn Form noch aktiv
if (m_IsFormMain)
{
//Wenn JitterBuffer
if (m_Config.IsTimeSyncClient)
{
//Sounddaten in kleinere Einzelteile zerlegen
int bytesPerInterval = WinSound.Utils.GetBytesPerInterval((uint)m_Config.SamplesPerSecondClient, m_Config.BitsPerSampleClient, m_Config.ChannelsClient);
int count = data.Length / bytesPerInterval;
int currentPos = 0;
for (int i = 0; i < count; i++)
{
//Teilstück in RTP Packet umwandeln
Byte[] partBytes = new Byte[bytesPerInterval];
Array.Copy(data, currentPos, partBytes, 0, bytesPerInterval);
currentPos += bytesPerInterval;
WinSound.RTPPacket rtp = ToRTPPacket(partBytes, m_Config.BitsPerSampleClient, m_Config.ChannelsClient);
//In Buffer legen
m_JitterBuffer.AddData(rtp);
}
}
else
{
Byte[] rtp = ToRTPData(data, m_Config.BitsPerSampleClient, m_Config.ChannelsClient);
//Absenden
m_Server.Send(m_PrototolClient.ToBytes(rtp));
}
}
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
/// <summary>
/// OnTimerStream
/// </summary>
/// <param name="lpParameter"></param>
/// <param name="TimerOrWaitFired"></param>
private void OnTimerStream()
{
try
{
//Wenn noch aktiv
if (m_IsTimerStreamRunning)
{
if ((m_CurrentRTPBufferPos + m_RTPPartsLength) <= m_FilePayloadBuffer.Length)
{
//Bytes senden
Array.Copy(m_FilePayloadBuffer, m_CurrentRTPBufferPos, m_PartByte, 0, m_RTPPartsLength);
m_CurrentRTPBufferPos += m_RTPPartsLength;
WinSound.RTPPacket rtp = ToRTPPacket(m_PartByte, m_FileHeader.BitsPerSample, m_FileHeader.Channels);
_send(_room, rtp.ToBytes());
}
else
{
//Rest-Bytes senden
int rest = m_FilePayloadBuffer.Length - m_CurrentRTPBufferPos;
Byte[] restBytes = new Byte[m_PartByte.Length];
Array.Copy(m_FilePayloadBuffer, m_CurrentRTPBufferPos, restBytes, 0, rest);
WinSound.RTPPacket rtp = ToRTPPacket(restBytes, m_FileHeader.BitsPerSample, m_FileHeader.Channels);
_send(_room, rtp.ToBytes());
if (m_Loop == false)
{
//QueueTimer beenden
StopTimerStream();
}
else
{
//Von vorne beginnen
m_CurrentRTPBufferPos = 0;
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
StopTimerStream();
}
}
/// <summary>
/// OnDataReceived
/// </summary>
/// <param name="strMessage"></param>
public void OnDataReceived(List <Byte[]> audio)
{
audio.ForEach(bytes =>
{
try
{
//Wenn der Player gestartet wurde
if (m_Player.Opened)
{
//RTP Header auslesen
WinSound.RTPPacket rtp = new WinSound.RTPPacket(bytes);
//Wenn Anzeige
if (IsDrawCurve)
{
TimeMeasurement();
m_BytesToDraw = rtp.Data;
}
//Wenn Header korrekt
if (rtp.Data != null)
{
//Wenn JitterBuffer verwendet werden soll
if (UseJitterBuffer)
{
m_JitterBuffer.AddData(rtp);
}
else
{
//Nach Linear umwandeln
Byte[] linearBytes = WinSound.Utils.MuLawToLinear(rtp.Data, Config.BitsPerSample, Config.Channels);
//Abspielen
m_Player.PlayData(linearBytes, false);
}
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(String.Format("FormMain.cs | OnDataReceived() | {0}", ex.Message));
}
});
}
/// <summary>
/// ToRTPPacket
/// </summary>
/// <param name="linearData"></param>
/// <param name="bitsPerSample"></param>
/// <param name="channels"></param>
/// <returns></returns>
private WinSound.RTPPacket ToRTPPacket(Byte[] linearData, int bitsPerSample, int channels)
{
//Daten Nach MuLaw umwandeln
Byte[] mulaws = WinSound.Utils.LinearToMulaw(linearData, bitsPerSample, channels);
//Neues RTP Packet erstellen
WinSound.RTPPacket rtp = new WinSound.RTPPacket();
//Werte übernehmen
rtp.Data = mulaws;
rtp.SourceId = m_SourceId;
rtp.CSRCCount = m_CSRCCount;
rtp.Extension = m_Extension;
rtp.HeaderLength = WinSound.RTPPacket.MinHeaderLength;
rtp.Marker = m_Marker;
rtp.Padding = m_Padding;
rtp.PayloadType = m_PayloadType;
rtp.Version = m_Version;
//RTP Header aktualisieren
try
{
rtp.SequenceNumber = Convert.ToUInt16(m_SequenceNumber);
m_SequenceNumber++;
}
catch (Exception)
{
m_SequenceNumber = 0;
}
try
{
rtp.Timestamp = Convert.ToUInt32(m_TimeStamp);
m_TimeStamp += mulaws.Length;
}
catch (Exception)
{
m_TimeStamp = 0;
}
//Fertig
return(rtp);
}
/// <summary>
/// OnJitterBufferDataAvailable
/// </summary>
/// <param name="rtp"></param>
private void OnJitterBufferDataAvailable(Object sender, WinSound.RTPPacket rtp)
{
try
{
if (IsServerRunning)
{
if (m_IsFormMain)
{
//RTP Packet in Bytes umwandeln
Byte[] rtpBytes = rtp.ToBytes();
//Absenden
m_Server.Send(m_PrototolClient.ToBytes(rtpBytes));
}
}
}
catch (Exception ex)
{
ShowError(ex.Message);
}
}
/// <summary>
/// OnDataAvailable
/// </summary>
/// <param name="packet"></param>
private void OnDataAvailable(Object sender, WinSound.RTPPacket rtp)
{
try
{
if (_send != null)
{
if (m_IsFormMain)
{
//RTP Packet in Bytes umwandeln
Byte[] rtpBytes = rtp.ToBytes();
//Absenden
_send(_room, rtpBytes);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// OnDataReceivedFromSoundcard
/// </summary>
/// <param name="linearData"></param>
private void OnDataReceivedFromSoundcard(Byte[] data)
{
try
{
lock (this)
{
if (_send != null)
{
//Wenn JitterBuffer
if (Config.UseJitterBuffer)
{
//Sounddaten in kleinere Einzelteile zerlegen
int bytesPerInterval = WinSound.Utils.GetBytesPerInterval((uint)Config.SamplesPerSecond, Config.BitsPerSample, Config.Channels);
int count = data.Length / bytesPerInterval;
int currentPos = 0;
for (int i = 0; i < count; i++)
{
//Teilstück in RTP Packet umwandeln
Byte[] partBytes = new Byte[bytesPerInterval];
Array.Copy(data, currentPos, partBytes, 0, bytesPerInterval);
currentPos += bytesPerInterval;
WinSound.RTPPacket rtp = ToRTPPacket(partBytes, Config.BitsPerSample, Config.Channels);
//In Buffer legen
m_JitterBuffer.AddData(rtp);
}
}
else
{
//Alles in RTP Packet umwandeln
Byte[] rtp = ToRTPData(data, Config.BitsPerSample, Config.Channels);
//Absenden
_send(_room, rtp);
}
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
private void OnJitterBufferClientDataAvailableRecording(Object sender, WinSound.RTPPacket rtp)
{
try
{
//Prüfen
if (rtp != null && m_Client != null && rtp.Data != null && rtp.Data.Length > 0)
{
if (IsClientConnected)
{
if (m_IsFormMain)
{
//RTP Packet in Bytes umwandeln
Byte[] rtpBytes = rtp.ToBytes();
//Absenden
m_Client.Send(m_PrototolClient.ToBytes(rtpBytes));
}
}
}
}
catch (Exception)
{
System.Diagnostics.StackFrame sf = new System.Diagnostics.StackFrame(true);
}
}
private void StackRtp2Instance(RecordInfo_t recInfo, byte[] buffer)
{
var ingInstance = RecordIngList.FirstOrDefault(x => x.ext == recInfo.extension && x.peer == recInfo.peer_number);
if (ingInstance == null)
{
byte[] rtpbuff = new byte[recInfo.size];
Array.Copy(recInfo.voice, 0, rtpbuff, 0, recInfo.size);
WinSound.RTPPacket rtp = new WinSound.RTPPacket(rtpbuff);
WaveFormat wavformat;
switch (rtp.PayloadType)
{
case 0:
wavformat = WaveFormat.CreateMuLawFormat(8000, 1);
break;
case 8:
wavformat = WaveFormat.CreateALawFormat(8000, 1);
break;
case 4:
wavformat = WaveFormat.CreateCustomFormat(WaveFormatEncoding.G723, 8000, 1, 8000, 1, 8);
break;
case 18:
wavformat = WaveFormat.CreateCustomFormat(WaveFormatEncoding.G729, 8000, 1, 8000, 1, 8);
break;
default:
wavformat = WaveFormat.CreateALawFormat(8000, 1);
break;
}
DateTime now = DateTime.Now;
TimeSpan ts = now - new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Local);
string header = string.Format("{0:0000}{1:00}{2:00}{3:00}{4:00}{5:00}{6:000}", now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, now.Millisecond);
string datepath = string.Format("{0:0000}-{1:00}-{2:00}", now.Year, now.Month, now.Day);
string fileName = string.Format("{0}_{1}_{2}.wav", header, recInfo.extension, recInfo.peer_number);
string path = string.Format(@"{0}\{1}", Options.savedir, datepath);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
RtpRecordInfo RecInstance = new RtpRecordInfo(wavformat, path, fileName)
{
ext = recInfo.extension, peer = recInfo.peer_number, codec = wavformat, idx = ts.TotalMilliseconds, savepath = path, filename = fileName
};
RecInstance.EndOfRtpStreamEvent += RecInstance_EndOfRtpStreamEvent;
// util.WriteLogTest3(recInfo.isExtension.ToString() + " : >> RTPPacket Codec : " + rtp.PayloadType.ToString() + " // RecInfo Codec : " + recInfo.codec.ToString(), fileName + "_codec");
RecInstance.chkcount++;
RecInstance.firstIsExtension = recInfo.isExtension;
RecInstance.Add(recInfo);
lock (RecordIngList)
{
RecordIngList.Add(RecInstance);
}
}
else
{
//if (ingInstance.chkcount == 1 && ingInstance.firstIsExtension != recInfo.isExtension)
//{
// byte[] rtpbuff = new byte[recInfo.size];
// Array.Copy(recInfo.voice, 0, rtpbuff, 0, recInfo.size);
// WinSound.RTPPacket rtp = new WinSound.RTPPacket(rtpbuff);
// util.WriteLogTest3(recInfo.isExtension.ToString() + " : >> RTPPacket Codec : " + rtp.PayloadType.ToString() + " // Structure Codec : " + recInfo.codec.ToString(), ingInstance.filename + "_codec");
// ingInstance.chkcount++;
//}
ingInstance.Add(recInfo);
}
}
private void StackRtp2Instance(RecordInfo_t _recInfo)
{
var _ingInstance = RecordIngList.FirstOrDefault(x => x.ext == _recInfo.extension && x.peer == _recInfo.peer_number);
if (_ingInstance == null)
{
byte[] rtpbuff = new byte[_recInfo.size];
Array.Copy(_recInfo.voice, 0, rtpbuff, 0, _recInfo.size);
WinSound.RTPPacket rtp = new WinSound.RTPPacket(rtpbuff);
WaveFormat _wavformat;
switch (rtp.PayloadType)
{
case 0:
_wavformat = WaveFormat.CreateMuLawFormat(8000, 1);
break;
case 8:
_wavformat = WaveFormat.CreateALawFormat(8000, 1);
break;
case 4:
_wavformat = WaveFormat.CreateCustomFormat(WaveFormatEncoding.G723, 8000, 1, 8000 * 1, 1, 8);
break;
case 18:
_wavformat = WaveFormat.CreateCustomFormat(WaveFormatEncoding.G729, 8000, 1, 8000 * 1, 1, 8);
break;
default:
_wavformat = WaveFormat.CreateALawFormat(8000, 1);
break;
}
DateTime now = DateTime.Now;
TimeSpan ts = now - new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Local);
string _header = string.Format("{0:0000}{1:00}{2:00}{3:00}{4:00}{5:00}{6:000}", now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, now.Millisecond);
string _datepath = string.Format("{0:0000}-{1:00}-{2:00}", now.Year, now.Month, now.Day);
string _fileName = string.Format("{0}_{1}_{2}.wav", _header, _recInfo.extension, _recInfo.peer_number);
string _wavFileName = string.Format(@"{0}\{1}\{2}", _option.SaveDirectory, _datepath, _fileName);
string _path = string.Format(@"{0}\{1}", _option.SaveDirectory, _datepath);
if (!Directory.Exists(_path))
{
Directory.CreateDirectory(_path);
}
RtpRecordInfo RecInstance = new RtpRecordInfo(_wavformat, string.Format(@"{0}\{1}", _option.SaveDirectory, _datepath), _fileName)
{
ext = _recInfo.extension, peer = _recInfo.peer_number, codec = _wavformat, idx = ts.TotalMilliseconds, savepath = string.Format(@"{0}\{1}", _option.SaveDirectory, _datepath), filename = _fileName
};
RecInstance.EndOfRtpStreamEvent += RecInstance_EndOfRtpStreamEvent;
RecInstance.Add(_recInfo);
lock (RecordIngList)
{
RecordIngList.Add(RecInstance);
}
}
else
{
_ingInstance.Add(_recInfo);
}
}
/// <summary>
/// OnProtocolDataComplete
/// </summary>
/// <param name="sender"></param>
/// <param name="data"></param>
private void OnProtocolDataComplete(Object sender, Byte[] bytes)
{
//Wenn initialisiert
if (IsInitialized)
{
if (ServerThread != null && Player != null)
{
try
{
//Wenn der Player gestartet wurde
if (Player.Opened)
{
//RTP Header auslesen
WinSound.RTPPacket rtp = new WinSound.RTPPacket(bytes);
////Wenn Anzeige
//if (IsDrawCurve)
//{
// TimeMeasurement();
// m_BytesToDraw = rtp.Data;
//}
//Wenn Header korrekt
if (rtp.Data != null)
{
//Wenn JitterBuffer verwendet werden soll
if (JitterBuffer != null && JitterBuffer.Maximum >= 2)
{
JitterBuffer.AddData(rtp);
}
else
{
//Nach Linear umwandeln
Byte[] linearBytes = WinSound.Utils.MuLawToLinear(rtp.Data, this.BitsPerSample, this.Channels);
//Abspielen
Player.PlayData(linearBytes, false);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
IsInitialized = false;
}
}
}
}
private void StackRtp2Instance(RecordInfo_t recInfo, byte[] buffer)
{
var ingInstance = RecordIngList.FirstOrDefault(x => x.ext == recInfo.extension && x.peer == recInfo.peer_number);
if (ingInstance == null)
{
byte[] rtpbuff = new byte[recInfo.size];
Array.Copy(recInfo.voice, 0, rtpbuff, 0, recInfo.size);
WinSound.RTPPacket rtp = new WinSound.RTPPacket(rtpbuff);
WaveFormat wavformat;
switch (rtp.PayloadType)
{
case 0:
wavformat = WaveFormat.CreateMuLawFormat(8000, 1);
break;
case 8:
wavformat = WaveFormat.CreateALawFormat(8000, 1);
break;
case 4:
wavformat = WaveFormat.CreateCustomFormat(WaveFormatEncoding.G723, 8000, 1, 8000, 1, 8);
break;
case 18:
wavformat = WaveFormat.CreateCustomFormat(WaveFormatEncoding.G729, 8000, 1, 8000, 1, 8);
break;
default:
wavformat = WaveFormat.CreateALawFormat(8000, 1);
break;
}
DateTime now = DateTime.Now;
TimeSpan ts = now - new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Local);
string header = string.Format("{0:0000}{1:00}{2:00}{3:00}{4:00}{5:00}{6:000}", now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, now.Millisecond);
string datepath = string.Format("{0:0000}-{1:00}-{2:00}", now.Year, now.Month, now.Day);
string fileName = string.Format("{0}_{1}_{2}.wav", header, recInfo.extension, recInfo.peer_number);
string path = string.Format(@"{0}\{1}", Options.savedir, datepath);
if (!Directory.Exists(path)) Directory.CreateDirectory(path);
RtpRecordInfo RecInstance = new RtpRecordInfo(wavformat, path, fileName) { ext = recInfo.extension, peer = recInfo.peer_number, codec = wavformat, idx = ts.TotalMilliseconds, savepath = path, filename = fileName };
RecInstance.EndOfRtpStreamEvent += RecInstance_EndOfRtpStreamEvent;
// util.WriteLogTest3(recInfo.isExtension.ToString() + " : >> RTPPacket Codec : " + rtp.PayloadType.ToString() + " // RecInfo Codec : " + recInfo.codec.ToString(), fileName + "_codec");
RecInstance.chkcount++;
RecInstance.firstIsExtension = recInfo.isExtension;
RecInstance.Add(recInfo);
lock (RecordIngList)
{
RecordIngList.Add(RecInstance);
}
}
else
{
//if (ingInstance.chkcount == 1 && ingInstance.firstIsExtension != recInfo.isExtension)
//{
// byte[] rtpbuff = new byte[recInfo.size];
// Array.Copy(recInfo.voice, 0, rtpbuff, 0, recInfo.size);
// WinSound.RTPPacket rtp = new WinSound.RTPPacket(rtpbuff);
// util.WriteLogTest3(recInfo.isExtension.ToString() + " : >> RTPPacket Codec : " + rtp.PayloadType.ToString() + " // Structure Codec : " + recInfo.codec.ToString(), ingInstance.filename + "_codec");
// ingInstance.chkcount++;
//}
ingInstance.Add(recInfo);
}
}
private void StackRtp2Instance(RecordInfo_t _recInfo)
{
var _ingInstance = RecordIngList.FirstOrDefault(x => x.ext == _recInfo.extension && x.peer == _recInfo.peer_number);
if (_ingInstance == null)
{
byte[] rtpbuff = new byte[_recInfo.size];
Array.Copy(_recInfo.voice, 0, rtpbuff, 0, _recInfo.size);
WinSound.RTPPacket rtp = new WinSound.RTPPacket(rtpbuff);
WaveFormat _wavformat;
switch (rtp.PayloadType)
{
case 0:
_wavformat = WaveFormat.CreateMuLawFormat(8000, 1);
break;
case 8:
_wavformat = WaveFormat.CreateALawFormat(8000, 1);
break;
case 4:
_wavformat = WaveFormat.CreateCustomFormat(WaveFormatEncoding.G723, 8000, 1, 8000 * 1, 1, 8);
break;
case 18:
_wavformat = WaveFormat.CreateCustomFormat(WaveFormatEncoding.G729, 8000, 1, 8000 * 1, 1, 8);
break;
default:
_wavformat = WaveFormat.CreateALawFormat(8000, 1);
break;
}
DateTime now = DateTime.Now;
TimeSpan ts = now - new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Local);
string _header = string.Format("{0:0000}{1:00}{2:00}{3:00}{4:00}{5:00}{6:000}", now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, now.Millisecond);
string _datepath = string.Format("{0:0000}-{1:00}-{2:00}", now.Year, now.Month, now.Day);
string _fileName = string.Format("{0}_{1}_{2}.wav", _header, _recInfo.extension, _recInfo.peer_number);
string _wavFileName = string.Format(@"{0}\{1}\{2}", _option.SaveDirectory, _datepath, _fileName);
string _path = string.Format(@"{0}\{1}", _option.SaveDirectory, _datepath);
if (!Directory.Exists(_path))
Directory.CreateDirectory(_path);
RtpRecordInfo RecInstance = new RtpRecordInfo(_wavformat, string.Format(@"{0}\{1}", _option.SaveDirectory, _datepath), _fileName) { ext = _recInfo.extension, peer = _recInfo.peer_number, codec = _wavformat, idx = ts.TotalMilliseconds, savepath = string.Format(@"{0}\{1}", _option.SaveDirectory, _datepath), filename = _fileName };
RecInstance.EndOfRtpStreamEvent += RecInstance_EndOfRtpStreamEvent;
RecInstance.Add(_recInfo);
lock (RecordIngList)
{
RecordIngList.Add(RecInstance);
}
}
else
{
_ingInstance.Add(_recInfo);
}
}
/// <summary>
/// ToRTPPacket
/// </summary>
/// <param name="linearData"></param>
/// <param name="bitsPerSample"></param>
/// <param name="channels"></param>
/// <returns></returns>
private WinSound.RTPPacket ToRTPPacket(Byte[] linearData, int bitsPerSample, int channels)
{
//Daten Nach MuLaw umwandeln
Byte[] mulaws = WinSound.Utils.LinearToMulaw(linearData, bitsPerSample, channels);
//Neues RTP Packet erstellen
WinSound.RTPPacket rtp = new WinSound.RTPPacket();
//Werte übernehmen
rtp.Data = mulaws;
rtp.CSRCCount = m_CSRCCount;
rtp.Extension = m_Extension;
rtp.HeaderLength = WinSound.RTPPacket.MinHeaderLength;
rtp.Marker = m_Marker;
rtp.Padding = m_Padding;
rtp.PayloadType = m_PayloadType;
rtp.Version = m_Version;
rtp.SourceId = m_SourceId;
//RTP Header aktualisieren
try
{
rtp.SequenceNumber = Convert.ToUInt16(m_SequenceNumber);
m_SequenceNumber++;
}
catch (Exception)
{
m_SequenceNumber = 0;
}
try
{
rtp.Timestamp = Convert.ToUInt32(m_TimeStamp);
m_TimeStamp += mulaws.Length;
}
catch (Exception)
{
m_TimeStamp = 0;
}
//Fertig
return rtp;
}
