👜 🔧 🔍 .Wav फ़ाइल की तरंग ड्रा करें 📄 👨🏿‍🔬 🦎

कुछ समय पहले, मैंने एक विदेशी समस्या को हल करने के लिए खुद को समर्पित करने का फैसला किया - एक लहर-फाइल की एक लहर खींचने के लिए, जैसा कि ऑडियो और वीडियो संपादक करते हैं, इसके लिए पायथन का उपयोग कर रहे हैं। नतीजतन, मुझे एक छोटी सी स्क्रिप्ट मिली जो इसे काफी अच्छी तरह से संभाल सकती है। तो, ऊपर की तस्वीर रानी के गीत "अंडर प्रेशर" से उत्पन्न हुई थी। तुलना के लिए, ऑडियो एडिटर में तरंग का प्रकार:

मैंने ध्वनि को पार्स करने के लिए सुप्पी लाइब्रेरी का उपयोग किया, और ध्वनि को प्लॉट करने के लिए मैटप्लोटलिब । कट के तहत, मैं wav फ़ाइलों और स्क्रिप्ट एल्गोरिथ्म के साथ काम करने की मूल बातें रेखांकित करूंगा।

UPD1: गुणांक k को पतला करना लगभग k = nframes / w / 32 लेने के लिए बेहतर है, अनुभवजन्य रूप से चयनित। एक नए गुणांक के साथ अद्यतित चित्र।

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

हेडर भाग से मुख्य पैरामीटर निकाले जाते हैं - चैनल की संख्या, बिट दर, फ़्रेम की संख्या - जिसके आधार पर ऑडियो स्ट्रीम पार्स किया जाता है। वेव-फाइल 1 या 2 चैनल को संग्रहीत करता है, जिनमें से प्रत्येक 8, 16, 24 या 32 बिट्स में एन्कोडेड है। एक समय में एक तरंग के आयाम का वर्णन करने वाले बिट्स के एक अनुक्रम को एक नमूना कहा जाता है। एक निश्चित समय में सभी चैनलों के लिए नमूनों के अनुक्रम को एक फ्रेम कहा जाता है।

उदाहरण के लिए, \ xe2 \ xff \ xe3 \ xfa 16-बिट wav फ़ाइल का एक फ्रेम है। इसलिए, \ xe2 \ xff पहले (बाएं) चैनल का एक नमूना है, और \ xe3 \ xfa दूसरा (दाएं) चैनल है। नमूने पूर्णांक संख्या (8-बिट नमूने, अहस्ताक्षरित संख्या के साथ फ़ाइलों को छोड़कर) पर हस्ताक्षर किए गए हैं।

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

import wave wav = wave.open("music.wav", mode="r") (nchannels, sampwidth, framerate, nframes, comptype, compname) = wav.getparams() content = wav.readframes(nframes)

इन पंक्तियों के साथ हम वेव-फाइल पढ़ने के लिए एक ऑब्जेक्ट बनाते हैं (यदि आप "आर" पैरामीटर को छोड़ देते हैं, तो लेखन के लिए एक ऑब्जेक्ट बनाया जाएगा, जो हमें सूट नहीं करता है)। गेटपराम () विधि मूल फ़ाइल मापदंडों का एक टपल देती है (क्रम में): चैनलों की संख्या, प्रति नमूना बाइट्स की संख्या, प्रति सेकंड फ्रेम की संख्या, फ्रेम की कुल संख्या, संपीड़न प्रकार, संपीड़न प्रकार का नाम। मैंने उन सभी को अलग-अलग चर में डाल दिया ताकि हर बार ऑब्जेक्ट के क्षेत्रों तक पहुंच न हो।

रीडफ़्रेम () विधि ऑब्जेक्ट के आंतरिक पॉइंटर के सापेक्ष निर्दिष्ट फ़्रेम को पढ़ती है और इसे बढ़ाती है। इस मामले में, हम चर सामग्री में एक समय में एक बाइट स्ट्रिंग में सभी फ्रेम पढ़ते हैं।

अब आपको इस लाइन को पार्स करने की आवश्यकता है। सैम्पोज़िशन पैरामीटर यह निर्धारित करता है कि एक नमूने को एन्कोड करने में कितने बाइट्स लगते हैं:

1 = 8 बिट्स, अहस्ताक्षरित पूर्णांक (0-255),
2 = 16 बिट्स, पूर्णांक हस्ताक्षरित (-32768-32767)
4 = 32 बिट्स, लंबे पूर्णांक पर हस्ताक्षरित (-2147483648-2147483647)

विश्लेषण इस प्रकार है:

 import numpy as np types = { 1: np.int8, 2: np.int16, 4: np.int32 } samples = np.fromstring(content, dtype=types[sampwidth])

यह संख्यात्मक पुस्तकालय का उपयोग करता है। इसका मुख्य उद्देश्य arrays और matrices के साथ गणितीय संचालन है। Numpy अपने डेटा प्रकारों पर काम करता है। फ़ॉर्स्ट्रिंग () फ़ंक्शन बाइट स्ट्रिंग से एक-आयामी सरणी बनाता है, और dtype पैरामीटर निर्धारित करता है कि सरणी के तत्वों की व्याख्या कैसे की जाती है। हमारे उदाहरण में, डेटा प्रकार "प्रकार" शब्दकोश से लिया गया है, जो नमूना आकार और संख्यात्मक डेटा प्रकारों की तुलना करता है।

