एंड्रॉयड। सतह

त्याग

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

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

विभिन्न एपीआई के साथ उदाहरण उपयोग

आइए निम्नलिखित उदाहरण लिखने की कोशिश करें: हम कैमरे से एक पूर्वावलोकन लेंगे, उस पर एक एनिमेटेड ड्रॉबल ओवरले करेंगे, इसे स्क्रीन पर सभी प्रदर्शित करेंगे और यदि आवश्यक हो, तो इसे एक फ़ाइल पर लिखें। पूरा कोड https://github.com/tttzof351/AndroidSurfaceExample/ होगा

प्रदर्शन के लिए, हम मीडियाकोड और ईजीएलएसयूआरएसफेस कक्षाओं के साथ रिकॉर्डिंग के लिए GLSurfaceView का उपयोग करेंगे, और एपीआई V2 के माध्यम से कैमरे के साथ संवाद करेंगे। सामान्य योजना लगभग इस प्रकार है:

मल्टीपल सरफेस ओवरले

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

कई सर्फेस से ओवरले बनाने के लिए हम ओपनजीएल का उपयोग करेंगे।
ऐसा करने के लिए, हम दो वर्ग बाहरी बनावट बनाएंगे और उनसे प्राप्त करेंगे

कोड में, यह कुछ इस तरह दिखेगा:

OpenGLExtarnalTexture.kt

val textures = IntArray(1) GLES20.glGenTextures(1, textures, 0) val textureId = textures[0] //    val textureWidth = ... val textureHeight = ... //  val surfaceTexture = SurfaceTexture(textureId) surfaceTexture.setDefaultBufferSize(textureWidth, textureHeight) //, surface  ""    val surface = Surface(surfaceTexture) 

XYZ निर्देशांक

अब हमें यह समझने की आवश्यकता है कि बनावट कैसे बनाएं और व्यवस्थित करें, और इसके लिए हमें यह याद रखना होगा कि ओपेनग्ल में समन्वित ग्रिड कैसे संरचित है: इसका केंद्र दृश्य (खिड़की) के केंद्र के साथ मेल खाता है, और सीमाएं सामान्यीकृत हैं, अर्थात् -1 से 1 तक।

इस दृश्य में, हम दो आयतें सेट करना चाहते हैं (काम विमान पर है, इसलिए सभी z निर्देशांक तार्किक रूप से 0f पर सेट हैं) - लाल रंग में हम एक को इंगित करेंगे जहां हम कैमरे के लिए पूर्वावलोकन करेंगे, और एनिमेटेड ड्रा करने योग्य के लिए नीले रंग में:

