लिनक्स पर पीसी स्पीकर के लिए .Wav कंसोल प्लेयर

मैं लंबे समय से पीसी-स्पीकर के लिए एक खिलाड़ी लिखना चाहता था और न केवल नोट्स और मोनोफोनिक रिंगटोन। लेकिन उस समय जब यह प्रासंगिक था (डॉस - हमेशा के लिए!) मुझे कोई ज्ञान नहीं था, कोई योग्यता नहीं थी, कोई विचार नहीं था। बाद में, मैं विंडोज डीडीके के माध्यम से इसे प्राप्त नहीं कर सका और QBASIC SOUND की शैली में चुपचाप चीख़ता रहा। हां, और साउंड डिवाइस के रूप में पीसी-स्पीकर की प्रासंगिकता शून्य हो गई है, गर्व स्पीकर एक बीपर और बजर में बदल गया है। हालांकि, यह पीसी से कहीं भी गायब नहीं हुआ (रास्ते में सभी ड्राइवों को रेखांकित किया गया), पहले की तरह, खुद को स्टार्टअप और रिपोर्टिंग त्रुटियों पर महसूस किया। तो क्या आधुनिक उपयोगकर्ता-अंतरिक्ष हार्डवेयर और सॉफ्टवेयर वातावरण में पीसी-स्पीकर पर पॉलीफोनिक राग या आवाज बजाना संभव है? बेशक आप कर सकते हैं - सी और लिनक्स हमें इसमें मदद करेंगे।
एक टोपी और चश्मे में एक व्यक्ति को समर्पित , सभी को एक निश्चित दिशा में भेजना (लेखक द्वारा मेरे लिए सब कुछ, डॉसबॉक्स में सब कुछ अच्छा काम करता है)।
एक प्रोग्रामर के दृष्टिकोण से एक वक्ता क्या है? इस उपकरण की दो अवस्थाएँ हैं: चालू और बंद - इसके साथ हम झिल्ली को नियंत्रित करते हैं (शायद, शायद कुछ अन्य सक्रिय तत्व) जो ध्वनि बनाता है। जीवविज्ञानियों के अनुसार, मानव सुनवाई की सीमा लगभग 22KHz ऊपर और 20Hz नीचे है, इसलिए हमें राज्यों को बहुत जल्दी स्विच करना होगा। आमतौर पर, वक्ता अंतराल टाइमर नियंत्रित किया जाता है, लेकिन इस तरह से हम ध्वनि केवल एक निर्दिष्ट आवृत्ति और अवधि खेल सकते हैं, जिसके लिए पहले से तैयार सॉफ्टवेयर और यूजर इंटरफेस (टाइमर सीधे की आवश्यकता नहीं है के लिए उपयोग) कर रहे हैं। उदाहरण के लिए, लिनक्स कंसोल के लिए, नोट "टू" पहला ऑक्टेव है, जो 1 सेकंड तक चलता है:

echo -en "\e[10;263;11;1000]\a" echo -en "\ec" 