अब हमारे पास ऑडियो स्ट्रीम नमूनों की एक सरणी है। यदि इसमें एक चैनल है, तो संपूर्ण सरणी इसका प्रतिनिधित्व करेगी, यदि दो (या कई) हैं, तो आपको प्रत्येक चैनल के लिए प्रत्येक n-वें तत्व का चयन करके सरणी को "पतला" करने की आवश्यकता है:

 for n in range(nchannels): channel = samples[n::nchannels]

इस लूप में, प्रत्येक ऑडियो चैनल को फॉर्म [ऑफसेट :: n] के एक स्लाइस का उपयोग करके चैनल सरणी में चुना जाता है, जहां ऑफसेट पहले तत्व का सूचकांक है और n नमूनाकरण चरण है। लेकिन चैनल सरणी में बड़ी संख्या में अंक होते हैं, और 3-मिनट की फ़ाइल के लिए ग्राफ़ आउटपुट में बड़ी मात्रा में मेमोरी और समय की आवश्यकता होती है। हम कोड में कुछ अतिरिक्त चर पेश करते हैं:

 duration = nframes / framerate w, h = 800, 300 DPI = 72 peak = 256 ** sampwidth / 2 k = nframes/w/32

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

ग्राफ़ प्रदर्शन समायोजित करें:

 plt.figure(1, figsize=(float(w)/DPI, float(h)/DPI), dpi=DPI) plt.subplots_adjust(wspace=0, hspace=0)

अब चैनलों के आउटपुट के साथ लूप इस तरह दिखेगा:

 for n in range(nchannels): channel = samples[n::nchannels] channel = channel[0::k] if nchannels == 1: channel = channel - peak axes = plt.subplot(2, 1, n+1, axisbg="k") axes.plot(channel, "g") axes.yaxis.set_major_formatter(ticker.FuncFormatter(format_db)) plt.grid(True, color="w") axes.xaxis.set_major_formatter(ticker.NullFormatter())

लूप चैनलों की संख्या की जांच करता है। जैसा कि मैंने पहले ही कहा, अहस्ताक्षरित पूर्णांक में 8-बिट ध्वनि संग्रहीत होती है, इसलिए प्रत्येक नमूने से आधा आयाम लेकर इसे सामान्य करना आवश्यक है।

अंत में, निचले अक्ष का प्रारूप निर्धारित करें

 axes.xaxis.set_major_formatter(ticker.FuncFormatter(format_time))

चित्र में ग्राफ़ को सहेजें और दिखाएँ:

 plt.savefig("wave", dpi=DPI) plt.show()

format_time और format_db एब्सिसा और ऑर्डिनेट कुल्हाड़ियों के तराजू के मूल्यों को प्रारूपित करने के लिए कार्य हैं।

format_time प्रारूप समय नमूना संख्या द्वारा:

 def format_time(x, pos=None): global duration, nframes, k progress = int(x / float(nframes) * duration * k) mins, secs = divmod(progress, 60) hours, mins = divmod(mins, 60) out = "%d:%02d" % (mins, secs) if hours > 0: out = "%d:" % hours return out

Format_db फ़ंक्शन अपने आयाम द्वारा ध्वनि की मात्रा को प्रारूपित करता है:

 def format_db(x, pos=None): if pos == 0: return "" global peak if x == 0: return "-inf" db = 20 * math.log10(abs(x) / float(peak)) return int(db)

पूरी स्क्रिप्ट:

 import wave import numpy as np import matplotlib.pyplot as plt import matplotlib.ticker as ticker import math types = { 1: np.int8, 2: np.int16, 4: np.int32 } def format_time(x, pos=None): global duration, nframes, k progress = int(x / float(nframes) * duration * k) mins, secs = divmod(progress, 60) hours, mins = divmod(mins, 60) out = "%d:%02d" % (mins, secs) if hours > 0: out = "%d:" % hours return out def format_db(x, pos=None): if pos == 0: return "" global peak if x == 0: return "-inf" db = 20 * math.log10(abs(x) / float(peak)) return int(db) wav = wave.open("music.wav", mode="r") (nchannels, sampwidth, framerate, nframes, comptype, compname) = wav.getparams() duration = nframes / framerate w, h = 800, 300 k = nframes/w/32 DPI = 72 peak = 256 ** sampwidth / 2 content = wav.readframes(nframes) samples = np.fromstring(content, dtype=types[sampwidth]) plt.figure(1, figsize=(float(w)/DPI, float(h)/DPI), dpi=DPI) plt.subplots_adjust(wspace=0, hspace=0) for n in range(nchannels): channel = samples[n::nchannels] channel = channel[0::k] if nchannels == 1: channel = channel - peak axes = plt.subplot(2, 1, n+1, axisbg="k") axes.plot(channel, "g") axes.yaxis.set_major_formatter(ticker.FuncFormatter(format_db)) plt.grid(True, color="w") axes.xaxis.set_major_formatter(ticker.NullFormatter()) axes.xaxis.set_major_formatter(ticker.FuncFormatter(format_time)) plt.savefig("wave", dpi=DPI) plt.show()

अधिक उदाहरण:

.Wav फ़ाइल की तरंग ड्रा करें

More articles: