सॉफ्टवेयर सिंथेसाइज़र

और इसलिए सज्जनों, मैंने अंततः संगीत के सॉफ्टवेयर संश्लेषण से निपटने का फैसला किया, अर्थात् इस तरह के कार्य के कार्यान्वयन के व्यावहारिक भाग के साथ। आइए देखें कि यह क्या हुआ और इसे कैसे लागू किया गया ...

तरंगें बनाएं

हम सभी पूरी तरह से समझते हैं कि ध्वनि एक तरंग है और शून्य स्तर से एक तरंग की आवृत्ति एक ध्वनि तरंग की आवृत्ति से मेल खाती है, और इस तरंग का आयाम अपनी ताकत या बस जोर से बोलने के लिए जिम्मेदार है, लेकिन मशीन प्रतिनिधित्व में, पल्स-कोड मॉडुलन के रूप में दर्ज की गई ध्वनि डेटा का एक सरणी है। , जिनमें से प्रत्येक तत्व समय में एक विशेष बिंदु पर लहर की स्थिति का प्रतिनिधित्व करता है।
आइए पीसीएम प्रारूप में एक सरल ध्वनि तरंग को बेहतर तरीके से देखें, इसके लिए हम पहले एक फ़ंक्शन लिखते हैं जो साइन लहर का एक मॉडल होगा। यह दो मान लेगा - ऑफसेट और आवृत्ति।

public static double Sine(int index, double frequency) { return Math.Sin(frequency * index); } 

