🧙🏽 🚝 #⃣ Android NDK: ओपनएसएल ES 🥟 🚱 🚵🏾

हैलो, प्रिय harazhiteli!
हाल ही में, एक हब को पढ़ने के दौरान, मैंने Android NDK और OpenAL के बारे में एक लेख देखा। और टिप्पणियों में, OpenSL ES के बारे में एक सवाल पूछा गया था। तब मुझे इस पुस्तकालय के बारे में एक लेख लिखने का विचार आया। जब मैं NDK के तहत C ++ में लिखे गए Android गेम में ध्वनियों और संगीत को जोड़ना चाहता था, तो मैंने इस विषय से निपटा दिया। लेख पूरा होने का दावा नहीं करता है, केवल मूल बातें होंगी।

सामग्री:

OpenSL ES संरचनाओं का संक्षिप्त विवरण
पुस्तकालय तंत्र की शुरुआत करना और वक्ताओं के साथ काम करने के लिए एक वस्तु बनाना
पीसीएम प्ले (wav)
एमपी 3 प्ले, ओजीजी
निष्कर्ष

1. संरचनाओं का संक्षिप्त विवरण

ओपनएसएल ईएस के साथ काम सी भाषा के छद्म-वस्तु-उन्मुख संरचनाओं पर आधारित है। उनका उपयोग तब किया जाता है जब परियोजना सी में लिखी जाती है, लेकिन मैं एक वस्तु-उन्मुख दृष्टिकोण चाहता हूं। सामान्य तौर पर, छद्म-वस्तु-उन्मुख संरचनाएं सामान्य सी भाषा संरचनाएं होती हैं, जिनमें फ़ंक्शन के लिए संकेत होते हैं जो संरचना को पहले तर्क के रूप में प्राप्त करते हैं, जैसे कि C ++ में, लेकिन स्पष्ट रूप से।
OpenSL ES में ऊपर वर्णित दो संरचनाएं हैं:

ऑब्जेक्ट (SLObjectItf) इन संसाधनों के बारे में जानकारी की एक विशिष्ट श्रेणी को कार्य करने और जानकारी संग्रहीत करने के लिए डिज़ाइन किए गए संसाधनों का एक समूह है। ऑब्जेक्ट बनाते समय, इसका प्रकार निर्धारित किया जाता है, जो उन कार्यों की सीमा निर्धारित करता है जिनकी मदद से हल किया जा सकता है। एक वस्तु जावा भाषा की एक वस्तु के समान है, इसे C ++ में एक कक्षा की तरह माना जा सकता है
इंटरफ़ेस (SLEngineItf, SLPlayItf, SLSeekItf, आदि) एक विशेष वस्तु द्वारा प्रदान की गई अंतर्संबंधित कार्यात्मकताओं के एक सेट का एक अमूर्तन है। इंटरफ़ेस में किसी ऑब्जेक्ट पर कार्रवाई करने के लिए उपयोग किए जाने वाले कई तरीके शामिल हैं। एक इंटरफ़ेस उस इंटरफ़ेस द्वारा समर्थित विधियों की सटीक सूची को परिभाषित करने वाले एक प्रकार का है। एक इंटरफ़ेस को उसके पहचानकर्ता द्वारा परिभाषित किया जाता है, जिसका उपयोग कोड में इंटरफ़ेस के प्रकार को संदर्भित करने के लिए किया जा सकता है।

सीधे शब्दों में कहें, तो संसाधनों को आवंटित करने और इंटरफेस प्राप्त करने के लिए वस्तुओं की आवश्यकता होती है, और इंटरफेस वस्तुओं की क्षमताओं तक पहुंच प्रदान करते हैं। किसी एकल ऑब्जेक्ट में कई इंटरफ़ेस हो सकते हैं। डिवाइस के आधार पर, कुछ इंटरफेस उपलब्ध नहीं हो सकते हैं। हालाँकि, मैं इस पार नहीं आया हूँ।

2. पुस्तकालय तंत्र की शुरुआत करना और वक्ताओं के साथ काम करने के लिए एक वस्तु बनाना

