मैंने गानों में बीट्स का पता लगाने के लिए यह साउंडअनलीज़र क्लास बनाई:
class SoundAnalyzer
{
public SoundBuffer soundData;
public Sound sound;
public List<double> beatMarkers = new List<double>();
public SoundAnalyzer(string path)
{
soundData = new SoundBuffer(path);
sound = new Sound(soundData);
}
// C = threshold, N = size of history buffer / 1024 B = bands
public void PlaceBeatMarkers(float C, int N, int B)
{
List<double>[] instantEnergyList = new List<double>[B];
GetEnergyList(B, ref instantEnergyList);
for (int i = 0; i < B; i++)
{
PlaceMarkers(instantEnergyList[i], N, C);
}
beatMarkers.Sort();
}
private short[] getRange(int begin, int end, short[] array)
{
short[] result = new short[end - begin];
for (int i = 0; i < end - begin; i++)
{
result[i] = array[begin + i];
}
return result;
}
// get a array of with a list of energy for each band
private void GetEnergyList(int B, ref List<double>[] instantEnergyList)
{
for (int i = 0; i < B; i++)
{
instantEnergyList[i] = new List<double>();
}
short[] samples = soundData.Samples;
float timePerSample = 1 / (float)soundData.SampleRate;
int sampleIndex = 0;
int nextSamples = 1024;
int samplesPerBand = nextSamples / B;
// for the whole song
while (sampleIndex + nextSamples < samples.Length)
{
complex[] FFT = FastFourier.Calculate(getRange(sampleIndex, nextSamples + sampleIndex, samples));
// foreach band
for (int i = 0; i < B; i++)
{
double energy = 0;
for (int j = 0; j < samplesPerBand; j++)
energy += FFT[i * samplesPerBand + j].GetMagnitude();
energy /= samplesPerBand;
instantEnergyList[i].Add(energy);
}
if (sampleIndex + nextSamples >= samples.Length)
nextSamples = samples.Length - sampleIndex - 1;
sampleIndex += nextSamples;
samplesPerBand = nextSamples / B;
}
}
// place the actual markers
private void PlaceMarkers(List<double> instantEnergyList, int N, float C)
{
double timePerSample = 1 / (double)soundData.SampleRate;
int index = N;
int numInBuffer = index;
double historyBuffer = 0;
//Fill the history buffer with n * instant energy
for (int i = 0; i < index; i++)
{
historyBuffer += instantEnergyList[i];
}
// If instantEnergy / samples in buffer < instantEnergy for the next sample then add beatmarker.
while (index + 1 < instantEnergyList.Count)
{
if(instantEnergyList[index + 1] > (historyBuffer / numInBuffer) * C)
beatMarkers.Add((index + 1) * 1024 * timePerSample);
historyBuffer -= instantEnergyList[index - numInBuffer];
historyBuffer += instantEnergyList[index + 1];
index++;
}
}
}
किसी कारण से यह केवल 637 सेकंड से लगभग 641 सेकंड तक बीट्स का पता लगा रहा है, और मुझे नहीं पता कि क्यों। मुझे पता है कि बीट को कई बैंड से डाला जा रहा है क्योंकि मुझे डुप्लिकेट मिल रहा है, और ऐसा लगता है कि यह उन मूल्यों के बीच प्रत्येक तात्कालिक ऊर्जा मूल्य को हरा दे रहा है।
इसके बाद इसका मॉडल तैयार किया गया है: http://www.flipcode.com/misc/BeatDetectionAlgorithms.pdf
तो धड़कन ठीक से रजिस्टर क्यों नहीं होगी?
2
क्या आप एक बैंड के लिए समय के साथ InstantEnergyList [सूचकांक + 1] और इतिहास के विकास की साजिश पोस्ट कर सकते हैं? दो रेखांकन एक दूसरे के ऊपर ओवरले हुए। इससे इस बात की जानकारी मिलेगी कि समस्या क्या हो सकती है। इसके अलावा, ऊर्जा परिमाण का वर्ग होना चाहिए, यह मत भूलना।
—
सीजय
आह हाँ जो इस समस्या का अनावरण कर सकता है, मुझे यह देखने दो कि क्या मैं किसी तरह कुछ रेखांकन बना सकता हूँ
—
क्विंसी
लेकिन यह कथानक सिर्फ इतिहास है बफ़र, या इतिहास बफ़र / अंकइन्फ़र * सी? ऐसा लगता है कि आपके पास वहां एक विशाल सी है। कोड को देखते हुए, हिस्ट्रीबफ़र के पास तात्कालिकता के समान मूल्य होने चाहिए, वह ग्राफ़ केवल तभी हो सकता है जब सी बहुत अधिक हो या न्यूमबफ़र बहुत कम हो (1 से नीचे का रास्ता), जो मुझे लगता है कि ऐसा नहीं है।
—
सिजय
सवाल यह है कि मर नहीं होगा ...
—
इंजीनियर
यह सवाल dsp.stackexchange.com
—
Atav32