दूसरा इको कमांड डिफ़ॉल्ट राज्य में अवधि और आवृत्ति सेटिंग्स लौटाता है।
स्पीकर कंट्रोल को एक्सेस करने के लिए, आपको 0x61 (हेक्साडेसिमल 61) पोर्ट के साथ इसके शून्य और पहले बिट्स के साथ सीधे संवाद करना होगा। शून्य बिट: स्पीकर के बाइंडिंग को टाइमर पर नियंत्रित करता है - यदि 1 तो यह टाइमर द्वारा नियंत्रित किया जाता है। पहला बिट: स्पीकर स्थिति स्विच करता है - 1 चालू, 0 बंद। यह वह तरीका है जिसका हम उपयोग करेंगे।
अब, यह समझने के लिए कि कैसे खेलना है, हमें यह तय करना चाहिए कि हम क्या खेलेंगे। प्लेबैक के लिए, हम .WAV फ़ाइलों का उपयोग करेंगे। .WAV फ़ाइल का डेटा प्रारूप विविध हो सकता है, लेकिन आमतौर पर यह पल्स कोड मॉडुलन में डेटा युक्त फ़ाइलों को संदर्भित करता है। यह ADC से दी गई फ़्रीक्वेंसी (सैंपलिंग फ़्रीक्वेंसी) के साथ प्राप्त मूल्यों का एक क्रम है और प्रत्येक चैनल के लिए फ़ाइल के रूप में लिखा जाता है। ध्वनि के दृष्टिकोण से, यह समय में दिए गए बिंदु पर मात्रा है, या एक वक्ता के दृष्टिकोण से, आराम बिंदु के सापेक्ष झिल्ली की स्थिति। ADC से एक बार में प्राप्त अधिकतम मान बिट स्ट्रीम (बिटरेट) का मान निर्धारित करता है। एक निश्चित समय में सभी चैनलों के लिए डेटा रिकॉर्ड का एक नमूना है। ध्वनि के बारे में बोलते हुए, हमें निश्चित रूप से Kotelnikov के प्रमेय को याद रखना चाहिए, और कहेंगे कि इन आंकड़ों के आधार पर, हम बिना नुकसान के मूल लहर (उच्च नमूना आवृत्तियों और बिटस्ट्रीम) पर पुनर्स्थापित कर सकते हैं। लेकिन हमारे मामले में, यह काम नहीं करेगा, क्योंकि स्पीकर में वॉल्यूम की अवधारणा नहीं है, या बल्कि, यह मौजूद है, लेकिन इसे बदला नहीं जा सकता है - या तो संपूर्ण वॉल्यूम (चालू) या नहीं (बंद)। यह देखते हुए कि एडीसी मात्रा के नमूने में भी परिमित सटीकता है, "गर्म ट्यूब ध्वनि" का मूल्य स्पष्ट हो जाता है।
रिकॉर्ड किए गए डेटा को सकारात्मक और नकारात्मक मूल्यों (एब्सिस्सा अक्ष को पार करने वाली लहर की गति) के रूप में प्रस्तुत किया जाता है, लेकिन थोड़े अलग प्रारूप में: आधा (शून्य) अधिकतम मूल्य से लिया जाता है। यदि हमारे डेटा को सिंगल-बाइट नमूनों द्वारा दर्शाया जाता है, तो शून्य 256/2 = 128 होगा। 256 अधिकतम संभव संख्या है जिसे एक बाइट द्वारा दर्शाया जा सकता है, या 256 = 255 (0xFF, संख्या का अधिकतम मूल्य) + 1. तदनुसार, यदि आप रिकॉर्डिंग के लिए उपयोग करते हैं 2 बाइट्स, तब (65535 + 1) / 2 = 32768. इस संख्या से अधिक मान सकारात्मक हैं, और छोटे से बड़े तक बढ़ते हैं, इस संख्या से कम मूल्य नकारात्मक हैं, और बड़े से छोटे तक घटते हैं। उदाहरण के लिए, एकल-बाइट मानों के लिए एक नियमित संख्या में अनुवाद करें:

 245 (ADC मान) => 117 = 245 - 128
  93 (ADC मान) => -35 = 93 - 128