OpenSL ES को एंड्रॉइड NDK से कनेक्ट करने के लिए, LOpenSLES ध्वज को Android.mk फ़ाइल के LOCAL_LDLIBS अनुभाग में जोड़ें:

LOCAL_LDLIBS := /*...*/ -lOpenSLES

हैडर फ़ाइलें प्रयुक्त:

 #include <SLES/OpenSLES.h> #include <SLES/OpenSLES_Android.h>

OpenSL ES के साथ आरंभ करने के लिए, आपको OpenSL ES इंजन ऑब्जेक्ट (SLObjectItf) को slCreateEngine पर कॉल करके आरंभ करना होगा, यह दर्शाता है कि SL_IID_ENGINE इंटरफ़ेस का उपयोग इसके साथ काम करने के लिए किया जाएगा। अन्य वस्तुओं को बनाने में सक्षम होने के लिए यह आवश्यक है। इस तरह के कॉल के माध्यम से प्राप्त एक वस्तु ओपनएसएल ईएस एपीआई तक पहुंचने के लिए केंद्रीय वस्तु बन जाती है। इसके बाद, ऑब्जेक्ट को Realize pseudo-method का उपयोग करके लागू किया जाना चाहिए, जो C ++ में कंस्ट्रक्टर का एक एनालॉग है। Realize का पहला पैरामीटर ऑब्जेक्ट के कार्यान्वित होने (इस का एनालॉग) को इंगित करता है, और दूसरा async फ्लैग है, जो इंगित करता है कि ऑब्जेक्ट एसिंक्रोनस होगा या नहीं।
वर्तमान एंड्रॉइड NDK कार्यान्वयन केवल एक लाइब्रेरी इंजन और 32 ऑब्जेक्ट तक सामान्य रूप से बनाना संभव बनाता है। हालाँकि, ऑब्जेक्ट बनाने के लिए कोई भी ऑपरेशन विफल हो सकता है (उदाहरण के लिए, सिस्टम संसाधनों की कमी के कारण)।

लाइब्रेरी इंजन की शुरुआत

 SLObjectItf engineObj; const SLInterfaceID pIDs[1] = {SL_IID_ENGINE}; const SLboolean pIDsRequired[1] = {SL_TRUE}; SLresult result = slCreateEngine( &engineObj, /*   */ 0, /*     */ NULL, /*  , NULL,     */ 1, /* ,      */ pIDs, /* ID */ pIDsRequired /* , ,    .   SL_TRUE,    ,   ,    SL_RESULT_FEATURE_UNSUPPORTED*/ ); /* .   slCreateEngine   –   */ if(result != SL_RESULT_SUCCESS){ LOGE("Error after slCreateEngine"); return; } /* .      this*/ result = (*engineObj)->Realize(engineObj, SL_BOOLEAN_FALSE); //     /*      ,    */ if(result != SL_RESULT_SUCCESS){ LOGE("Error after Realize engineObj"); return; }

अगला, आपको SL_IID_ENGINE इंटरफ़ेस प्राप्त करने की आवश्यकता है, जिसके साथ हम वक्ताओं, संगीत, ध्वनियों आदि तक पहुंच पाएंगे।

इंटरफ़ेस SL_IID_ENGINE प्राप्त करना

 SLEngineItf engine; result = (*engineObj)->GetInterface( engineObj, /*this*/ SL_IID_ENGINE, /*ID */ &engine /*  */ );

आइए हम वस्तुओं के साथ काम करने की सामान्य योजना पर थोड़ा ध्यान दें:

इच्छित इंटरफेस निर्दिष्ट करके एक वस्तु प्राप्त करें
इसे कॉल करके लागू करें (*obj)->Realize(obj, async);
कॉल करके आवश्यक इंटरफेस प्राप्त करें (*obj)-> GetInterface (obj, ID, &itf);
इंटरफेस के साथ काम करें
किसी वस्तु को कॉल करके हटाएं (*obj)->Destroy(obj);

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

वक्ताओं के साथ काम करने के लिए एक वस्तु बनाना

 SLObjectItf outputMixObj; const SLInterfaceID pOutputMixIDs[] = {}; const SLboolean pOutputMixRequired[] = {}; /* slCreateEngine()*/ result = (*engine)->CreateOutputMix(engine, &outputMixObj, 0, pOutputMixIDs, pOutputMixRequired); result = (*outputMixObj)->Realize(outputMixObj, SL_BOOLEAN_FALSE);

