Is there any way?

Please reply.

Thank you.

The code works for me! Thx! (windows 7 x64)
But i have a problem:
I’m capturing a webcam at the same time and the sound is laging about 0.4-0.7 seconds.
Can anyone help to “make the sound faster”?
Any solutions?

Thx

I’ve just tested it again after some sleep and it’s still glitching – can anyone suggest why? Maybe I’ll try writing code from scratch and see if that helps…

using Microsoft.DirectX.DirectSound;

using System.Threading;

namespace Echo
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void StartButton_Click(object sender, EventArgs e)
{
if (!StartEcho(“Input”, this)) // change “Input” to something suitable
MessageBox.Show(“No matching Sound Card was found”);
// These parameters are guessed at – owner WAS Native.GetDesktopWindow()
}

private void StopButton_Click(object sender, EventArgs e)
{
IsReady = false;
}

private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
IsReady = false; // ensures the playback thread shuts down
}

// botch – not sure if these and IsReady are thread safe for multiple threads
public int _dwCaptureBufferSize, _dwOutputBufferSize, _dwNotifySize;
public CaptureBuffer _dwCapBuffer;
public SecondaryBuffer[] _dwDevBuffers;
public Thread _dwCaptureThread;

public bool IsReady = false;
// IsReady should be true while you wish to capture and then output the sound.

private bool StartEcho(string captureDescriptor, Control owner)
{
// string captureDescriptor – string for eg “Mic”, “Input”
// Control owner – maybe Window or Form would do for this – was Native.GetDesktopWindow()
// if windowless application use desktop window as message broker
// Returns true for setup done and thread started, false for problem

// Choose a Wave format, calculating BlockAlign and AverageBytesPerSecond

var format = new WaveFormat
{
SamplesPerSecond = 96000,
BitsPerSample = 16,
Channels = 2,
FormatTag = WaveFormatTag.Pcm
};

// Both of these are calculate for All channels
// BlockAlign = BytesPerSampleAllChannels, AverageBytesPerSecond = BytesPerSecondAllChannels
format.BlockAlign = (short)(format.Channels * (format.BitsPerSample / 8));
format.AverageBytesPerSecond = format.SamplesPerSecond * format.BlockAlign;

// Set the size of input and output buffers

// Multiplier of both delay and minimum buffer size in units of 1/16th secs,
int NUM_BUFFERS = 8;

// Sets _dwNotifySize to enough bytes for 1/16th of a second, all channels
// Note that this was 1/8th (ie line ended ‘/ 8);’), and output buffer size = capture size/2
// But this was changed to allow output buffer size to be a multiple of BlockAlign
_dwNotifySize = Math.Max(4096, format.AverageBytesPerSecond / (8*2));
// rounds _dwNotifySize to a multiple of BlockAlign (BytesPerSampleAllChannel)
_dwNotifySize -= _dwNotifySize % format.BlockAlign;

// Capture buffer is looped – when the end is reached, it starts from the beginning again.
// Capturing one should be twice as large as output – so that when completed capture
// is being read to output buffer there is still room to for the buffer to keep filling
// without overwriting the output. I think.
_dwCaptureBufferSize = NUM_BUFFERS * _dwNotifySize * 2;
_dwOutputBufferSize = NUM_BUFFERS * _dwNotifySize;

// Create CaptureBufferDescriptor and actual capturing buffer
// Enumerate all devices, choosing one containing the given string (captureDescriptor)
var cap = default(Capture);
var cdc = new CaptureDevicesCollection();
for (int i = 0; i < cdc.Count; i++)
{
if (cdc[i].Description.ToLower().Contains(captureDescriptor.ToLower()))
{
cap = new Capture(cdc[i].DriverGuid);
break;
}
}

// Check a matching capture device was found
if (cap == null)
return false; // no matching sound card/capture device
{

// Make the description and create a CaptureBuffer accordingly
var capDesc = new CaptureBufferDescription
{
Format = format,
BufferBytes = _dwCaptureBufferSize
};

_dwCapBuffer = new CaptureBuffer(capDesc, cap);

// Create output device and buffers

// Uses default speakers to output – choose output device in same way as for capturing.
var dev = new Device();
// As DirectSound uses any window for a message pump we have to SetCooperativeLevel()
dev.SetCooperativeLevel(owner, CooperativeLevel.Priority);

// Set GlobalFocus=True if you want echo even if desktop window is not focused.
var devDesc = new BufferDescription
{
BufferBytes = _dwOutputBufferSize,
Format = format,
DeferLocation = true,
GlobalFocus = true
};
// Create two output buffers – this seems to avoid the buffer being locked and written
// to while it's still playing, helping to avoid a sound glitch on my machine.
_dwDevBuffers = new SecondaryBuffer[2];
_dwDevBuffers[0] = new SecondaryBuffer(devDesc, dev);
_dwDevBuffers[1] = new SecondaryBuffer(devDesc, dev);

// Set autoResetEvent to be fired when it's filled and subscribe to buffer notifications

var _resetEvent = new AutoResetEvent(false);
var _notify = new Notify(_dwCapBuffer);
// Half&half – one notification halfway through the output buffer, one at the end
var bpn1 = new BufferPositionNotify();
bpn1.Offset = _dwCapBuffer.Caps.BufferBytes / 2 – 1;
bpn1.EventNotifyHandle = _resetEvent.SafeWaitHandle.DangerousGetHandle();
var bpn2 = new BufferPositionNotify();
bpn2.Offset = _dwCapBuffer.Caps.BufferBytes – 1;
bpn2.EventNotifyHandle = _resetEvent.SafeWaitHandle.DangerousGetHandle();

_notify.SetNotificationPositions(new BufferPositionNotify[] { bpn1, bpn2 });

IsReady = true; // ready to capture sound

// Fire worker thread to take care of messages
// Note that on a uniprocessor, the new thread may not get any processor time
// until the main thread is preempted or yields, eg by ending button click event or
// calling Thread.Sleep(0)

// botch – not sure if these are thread safe for multiple threads
int offset = 0;
int devbuffer = 0;

// Make a new thread – as countained in the { }
_dwCaptureThread = new Thread((ThreadStart)delegate
// *********************************************************************
{
_dwCapBuffer.Start(true); // start capture

// IsReady – This should be true while you wish to capture and then output the sound.
while (IsReady)
{
_resetEvent.WaitOne(); // blocks thread until _dwCapBuffer is half/totally full
// Read the capture buffer into an array, and output it to the next DevBuffer
var read = _dwCapBuffer.Read(offset, typeof(byte), LockFlag.None, _dwOutputBufferSize);
_dwDevBuffers[devbuffer].Write(0, read, LockFlag.EntireBuffer);

// Update offset
offset = (offset + _dwOutputBufferSize) % _dwCaptureBufferSize;

// Play the sound
_dwDevBuffers[devbuffer].SetCurrentPosition(0);
_dwDevBuffers[devbuffer].Play(0, BufferPlayFlags.Default);
devbuffer = 1 – devbuffer; // toggle between 0 and 1
}
_dwCapBuffer.Stop(); // stop capture
// *********************************************************************
});

_dwCaptureThread.Start(); // start the new Thread

return true;
}
}

}
}

