🐪 ✉️ 👨‍🌾 एक उदाहरण के रूप में OpenAL का उपयोग करते हुए Android NDK मूल बातें 🕊️ 🍜 ♒️

शुभ दिन, प्रिय Habrausers!

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

परिचय

यह पर्यावरण की स्थापना के बारे में बहुत कुछ लिखने के लायक नहीं है, यह मुझे लगता है। भले ही आप जिस वातावरण में विकास कर रहे हों (ग्रहण, इंटेलीज आईडिया, आदि), सेटअप काफी सरल है।

Android NDK ही ।
WIn के तहत निर्माण करने के लिए, आपको साइगविन की आवश्यकता है ।
प्लगइन्स, उसी ग्रहण के लिए: सीडीटी ।

स्वाभाविक रूप से, आपके पास पहले से ही ADT, JDK होना चाहिए।

हमें एनडीके की आवश्यकता क्यों है?

OpenGL ES के साथ काम करें। मुझे लगता है कि जो लोग एनडीके का इस्तेमाल करते हैं, वे इसका इस्तेमाल सिर्फ गेम लिखने के लिए करते हैं।
Cocos2Dx जैसे क्रॉस-प्लेटफॉर्म गेम इंजन का उपयोग करना
सबसे स्पष्ट मामला तब है जब आपको सी ++ में पहले से लिखे गए कोड का उपयोग करने की आवश्यकता होती है। दशकों से, C ++ में बहुत कुछ लिखा गया है। हां, और सब कुछ फिर से लिखा नहीं जा सकता है, मुझे लगता है कि वही ओपनसीवी फिर से लिखने के लिए संवेदनहीन होगा, जबकि आप बस तैयार स्रोतों को जोड़ सकते हैं।

जावा से C ++ कोड को कॉल करें

सामान्य तौर पर, सब कुछ काफी सरल है, मुख्य चरण:

C ++ के साथ फाइल बनाना और एक्सपोर्ट के तरीकों को परिभाषित करना।
.Mk फाइलें बनाना।
पुस्तकालय पीढ़ी।
जावा में लाइब्रेरी कनेक्ट करना।

Makefiles (.mk) के बारे में मैं पेंट नहीं करूंगा। आप उसके बारे में यहां पढ़ सकते हैं। इसके अलावा, एक हब पर BubaVV से .mk फ़ाइलों के साथ काम करने का एक अच्छा लेख है ।

आप यहाँ ndk से पुस्तकालयों के बारे में पढ़ सकते हैं।

C ++ फ़ाइलें बनाना

निर्यात के लिए तरीकों को परिभाषित करना आवश्यक है, जिसे हम जावा से कहेंगे। एक उदाहरण के रूप में, जब आवेदन शुरू होता है, तो हम ओपन में संगीत लोड करेंगे। ऐसा करने के लिए, हम एक विधि को परिभाषित करते हैं:

JNIEXPORT void JNICALL Java_ru_suvitruf_androidndk_tutorial4_MainActivity_loadAudio(JNIEnv *pEnv, jobject pThis, jobject pNativeCallListener, jobject assetManager);

मैं यह सब कलम के साथ लिखता हूं, लेकिन जेवह की स्वचालित पीढ़ी के लिए एक सुविधाजनक उपयोगिता है।

फिर हमें इसे लागू करने की आवश्यकता होगी, लेकिन उस पर और बाद में।

नाम के बारे में थोड़ा

यह तरीकों के नाम के बारे में थोड़ा कहने के लायक है। Java_ एक आवश्यक उपसर्ग है। ru_suvitruf_androidndk_tutorial4 , क्योंकि हमारे पास ru.suvitruf.androidndk.tutorial4 पैकेज है, और तब क्लास और मेथड का नाम जावा की तरफ होता है। प्रत्येक फ़ंक्शन में JNIEnv * एक तर्क के रूप में है - जावा के साथ काम करने के लिए एक इंटरफ़ेस, इसके साथ आप जावा विधियों को कॉल कर सकते हैं, जावा ऑब्जेक्ट बना सकते हैं। दूसरा आवश्यक पैरामीटर जॉबजेक्ट या jclass है , यह इस बात पर निर्भर करता है कि क्या विधि स्थिर है। यदि विधि स्थिर है, तो तर्क टाइप jclass (ऑब्जेक्ट के वर्ग का एक संदर्भ जिसमें विधि घोषित की गई है) का होगा, यदि स्थिर नहीं है - jobject - उस ऑब्जेक्ट का संदर्भ जिस पर विधि को बुलाया गया था।

जावा में लाइब्रेरी कनेक्शन