SLOutputMixItf एक ध्वनि आउटपुट डिवाइस (स्पीकर, हेडफ़ोन) का प्रतिनिधित्व करने वाली एक वस्तु है। ओपनएसएल ईएस विनिर्देश उपलब्ध आई / ओ उपकरणों की एक सूची प्राप्त करने की क्षमता प्रदान करता है, लेकिन एंड्रॉइड एनडीके कार्यान्वयन पर्याप्त रूप से पूरा नहीं होता है और या तो डिवाइसों की सूची प्राप्त करने का समर्थन नहीं करता है या जिसे आप चाहते हैं उसे चुनें (आधिकारिक तौर पर SLAudioIODeviceCapetItf इसके लिए इरादा है)।

3. PCM खेलना (wav)

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

पीसीएम बफर के साथ काम करना

 struct WAVHeader{ char RIFF[4]; unsigned long ChunkSize; char WAVE[4]; char fmt[4]; unsigned long Subchunk1Size; unsigned short AudioFormat; unsigned short NumOfChan; unsigned long SamplesPerSec; unsigned long bytesPerSec; unsigned short blockAlign; unsigned short bitsPerSample; char Subchunk2ID[4]; unsigned long Subchunk2Size; }; struct SoundBuffer{ WAVHeader* header; char* buffer; int length; }; /*   PCM    AAssetManager:*/ SoundBuffer* loadSoundFile(const char* filename){ SoundBuffer* result = new SoundBuffer(); AAsset* asset = AAssetManager_open(assetManager, filename, AASSET_MODE_UNKNOWN); off_t length = AAsset_getLength(asset); result->length = length - sizeof(WAVHeader); result->header = new WAVHeader(); result->buffer = new char[result->length]; AAsset_read(asset, result->header, sizeof(WAVHeader)); AAsset_read(asset, result->buffer, result->length); AAsset_close(asset); return result; }

अब एक क्विक बफर ऑडियो आउटपुट सेट करते हैं। इसके लिए हम विशेष एक्सटेंशन SLDataLocator_AndroidSimpleBufferQueue का उपयोग करते हैं। इसके अलावा, संगीत बजाने के लिए, आपको दो संरचनाओं को भरने की आवश्यकता है: SLDataSource और SLDataSink, जो क्रमशः ऑडियो चैनल के इनपुट और आउटपुट का वर्णन करते हैं।

बफर ऑडियो आउटपुट सेटिंग्स

 /*,     CreateAudioPlayer()     */ SLDataLocator_AndroidSimpleBufferQueue locatorBufferQueue = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 1}; /*   */ /*,      wav*/ SLDataFormat_PCM formatPCM = { SL_DATAFORMAT_PCM, 1, SL_SAMPLINGRATE_44_1, SL_PCMSAMPLEFORMAT_FIXED_16, SL_PCMSAMPLEFORMAT_FIXED_16, SL_SPEAKER_FRONT_CENTER, SL_BYTEORDER_LITTLEENDIAN }; SLDataSource audioSrc = {&locatorBufferQueue, &formatPCM}; SLDataLocator_OutputMix locatorOutMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObj}; SLDataSink audioSnk = {&locatorOutMix, NULL}; const SLInterfaceID pIDs[1] = {SL_IID_BUFFERQUEUE}; const SLboolean pIDsRequired[1] = {SL_BOOLEAN_TRUE }; /* */ result = (*engine)->CreateAudioPlayer(engine, &playerObj, &audioSrc, &audioSnk, 1, pIDs, pIDsRequired); result = (*playerObj)->Realize(playerObj, SL_BOOLEAN_FALSE);

