स्ट्रीमिंग ऑडियो के साथ काम करें

परिचय

माइक्रोफ़ोन से कच्चा डेटा प्राप्त करने के लिए, वर्ग जिम्मेदार है android.media.AudioRecord android.media.AudioRecord । यह आंतरिक बफर को डेटा लिखता है, जिससे हमें समय-समय पर इसे इकट्ठा करना चाहिए।

डिजाइनर

एक ऑब्जेक्ट बनाने के लिए आपको निर्दिष्ट करना होगा:

audioSource	रिकॉर्डिंग कहाँ से है? हमारे मामले में, यह MediaRecorder.AudioSource.MIC
sampleRateInHz	हर्ट्ज नमूना दर। प्रलेखन का दावा है कि 44100Hz सभी उपकरणों द्वारा समर्थित है
channelConfig	चैनल कॉन्फ़िगरेशन हो सकता है CHANNEL_IN_MONO CHANNEL_IN_MONO या CHANNEL_IN_STEREO CHANNEL_IN_STEREO मोनो हर जगह काम करता है। महत्वपूर्ण: ये स्थिरांक उन चैनलों की संख्या से मेल नहीं खाते जिन्हें वे निरूपित करते हैं। आप इस पैरामीटर में 1 या 2 पास नहीं कर सकते।
audioFormat	एक इनपुट डेटा प्रारूप, जिसे एक कोडेक के रूप में जाना जाता है। हो सकता है ENCODING_PCM_16BIT ENCODING_PCM_16BIT या ENCODING_PCM_8BIT
bufferSizeInBytes	उसी आंतरिक बफर का आकार। इससे आप ऑडियो स्ट्रीम पढ़ सकते हैं। पढ़ने के हिस्से का आकार इस मूल्य से अधिक नहीं होना चाहिए। इस पैरामीटर का न्यूनतम स्वीकार्य मूल्य है, जिसे प्राप्त किया जा सकता है getMinBufferSize() getMinBufferSize() ।

इसके निर्माण के दौरान, एक वस्तु सिस्टम संसाधनों को प्राप्त करने की कोशिश करती है जो उसे चाहिए। वह कितनी सफलतापूर्वक सफल हुई, आप फ़ंक्शन को कॉल करके पता कर सकते हैं getState() getState() । अगर वह लौटती है STATE_INITIALIZED STATE_INITIALIZED , तो सब कुछ ठीक है, यदि STATE_UNINITIALIZED STATE_UNINITIALIZED अर्थ है कि त्रुटि हुई है।

त्रुटि के दो कारण हो सकते हैं: एक बफर जो बहुत छोटा है और एक अमान्य प्रारूप है। सबसे पहले getMinBufferSize() कॉल करके इससे बचा जा सकता है । दूसरा, वास्तव में, उसके द्वारा।

getMinBufferSize ()

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

लिस्टिंग प्रारूप

getMinBufferSize() पद्धति की एक अच्छी विशेषता है - इस उपकरण के लिए अमान्य हैं , जो इस उपकरण के लिए अमान्य हैं, ERROR_BAD_VALUE ERROR_BAD_VALUE या ERROR ERROR । इसका मतलब यह है कि सभी संभव संयोजनों के माध्यम से, आप यह पता लगा सकते हैं कि डिवाइस किस प्रारूप का समर्थन करता है।