जैसा कि ऊपर उल्लेख किया गया है, हम स्पीकर को केवल चालू और बंद कर सकते हैं, अर्थात् प्राप्त डेटा से हम एक वर्ग तरंग बनाएंगे, जहां 1 मान शून्य है, अन्य सभी मामलों में 0 से अधिक है। आप यहां स्पीकर को कैसे खेलें, इसके बारे में अधिक विवरण देख सकते हैं, इस लेख ने कल्पना के कार्यान्वयन में एक शुरुआती बिंदु के रूप में कार्य किया है, इसके लिए लेखक को बहुत धन्यवाद।
हम अपनी योजना को लागू करना शुरू करेंगे। मुझे एक आरक्षण करना चाहिए कि केवल एक चैनल खेला जाता है, विश्लेषण के लिए अधिकतम डेटा आकार प्रति चैनल 4 बाइट्स है (यह कहा जाता है कि स्पीकर के लिए अधिकतम संभव गुणवत्ता के लिए एक बिट पर्याप्त है, यह मान 32 गुना बेमानी है)। शुरुआत से ही, मैंने दो बड़ी समस्याएं देखीं:
सबसे पहले, बंदरगाहों तक पहुंच - जैसे कि डॉस में सब कुछ सरल था, उसी हद तक विंडोज में मेरे लिए सब कुछ मुश्किल था। हालांकि, लिनक्स बंदरगाहों तक सीधी पहुंच के लिए एक बहुत ही शानदार अवसर प्रदान करता है, आपको बस सुपर पासवर्ड अधिकार प्राप्त करने के लिए रूट पासवर्ड या किसी अन्य तरीके से जानने की जरूरत है, या इस प्रक्रिया के लिए CAP_SYS_RAWIO विशेषाधिकार प्राप्त करना होगा। इस सुविधा को ioperm कहा जाता है और यह आपको 0 से 0x3FF की सीमा में सभी बंदरगाहों तक पहुंच खोलने की अनुमति देता है। मैं और अधिक चाहूंगा, हम एक और कॉल का उपयोग करते हैं - iopl , यह हमारे लिए उपयोगी नहीं होगा।
अनुमति के बाद इनपुट / आउटपुट पोर्ट पर सीधे पहुंचें, असेंबलर में इनलाइन आवेषण का वर्णन करने वाले मैक्रोज़ का उपयोग किया जाता है। आप लिख (आउट) और पढ़ सकते हैं (बाइट्स में) (बी), शब्द (डब्ल्यू), डबल शब्द (एल), लाइनें (ओं), ऑपरेशन के बाद पॉज (_p) का उपयोग करें। MAN पृष्ठ में बहुत कम जानकारी होती है और यह अधिक डरावना होता है कि आपको ऐसा नहीं करना चाहिए, इसलिए शीर्ष लेख फ़ाइलों के स्रोत फ़ाइलों को देखना बेहतर होगा। यदि आप मैक्रो का उपयोग _p के साथ करते हैं , तो आपको 0x80 पोर्ट तक पहुंच खोलने की भी आवश्यकता है, क्योंकि इस पोर्ट पर डेटा बाइट को आउटपुट करने में देरी होती है।
कार्यक्रम में - सबसे पहले, बंदरगाहों तक पहुंच शुरू करें, जो उस मान को सहेजता है जो पहले से ही 0x61 पोर्ट में था, प्रोग्राम के बाद रिकवरी के लिए:

 #define SPKPORT 0x61 static unsigned char old61 = 0; unsigned char out61 = 0; if (!ioperm(SPKPORT,1,1)){ //   0x61  old61 = inb(SPKPORT); // out61 = old61 & 0xFE; //   outb(old61,SPKPORT); //,       } 

अंत में, हम वापस लौटेंगे क्योंकि यह था:

 outb(old61,SPKPORT); //   ioperm(SPKPORT,1,0); //      0x61  