Android NDK में OpenSL ES का कार्यान्वयन सख्त नहीं है। यदि कुछ इंटरफेस निर्दिष्ट नहीं हैं, तो इसका मतलब यह नहीं है कि उन्हें प्राप्त नहीं किया जा सकता है। लेकिन ऐसा न करना बेहतर है । अपने ऊपर SL_IID_PLAY इंटरफ़ेस इंगित करें।

 SLPlayItf player; result = (*playerObj)->GetInterface(playerObj, SL_IID_PLAY, &player); SLBufferQueueItf bufferQueue; result = (*playerObj)->GetInterface(playerObj, SL_IID_BUFFERQUEUE, &bufferQueue); result = (*player)->SetPlayState(player, SL_PLAYSTATE_PLAYING);

SL_IID_PLAY और SL_IID_BUFFERQUEUE के अलावा, आप अन्य इंटरफ़ेस के लिए अनुरोध कर सकते हैं, उदाहरण के लिए:

वॉल्यूम नियंत्रण के लिए SL_IID_VOLUME
चैनल प्रबंधन के लिए SL_IID_MUTESOLO (केवल मल्टी-चैनल ऑडियो के लिए, यह SLDataFormat_PCM संरचना के अंक क्षेत्र में इंगित किया गया है)।
सुपरइम्पोज़िंग प्रभावों के लिए SL_IID_EFFECTSEND (विनिर्देश के अनुसार - केवल reverb प्रभाव)

आदि
(*player)->SetPlayState(player, SL_PLAYSTATE_PLAYING); हम नए बनाए गए खिलाड़ी को चालू करते हैं। जबकि कतार खाली है, इसलिए केवल मौन ही सुनाई देता है। चलो कतार में कुछ आवाज लगाते हैं।

कतार में ध्वनि जोड़ें

 SoundBuffer* sound = loadSoundFile("mySound.wav"); (*soundsBufferQueue)->Clear(bufferQueue); /*   ,   - .  ,  ,     */ (*soundsBufferQueue)->Enqueue(bufferQueue, sound->buffer, sound->length); /*     SoundBuffer,     */

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

4. एमपी प्ले, ओजीजी

उपरोक्त योजना लंबी संगीत फ़ाइलों को चलाने के लिए उपयुक्त नहीं है। सबसे पहले, इस तथ्य के कारण कि एक लंबी wav फ़ाइल बहुत, बहुत अधिक वजन करेगी। एमपी 3 या ओजीजी का उपयोग करना बेहतर है। OpenSL ES बॉक्स से बाहर स्ट्रीमिंग फ़ाइलों का समर्थन करता है। बफ़र्ड आउटपुट से अंतर यह भी है कि प्रत्येक संगीत फ़ाइल के लिए एक अलग प्लेयर ऑब्जेक्ट बनाया जाना चाहिए। इस खिलाड़ी के लिए प्लेबैक के दौरान फ़ाइल को बदलना संभव नहीं है।
संगीत चलाने के लिए तैयार:

फ़ाइल डिक्रिप्टर्स के साथ काम करें

 struct ResourseDescriptor{ int32_t decriptor; off_t start; off_t length; }; /*  AAssetManager*/ ResourseDescriptor loadResourceDescriptor(const char* path){ AAsset* asset = AAssetManager_open(assetManager, path, AASSET_MODE_UNKNOWN); ResourseDescriptor resourceDescriptor; resourceDescriptor.decriptor = AAsset_openFileDescriptor(asset, &resourceDescriptor.start, &resourceDescriptor.length); AAsset_close(asset); return resourceDescriptor; }

अगला, फिर से SLDataSource और SLDataSink भरें। और एक ऑडियो प्लेयर बनाएं।

खिलाड़ी निर्माण

 ResourseDescriptor resourceDescriptor = loadResourceDescriptor("myMusic.mp3"); SLDataLocator_AndroidFD locatorIn = { SL_DATALOCATOR_ANDROIDFD, resourseDescriptor.decriptor, resourseDescriptor.start, resourseDescriptor.length } SLDataFormat_MIME dataFormat = { SL_DATAFORMAT_MIME, NULL, SL_CONTAINERTYPE_UNSPECIFIED }; SLDataSource audioSrc = {&locatorIn, &dataFormat}; SLDataLocator_OutputMix dataLocatorOut = { SL_DATALOCATOR_OUTPUTMIX, outputMixObj }; SLDataSink audioSnk = {&dataLocatorOut, NULL}; const SLInterfaceID pIDs[2] = {SL_IID_PLAY, SL_IID_SEEK}; const SLboolean pIDsRequired[2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE}; SLObjectItf playerObj; SLresult result = (*engine)->CreateAudioPlayer(engine, &playerObj, &audioSrc, &audioSnk, 2, pIDs, pIDsRequired); result = (*playerObj)->Realize(playerObj, SL_BOOLEAN_FALSE);