लाइब्रेरी बनाने के बाद, आपको इसे जावा से कनेक्ट करना होगा।

 static { System.loadLibrary("AndroidNDK"); }

और C ++ कोड के समान नाम वाली विधि को परिभाषित करें:

 //  native public void loadAudio(NativeCalls nativeCallListener, AssetManager mng);

इस तरह कॉल करें:

 loadAudio(activity, activity.getResources().getAssets());

C ++ से जावा कॉल

थोड़ा और जटिल, लेकिन इतना डरावना नहीं। हमें क्या चाहिए:

क्लास विधि (जावा में) को परिभाषित करें जिसे हम कॉल करना चाहते हैं।
वांछित वर्ग (सी ++ में) का विवरण प्राप्त करें।
विधि हस्ताक्षर का वर्णन करें।
विधि पहचानकर्ता (लिंक) प्राप्त करें।
इच्छित वस्तु पर विधि को बुलाओ।

बेशक, आप बस कक्षा की विधि को परिभाषित कर सकते हैं, लेकिन इंटरफेस का उपयोग करना बेहतर है। यदि हमें दूसरी कक्षा के साथ काम करना है तो हमें मूल कोड नहीं बदलना होगा।

एक उदाहरण के रूप में, केवल एक विधि के साथ एक इंटरफ़ेस बनाएँ:

 public interface NativeCalls { public void sendLog(String result); }

CalledFromWrongThreadException और उचित इंटरफ़ेस कार्यान्वयन

अरे ये बहता है। समस्या यह है कि आप किसी अन्य स्ट्रीम से दृश्य को प्रभावित नहीं कर सकते। इसलिए, इंटरफ़ेस का संपूर्ण कार्यान्वयन कुछ इस तरह होगा:

 protected Handler handler = new Handler() { @Override public void handleMessage(Message msg) { showResult(msg.getData().getString("result")); } }; public void showResult(String result){ ((TextView) findViewById(R.id.log)). setText(((TextView) findViewById(R.id.log)).getText()+result+"\n"); } //    @Override public void sendLog(String result){ Message msg = new Message(); Bundle data = new Bundle(); data.putString("result", result); msg.setData(data); handler.sendMessage(msg); }

थ्रेड्स के साथ समस्याएं नहीं हो सकती हैं, लेकिन हमारे मामले में, आवेदन शुरू करते समय, हम लोडिंग संसाधनों के लिए एक अलग थ्रेड बनाएंगे, इसलिए प्रश्न हमारे लिए प्रासंगिक है।

निम्न वर्ग मूल C ++ कोड में जावा इंटरफ़ेस के अनुरूप होगा:

