Эх товарищи... 
Нашел один пример гитарного тюнера и разобрал его. Но только потом заметил, что результат выполнения программы не всегда точный... 
Здесь http://narod.ru/disk/16731477000/FftGuitarTuner_src.rar.html пример и мой http://narod.ru/disk/16731624000/singer.rar.html.
И вообщем, вот разобранный (и упрощенный) код:
Начало программы (обязательно добовляемые библиотеки: DirectSound, SafeHandles и Threading)
| Код |
using Microsoft.DirectX.DirectSound;
using Microsoft.Win32.SafeHandles;
using System.Threading;
namespace singer
{
public partial class Form1 : Form
{
private CaptureBuffer buffer = null;
private Capture capture = null;
private WaveFormat format;
public DeviceInformation devInfo;
private CaptureBufferDescription description;
private BufferPositionNotify position;
private BufferPositionNotify[] positions;
private AutoResetEvent positionEvent;
private SafeWaitHandle positionEventHandle;
private Notify notify;
private ManualResetEvent terminated;
private Thread thread;
private WaitHandle[] handles;
private int bufferSeconds = 3;
private int notifyPointsInSecond = 10;
private int waitHandleCount;
private int bufferLenght;
public Form1()
{
InitializeComponent();
CheckForIllegalCrossThreadCalls = false; // Чтобы компилятор не ругался на доступ к элементам формы, из потока, в котором они не были созданны
}
|
Нажимаем на кнопочку и тем самым создаем новую форму с выбором устройства:
| Код |
private void Device_btn_Click(object sender, EventArgs e)
{
SelectDevice sf = new SelectDevice(this); // создаем форму и передаем ей идентификатор родителя
if (sf.ShowDialog() == DialogResult.OK)
{
GetData();
}
}
|
Код формы, где мы выбираем устройство захвата:
| Код |
using Microsoft.DirectX.DirectSound;
namespace singer
{
public partial class SelectDevice : Form
{
private CaptureDevicesCollection collection; // объявляем коллекцию устройств
Form1 f; // объявляем форму (такую же, как и родитель)
public SelectDevice(Form1 f) // конструктор
{
InitializeComponent();
this.f = f; // теперь наша форма - это форма родитель (этому я у мужиков из DirectX'а научился...)
}
private void SelectDevice_Load(object sender, EventArgs e)
{
collection = new CaptureDevicesCollection(); // заполняем коллекцию
foreach (DeviceInformation d in collection) // заполняем элемент формы listBox1 описаниями полученных устройств
{
listBox1.Items.Add(d.Description);
}
listBox1.SelectedIndex = 0; // сразу же выделяем первый элемент, чтобы пользователь, инстинктивно кликнувший на ОК не получил ошибки
}
private void button2_Click(object sender, EventArgs e) // Нажимаем на ОК
{
f.devInfo = collection[listBox1.SelectedIndex]; // получаем то, за чем мы сюда приходили....
}
}
}
|
Создаём буффер захвата и поток, который сразу же и запускаем:
| Код |
private void GetData()
{
format = new WaveFormat();
format.Channels = 1;
format.BitsPerSample = 16;
format.SamplesPerSecond = 44100;
format.FormatTag = WaveFormatTag.Pcm;
format.BlockAlign = (short)(format.Channels * (format.BitsPerSample / 8));
format.AverageBytesPerSecond = format.BlockAlign * format.SamplesPerSecond;
bufferLenght = format.AverageBytesPerSecond * bufferSeconds;
description = new CaptureBufferDescription();
description.Format = format;
description.BufferBytes = bufferLenght;
capture = new Capture(devInfo.DriverGuid);
buffer = new CaptureBuffer(description, capture);
positionEvent = new AutoResetEvent(false);
positionEventHandle = positionEvent.SafeWaitHandle;
terminated = new ManualResetEvent(true);
waitHandleCount = bufferSeconds * notifyPointsInSecond;
positions = new BufferPositionNotify[waitHandleCount];
for (int i = 0; i < waitHandleCount; i++)
{
position = new BufferPositionNotify();
position.Offset = (i+1) * bufferLenght / positions.Length - 1; // (x-1)
position.EventNotifyHandle = positionEventHandle.DangerousGetHandle();
positions[i] = position;
}
notify = new Notify(buffer);
notify.SetNotificationPositions(positions);
terminated.Reset();
thread = new Thread(new ThreadStart(ThreadLoop));
thread.Name = "Sound Capture";
thread.Start();
}
|
Постоянно получаем данные и отправляем их на обработку
| Код |
private void ThreadLoop()
{
buffer.Start(true); // Запускаем зверь-машину с параметром true (то есть он будет работать циклически)
try
{
int nextCapturePosition = 0;
handles = new WaitHandle[] {terminated, positionEvent};
while(WaitHandle.WaitAny(handles) > 0)
{
int capturePosition, readPosition;
buffer.GetCurrentPosition(out capturePosition, out readPosition);
int lockSize = readPosition - nextCapturePosition;
if (lockSize < 0)
{
lockSize += bufferLenght;
}
if ((lockSize & 1) != 0)
{
lockSize--;
}
int itemsCount = lockSize >> 1;
short[] data = (short[])buffer.Read(nextCapturePosition,typeof(short),LockFlag.None, itemsCount); // Считываем ценные данные в наш массив
ProcessData(data); // и посылаем его на обработку
nextCapturePosition = (nextCapturePosition + lockSize) % bufferLenght;
}
}
finally
{
buffer.Stop();
}
}
|
Копируем short массив в double, получаем из него спектрограмму, а из нее частоту...
| Код |
int maxFrequency = 1300;
int minFrequency = 60;
int sampleRate = 44100;
private void ProcessData(short[] data)
{
double[] x = new double[data.Length];
for (int i = 0; i < x.Length; i++) // копирование
{
x[i] = data[i];
}
double[] spectrogramm = Calculate(x); // получаем спектрограмму
int index = 0;
double max = spectrogramm[0];
int usefullMaxSpectr = Math.Min(spectrogramm.Length, (int)(maxFrequency * spectrogramm.Length/ sampleRate) + 1); // не знаю за чем автор это сделал, взял бы просто длинну...
for (int i = 1; i < usefullMaxSpectr; i++ )
{
if (max < spectrogramm[i])
{
max = spectrogramm[i];
index = i;
}
}
double frequency = (double)sampleRate * index / spectrogramm.Length; // высчитываем частоту
if (frequency < minFrequency) frequency = 0;
richTextBox1.Text = frequency.ToString(); // собственно, наглядное отображение искомого
}
|
Черная магия 
| Код |
private double[] Calculate(double[] x)
{
int lenght;
int bitsInLenght;
if (IsPowerOfTwo(x.Length)) // не понимаю что это (проверка на стерео сигнал что ли?)
{
lenght = x.Length;
bitsInLenght = Log2(lenght) - 1; // и что мы тут делаем?
}
else
{
bitsInLenght = Log2(x.Length); // ничего не понимаю...
lenght = 1 << bitsInLenght;
}
ComplexNumber[] data = new ComplexNumber[lenght];
for (int i = 0; i < x.Length; i++ )
{
int j = ReverseBits( i, bitsInLenght); // зачем реверс?
data[j] = new ComplexNumber(x[i]);
}
// Cooley-Turkey
for (int i = 0; i < bitsInLenght; i++ ) // самое сердце программы, и тут я вообще ничего не понимаю...
{
int m = 1 << i;
int n = m * 2;
double alpha = -(2 * Math.PI / n);
for (int k = 0; k < m; k++)
{
ComplexNumber oddPartMultiplier = new ComplexNumber(0, alpha * k).PoweredE();
for (int j = k; j < lenght; j += n )
{
ComplexNumber evenPart = data[j];
ComplexNumber oddPart = oddPartMultiplier * data[j + m];
data[j] = evenPart + oddPart;
data[j + m] = evenPart - oddPart;
}
}
}
// calculate spectrogramm
double[] spectrogramma = new double[lenght];
for (int i = 0; i < spectrogramma.Length; i++)
{
spectrogramma[i] = data[i].AbsPower2();
}
return spectrogramma;
}
//==========Log2============================
private int Log2(int n)
{
int i = 0;
while (n > 0)
{
++i;
n >>= 1;
}
return i;
}
//==========ReverseBits=======================
private int ReverseBits(int n, int bitsCount)
{
int reversed = 0;
for (int i = 0; i < bitsCount; i++)
{
int nextBit = n & 1;
n >>= 1;
reversed <<= 1;
reversed |= nextBit;
}
return reversed;
}
//===========IsPowerOfTwo====================
private bool IsPowerOfTwo(int n)
{
return n > 1 && (n & (n - 1)) == 0;
}
//=========================================
struct ComplexNumber
{
public double Re;
public double Im;
public ComplexNumber(double re)
{
this.Re = re;
this.Im = 0;
}
public ComplexNumber(double re, double im)
{
this.Re = re;
this.Im = im;
}
public static ComplexNumber operator *( ComplexNumber n1, ComplexNumber n2)
{
return new ComplexNumber(n1.Re * n2.Re - n1.Im * n2.Im, n1.Re * n2.Im + n1.Im * n2.Re);
}
public static ComplexNumber operator +( ComplexNumber n1, ComplexNumber n2)
{
return new ComplexNumber(n1.Re + n2.Re, n1.Im + n2.Im);
}
public static ComplexNumber operator -( ComplexNumber n1, ComplexNumber n2)
{
return new ComplexNumber(n1.Re - n2.Re, n1.Im - n2.Im);
}
public static ComplexNumber operator -( ComplexNumber n )
{
return new ComplexNumber(-n.Re, -n.Im);
}
public static implicit operator ComplexNumber(double n)
{
return new ComplexNumber(n, 0);
}
public double Power2()
{
return Re * Re - Im * Im;
}
public double AbsPower2()
{
return Re * Re + Im * Im;
}
public override string ToString()
{
return String.Format("{0}+i*{1}", Re, Im);
}
public ComplexNumber PoweredE()
{
double e = Math.Exp(Re);
return new ComplexNumber(e * Math.Cos(Im), e * Math.Sin(Im));
}
}
|
|
).