उदाहरण के लिए, इस तरह:

 int[] rates = {8000, 11025, 22050,44100, 48000, 96000 }; int[] chans = {AudioFormat.CHANNEL_IN_MONO, AudioFormat.CHANNEL_IN_STEREO}; int[] encs = {AudioFormat.ENCODING_PCM_8BIT, AudioFormat.ENCODING_PCM_16BIT}; for(int enc : encs) { for(int ch : chans) { for(int rate : rates) { int t = AudioRecord.getMinBufferSize(rate, ch, enc); if((t != AudioRecord.ERROR) && (t != AudioRecord.ERROR_BAD_VALUE)) { //   } } } } 

डेटा रीडिंग

आंतरिक बफर से डेटा प्राप्त करने के लिए, विधि का उपयोग करें read() read() । यह तीन संस्करणों में मौजूद है:

• read(byte[] audioData, int offsetInBytes, int sizeInBytes)
• read(short[] audioData, int offsetInShorts, int sizeInShorts)
• read(ByteBuffer audioBuffer, int sizeInBytes)

उनके पैरामीटर:

audioData	सरणी जिसमें डेटा लिखा जाएगा
audioBuffer	बफर जिसमें डेटा लिखा जाएगा
ऑफसेटबाइट / offsetInShorts	जिस पर रिकॉर्डिंग शुरू हो जाएगी
sizeInShorts	अनुरोधित डेटा ब्लॉक का आकार। बाइट के लिए बाइट्स में बाइट और byte[] , शॉर्ट के लिए short[] पूर्णांक में short[]

यदि सब कुछ ठीक है, तो विधि पढ़ी गई बाइट्स की संख्या वापस कर देगी, अगर यह ByteBuffer या byte[] साथ एक प्रकार है, या short[] लिए short[] पूर्णांक पढ़ें। यदि कॉल के समय ऑब्जेक्ट को सही ढंग से प्रारंभ नहीं किया गया था, तो वह ERROR_INVALID_OPERATION लौटेगा , और यदि पैरामीटर में कुछ गड़बड़ है - ERROR_BAD_VALUE

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

दृष्टिकोण, पीछे हटना, निर्धारण

ताकि कार्यक्रम माइक्रोफोन से डेटा प्राप्त कर सके, आपको AndroidManifest, xml फ़ाइल में उपयुक्त रिज़ॉल्यूशन निर्दिष्ट करने की आवश्यकता है:

 <uses-permission android:name="android.permission.RECORD_AUDIO" /> 

रिकॉर्डिंग शुरू करने के लिए, आपको विधि को कॉल करने की आवश्यकता है startRecording() startRecording() , और खत्म करने के लिए - stop() stop() । आप जितनी बार चाहें उतनी बार रिकॉर्डिंग शुरू और बंद कर सकते हैं।

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

महत्वपूर्ण: ये तीन विधियां, जो पहले उल्लेखित हैं, के विपरीत, फेंक देंगे IllegalStateException IllegalStateException , यदि उन्हें एक असंगठित (अच्छी तरह से, शब्द ... :) वस्तु या गलत क्रम में कहा जाता है। इसलिए, उन्हें "सावधानीपूर्वक" संभाला जाना चाहिए, अर्थात try ब्लॉक के माध्यम से।

उदाहरण का उपयोग करें

नीचे दिया गया वर्ग वह सब कुछ करता है जो ऊपर उल्लिखित है। इसके अलावा, वह उसके साथ पंजीकृत भेजता है Handler प्राप्त डेटा के बारे में Handler संदेश। यह डेटा किसी अन्य थ्रेड में संसाधित किया जाएगा, इसलिए, उन डेटा को अधिलेखित नहीं करने के लिए जो अभी तक नए लोगों के साथ संसाधित नहीं हुए हैं, एक परिपत्र बफर का उपयोग किया जाता है।

कोड AudioFormatInfo वर्ग का उपयोग करता है। यह तीन क्षेत्रों के साथ एक POJO है जिसमें रिकॉर्डिंग प्रारूप का वर्णन किया गया है: sampleRateInHz , channelConfig और audioFormat ।

 package com.MyCompany; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import android.media.AudioFormat; import android.media.AudioRecord; import android.media.MediaRecorder; import android.os.Handler; import android.os.Process; //AudioFormatInfo - POJO   sampleRateInHz, channelConfig  audioFormat public class AudioReciever implements Runnable { private boolean mIsRunning; private List<Handler> handlers; private AudioFormatInfo format; private AudioRecord mRecord; private final int BUFF_COUNT = 32; public AudioReciever(AudioFormatInfo format) { this.format = format; handlers = new ArrayList<Handler>(); mIsRunning = true; mRecord = null; } public void addHandler(Handler handler) { handlers.add(handler); } public void stop() { mIsRunning = false; } @Override public void run() { //      Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_AUDIO); mIsRunning = true; int buffSize = AudioRecord.getMinBufferSize(format.getSampleRateInHz(), format.getChannelConfig(), format.getAudioFormat()); if(buffSize == AudioRecord.ERROR) { System.err.println("getMinBufferSize returned ERROR"); return; } if(buffSize == AudioRecord.ERROR_BAD_VALUE) { System.err.println("getMinBufferSize returned ERROR_BAD_VALUE"); return; } //    short,   16-bit if(format.getAudioFormat() != AudioFormat.ENCODING_PCM_16BIT) { System.err.println("unknown format"); return; } //   .    , //      short[][] buffers = new short[BUFF_COUNT][buffSize >> 1]; mRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, format.getSampleRateInHz(), format.getChannelConfig(), format.getAudioFormat(), buffSize * 10); if(mRecord.getState() != AudioRecord.STATE_INITIALIZED) { System.err.println("getState() != STATE_INITIALIZED"); return; } try { mRecord.startRecording(); } catch(IllegalStateException e) { e.printStackTrace(); return; } int count = 0; while(mIsRunning) { int samplesRead = mRecord.read(buffers[count], 0, buffers[count].length); if(samplesRead == AudioRecord.ERROR_INVALID_OPERATION) { System.err.println("read() returned ERROR_INVALID_OPERATION"); return; } if(samplesRead == AudioRecord.ERROR_BAD_VALUE) { System.err.println("read() returned ERROR_BAD_VALUE"); return; } //    sendMsg(buffers[count]); count = (count + 1) % BUFF_COUNT; } try { try { mRecord.stop(); } catch(IllegalStateException e) { e.printStackTrace(); return; } } finally { //   mRecord.release(); mRecord = null; } } private void sendMsg(short[] data) { for(Handler handler : handlers) { handler.sendMessage(handler.obtainMessage(MSG_DATA, data)); } } }