दूसरी समस्या समय की है। लिनक्स एक बहु-कार्यशील बहु-उपयोगकर्ता वातावरण है और कोई एक संसाधन (विशेष रूप से, एक प्रोसेसर) के एकाधिकार के स्वामित्व पर भरोसा नहीं कर सकता है। ध्वनि को चलाने के लिए, जितना संभव हो उतना करीब है (यह देखते हुए कि यह एक पीसी-स्पीकर है) मूल में, हमें डेटा को कड़ाई से अंतराल में भेजना चाहिए, इस अंतराल से विचलन ध्वनि को तुरंत विकृत कर देगा। यदि अंतराल लयबद्ध (समान) है, लेकिन अधिक लंबा या छोटा है, तो खेले जाने वाले स्वर मूल लोगों की तुलना में क्रमशः कम या अधिक होंगे। यदि हर बार अंतराल अलग है, तो ध्वनि को बस पहचाना नहीं जाएगा। यह सब इस तथ्य से जटिल है कि न्यूनतम नमूना आवृत्ति 8000 हर्ट्ज है, जो हमें 1/8000 ~ 125 माइक्रोसेकंड से अधिक नहीं के सबसे लंबे अंतराल को निर्दिष्ट करने के लिए मजबूर करती है। 22KHz पर, यह 45 माइक्रोसेकंड अंतराल है। इस तरह के विलंब, MAN के अनुसार, सोते समय या नैनोसेलेप का उपयोग करते समय संभव हैं। लेकिन पहले, जहां उन्हें किया जाना था:

 char wavdata[0x10000]; //   unsigned int *curdata; //      unsigned int bufsize; //    unsigned int cursampleraw; //    unsigned int datamask; //        short int onechannelinc; //     =   unsigned int samplezero; //   for (i = 0;i < bufsize;i += onechannelinc){ curdata = (void*)(wavdata+i); //     cursampleraw = *curdata&datamask; //    if (cursampleraw > samplezero){ //    out61 |= 0x2; // ,  1  = 1 }else{ out61 &= 0xFD; // ,  1  = 0 } outb(out61,SPKPORT); //   //  ,     } 

यह व्यावहारिक रूप से संपूर्ण कार्यक्रम है, बाकी सब कुछ एक फ़ाइल और प्रारंभिक डेटा विश्लेषण से पढ़ रहा है।
तो, देरी के बारे में क्या? Usleep और nanosleep का उपयोग करने से कोई परिणाम नहीं मिला, या इसके बजाय उनके परिणाम निकले, लेकिन विराम के साथ मान 10 माइक्रोसे कम है। यदि ठहराव लंबा था, तो ध्वनि पूरी तरह से टूट गई, और बिंदु पिच नहीं था, लेकिन तथ्य यह है कि ठहराव बनाए नहीं रखा गया था, कोई ताल नहीं था, अर्थात, चक्र के प्रत्येक मार्ग की एक अलग अवधि थी। यह सोचकर कि प्रक्रिया में बहुत कम प्राथमिकता है, हम अच्छा उपयोग करते हैं। लेकिन न तो उपयोगिता और न ही सॉफ्टवेयर कॉल ने समस्या को हल किया। यह शेड्यूलर नीति को बदलने की कोशिश करने के लिए बनी हुई है:

 struct sched_param schedio; sched_getparam(0,&schedio); //   schedio.sched_priority = sched_get_priority_max(SCHED_FIFO); //   sched_setscheduler(0,SCHED_FIFO,&schedio); //  SCHED_FIFO 