NativeCallListener

 class NativeCallListener { public: NativeCallListener(JNIEnv* pJniEnv, jobject pWrapperInstance); NativeCallListener() {} //  //   Java  void sendLog(jobject log); //   void destroy(); ~NativeCallListener(){ } void loadAudio(); //void play(); //void playOGG(); ALCdevice* device; ALCcontext* context; private: JNIEnv* getJniEnv(); //   jmethodID sendLogID; //   jobject mObjectRef; JavaVM* mJVM; ALuint soundWAV; ALuint soundOGG; void load(); void clean(); };

अब आप लोडएडियो विधि के कार्यान्वयन को दिखा सकते हैं, जिसका शीर्षक लेख के पहले भाग में था।

 JNIEXPORT void JNICALL Java_ru_suvitruf_androidndk_tutorial4_MainActivity_loadAudio(JNIEnv *pEnv, jobject pThis, jobject pNativeCallListener, jobject assetManager) { listener = NativeCallListener(pEnv, pNativeCallListener); mgr = AAssetManager_fromJava(pEnv, assetManager); listener.loadAudio(); }

क्लास कंस्ट्रक्टर में, हम क्लास डिस्क्रिप्टर को सेव करते हैं और इसकी विधि का संदर्भ प्राप्त करते हैं:

 NativeCallListener::NativeCallListener(JNIEnv* pJniEnv, jobject pWrappedInstance) { pJniEnv->GetJavaVM(&mJVM); mObjectRef = pJniEnv->NewGlobalRef(pWrappedInstance); jclass cl = pJniEnv->GetObjectClass(pWrappedInstance); // ,       Java sendLogID = pJniEnv->GetMethodID(cl, "sendLog", "(Ljava/lang/String;)V"); }

अब हम जावा विधि को लिखकर कॉल कर सकते हैं:

 void NativeCallListener::sendLog(jobject log) { JNIEnv* jniEnv = getJniEnv(); jniEnv->CallIntMethod(mObjectRef, sendLogID, log); }

AAssetManager

पहले, ओपन सोर्स लिबजीप लाइब्रेरी का उपयोग एप्लिकेशन संसाधनों के साथ काम करने के लिए किया जाता था।
एपीआई के संस्करण 2.3 के साथ, एंड्रॉइड एनडीके के पास सी ++ कोड से सीधे संपत्ति निर्देशिका के साथ काम करने के लिए एक महान वर्ग है।
तरीके stdio.h से फ़ाइलों के साथ काम करने के तरीकों के समान हैं। AAssetManager_open बजाय fopen, AAsset_read बजाय fread, AAsset_close बजाय fclose।

मैंने उसके लिए एक छोटा रैपर लिखा। मैं यहां कोड नहीं डालूंगा, क्योंकि सामान्य रूप से काम सामान्य फ़ाइल के साथ ही होता है।

ओपन के साथ काम करें

लेख पहले से ही काफी बड़ा है, लेकिन मैंने सबसे दिलचस्प हिस्सा शुरू नहीं किया है। कृपया मुझे इसके लिए क्षमा करें ...

ट्रेनिंग

सबसे पहले आपको OpenAL बनाने की आवश्यकता है। यह WAV के साथ काम करने के लिए पर्याप्त है, लेकिन हम अभी भी OGG के साथ काम करना चाहते हैं। ओजीजी को एक ट्रेमर डिकोडर की जरूरत होती है।

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

Wav फ़ाइल पढ़ें

पहले आपको हेडर के लिए संरचना का वर्णन करना होगा:

BasicWAVEHeader

 typedef struct { char riff[4];//'RIFF' unsigned int riffSize; char wave[4];//'WAVE' char fmt[4];//'fmt ' unsigned int fmtSize; unsigned short format; unsigned short channels; unsigned int samplesPerSec; unsigned int bytesPerSec; unsigned short blockAlign; unsigned short bitsPerSample; char data[4];//'data' unsigned int dataSize; }BasicWAVEHeader;

अब हम पढ़ते हैं:

 void OALWav::load(AAssetManager *mgr, const char* filename){ this->filename = filename; this->data = 0; //  this->data = this->readWAVFull(mgr, &header); //  getFormat(); // OpenAL  createBufferFromWave(data); source = 0; alGenSources(1, &source); alSourcei(source, AL_BUFFER, buffer); }

readWAVFull

 char* OALWav::readWAVFull(AAssetManager *mgr, BasicWAVEHeader* header){ char* buffer = 0; AAssetFile f = AAssetFile(mgr, filename); if (f.null()) { LOGE("no file %s in readWAV",filename); return 0; } int res = f.read(header,sizeof(BasicWAVEHeader),1); if(res){ if (!( //    . //   ,    . //          =/ memcmp("RIFF",header->riff,4) || memcmp("WAVE",header->wave,4) || memcmp("fmt ",header->fmt,4) || memcmp("data",header->data,4) )){ buffer = (char*)malloc(header->dataSize); if (buffer){ if(f.read(buffer,header->dataSize,1)){ f.close(); return buffer; } free(buffer); } } } f.close(); return 0; }

WAV के बारे में कुछ कहा जाना है। कभी-कभी, पीसी पर फ़ाइल ठीक सुनाई देती है, लेकिन OpenAL के साथ काम करते समय त्रुटियां होती हैं। यह हेडर टूटे होने का एक परिणाम है। मैं बहुत से कन्वर्टर्स से मिला, जिन्होंने हेडर्स (उनके उदाहरण के रूप में लोगो) को किसी तरह की बकवास लिखी, आमतौर पर डेटासाइज़ में । तो यह काम क्यों नहीं करता है, लेकिन पीसी पर खेलता है?
डेटा डेटा को हेडर और उसके आकार के बाद स्वयं संग्रहीत किया जाता है । यदि इस क्षेत्र में कुछ गड़बड़ है, तो त्रुटियां होंगी। आप वास्तव में माथे में आकार की गणना कर सकते हैं। डेटा का आकार = फ़ाइल का आकार - हेडर का आकार । इसलिए, मुझे लगता है, खिलाड़ी डेटा का आकार घटाकर ले जाते हैं, हेडर से नहीं।

WAV के साथ काम करने पर, सब कुछ सरल प्रतीत होता है, क्योंकि प्रारूप संकुचित नहीं है। जब काम करते हैं। तो, चीजें अधिक जटिल होती हैं।

Ogg फ़ाइल पढ़ें

WAV की तुलना में Ogg की क्या विशेषता है? यह एक संकुचित प्रारूप है। इसलिए, वहाँ से पहले, कैसे ओप्पल बफर को डेटा लिखना है, हमें डेटा को डीकोड करने की आवश्यकता है।
पकड़ यह है कि डिफ़ॉल्ट Vorbis FILE से स्ट्रीम करता है, इसलिए हमें डेटा के साथ काम करने के लिए सभी कॉलबैक विधियों को ओवरराइड करने की आवश्यकता है:

कॉलबैक

 static size_t read_func(void* ptr, size_t size, size_t nmemb, void* datasource) { unsigned int uiBytes = Min(suiSize - suiCurrPos, (unsigned int)nmemb * (unsigned int)size); memcpy(ptr, (unsigned char*)datasource + suiCurrPos, uiBytes); suiCurrPos += uiBytes; return uiBytes; } static int seek_func(void* datasource, ogg_int64_t offset, int whence) { if (whence == SEEK_SET) suiCurrPos = (unsigned int)offset; else if (whence == SEEK_CUR) suiCurrPos = suiCurrPos + (unsigned int)offset; else if (whence == SEEK_END) suiCurrPos = suiSize; return 0; } static int close_func(void* datasource) { return 0; } static long tell_func(void* datasource) { return (long)suiCurrPos; }

अब आपको पढ़ने की आवश्यकता है:

पढ़ना Ogg

 void OALOgg::getInfo(unsigned int uiOggSize, char* pvOggBuffer){ //   ov_callbacks callbacks; callbacks.read_func = &read_func; callbacks.seek_func = &seek_func; callbacks.close_func = &close_func; callbacks.tell_func = &tell_func; suiCurrPos = 0; suiSize = uiOggSize; int iRet = ov_open_callbacks(pvOggBuffer, &vf, NULL, 0, callbacks); //  vi = ov_info(&vf, -1); uiPCMSamples = (unsigned int)ov_pcm_total(&vf, -1); } void * OALOgg::ConvertOggToPCM(unsigned int uiOggSize, char* pvOggBuffer) { if(suiSize == 0){ getInfo( uiOggSize, pvOggBuffer); current_section = 0; iRead = 0; uiCurrPos = 0; } void* pvPCMBuffer = malloc(uiPCMSamples * vi->channels * sizeof(short)); //  do { iRead = ov_read(&vf, (char*)pvPCMBuffer + uiCurrPos, 4096, ¤t_section); uiCurrPos += (unsigned int)iRead; } while (iRead != 0); return pvPCMBuffer; } void OALOgg::load(AAssetManager *mgr, const char* filename){ this->filename = filename; char* buf = 0; AAssetFile f = AAssetFile(mgr, filename); if (f.null()) { LOGE("no file %s in readOgg",filename); return ; } buf = 0; buf = (char*)malloc(f.size()); if (buf){ if(f.read(buf,f.size(),1)){ } else { free(buf); f.close(); return; } } char * data = (char *)ConvertOggToPCM(f.size(),buf); f.close(); if (vi->channels == 1) format = AL_FORMAT_MONO16; else format = AL_FORMAT_STEREO16; alGenBuffers(1,&buffer); alBufferData(buffer,format,data,uiPCMSamples * vi->channels * sizeof(short),vi->rate); source = 0; alGenSources(1, &source); alSourcei(source, AL_BUFFER, buffer); }

जब हम एप्लिकेशन लोड करते हैं, तो हम C ++ विधि loadAudio कहते हैं, जो NativeCallListener पर लोड को कॉल करता है, जो ध्वनियों को लोड करता है:

 void NativeCallListener:: load(){ oalContext = new OALContext(); //sound = new OALOgg(); sound = new OALWav(); char * fileName = new char[64]; strcpy(fileName, "audio/industrial_suspense1.wav"); //strcpy(fileName, "audio/Katatonia - Deadhouse_(piano version).ogg"); sound->load(mgr,fileName); }

sound मैं टाइप OALSound । डब्ल्यूएवी और ओग के साथ काम करने के लिए, मेरे पास कक्षाएं हैं जो इसे विरासत में मिली हैं। हमें केवल बेस क्लास पद्धति virtual void load(AAssetManager *mgr, const char* filename)= 0; ओवरराइड करने के लिए एक लोड कार्यान्वयन लिखना होगा virtual void load(AAssetManager *mgr, const char* filename)= 0;
यह आपको ध्वनियों के साथ काम को एकजुट करने की अनुमति देता है।

निष्कर्ष

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

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

स्रोत कोड

परियोजना ग्रहण में लिखी गई है। सूत्रों को जीथब पर देखा जा सकता है।

पुनश्च मैं आलोचना और सलाह के लिए तत्पर हूं
पीपीएस यदि आपको पाठ में व्याकरण संबंधी त्रुटियां मिलती हैं, तो दोपहर में लिखना बेहतर है।

एक उदाहरण के रूप में OpenAL का उपयोग करते हुए Android NDK मूल बातें