हम स्पष्ट रूप से अपने निर्देशांक लिखते हैं:

 fullscreenTexture = floatArrayOf( // X, Y, Z -1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, ) smallTexture = floatArrayOf( // X, Y, Z 0.3f, 0.3f, 0.0f, 0.8f, 0.3f, 0.0f, 0.3f, 0.8f, 0.0f, 0.8f, 0.8f, 0.0f ) 

यूवी निर्देशांक

क्या यह पर्याप्त है? यह पता चला है कि नहीं :(

एक बनावट एक दृश्य क्षेत्र की तस्वीर का मानचित्रण है और इसे सही ढंग से बनाने के लिए आपको यह निर्दिष्ट करने की आवश्यकता है कि चित्र के बिंदु इस क्षेत्र में कहां गिरेंगे - इसके लिए, ओपनजीएल यूवी निर्देशांक का उपयोग करता है - वे निचले बाएं कोने से बाहर निकलते हैं और प्रत्येक के लिए 0 से 1 तक की सीमाएँ होती हैं। कुल्हाड़ियों।

यह निम्नानुसार काम करता है - हम अपने क्षेत्र के प्रत्येक शीर्ष के लिए यूवी निर्देशांक सेट करेंगे और छवि में संबंधित बिंदुओं की तलाश करेंगे, यह मानते हुए कि चौड़ाई और ऊंचाई 1 के बराबर है।

एक उदाहरण पर विचार करें - हम मान लेंगे कि कैमरा हमें एक उल्टे और परिलक्षित स्थिति में छवि देता है, और साथ ही हम केवल सही-ऊपरी हिस्से को दिखाना चाहते हैं, अर्थात् छवि के अक्षांश और ऊंचाई में 0.8 लेते हैं।

सूक्ष्म बिंदु - इस स्तर पर हम स्क्रीन पर क्षेत्र के पहलू अनुपात को नहीं जानते हैं - हमारे पास केवल सापेक्ष निर्देशांक में एक वर्ग है, जो पूरे दृश्य को भर देगा और तदनुसार खिंचाव करेगा। यदि हम एक फुलस्क्रीन कैमरा बनाने के लिए थे, तो हमारे सापेक्ष आकार (प्रत्येक तरफ 2) पारंपरिक 1080x1920 तक फैल जाएंगे। हम मानते हैं कि हम दृश्य के आयामों को ऐसे सेट करते हैं कि उनका अनुपात कैमरे के अनुपात के बराबर होगा।
आइए देखें कि निर्देशांक कहां जाते हैं - हमारे क्षेत्र के ऊपरी दाएं बिंदु (1, 1, 0) को यूवी समन्वय (0, 0) पर जाना चाहिए, निचले बाएं हिस्से में (0.8f, 0.8f), आदि।

इस प्रकार, हम XYZ और यूवी के पत्राचार प्राप्त करते हैं:

 // X, Y, Z, U, V -1.0f, -1.0f, 0.0f, 0.8f, 0.8f, 1.0f, -1.0f, 0.0f, 0.8f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.8f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f 

यदि कैमरे से पूर्वावलोकन और स्क्रीन पर क्षेत्र के बीच पहलू अनुपात शुरू में मेल खाता है, तो यह स्पष्ट रूप से सहेजा जाना जारी रहेगा, क्योंकि हमारे मामले में हम सिर्फ 0.8f से गुणा करते हैं।
और हम क्या खाएंगे हम 1 से अधिक मूल्य निर्धारित करेंगे? हमने ओपनजीएल को जो सेटिंग्स पास की हैं, उसके आधार पर, हमें छवि के कुछ हिस्से के अंक मिलेंगे। हमारे उदाहरण में, अंतिम पंक्ति को इसी अक्ष पर दोहराया जाएगा और हम "धारियों" के रूप में कलाकृतियों को देखेंगे।

नीचे पंक्ति: यदि हम स्क्रीन पर क्षेत्र की स्थिति बनाए रखते हुए छवि को संपीड़ित / काट देना चाहते हैं, तो यूवी निर्देशांक हमारी पसंद हैं!

हमारे बनावट के लिए निर्देशांक सेट करें।

 fullscreenTexture = floatArrayOf( // X, Y, Z, U, V -1.0f, -1.0f, 0.0f, 1f, 0f, 1.0f, -1.0f, 0.0f, 0f, 0f, -1.0f, 1.0f, 0.0f, 1f, 1f, 1.0f, 1.0f, 0.0f, 0f, 1f ) smallTexture = floatArrayOf( // X, Y, Z, U, V 0.3f, 0.3f, 0.0f, 0f, 0f, 0.8f, 0.3f, 0.0f, 1f, 0f, 0.3f, 0.8f, 0.0f, 0f, 1f, 0.8f, 0.8f, 0.0f, 1f, 1f ) 

shaders

स्थिर XYZ और UV निर्देशांक होना बहुत सुविधाजनक नहीं है - उदाहरण के लिए, हम इशारों के साथ अपने बनावट को स्थानांतरित और स्केल करना चाह सकते हैं। उन्हें बदलने के लिए, हम क्रमशः प्रत्येक बनावट के लिए दो मैट्रिक्स बनाएंगे : एक्सवाईजेड और यूवी निर्देशांक के लिए एमवीपीमैट्रिक्स और टेक्समैट्रिक्स ।

प्रत्येक OpenGL2 में स्क्रीन पर कुछ प्रदर्शित करने के लिए शेड होने चाहिए। बेशक, यह एक विषय नहीं है जिसे एक पैराग्राफ में खुलासा किया जा सकता है, हालांकि, हमारे मामले में वे तुच्छ होंगे, और इसलिए आप जल्दी से समझ सकते हैं कि वे क्या कर रहे हैं, सामग्री के बारे में अधिक जानकारी के बिना।

सबसे पहले, दो शेड हैं - वर्टेक्स और टुकड़ा।

पहला (वर्टेक्स) हमारे सिरों को प्रोसेस करेगा, अर्थात्, हमारे एक्सवाईजेड / यूवी को उनके संबंधित मेट्रिसेस से गुणा करता है और ओपनजीएल वेरिएबल gl_Position में भरता है जो स्क्रीन पर हमारी बनावट की अंतिम स्थिति के लिए बिल्कुल जिम्मेदार है।

दूसरा (टुकड़ा) छवि पिक्सेल के साथ gl_FragColor भरना चाहिए।

हमारे पास कुल: वर्टिकल शेडर के अंदर के वैरिएबल हमें अपने डेटा के साथ खेतों में भरने चाहिए, अर्थात्:

• MVPMatrix -> uMVPMatrix
• टेक्समैट्रिक्स -> यूटेक्समैट्रिक्स
• हमारे XYZ शीर्ष निर्देशांक -> aPosition
• यूवी निर्देशांक -> aTextureCoord

vTextureCoord - वर्टेक्स शैडर से टुकड़े टुकड़े करने के लिए डेटा अग्रेषित करने की आवश्यकता है
खंड छायादार में, हम परिवर्तित यूवी निर्देशांक लेते हैं और उनका उपयोग बनावट क्षेत्र में छवि पिक्सेल प्रदर्शित करने के लिए करते हैं।

 val vertexShader = """ uniform mat4 uMVPMatrix; uniform mat4 uTexMatrix; attribute vec4 aPosition; attribute vec4 aTextureCoord; varying vec2 vTextureCoord; void main() { gl_Position = uMVPMatrix * aPosition; vTextureCoord = (uTexMatrix * aTextureCoord).xy; } """ val fragmentShader = """ #extension GL_OES_EGL_image_external : require precision mediump float; varying vec2 vTextureCoord; uniform samplerExternalOES sTexture; void main() { gl_FragColor = texture2D(sTexture, vTextureCoord); } """ 

संदर्भ के लिए, हम प्रकारों के बीच अंतर को इंगित करते हैं:

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

कैसे एक shader के मापदंडों को पारित करने के लिए? ऐसा करने के लिए, आपको पहले वेरिएबल की आईडी (पॉइंटर) प्राप्त करनी होगी:

 val aPositionHandle = GLES20.glGetAttribLocation(programId, "aPosition") 

अब इस आईडी के लिए आपको डेटा लोड करना होगा:

 //      floatbuffer val verticesBuffer = ByteBuffer.allocateDirect( fullscreenTexture.size * FLOAT_SIZE_BYTES ).order( ByteOrder.nativeOrder() ).asFloatBuffer() verticesBuffer.put(fullscreenTexture).position(0) /*    -  XYZ   0 .       id      ,     ,               - 5  - XYZUV,  4 - -   float */ verticesBuffer.position(0) GLES20.glVertexAttribPointer( aPositionHandle, 3, GLES20.GL_FLOAT, false, 5 * 4, verticesBuffer ) 

सीधी ड्राइंग

जब हमने सभी डेटा के साथ अपने शेड्स को भर दिया, तो हमें बनावट को छवि को अपडेट करने के लिए कहना चाहिए, और ओपनजीएल को अपना सिरा खींचने के लिए:

 fun updateFrame(...) { ... surfaceTexture.updateTexImage() GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4) } 

हमारे उदाहरण में, हम ओपनजीएल दृश्य के साथ दो वर्गों में काम को तोड़ देंगे - सीधे दृश्य और बनावट:

OpenGLExternalTexture.kt

 class OpenGLExternalTexture(verticesData: FloatArray, ...) { val surfaceTexture: SurfaceTexture val surface: Surface init { // ,    . } ... fun updateFrame(aPositionHandle: Int, ...) {...} // ,   fun release() {...} //   } 

OpenGLScene.kt

 class OpenGLScene( sceneWidth: Int, sceneHeight: Int, ... ) { val fullscreenTexture = OpenGLExternalTexture(...) val smallTexture = OpenGLExternalTexture(..) val aPositionHandle: Int ... init { // ,        . } fun updateFrame() { ... fullscreenTexture.updateFrame(aPositionHandle, ...) smallTexture.updateFrame(aPositionHandle, ...) } fun release() { fullscreenTexture.release() smallTexture.release() } } 

StateMachine / राज्य मशीन / राज्य मशीन

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

आइए एक सरल उदाहरण देखें कि यह कैसा दिखेगा, मान लीजिए हमारे पास यह कोड है:

 imageView.setOnClickListener { loadImage { bitmap -> imageView.setBitmap(bitmap) } } 

सामान्य तौर पर, सब कुछ ठीक है - सुंदर और कॉम्पैक्ट, लेकिन हम इसे निम्नलिखित तरीके से फिर से लिखने की कोशिश करेंगे:

 val uiMachine = UIMachine() imageView.setOnClickListener { uiMachine.send(Click(imageView)) } class UIMachine { var state: State = WaitClick() fun send(action: Action) = transition(action) private fun transition(action: Action) { val state = this.state when { state is WaitingClick && action is Click -> { this.state = WaitBitmap(imageView = action.imageView) loadImage { send(BitmapIsReady(bitmap = it)) } } state is WaitingBitmap && action is BitmapIsReady -> { this.state = WaitClick state.imageView.setImageBitmap(action.bitmap) } } } } sealed class State { object WaitingClick : State() class WaitingBitmap(val imageView: ImageView): State() } sealed class Action { class Click(val imageView: ImageView): Action() class BitmapIsReady(val bitmap: Bitmap): Action() } 

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

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

StateMachine के लिए आधार इंटरफेस बनाएँ:

 interface Action interface State interface StateMachine<S : State, A : Action> { var state: S fun transition(action: A) fun send(action: A) } 

GLSurfaceView

Android में OpenGL का उपयोग करके कुछ प्रदर्शित करने का सबसे आसान तरीका GLSurfaceView वर्ग है - यह स्वचालित रूप से ड्राइंग के लिए एक नई स्ट्रीम बनाता है, जो GLSurfaceView :: onResume / onPause विधियों का उपयोग करके प्रारंभ / रोक देता है।

सादगी के लिए, हम अपने विचार को 16: 9 के अनुपात में सेट करेंगे

रेंडरिंग प्रक्रिया ही एक अलग कॉलबैक - GLSurfaceView.Renderer में स्थानांतरित हो जाती है।
StateMachine में लपेटकर, हमें कुछ इस तरह मिलता है:

GLSurfaceMachine.kt

 class GLSurfaceMachine: StateMachine<GLSurfaceState, GLSurfaceAction> { override var state: GLSurfaceState = WaitCreate() override fun send(action: GLSurfaceAction) = transition(action) override fun transition(action: GLSurfaceAction) { val state = this.state when { state is WaitCreate && action is Create -> { this.state = WaitSurfaceReady(...) this.state.glSurfaceView?.setRenderer(object :Renderer { override fun onSurfaceChanged(gl: GL10?, width: Int, height: Int) send(SurfaceReady(width, height, gl)) } override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) { } override fun onDrawFrame(gl: GL10?) { send(Draw) } }) } state is WaitSurfaceReady && action is SurfaceReady -> { val openGLScene = OpenGLScene(width, height) this.state = DrawingAvailable(openGLScene, ...) } state is DrawingAvailable && action is Draw -> { state.openGLScene.updateFrame() } state !is WaitCreate && action is Stop -> { state.uiHolder.glSurfaceView?.onPause() state.uiHolder.openGLScene?.release() this.state = WaitSurfaceReady() } state is WaitSurfaceReady && action is Start -> { state.uiHolder.glSurfaceView?.onResume() } } } } ... val glSurfaceMachine = GLSurfaceMachine() val glSurfaceView = findViewById(R.id.gl_view) glSurfaceView.layoutParams.width = width glSurfaceView.layoutParams.height = ((16f/9f) * width).toInt() glSurfaceMachine.send(GLSurfaceAction.Create(glSurfaceView, ...)) 

आइए एक संक्रमण चित्र बनाते हैं:

अब हमारा कोड स्क्रीन पर कुछ प्रदर्शित करने की कोशिश कर रहा है, हालांकि अब यह खराब तरीके से करता है - हम काली स्क्रीन के अलावा कुछ भी नहीं देखेंगे। इस तथ्य का अनुमान लगाना मुश्किल नहीं है कि अब हमारे सरफेस में कुछ भी नहीं हो रहा है, क्योंकि हमने अभी तक छवि स्रोतों को लागू नहीं किया है। चलिए इसे ठीक करते हैं - सबसे पहले, एक CanrawDrawable बनाएं:

CanvasDrawable.kt

 class CanvasDrawable : Drawable() { private val backgroundPaint = Paint().apply { ... } private val circlePaint = Paint().apply { ... } override fun draw(canvas: Canvas) { canvas.drawRect(bounds, backgroundPaint) val width = bounds.width() val height = bounds.height() val posX = ... val posY = ... canvas.drawCircle(posX, posY, 0.1f * width, circlePaint) } ... } 

अब हम GLSurfaceMachine में कैनवास पर प्रतिपादन करके अनुभाग को पूरक कर सकते हैं कैनवास पर संगत है जो इसी बनावट की सतह प्रदान करता है:

 state is DrawingAvailable && action is Draw -> { val canvasDrawable = state.canvasDrawable val smallTexture = state.openGLScene.smallTexture val bounds = canvasDrawable.bounds val canvas = smallSurface.lockCanvas(bounds) canvasDrawable.draw(canvas) smallSurface.unlockCanvasAndPost(canvas) state.openGLScene.updateFrame() } 

जिसके बाद हमें कुछ इस तरह दिखाई देगा:

कैमरा एपीआई V2

हरे रंग की आयत निश्चित रूप से मजेदार और पेचीदा है, लेकिन कैमरे से शेष सतह पर पूर्वावलोकन लाने का प्रयास करने का समय है।

आइए कैमरे के साथ काम करने के चरणों को लिखें:

• हम अनुमति की प्रतीक्षा कर रहे हैं। हमारे पास यह राज्य वेटिंगस्टार्ट होगा
• हम कैमरा मैनेजर का उदाहरण प्राप्त करते हैं, हम तार्किक आईडी पाते हैं (आमतौर पर उनमें से दो हैं - पीछे और सामने के लिए, और तार्किक एक है क्योंकि कैमरा वांछित उपकरणों के आधुनिक उपकरणों पर कई सेंसर शामिल कर सकता है), उपयुक्त आकार का चयन करें, कैमरा खोलें, हमें कैमराडेविस मिलता है। स्थिति WaitingOpen

 val manager = getSystemService(Context.CAMERA_SERVICE) as CameraManager var resultCameraId: String? = null var resultSize: Size? = null for (cameraId in manager.cameraIdList) { val chars = manager.getCameraCharacteristics(cameraId) val facing = chars.get(CameraCharacteristics.LENS_FACING) ?: -1 if (facing == LENS_FACING_BACK) { val confMap = chars.get( CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP ) val sizes = confMap?.getOutputSizes(SurfaceTexture::class.java) resultSize = findSize(sizes) resultCameraId = cameraId break } } resultCameraId?.let { cameraId -> manager.openCamera(cameraId, object : CameraDevice.StateCallback() { override fun onOpened(camera: CameraDevice) { //Success open camera ... } }) } 

• एक खुला कैमरा होने से, हम छवि को प्रदर्शित करने के लिए एक सतह के लिए आवेदन करने के लिए मुड़ते हैं। WaitingSurface स्थिति
• अब जब हमारे पास CameraDevice है, सरफेस, हमें एक सत्र खोलने की आवश्यकता है ताकि कैमरा अंततः डेटा भेजना शुरू कर दे। WaitingSession स्थिति

 cameraDevice.createCaptureSession( arrayListOf(surface), object : CameraCaptureSession.StateCallback() { override fun onConfigured(session: CameraCaptureSession) { send(CameraAction.SessionReady(session)) } }, handler ) 

• अब हम पूर्वावलोकन पर कब्जा कर सकते हैं। प्रारंभिक स्थिति

 val request = cameraDevice.createCaptureRequest( CameraDevice.TEMPLATE_PREVIEW ).apply { addTarget(surface) } session.setRepeatingRequest( request.build(), object : CameraCaptureSession.CaptureCallback() {...} handler ) 

हम अपनी वर्तमान योजना का वर्णन करते हैं:

CameraMachine.kt

MediaCodec

MediaCodec सिस्टम कोडेक्स के साथ निम्न-स्तर के काम के लिए एक वर्ग है, सामान्य तौर पर, इसका एपीआई इनपुट / आउटपुट बफ़र्स (यह दुर्भाग्य से, इसके साथ काम करने से आसान लगता है) का एक सेट है, जिसमें डेटा (कच्चा या एन्कोडेड, एनकोडर / डिकोडर के संचालन के मोड पर निर्भर करता है), और रखा जाता है। आउटपुट पर हमें परिणाम मिलता है।

इस तथ्य के बावजूद कि बाइटबफ़र आमतौर पर बफ़र्स के रूप में कार्य करता है, आप वीडियो के साथ काम करने के लिए सरफेस का उपयोग कर सकते हैं, जो MediaCodec :: createInputSurface हमें लौटाएगा, इस पर हमें उन फ़्रेमों को खींचना होगा जिन्हें हम रिकॉर्ड करना चाहते हैं (इस दृष्टिकोण के साथ, प्रलेखन हमें gpu के उपयोग के माध्यम से तेजी से एन्कोडिंग का वादा करता है। )।

खैर, अब हमें यह सीखने की जरूरत है कि मौजूदा सरफेस को कैसे बनाया जाए जिसे हमने GLSurfaceMachine में सर्फेस ऑन मीडियाकोड से बनाया है। यह याद रखना महत्वपूर्ण है: भूतल एक ऐसी वस्तु है जो एक उपभोक्ता बनाता है, और सामान्य तौर पर इससे कुछ पढ़ना असंभव है, अर्थात इसमें कोई सशर्त विधि नहीं मिलती है getBitmap / readImage / ...

हम निम्नानुसार आगे बढ़ेंगे: मौजूदा जीएल संदर्भ के आधार पर, हम एक नया बनायेंगे, जिसमें इसके साथ एक आम मेमोरी होगी, और इसलिए हम इसका उपयोग उन बनावटों के आईडी-शेकिन्स का पुन: उपयोग करने के लिए कर सकते हैं जो हमने पहले बनाए थे। फिर MediaCodec से नए GL संदर्भ और सरफेस का उपयोग करते हुए, हम एक EGLSurface - एक ऑफ-स्क्रीन बफर बनाएंगे, जिस पर हम अपनी OpenGLScene क्लास भी बना सकते हैं। फिर, प्रत्येक फ्रेम रेंडरिंग में, हम फ्रेम को फाइल के समानांतर लिखने की कोशिश करेंगे।

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

EncoderMachine.kt
EncoderHelper.kt

परिणाम:

• वीडियो के साथ काम करने के लिए OpenGL में कम से कम बुनियादी कौशल की आवश्यकता होती है
• Android Media API काफी निम्न-स्तर का है, जो लचीलापन देता है, लेकिन कभी-कभी यह आपको कुछ और कोड लिखता है जो आप चाहते हैं
• एसिंक्रोनस API को StateMachines में लपेटा जा सकता है