The last post above is the final version of the three.

And now for the source code…

Here is an annotated, working version of this code. It’s the first time I’ve done DirectSound, I don’t understand it yet, and I’m not finished tidying this up yet, but I wanted to quickly post it to help Vincent. Anyway, enough excuses!

I created a C# Windows Forms project in Visual C# 2008. I added references to Microsoft.DirectX and Microsoft.DirectX.DirectSound. I added start and stop buttons called StartButton and StopButton with click events

private void StartButton_Click(object sender, EventArgs e)
private void StopButton_Click(object sender, EventArgs e)

You may need to change the string in StartEcho(“Input”, this) – look in your Control Panel>Sounds and Audio Devices, under Audio>Sound recording>Default device and choose part or all of that name.

I’ve made some changes to the code either for comprehension or to get it to work. With the updated code I _was_ getting a sound glitch about twice every time the output buffer filled – ie often. I think the buffer was being overwritten or locked while it was still playing, so I created two output buffers and it seems to work OK now, still the very occasional glitch but it might be my computer (no sound card!) – please post with comments on this when you try it.

I’m rusty on thread safe variables, and I’ve not had time to do the research. As a result there are some variables that I’m not sure if they are safe or not; I’ve marked them. I think maybe they should be static volatile but it seems to work as is… If anyone can tell me what’s right I’d appreciate it.

If I continue to improve it (rather than getting on with writing my own code) then I may post back, and I hope others will do the same…

I hope this is helpful to someone, and I thank the original author, but suggest better, more complete and clearer code examples in the future.

Here is an annotated, working version of this code. I’m not finished tidying this up yet but wanted to quickly post it to help Vincent.

I created a C# Windows Forms project in Visual C# 2008. I added references to Microsoft.DirectX and Microsoft.DirectX.DirectSound. I added start and stop buttons called StartButton and StopButton with click events

private void StartButton_Click(object sender, EventArgs e)
private void StopButton_Click(object sender, EventArgs e)

You may need to change the string in StartEcho(“Input”, this) – look in your Control Panel>Sounds and Audio Devices, under Audio>Sound recording>Default device and choose part or all of that name.

I’ve made some changes to the code either for comprehension or to get it to work. With the updated code I _was_ getting a sound glitch about twice every time the output buffer filled – ie often. I think the buffer was being overwritten or locked while it was still playing, so I created two output buffers and it seems to work OK now, still the very occasional glitch but it might be my computer (no sound card!) – please post with comments on this when you try it.

I’m rusty on thread safe variables, and I’ve not had time to do the research. As a result there are some variables that I’m not sure if they are safe or not; I’ve marked them. I think maybe they should be static volatile but it seems to work as is… If anyone can tell me what’s right I’d appreciate it.

If I continue to improve it (rather than getting on with writing my own code) then I may post back, and I hope others will do the same…

I hope this is helpful to someone, and I thank the original author, but suggest better, more complete and clearer code examples in the future.

Here is an annotated, working version of this code. I’m not finished tidying this up yet but wanted to quickly post it to help Vincent.

I created a C# Windows Forms project in Visual C# 2008. I added references to Microsoft.DirectX and Microsoft.DirectX.DirectSound. I added start and stop buttons called StartButton and StopButton with click events

private void StartButton_Click(object sender, EventArgs e)
private void StopButton_Click(object sender, EventArgs e)

You may need to change the string in StartEcho(“Input”, this) – look in your Control Panel>Sounds and Audio Devices, under Audio>Sound recording>Default device and choose part or all of that name.

I’ve made some changes to the code either for comprehension or to get it to work. With the updated code I _was_ getting a sound glitch about twice every time the output buffer filled – ie often. I think the buffer was being overwritten or locked while it was still playing, so I created two output buffers and it seems to work OK now, still the very occasional glitch but it might be my computer (no sound card!) – please post with comments on this when you try it.

I’m rusty on thread safe variables, and I’ve not had time to do the research. As a result there are some variables that I’m not sure if they are safe or not; I’ve marked them. I think maybe they should be static volatile but it seems to work as is… If anyone can tell me what’s right I’d appreciate it.

If I continue to improve it (rather than getting on with writing my own code) then I may post back, and I hope others will do the same…

I hope this is helpful to someone, and I thank the original poster, but suggest better, more complete and clearer code examples in the future.