मैं सही उपयोग के बारे में सुनिश्चित नहीं हूं, लेकिन इस रूप में यह मदद नहीं की (यह कोड कार्यक्रम में टिप्पणी की गई, अगर यह अभी भी मदद करता है, तो इसे व्यवसाय में लौटाया जा सकता है, साथ ही साथ यह अच्छा भी है )। यह सब इस पृष्ठ से सिफारिशों का पालन करने की कोशिश की गई है। यह केवल एक खाली चक्र का प्रयास करने के लिए बना रहा, बल्कि बेकार ... और इसने परिणाम दिया - आप न केवल संगीत सुन सकते थे, बल्कि भाषण भी दे सकते थे।
सब कुछ काम कर गया। इसने आशा को प्रेरित किया, लेकिन अन्य मशीनों में स्थानांतरित होने पर खराब परिणामों को चित्रित किया। अंतिम लिंक में, इस तथ्य के बारे में पैराग्राफ के एक जोड़े थे कि बंदरगाहों के लिए आउटपुट लगभग 1 माइक्रोसेकंड की देरी देता है, मुझे संदेह था, हालांकि एक देरी के साथ पोर्ट के लिए आउटपुट के लिए आउटब_प मैक्रो उसी सिद्धांत द्वारा निर्देशित था। मुख्य लूप में एक विराम जोड़ा गया:

 short int pause; for (i = 0;i < bufsize;i += onechannelinc){ curdata = (void*)(wavdata+i); cursampleraw = *curdata&datamask; if (cursampleraw > samplezero){ out61 |= 0x2; }else{ out61 &= 0xFD; } for (k=0;k<pause;k++)outb(out61,SPKPORT); //    } 

- जिसके बाद कार्यशील सर्वर पर कार्यक्रम का परीक्षण किया गया, अप्रत्याशित रूप से मेरे लिए, कुछ भी नहीं टूटा और सब कुछ काम कर गया। प्लेबैक के दौरान एक फ़ाइल से पढ़ने की संभावित समस्याएं (पढ़ने के चक्र के बीच लुप्त होती) भी किसी भी परीक्षण किए गए कंप्यूटर पर नहीं हुईं: फ़ाइल को 64KB के बफर द्वारा पढ़ा जाता है, और ध्यान देने योग्य विकृति नहीं होती है। मुख्य लूप में किसी भी बाहरी कोड की उपस्थिति किसी भी तरह से ध्वनि की गुणवत्ता को प्रभावित नहीं करती है, जब तक कि यह कोड सिस्टम कॉल न हो। नतीजतन, मैं इस निष्कर्ष पर पहुंचा कि कंप्यूटर जितना अधिक शक्तिशाली होगा, उतना ही बेहतर हमारा स्पीकर ध्वनि करेगा, क्योंकि यह विरोधाभासी नहीं है। यदि हम शक्ति को कम करने की दिशा में जाते हैं, तो कुछ बिंदु पर मल्टी-टास्किंग सिस्टम पर सब कुछ टूट जाएगा, लेकिन सिंगल-टास्किंग पर स्विच करके, हम फिर से परिणाम प्राप्त करेंगे।
ईमानदारी से, मैं किसी भी सकारात्मक परिणाम के बारे में सुनिश्चित नहीं था, क्योंकि एक समय में डॉस के लिए इस कार्यक्रम के दो सामान्य संस्करण थे। सबसे पहले, हम सभी अवरोधों को रोकते हैं (हम हर चीज के अनन्य स्वामी बने रहते हैं) और ऊपर बताए गए अनुसार कोड फेस-टू-फेस निष्पादित करते हैं, एक अनंत लूप में घड़ी के चक्र द्वारा देरी की गिनती करते हैं। दूसरा, टाइमर को अधिकतम आवृत्ति पर सेट करें (न्यूनतम अंतराल केवल 1 माइक्रोसेकंड के बारे में है), 0x8 इंटरप्ट (IRQ0) उठाएं और स्पीकर को अपने स्वयं के परिकलित अंतराल पर डेटा दें, जिससे किसी को भी इस प्रक्रिया में हस्तक्षेप करने से रोका जा सके। ये दोनों विकल्प लिनक्स के उपयोगकर्ता-अंतरिक्ष वातावरण में कार्यात्मक नहीं हैं, लेकिन मुझे खुशी है कि सब कुछ इतना अजीब निकला।
अब बाकी कोड में क्या है इसके बारे में कुछ पंक्तियाँ। मूल रूप से, यह .WAV फ़ाइल हेडर की पार्सिंग है, इस विवरण को खोजने के बाद, मैंने सभी फ़ील्ड्स को सॉर्ट किया, उनकी जाँच की, लेकिन इंटरनेट से डाउनलोड की गई पहली फ़ाइल गलत प्रारूप में निकली। फिर, इस दस्तावेज़ की ओर मुड़ते हुए और विश्लेषण को सरल करते हुए, नए डेटा को ध्यान में रखते हुए, मैंने इंटरनेट से दूसरी फ़ाइल डाउनलोड की, जिसने मुझे फैक्ट चेन के सामने 2-बाइट फ़ील्ड की कमी से परेशान किया, परिणामस्वरूप, मुझे कुछ उचित राशि प्राप्त करने के लिए चेक को छोटा करना पड़ा। मनमानी फाइलें।
.WAV हेडर के विश्लेषण में आकार प्रकार के निर्माण का उपयोग करते हुए डेटा प्रकारों के लिए एक चेक होता है, यह माना जाता है कि उपयोग किए गए इंट डेटा प्रकार 4 बाइट्स हैं, शॉर्ट इंट 2 बाइट्स हैं और चार बाइट हैं। इस रूप में, आप 64-बिट सिस्टम के लिए संकलन कर सकते हैं। यदि यह मामला नहीं है, तो चेक पास नहीं होना चाहिए, और प्रोग्राम असमर्थित .WAV प्रारूप के बारे में एक त्रुटि फेंक देगा।
कोड में भी इस प्रक्रिया की कल्पना करने का एक प्रयास था, लेकिन इसे ध्वनि के साथ जोड़कर, हम केवल क्रोकिंग और क्रैकिंग प्राप्त करते हैं, इसलिए ग्राफ को देखा जा सकता है, लेकिन ध्वनि के बिना। वैसे, आप यह मूल्यांकन कर सकते हैं कि विलंब के रूप में उपयोग करते समय प्लेबैक कितना धीमा है (या अपनी दृश्य और ध्वनि संवेदनाओं की तुलना करें)।
विशेष रूप से संकलित भाषा में लिनक्स के लिए यह मेरा पहला कार्यक्रम है, इसलिए जो लोग बोरलैंड सी से कॉनियो की तलाश कर रहे हैं, यह यहां नहीं है, लेकिन सब कुछ बहुत बेहतर है: ईएससी अनुक्रम (या मैन कंसोल_कोड ) लगभग सब कुछ कोबीट से बदल देता है (यह सिर्फ है रीडिंग मोड्स में से एक), और कंसोल स्क्रीन का आकार प्राप्त करना, लेकिन यहां आपको ioctl (मैन कंसोल_ ioctl ) का उपयोग करके सीधे डिवाइस तक पहुंचने की आवश्यकता है:

 struct winsize scrsize; ioctl(STDOUT_FILENO,TIOCGWINSZ,&scrsize); //scrsize.ws_col -    //scrsize.ws_row -    

कार्यक्रम को यहां उठाया जा सकता है: playwav.zip - कई .WAV फाइलें भी संग्रह में शामिल हैं। आप 64-बिट सिस्टम पर परीक्षण सहित, बस संकलन कर सकते हैं:

 gcc playwav64.c -o playwav64 chmod +x playwav64 

आप इसे तीन मापदंडों के साथ चला सकते हैं, पहली बार खेलने के लिए एक फ़ाइल है,

 sudo ./playwav64 file.wav 

दूसरा समय गुणक है: जितना बड़ा है, टोन उतना ही कम है, यदि दूसरा पैरामीटर संख्या नहीं है या नहीं है, तो डिफ़ॉल्ट मान 650,000 है,

 sudo ./playwav64 file.wav 500000 

तीसरा - कोई भी मान, उस प्रोग्राम को बताता है जो स्क्रीन पर (ध्वनि के बिना) ग्राफ को प्रदर्शित करना आवश्यक है।

 ./playwav64 file.wav sw 

रूट विशेषाधिकार के साथ ही ध्वनि। Xs में नहीं दौड़ना बेहतर है, हालाँकि यह KDE में भी काम करता है। यदि आप एसएसएच सत्र में चलते हैं, तो ध्वनि उस भौतिक मशीन पर होगी, जिससे कनेक्शन बनाया गया है।
मैंने जितना संभव हो सके, सभी कंप्यूटरों पर इसकी जाँच की (यह हर जगह काम किया), हो सकता है कि मैंने कोड में बहुत गड़बड़ की, मैं इसके लिए माफी माँगता हूँ।