Process.Start("control.exe", "mmsys.cpl,,1")WaveFileWriter writer;
this.writer = new WaveFileWriter(this.outputFilePath, this.waveIn.WaveFormat);
this.bufferedWaveProvider = new BufferedWaveProvider(this.waveIn.WaveFormat);
// should be enough to buffer 1 minute in front
this.bufferedWaveProvider.BufferDuration = new TimeSpan(0, 1, 0);
this.bufferedWaveProvider.DiscardOnBufferOverflow = true;
this.waveIn.ShareMode = WaveInShareMode;
this.waveIn.StartRecording();private void OnDataAvailable(object sender, WaveInEventArgs e)
{
try
{
if (saveToFile)
{
this.writer.Write(e.Buffer, 0, e.BytesRecorded);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex.InnerException);
}
}socket.sendTo(byte[] buffer, EndPoint remoteEP); {
#region fields
public TCallStatus currentCallStatus = TCallStatus.clsUnknown;
public delegate void OnStatusChanged(object sender, TCallStatus oldStatus, TCallStatus newStatus);
public event OnStatusChanged OnCallStatusChanged;
public NAudio.Wave.WasapiLoopbackCapture capture;
#endregion
private const int micInPort = 667;
private const int micOutPort = 668;
private const int Protocol = 8;
private Skype skype;
private Call currentCall;
NAudio.CoreAudioApi.MMDevice device;
private NetworkStream outputDeviceStream;
TcpServer outputDeviceServer;
#region Public Methods
public void loopSystemAudio()
{
outputDeviceServer = new TcpServer(micOutPort);
outputDeviceServer.Connect += outputDeviceServer_Connect;
outputDeviceServer.Disconnect += outputDeviceServer_Disconnect;
outputDeviceServer.DataReceived += outputDeviceServer_DataReceived;
capture.StartRecording();
currentCall.InputDevice[TCallIoDeviceType.callIoDeviceTypePort] = micOutPort.ToString();
currentCall.set_InputDevice(TCallIoDeviceType.callIoDeviceTypePort, micOutPort.ToString());
}
public void loopSkypeAudio(bool includeUserMic)
{
}
#endregion
#region Constructors
public Interceptor()
{
skype = new Skype();
skype.Attach(Protocol, false);
_ISkypeEvents_Event events = (_ISkypeEvents_Event)skype;
events.AttachmentStatus += events_AttachmentStatus;
skype.CallStatus += skype_CallStatus;
device = NAudio.Wave.WasapiLoopbackCapture.GetDefaultLoopbackCaptureDevice();
capture = new WasapiLoopbackCapture(device);
capture.ShareMode = NAudio.CoreAudioApi.AudioClientShareMode.Shared;
capture.DataAvailable += capture_DataAvailable;
capture.RecordingStopped += capture_RecordingStopped;
}
#endregion
#region Private Methods
void capture_RecordingStopped(object sender, StoppedEventArgs e)
{
Debug.WriteLine("Recording Stopped");
}
void capture_DataAvailable(object sender, WaveInEventArgs e)
{
outputDeviceStream.Write(e.Buffer, 0, e.BytesRecorded);
}
void outputDeviceServer_DataReceived(object sender, DataReceivedEventArgs e)
{
Debug.WriteLine(e.Buffer.Length.ToString());
}
void outputDeviceServer_Disconnect(object sender, EventArgs e)
{
Debug.WriteLine("OutputDeviceServer Disconnected");
}
void outputDeviceServer_Connect(object sender, ConnectedEventArgs e)
{
Debug.WriteLine("OutputDeviceServer Connected");
outputDeviceStream = e.Stream;
}
void skype_CallStatus(Call pCall, TCallStatus Status)
{
currentCall = pCall;
}
void events_AttachmentStatus(TAttachmentStatus Status)
{
//throw new NotImplementedException();
}
#endregion
}
class SkypeBufferStream : WaveStream
{
byte[] latestInBuffer;
WaveFormat waveFormat;
public SkypeBufferStream(int sampleRate)
{
waveFormat = new WaveFormat(sampleRate, 16, 2);
}
public override WaveFormat WaveFormat
{
get { return waveFormat; }
}
public override long Length
{
get { return 0; }
}
public override long Position
{
get
{
return 0;
}
set
{
throw new NotImplementedException();
}
}
public void SetLatestInBuffer(byte[] buffer)
{
latestInBuffer = buffer;
}
public override int Read(byte[] buffer, int offset, int count)
{
if (offset != 0)
throw new ArgumentOutOfRangeException("offset");
if (buffer != latestInBuffer)
Array.Copy(latestInBuffer, buffer, count);
return count;
}
}
class TcpServer : IDisposable
{
TcpListener listener;
public event EventHandler<ConnectedEventArgs> Connect;
public event EventHandler Disconnect;
public event EventHandler<DataReceivedEventArgs> DataReceived;
public TcpServer(int port)
{
listener = new TcpListener(IPAddress.Loopback, port);
listener.Start();
ThreadPool.QueueUserWorkItem(Listen);
}
private void Listen(object state)
{
while (true)
{
using (TcpClient client = listener.AcceptTcpClient())
{
AcceptClient(client);
}
}
}
private void AcceptClient(TcpClient client)
{
using (NetworkStream inStream = client.GetStream())
{
OnConnect(inStream);
while (client.Connected)
{
int available = client.Available;
if (available > 0)
{
byte[] buffer = new byte[available];
int read = inStream.Read(buffer, 0, available);
Debug.Assert(read == available);
OnDataReceived(buffer);
}
else
{
Thread.Sleep(50);
}
}
}
OnDisconnect();
}
private void OnConnect(NetworkStream stream)
{
var connect = Connect;
if (connect != null)
{
connect(this, new ConnectedEventArgs() { Stream = stream });
}
}
private void OnDisconnect()
{
var disconnect = Disconnect;
if (disconnect != null)
{
disconnect(this, EventArgs.Empty);
}
}
private void OnDataReceived(byte[] buffer)
{
var execute = DataReceived;
if (execute != null)
{
execute(this, new DataReceivedEventArgs() { Buffer = buffer });
}
}
#region IDisposable Members
public void Dispose()
{
listener.Stop();
}
#endregion
}
public class DataReceivedEventArgs : EventArgs
{
public byte[] Buffer { get; set; }
}
public class ConnectedEventArgs : EventArgs
{
public NetworkStream Stream { get; set; }
}
using (var reader = new WaveFileReader(input))
{
var sp = reader.ToSampleProvider();
var wp24 = new SampleToWaveProvider24(sp);
WaveFileWriter.CreateWaveFile(output, wp24);
}