और अब इसे प्रोग्राम क्लास में जोड़ें और मुख्य मुख्य फ़ंक्शन लिखें जो लंबाई में 75 तत्वों के डेटा सरणी को इनिशियलाइज़ करेगा जो हमारे द्वारा लिखी गई साइन वेव मॉडल का उपयोग करके अपने प्रत्येक सेल के माध्यम से हमारे ध्वनि और चक्र का प्रतिनिधित्व करेगा। एक विशिष्ट विस्थापन के लिए फ़ंक्शन के मूल्य की गणना करने के लिए, हमें 2 * पाई के बराबर साइन लहर की अवधि को ध्यान में रखना होगा और इस अवधि को उस तरंग आवृत्ति से गुणा करना होगा जो हमें चाहिए। लेकिन यह समझने के लिए कि पीसीएम प्रारूप में परिणामी आवृत्ति क्या होगी, आपको इसकी नमूना आवृत्ति जानने की आवश्यकता है। नमूनाकरण आवृत्ति - प्रति इकाई समय में तत्वों की नमूना आवृत्ति, लेकिन अगर सरलीकृत किया जाता है, तो यह प्रति सेकंड सरणी तत्वों की संख्या है, जिसका अर्थ है कि पीसीएम प्रारूप में ध्वनि आवृत्ति इसकी आवृत्ति आवृत्ति द्वारा विभाजित तरंग आवृत्ति है। आइए सहमति व्यक्त करते समय 2 हर्ट्ज की आवृत्ति के साथ एक ध्वनि तरंग उत्पन्न करते हैं कि नमूना आवृत्ति 75 हर्ट्ज के बराबर होगी।

 class Program { public static void Main(string[] args) { double[] data = new double[75]; //  . for (int index = 1; index < 76; index++) { //     . data[index-1] = Sine(index, Math.PI * 2 * 2.0 / 75); //     . } Console.ReadKey(true); //    . } public static double Sine(int index, double frequency) { return Math.Sin(frequency * index); } } 

और अब, हमारे काम के परिणाम को देखने के लिए, हम प्रोग्राम क्लास में एक नया फ़ंक्शन जोड़ेंगे जो हमारे फ़ंक्शन को सीधे कंसोल में दिखा सकता है (यह सबसे तेज़ तरीका होगा), इसलिए हम इसके विवरण में नहीं जाएंगे।

 public static void Draw (double[] data) { Console.BufferHeight = 25; //        . Console.CursorVisible = false; //    . for (int y = 0; y < 19; y++) {//    . Console.SetCursorPosition(77, y + 5);//     . Console.Write(9 - y); //    . } for (int x = 0; x < 75; x++) { //     Console.SetCursorPosition(x, x % 3); //    . Console.Write(x + 1); //   . int point = (int)(data[x] * 9); //         -9  9. int step = (point > 0)? -1 : 1; //     0. for (int y = point; y != step; y += step) {//   Console.SetCursorPosition(x, point + 14 - y); //    . Console.Write("█"); //  . } } } 

अब हम देख सकते हैं कि मशीन के दृश्य में हमारे दो हर्ट्ज क्या दिखते हैं।



लेकिन यह केवल एक प्रकार की लहर है, जबकि कई अन्य प्रकार की तरंगें हैं, आइए उन कार्यों का वर्णन करें जो मुख्य प्रकार की तरंगों का अनुकरण कर सकते हैं और विचार कर सकते हैं कि वे कैसे दिखते हैं।

 private static double Saw(int index, double frequency) { return 2.0 * (index * frequency - Math.Floor(index * frequency )) -1.0; } 

 private static double Triangle(int index, double frequency) { return 2.0 * Math.Abs (2.0 * (index * frequency - Math.Floor(index * frequency + 0.5))) - 1.0; } 

 private static double Flat(int index, double frequency) { if (Math.Sin(frequency * index ) > 0) return 1; else return -1; } 

ध्यान दें कि साइन और फ़्लैट फ़ंक्शंस की अवधि 2 * पाई है, और सॉ और ट्राइंगल फ़ंक्शंस की अवधि एक है।

एक wav फ़ाइल लिखना

जब हम अपनी आवाज़ बनाने में सक्षम थे और यहाँ तक कि अपनी आवाज़ पर भी विचार कर रहे थे, तो मैं भी इसके लिए इसे सुनना चाहूँगा, आइए इसे .wav कंटेनर में रिकॉर्ड करें और सुनें। सच है, जब तक हम जानते हैं कि वेव कंटेनर की व्यवस्था कैसे की जाती है, हमें इस कष्टप्रद गलती को ठीक करना चाहिए! तो तरंग फ़ाइल बहुत सरल है, इसमें तीन भाग होते हैं, पहला एक ब्लॉक हेडर है, दूसरा एक प्रारूप ब्लॉक है, तीसरा एक डेटा ब्लॉक है। एक साथ, यह इस तरह दिखता है:

दरअसल, सब कुछ बेहद स्पष्ट है, प्रत्येक बिंदु पर विवरण यहां वर्णित है । चूंकि हमारा काम बेहद सरल है, हम हमेशा 16 बिट्स की चौड़ाई और केवल एक ट्रैक का उपयोग करेंगे। अब मैं जो फ़ंक्शन लिखूंगा वह हमारे पीसीएम ध्वनि को स्ट्रीम के अंदर वेव कंटेनर में बचाएगा, जो काम को और अधिक लचीला बना देगा। तो यह है कि वह कैसा दिखता है।

 public static void SaveWave(Stream stream, short[] data, int sampleRate) { BinaryWriter writer = new BinaryWriter(stream); short frameSize = (short)(16 / 8); //     (16    8). writer.Write(0x46464952); //  "RIFF". writer.Write(36 + data.Length * frameSize); //     . writer.Write(0x45564157); //  "WAVE". writer.Write(0x20746D66); //  "frm ". writer.Write(16); //   . writer.Write((short)1); //  1  PCM. writer.Write((short)1); //  . writer.Write(sampleRate); //  . writer.Write(sampleRate * frameSize); //  (    ). writer.Write(frameSize); //    . writer.Write((short)16); // . writer.Write(0x61746164); //  "DATA". writer.Write(data.Length * frameSize); //    . for (int index = 0; index < data.Length; index++) { //      . foreach (byte element in BitConverter.GetBytes(data[index])) { //       . stream.WriteByte(element); //     . } } } 

आप देखते हैं कि यह कितना सरल है, और सबसे महत्वपूर्ण बात यह है कि अब हम अपनी आवाज़ सुन सकते हैं, चलो पहले सप्तक के लिए 1 सेकंड के नोट उत्पन्न करते हैं, इसकी आवृत्ति 440 हर्ट्ज है, इस कार्य के साथ मुख्य कार्य इस तरह दिखेगा

 public static void Main(string[] args) { int sampleRate = 8000; //   . short[] data = new short[sampleRate]; //   16  . double frequency = Math.PI * 2 * 440.0 / sampleRate; //   . for (int index = 0; index < sampleRate; index++) { //  . data[index] = (short)(Sine(index, frequency) * short.MaxValue); //      32767  -32767. } Stream file = File.Create("test.wav"); //        . SaveWave(file, data, sampleRate); //     . file.Close(); //  . } 

हम कार्यक्रम और लो और निहारना शुरू करते हैं! हमें टेस्ट मिल गया। इसे प्लेयर में डाउनलोड करना, बीप सुनना जब तक कि कैथार्सिस हासिल नहीं हो जाता और आगे बढ़ता रहता है। आइए एक आस्टसीलस्कप पर सभी तरफ से हमारी लहर को देखें और यह सुनिश्चित करने के लिए एक स्पेक्ट्रोग्राम कि हम प्राप्त किए गए परिणाम के ठीक विपरीत हैं।



लेकिन जीवन में, ध्वनियां अंतहीन रूप से नहीं सुनाई देती हैं, लेकिन कम हो जाती हैं, चलो एक संशोधक लिखें जो समय के साथ हमारी ध्वनि को गूंथ देगा। उसे पूर्ण मूल्यों की आवश्यकता होगी, इसलिए हम उसे गुणांक, वर्तमान स्थिति, आवृत्ति, गुणांक गुणक और नमूना आवृत्ति देंगे, और वह पूर्ण मूल्यों की गणना स्वयं करेगा, गुणांक हमेशा नकारात्मक होना चाहिए।

 public static double Length(double compressor, double frequency, double position, double length, int sampleRate){ return Math.Exp(((compressor / sampleRate) * frequency * sampleRate * (position / sampleRate)) / (length / sampleRate)); } 

ध्वनि स्तर की गणना करने वाली रेखा को भी बदलना होगा।

 data[index] = (short)(Sine(index, frequency) * Length(-0.0015, frequency, index, 1.0, sampleRate) * short.MaxValue); 

अब आस्टसीलस्कप पर हम एक पूरी तरह से अलग तस्वीर देखेंगे।

संगीत लेखन

चूंकि हम चौथे सप्तक के नोट को चलाने में कामयाब रहे, इसलिए कोई भी हमें अलग-अलग नोट चलाने के लिए परेशान नहीं करता है। क्या आपने कभी सोचा है कि नोटों की आवृत्तियों का पता कैसे लगाया जाए? यह पता चला है कि एक अद्भुत सूत्र 440 * 2 ^ (पूर्ण नोट इंडेक्स / 12) है। यदि आप किसी भी पियानो जैसे उपकरण को देखते हैं, तो याद रखें कि इसमें 7 सफेद कुंजी और 5 काले वाले ब्लॉक हैं, ब्लॉक अष्टक हैं, सफेद कुंजी मुख्य नोट हैं (C, D, E, F, S, A, C) और काले उनके मध्यवृत्त, अर्थात्, एक सप्तक में केवल 12 ध्वनियाँ हैं, इसे एक समान स्वभाव कहा जाता है।
आइए इस फ़ंक्शन के ग्राफ को देखें।

लेकिन हम वैज्ञानिक संकेतन में नोट लिखेंगे, इसलिए हम इसे 4 ऑक्टेव से कम करके सूत्र को बदल देंगे और इसे अपने मूल रूप में लिखेंगे।

 private static double GetNote(int key, int octave) { return 27.5 * Math.Pow(2, (key + octave * 12.0) / 12.0); } 

अब जब हमने बुनियादी कार्यक्षमता को इकट्ठा कर लिया है और इसके काम पर बहस की है, तो आइए भविष्य के सिंथेसाइज़र की वास्तुकला के बारे में सोचें।
सिंथेसाइज़र तत्वों का एक निश्चित समूह होगा जो ध्वनि को संश्लेषित करेगा और इसे सही जगह पर एक खाली डेटा सरणी पर ओवरले करेगा, यह सरणी और तत्व ट्रैक ऑब्जेक्ट में शामिल होंगे। उनका वर्णन करने वाले वर्ग सिंथेसाइज़र नामस्थान में निहित होंगे, आइए तत्व और ट्रैक वर्ग का वर्णन करें

 public class Element { int length; int start; double frequency; double compressor; public Element(double frequency, double compressor, double start, double length, int sampleRate) { this.frequency = Math.PI * 2 * frequency / sampleRate ; this.start = (int)(start * sampleRate); this.length = (int)(length * sampleRate); this.compressor = compressor / sampleRate; } public void Get(ref short[] data, int sampleRate) { double result; int position; for (int index = start; index < start + length * 2; index++) { position = index - start; result = 0.5 * Sine(position, frequency) ; result += 0.4 * Sine(position, frequency / 4); result += 0.2 * Sine(position, frequency / 2); result *= Length(compressor, frequency, position, length, sampleRate) * short.MaxValue * 0.25; result += data[index]; if (result > short.MaxValue) result = short.MaxValue; if (result < -short.MaxValue) result = -short.MaxValue; data[index] = (short)(result); } } private static double Length(double compressor, double frequency, double position, double length, int sampleRate){ return Math.Exp((compressor * frequency * sampleRate * (position / sampleRate)) / (length / sampleRate)); } private static double Sine(int index, double frequency) { return Math.Sin(frequency * index); } } 

 public class Track { private int sampleRate; private List<Element> elements = new List<Element>(); private short[] data; private int length; private static double GetNote(int key, int octave) { return 27.5 * Math.Pow(2, (key + octave * 12.0) / 12.0); } public Track(int sampleRate) { this.sampleRate = sampleRate; } public void Add(double frequency, double compressor, double start, double length) { if (this.length < (start+ length * 2 + 1) * sampleRate) this.length = (int)(start + length * 2 +1) * sampleRate; elements.Add(new Element(frequency, compressor, start, length, sampleRate)); } public void Synthesize() { data = new short[length]; foreach (var element in elements) { element.Get(ref data, sampleRate); } } } 

अब हम अंतिम समारोह में आए हैं जो नोट्स के साथ लाइन को पढ़ेगा और हमारी धुन उत्पन्न करेगा
ऐसा करने के लिए, एक ऐसा शब्दकोश बनाएं जो नोटों के नामों को सूचकांकों के साथ जोड़ देगा, और इसमें नियंत्रण कुंजी / सूचकांक भी होंगे।
फ़ंक्शन स्वयं को शब्दों में पंक्ति को तोड़ देगा और प्रत्येक शब्द को अलग से दो भागों में विभाजित करते हुए आगे की प्रक्रिया करेगा - बाएं और दाएं, दाएं भाग में हमेशा एक वर्ण (अंक) होता है जिसे एक संख्या के रूप में चर सप्तक में लिखा जाता है, और पहले भाग की लंबाई शब्द की लंबाई होती है - 1 (अर्थात, दाईं ओर ऋण शब्द) और आगे हमारे शब्दकोश की कुंजी के रूप में कार्य करता है, जो नोट के सूचकांक को वापस करता है, जब हम शब्द को पार्स करते हैं, तो हम तय करते हैं कि क्या करना है, यदि सूचकांक नियंत्रित हो रहा है, तो हम सूचकांक के अनुरूप कार्य करेंगे, और यदि नहीं, तो इसका मतलब है कि हमारे पास एक नोट इंडेक्स है और हम अपने ट्रैक की लंबाई और आवृत्ति की एक नई ध्वनि जोड़ेंगे, जिसकी हमें आवश्यकता है।

 public void Music (string melody, double temp = 60.0) { string[] words = melody.Split(' '); foreach (string word in words) { int note = notes[word.Substring(0, word.Length - 1)]; int octave = Convert.ToInt32(word.Substring(word.Length - 1, 1)); if (note > 2){ switch (note) { case 3: dtime = Math.Pow(0.5, octave + 1) * 8 * (60.0 / temp); break; case 4: length += (int)(Math.Pow(0.5, octave + 1) * 8 * (60.0 / temp)); position += Math.Pow(0.5, octave + 1) * 8 * (60.0 / temp); break; } } else { Add(GetNote(note, octave), -0.51, position, dtime); position += dtime; } } } 

इस क्षण से, मेलोडी को L4 B6 S4 D7 B6 F#6 S4 B6 F#6 रूप में लिखा जा सकता है, जहां L वह कमांड है, जो नोट की लंबाई निर्धारित करता है, और S एक पॉज बनाता है, बाकी अक्षर नोट हैं। दरअसल, यह वह जगह है जहां सॉफ्टवेयर सिंथेसाइज़र का लेखन समाप्त हो गया है और हम "बाख कोक" के एक टुकड़े को सुनकर परिणाम की जांच कर सकते हैं।

बाइनरी फ़ाइल
स्रोत कोड