स्रोत डेटा का वर्णन करने के लिए, हम MIME प्रकार का उपयोग करते हैं, यह फ़ाइल प्रकार का स्वत: पता लगाता है।
आगे हमें इंटरफेस SL_IID_PLAY और SL_IID_SEEK मिलते हैं। फ़ाइल और लूप में प्लेबैक की स्थिति को बदलने के लिए उत्तरार्द्ध की आवश्यकता होती है। इसका उपयोग प्लेबैक स्थिति और गति की परवाह किए बिना किया जा सकता है।

इंटरफेसेस प्राप्त करना

 SLPlayItf player; result = (*playerObj)->GetInterface(playerObj, SL_IID_PLAY, &player); SLSeekItf seek; result = (*playerObj)->GetInterface(playerObj, SL_IID_SEEK, &seek); (*seek)->SetLoop( seek, SL_BOOLEAN_TRUE, /* */ 0, /*   (0 )*/ SL_TIME_UNKNOWN /*  */ ); (*player)->SetPlayState(player, SL_PLAYSTATE_PLAYING);

सिद्धांत रूप में, एक खेल में पृष्ठभूमि संगीत स्थापित करने के लिए लूपिंग तंत्र सुविधाजनक होना चाहिए। व्यवहार में, रचना के अंत और इसकी शुरुआत (सुनने का समय, विभिन्न उपकरणों पर तैरने के बीच) के बीच 0.5-1.0 सेकंड का अंतराल। मैंने पार्श्व संगीत में मध्य और अंत में कुछ चिकनी लुप्त होती बनाकर इसे पछाड़ दिया। इस प्रकार अंतर अदृश्य है।
विनिर्देश के अनुसार, विभिन्न कॉलबैक SLPlayItf इंटरफ़ेस पर लटकाए जा सकते हैं। Android में, NDK सुविधा समर्थित नहीं है (विधि SL_RESULT_SUCCESS देता है, लेकिन कॉलबैक काम नहीं करता है)।
खिलाड़ी को रोकने या रोकने के लिए, आप क्रमशः SL_PLAYSTATE_STOPPED या SL_PLAYSTATE_PAUSED मानों के साथ SLPlayItf इंटरफ़ेस की SetPlayState पद्धति का उपयोग कर सकते हैं। GetPlayState विधि खिलाड़ी की स्थिति का पता लगाने के लिए समान मान लौटाती है।

5. निष्कर्ष

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

साहित्य

सिल्वेन रेटाबॉइल। Android NDK। Android के लिए C / C ++ में एप्लिकेशन डेवलपमेंट।
द क्रोनोस ग्रुप इंक। OpenSL ES विशिष्टता ।

मानक Android NDK (NativeAudio प्रोजेक्ट) में अच्छे और अधिक पूर्ण कोड उदाहरण देखे जा सकते हैं।
विशेष रूप से एंड्रॉइड एनडीके का उपयोग करने की आवश्यकता के बारे में प्रश्नों की व्याख्या करना और विशेष रूप से ओपनएसएल ईएस, मैं तुरंत जवाब दूंगा। एंड्रॉइड एनडीके को प्रसिद्ध गेम डेवलपमेंट कंपनी (हब पर प्रतियोगिता थे) से परीक्षण कार्य की स्थिति की आवश्यकता थी। बाद में यह मेरे लिए एक चुनौती बन गया: क्या मैं काम को खूबसूरती से पूरा कर सकता हूं। धुंध। ओपनएसएल ईएस ने कब से चुना मुझे उसके साथ या ओपनल के साथ काम करने का कोई अनुभव नहीं था, और इसके लिए मैंने जावा में एक बदसूरत समाधान में ड्राइंग कॉल पर विचार किया।

Android NDK: ओपनएसएल ES